Add2HitsList(hACORDExz,9);
Add2HitsList(hACORDEyz,10);
Add2HitsList(hACORDEAzimPol,11);
-
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
+
//____________________________________________________________________________
void AliACORDEQADataMaker::InitDigits()
{
modulename = "hDigitsModule";
fhDigitsModule = new TH1F(modulename.Data(),"hDigitsModuleSingle",60,0,60);
Add2DigitsList( fhDigitsModule,0);
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
void AliACORDEQADataMaker::InitRaws()
{
// create Raw histograms in Raw subdir
-TH1D *fhACORDEBitPattern[4];
-fhACORDEBitPattern[0] = new TH1D("ACORDERawDataSM","ACORDE-SingleMuon",60,1,60);//AcordeSingleMuon BitPattern
-fhACORDEBitPattern[1] = new TH1D("ACORDERawDataMM","ACORDE-MultiMuon",60,1,60);//AcordeMultiMuon BitPattern
-fhACORDEBitPattern[2] = new TH1D("ACORDERawDataSMM","ACORDE-SingleMuonMultiplicity",60,1,60);//AcordeSingleMuon Multiplicity
-fhACORDEBitPattern[3] = new TH1D("ACORDERawDataMMM","ACORDE-MultiMuonMultiplicity",60,1,60);//AcordeMultiMuon Multiplicity
-for(Int_t i=0;i<4;i++)
-{
- Add2RawsList(fhACORDEBitPattern[i],i);
-}
+ TH1F *fhACORDEBitPattern[4];
+ fhACORDEBitPattern[0] = new TH1F("ACORDERawDataSM","ACORDE-SingleMuon",60,1,60);//AcordeSingleMuon BitPattern
+ fhACORDEBitPattern[1] = new TH1F("ACORDERawDataMM","ACORDE-MultiMuon",60,1,60);//AcordeMultiMuon BitPattern
+ fhACORDEBitPattern[2] = new TH1F("ACORDERawDataSMM","ACORDE-SingleMuonMultiplicity",60,1,60);//AcordeSingleMuon Multiplicity
+ fhACORDEBitPattern[3] = new TH1F("ACORDERawDataMMM","ACORDE-MultiMuonMultiplicity",60,1,60);//AcordeMultiMuon Multiplicity
+ for(Int_t i=0;i<4;i++) {
+ Add2RawsList(fhACORDEBitPattern[i],i);
+ }
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
void AliACORDEQADataMaker::InitRecPoints()
{
// create cluster histograms in RecPoint subdir
- // Not needed for ACORDE by now !!!
+ // Not needed for ACORDE by now !!
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
+
//____________________________________________________________________________
void AliACORDEQADataMaker::InitESDs()
{
name = "hESDsMulti";
fhESDsMulti = new TH1F(name.Data(),"hESDsMulti",60,0,60);
Add2ESDsList( fhESDsMulti,1);
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
{
// Here we fill the QA histos for Hits declared above
-
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+
printf("Estamos en make Hits");
TClonesArray * hits = new TClonesArray("AliACORDEhit",1000);
TBranch * branch = hitTree->GetBranch("ACORDE");
AliError("The unchecked hit doesn't exist");
break;
}
- GetHitsData(0)->Fill(AcoHit->Eloss());
- GetHitsData(1)->Fill(AcoHit->PolarAngle());
- GetHitsData(2)->Fill(AcoHit->AzimuthAngle());
- GetHitsData(3)->Fill(AcoHit->Px());
- GetHitsData(4)->Fill(AcoHit->Py());
- GetHitsData(5)->Fill(AcoHit->Pz());
- GetHitsData(6)->Fill(TMath::Sqrt( (AcoHit->Px())*(AcoHit->Px())+
+ FillHitsData(0,AcoHit->Eloss());
+ FillHitsData(1,AcoHit->PolarAngle());
+ FillHitsData(2,AcoHit->AzimuthAngle());
+ FillHitsData(3,AcoHit->Px());
+ FillHitsData(4,AcoHit->Py());
+ FillHitsData(5,AcoHit->Pz());
+ FillHitsData(6,TMath::Sqrt( (AcoHit->Px())*(AcoHit->Px())+
(AcoHit->Py())*(AcoHit->Py())));
- if((AcoHit->Py()) != 0.0 ) GetHitsData(7)->Fill(TMath::ATan(AcoHit->Px()/AcoHit->Py()));
- GetHitsData(8)->Fill( (Float_t)(AcoHit->X()),(Float_t)(AcoHit->Y()) );
- GetHitsData(9)->Fill( (Float_t)(AcoHit->X()),(Float_t)(AcoHit->Z()) );
- GetHitsData(10)->Fill( (Float_t)(AcoHit->Y()),(Float_t)(AcoHit->Z()) );
- GetHitsData(11)->Fill( (Float_t)(AcoHit->AzimuthAngle()),
- (Float_t)(AcoHit->PolarAngle()));
+ if((AcoHit->Py()) != 0.0 ) FillHitsData(7,TMath::ATan(AcoHit->Px()/AcoHit->Py()));
+ FillHitsData(8, (Float_t)(AcoHit->X()),(Float_t)(AcoHit->Y()) );
+ FillHitsData(9, (Float_t)(AcoHit->X()),(Float_t)(AcoHit->Z()) );
+ FillHitsData(10, (Float_t)(AcoHit->Y()),(Float_t)(AcoHit->Z()) );
+ FillHitsData(11, (Float_t)(AcoHit->AzimuthAngle()),
+ (Float_t)(AcoHit->PolarAngle()));
}
}
}
void AliACORDEQADataMaker::MakeDigits( TTree *digitsTree)
{
//fills QA histos for Digits
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
TClonesArray * digits = new TClonesArray("AliACORDEdigit",1000);
AliError("The unchecked digit doesn't exist");
break;
}
- GetDigitsData(0)->Fill(AcoDigit->GetModule()-1);
+ FillDigitsData(0,AcoDigit->GetModule()-1);
}
}
{
//fills QA histos for RAW
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+
rawReader->Reset();
AliACORDERawStream rawStream(rawReader);
size_t contSingle=0;
{
if(kroSingle[r]==1)
{
- GetRawsData(0)->Fill(r+1);
- contSingle=contSingle+1;
+ FillRawsData(0,r+1);
+ contSingle=contSingle+1;
}
if(kroMulti[r]==1)
{
- GetRawsData(1)->Fill(r+1);
- contMulti++;
+ FillRawsData(1,r+1);
+ contMulti++;
}
- }GetRawsData(2)->Fill(contSingle);GetRawsData(3)->Fill(contMulti);
+ } FillRawsData(2,contSingle); FillRawsData(3,contMulti);
}
void AliACORDEQADataMaker::MakeRecPoints(TTree * clustersTree)
{
//fills QA histos for clusters
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+
// Not needed for ACORDE by now!!!
}
void AliACORDEQADataMaker::MakeESDs(AliESDEvent * esd)
{
//fills QA histos for ESD
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+
AliESDACORDE * fESDACORDE= esd->GetACORDEData();
Int_t *fACORDEMultiMuon =fESDACORDE->GetACORDEMultiMuon();
Int_t *fACORDESingleMuon=fESDACORDE->GetACORDESingleMuon();
- for(int i=0;i<60;i++){
- if(fACORDESingleMuon[i]==1)
- GetESDsData(0) -> Fill(i);
- if(fACORDEMultiMuon[i]==1)
- GetESDsData(1) -> Fill(i);
+ for(int i=0;i<60;i++){
+ if(fACORDESingleMuon[i]==1)
+ FillESDsData(0,i);
+ if(fACORDEMultiMuon[i]==1)
+ FillESDsData(1,i);
}
-
-
+
+
}
virtual TObjArray* Init(AliQAv1::TASKINDEX_t, Int_t, Int_t){return 0;};
virtual void Init(AliQAv1::TASKINDEX_t, TObjArray*, Int_t, Int_t){};
virtual void StartOfCycle(AliQAv1::TASKINDEX_t, Bool_t){};
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray*){};
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray**) {}
virtual void InitSDigits(){};
virtual void MakeHits(TClonesArray*){};
virtual void MakeDigits(TClonesArray*){};
//\r
// Created: June 13th 2008\r
//---\r
-// Last update: May 5th. 2011 (by Mario RC: mrodrigu@mail.cern.ch) -->Creates QA expert histograms and QA-shifter histograms also with threshold lines and visual alarm\r
+// Last update: May 5th. 2011 (by Mario RC: mrodrigu@mail.cern.ch) -->Creates QA expert histograms \r
+// and QA-shifter histograms also with threshold lines and visual alarm\r
// Last Update: Aug. 27th 2008 --> Implementation to declare QA expert histogram\r
-// Last update: Nov. 14t 2009 --> MRC <mrodrigu@mail.cern.ch> (FCFM-BUAP) \r
+// Last update: Nov. 14t 2009 --> MRC <mrodrigu@mail.cern.ch> (FCFM-BUAP) \r
// |--> Change in Multiplicity histogram for AMORE (to detect empty triggers events of ACORDE)\r
\r
\r
#include <TFile.h> \r
#include <TH1F.h> \r
#include <TDirectory.h>\r
-#include <TLine.h>\r
#include <TPaveText.h>\r
// --- Standard library ---\r
\r
ClassImp(AliACORDEQADataMakerRec)\r
\r
//____________________________________________________________________________ \r
-AliACORDEQADataMakerRec::AliACORDEQADataMakerRec():AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker"),\r
-fhACOMean(new TLine(0.,4.,60.,4.)),\r
-fhACOMin(new TLine(0.,4.,60.,4.)),\r
-fhACOMax(new TLine(0.,4.,60.,4.)),\r
-fhACOMulti(new TLine(0.,4.,60.,4.)),\r
-fhACOMeanAMU(new TLine(0.,4.,60.,4.)),\r
-fhACOMinAMU(new TLine(0.,4.,60.,4.)),\r
-fhACOMaxAMU(new TLine(0.,4.,60.,4.)),\r
-fhACOMultiAMU(new TLine(0.,4.,60.,4.)),\r
-fhACOTriggerCheck(new TLine(0.,4.,60.,4.))\r
+ AliACORDEQADataMakerRec::AliACORDEQADataMakerRec():AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kACORDE), "ACORDE Quality Assurance Data Maker"),\r
+ fhACOMean(new TLine(0.,4.,60.,4.)),\r
+ fhACOMin(new TLine(0.,4.,60.,4.)),\r
+ fhACOMax(new TLine(0.,4.,60.,4.)),\r
+ fhACOMulti(new TLine(0.,4.,60.,4.)),\r
+ fhACOMeanAMU(new TLine(0.,4.,60.,4.)),\r
+ fhACOMinAMU(new TLine(0.,4.,60.,4.)),\r
+ fhACOMaxAMU(new TLine(0.,4.,60.,4.)),\r
+ fhACOMultiAMU(new TLine(0.,4.,60.,4.)),\r
+ fhACOTriggerCheck(new TLine(0.,4.,60.,4.))\r
{\r
\r
}\r
//____________________________________________________________________________ \r
-AliACORDEQADataMakerRec::AliACORDEQADataMakerRec(const AliACORDEQADataMakerRec& qadm):AliQADataMakerRec(),\r
-fhACOMean(qadm.fhACOMean),\r
-fhACOMin(qadm.fhACOMin),\r
-fhACOMax(qadm.fhACOMax),\r
-fhACOMulti(qadm.fhACOMulti),\r
-fhACOMeanAMU(qadm.fhACOMeanAMU),\r
-fhACOMinAMU(qadm.fhACOMinAMU),\r
-fhACOMaxAMU(qadm.fhACOMaxAMU),\r
-fhACOMultiAMU(qadm.fhACOMultiAMU),\r
-fhACOTriggerCheck(qadm.fhACOTriggerCheck)\r
+AliACORDEQADataMakerRec::AliACORDEQADataMakerRec(const AliACORDEQADataMakerRec& qadm):\r
+ AliQADataMakerRec(),\r
+ fhACOMean(qadm.fhACOMean),\r
+ fhACOMin(qadm.fhACOMin),\r
+ fhACOMax(qadm.fhACOMax),\r
+ fhACOMulti(qadm.fhACOMulti),\r
+ fhACOMeanAMU(qadm.fhACOMeanAMU),\r
+ fhACOMinAMU(qadm.fhACOMinAMU),\r
+ fhACOMaxAMU(qadm.fhACOMaxAMU),\r
+ fhACOMultiAMU(qadm.fhACOMultiAMU),\r
+ fhACOTriggerCheck(qadm.fhACOTriggerCheck)\r
{\r
SetName((const char*)qadm.GetName()) ; \r
SetTitle((const char*)qadm.GetTitle()); \r
}\r
+\r
//__________________________________________________________________\r
AliACORDEQADataMakerRec::~AliACORDEQADataMakerRec()\r
{\r
- delete fhACOMean;\r
- delete fhACOMin;\r
- delete fhACOMax;\r
- delete fhACOMulti;\r
- delete fhACOTriggerCheck;\r
+ delete fhACOMean;\r
+ delete fhACOMin;\r
+ delete fhACOMax;\r
+ delete fhACOMulti;\r
+ delete fhACOTriggerCheck;\r
}\r
\r
//__________________________________________________________________\r
{\r
//Detector specific actions at end of cycle\r
// do the QA checking\r
- // Update for DQM GUI\r
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) \r
- {\r
- if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) \r
- continue ; \r
- if (!GetRawsData(0)||!GetRawsData(1)) continue;\r
- Double_t integral = GetRawsData(0)->Integral();\r
- if (integral==0) \r
- {\r
- printf("No entries in ACORDE Hits histograms --> fatal error, please check !!!\n");\r
- TPaveText *acoBoxFatal=new TPaveText(35,0.5,55,1,"b"); \r
- acoBoxFatal->SetFillColor(kRed);\r
- acoBoxFatal->SetLineColor(kRed);\r
- acoBoxFatal->SetLineWidth(2);\r
- //acoBox2->SetTextSize(3);\r
- //acoBox2->SetTextColor(kBlack);\r
- acoBoxFatal->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
- acoBoxFatal->AddText("Blue line: mean of hits");\r
- acoBoxFatal->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(0)->GetListOfFunctions()->Add(acoBoxFatal);\r
-\r
- TPaveText *acoMultiBoxFatal = new TPaveText(20,0.5,40,1,"b");\r
- acoMultiBoxFatal->SetFillColor(kRed);\r
- acoMultiBoxFatal->SetLineColor(kRed);\r
- acoMultiBoxFatal->SetLineWidth(2);\r
- acoMultiBoxFatal->AddText("ACO. Not O.K., Call the experts");\r
- GetRawsData(1)->GetListOfFunctions()->Add(acoMultiBoxFatal);\r
- \r
- continue;\r
- }\r
- Double_t mean = integral/60;\r
- fhACOMean->SetY1(mean);\r
- fhACOMean->SetY2(mean);\r
- fhACOMin->SetY1(0.05*mean);\r
- fhACOMin->SetY2(0.05*mean);\r
- fhACOMax->SetY1(2.25*mean);\r
- fhACOMax->SetY2(2.25*mean);\r
- \r
- // alarms\r
- Double_t max = GetRawsData(0)->GetMaximum();\r
- if (max == 0)\r
- {\r
- printf("Maximum of hits equal to ZERO, please check the status of ACORDE !!\n");\r
- continue;\r
- }\r
- // Multiplicity histogram threshold\r
- Double_t maxMulti = GetRawsData(1)->GetMaximum();\r
- if (maxMulti == 0)\r
- {\r
- printf("Maximum of entries equal to ZERO, please check the status of ACORDE !!\n");\r
- continue;\r
- }\r
- fhACOMulti->SetX1(1);\r
- fhACOMulti->SetY1(1);\r
- fhACOMulti->SetX2(1);\r
- fhACOMulti->SetY2(maxMulti);\r
- TPaveText *acoBox=new TPaveText(35,max-0.20*max,55,max,"b"); \r
- //acoBox->SetFillStyle(0);\r
- TPaveText *acoBox1=new TPaveText(35,max-0.20*max,55,max,"b"); \r
- //acoBox1->SetFillStyle(0);\r
- TPaveText *acoBox2=new TPaveText(35,max-0.20*max,55,max,"b"); \r
- //acoBox2->SetFillStyle(0);\r
- Int_t flagACO_DQM = 0;\r
- Bool_t isACOOk = kTRUE;\r
- Bool_t isACOWarning = kFALSE;\r
- for(Int_t iModule=0;iModule<60;iModule++)\r
- {\r
- if ((GetRawsData(0)->GetBinContent(iModule))/max < 0.5) flagACO_DQM++;\r
- }\r
- if (flagACO_DQM < 15)\r
- {\r
- acoBox->SetFillColor(kGreen);\r
- acoBox->SetLineColor(kGreen);\r
- acoBox->SetLineWidth(2);\r
- //acoBox->SetTextSize(3);\r
- //acoBox->SetTextColor(kBlack);\r
- acoBox->AddText("FLAG MESSAGE: O.K. !!!");\r
- acoBox->AddText("Blue line: mean of hits");\r
- acoBox->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(0)->GetListOfFunctions()->Add(acoBox);\r
-\r
- \r
- }else if (flagACO_DQM > 15 && flagACO_DQM<30)\r
- {\r
- acoBox1->SetFillColor(kYellow);\r
- acoBox1->SetLineColor(kYellow);\r
- acoBox1->SetLineWidth(2);\r
- //acoBox1->SetTextSize(3);\r
- //acoBox1->SetTextColor(kBlack);\r
- acoBox1->AddText("FLAG MESSAGE: Warning, some modules are not working properly !!!");\r
- acoBox1->AddText("Blue line: mean of hits");\r
- acoBox1->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(0)->GetListOfFunctions()->Add(acoBox1);\r
- isACOWarning=kTRUE;\r
-\r
- }else if (flagACO_DQM > 30)\r
- {\r
- acoBox2->SetFillColor(kRed);\r
- acoBox2->SetLineColor(kRed);\r
- acoBox2->SetLineWidth(2);\r
- //acoBox2->SetTextSize(3);\r
- //acoBox2->SetTextColor(kBlack);\r
- acoBox2->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
- acoBox2->AddText("Blue line: mean of hits");\r
- acoBox2->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(0)->GetListOfFunctions()->Add(acoBox2);\r
- isACOOk=kFALSE;\r
-\r
- }\r
- \r
- \r
- TPaveText *acoMultiBox = new TPaveText(20,maxMulti-0.20*maxMulti,40,maxMulti,"b");\r
- if (GetRawsData(1)->Integral()==0 || isACOOk==kFALSE)\r
- {\r
- acoMultiBox->SetFillColor(kRed);\r
- acoMultiBox->SetLineColor(kRed);\r
- acoMultiBox->SetLineWidth(2);\r
- acoMultiBox->AddText("ACO. Not O.K., Call the experts");\r
- GetRawsData(1)->GetListOfFunctions()->Add(acoMultiBox);\r
- }\r
-/* if (GetRawsData(5)->GetBinContent(1) > 0 || isACOOk && GetRawsData(5)->Integral()!=0 && isACOOk==kTRUE){\r
- acoMultiBox->SetFillColor(kYellow);\r
- acoMultiBox->SetLineColor(kYellow);\r
- acoMultiBox->SetLineWidth(2);\r
- acoMultiBox->AddText("Warning: possible empy events only IF ACORDE is triggering, else: O.K.");\r
- GetRawsData(5)->GetListOfFunctions()->Add(acoMultiBox);\r
- }\r
-*/\r
- if (isACOOk==kTRUE)\r
- {\r
- acoMultiBox->SetFillColor(kGreen);\r
- acoMultiBox->SetLineColor(kGreen);\r
- acoMultiBox->SetLineWidth(2);\r
- acoMultiBox->AddText("FLAG MESSAGE: ACO. O.K.");\r
- //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
- GetRawsData(1)->GetListOfFunctions()->Add(acoMultiBox);\r
- }\r
- if (isACOWarning==kTRUE)\r
- {\r
- acoMultiBox->SetFillColor(kYellow);\r
- acoMultiBox->SetLineColor(kYellow);\r
- acoMultiBox->SetLineWidth(2);\r
- acoMultiBox->AddText("FLAG MESSAGE: ACO. O.K., warning, some modules are not working properly");\r
- //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
- GetRawsData(1)->GetListOfFunctions()->Add(acoMultiBox);\r
- }\r
-\r
- // for AMU ACORDE trigger option\r
- \r
- if (!GetRawsData(2)||!GetRawsData(3)) continue;\r
- Double_t integral1 = GetRawsData(2)->Integral();\r
- if (integral1==0) \r
- {\r
- printf("No entries in ACORDE Hits histograms --> fatal error, please check !!!\n");\r
- TPaveText *acoBoxFatalAMU=new TPaveText(35,0.5,55,1,"b"); \r
- acoBoxFatalAMU->SetFillColor(kRed);\r
- acoBoxFatalAMU->SetLineColor(kRed);\r
- acoBoxFatalAMU->SetLineWidth(2);\r
- //acoBox2->SetTextSize(3);\r
- //acoBox2->SetTextColor(kBlack);\r
- acoBoxFatalAMU->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
- acoBoxFatalAMU->AddText("Blue line: mean of hits");\r
- acoBoxFatalAMU->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(2)->GetListOfFunctions()->Add(acoBoxFatalAMU);\r
-\r
- TPaveText *acoMultiBoxFatalAMU = new TPaveText(20,0.5,40,1,"b");\r
- acoMultiBoxFatalAMU->SetFillColor(kRed);\r
- acoMultiBoxFatalAMU->SetLineColor(kRed);\r
- acoMultiBoxFatalAMU->SetLineWidth(2);\r
- acoMultiBoxFatalAMU->AddText("ACO. Not O.K., Call the experts");\r
- GetRawsData(3)->GetListOfFunctions()->Add(acoMultiBoxFatalAMU);\r
- \r
- continue;\r
- }\r
- Double_t mean1 = integral1/60;\r
- fhACOMeanAMU->SetY1(mean1);\r
- fhACOMeanAMU->SetY2(mean1);\r
- fhACOMinAMU->SetY1(0.05*mean1);\r
- fhACOMinAMU->SetY2(0.05*mean1);\r
- fhACOMaxAMU->SetY1(2.25*mean1);\r
- fhACOMaxAMU->SetY2(2.25*mean1);\r
- \r
- // alarms\r
- Double_t max1 = GetRawsData(2)->GetMaximum();\r
- if (max1 == 0)\r
- {\r
- printf("Maximum of hits equal to ZERO, please check the status of ACORDE !!\n");\r
- continue;\r
- }\r
- // Multiplicity histogram threshold\r
- Double_t maxMulti1 = GetRawsData(3)->GetMaximum();\r
- if (maxMulti1 == 0)\r
- {\r
- printf("Maximum of entries equal to ZERO, please check the status of ACORDE !!\n");\r
- continue;\r
- }\r
- fhACOMultiAMU->SetX1(1);\r
- fhACOMultiAMU->SetY1(1);\r
- fhACOMultiAMU->SetX2(1);\r
- fhACOMultiAMU->SetY2(maxMulti1);\r
- TPaveText *acoBoxAMU=new TPaveText(35,max1-0.20*max1,55,max1,"b"); \r
- //acoBox->SetFillStyle(0);\r
- TPaveText *acoBox1AMU=new TPaveText(35,max1-0.20*max1,55,max1,"b"); \r
- //acoBox1->SetFillStyle(0);\r
- TPaveText *acoBox2AMU=new TPaveText(35,max1-0.20*max1,55,max1,"b"); \r
- //acoBox2->SetFillStyle(0);\r
- Int_t flagACO_DQMAMU = 0;\r
- Bool_t isACOOkAMU = kTRUE;\r
- Bool_t isACOWarningAMU = kFALSE;\r
- for(Int_t iModule=0;iModule<60;iModule++)\r
- {\r
- if ((GetRawsData(2)->GetBinContent(iModule))/max1 < 0.5) flagACO_DQMAMU++;\r
- }\r
- if (flagACO_DQMAMU < 15)\r
- {\r
- acoBoxAMU->SetFillColor(kGreen);\r
- acoBoxAMU->SetLineColor(kGreen);\r
- acoBoxAMU->SetLineWidth(2);\r
- //acoBox->SetTextSize(3);\r
- //acoBox->SetTextColor(kBlack);\r
- acoBoxAMU->AddText("FLAG MESSAGE: O.K. !!!");\r
- acoBoxAMU->AddText("Blue line: mean of hits");\r
- acoBoxAMU->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(2)->GetListOfFunctions()->Add(acoBoxAMU);\r
-\r
- \r
- }else if (flagACO_DQMAMU > 15 && flagACO_DQMAMU<30)\r
- {\r
- acoBox1AMU->SetFillColor(kYellow);\r
- acoBox1AMU->SetLineColor(kYellow);\r
- acoBox1AMU->SetLineWidth(2);\r
- //acoBox1->SetTextSize(3);\r
- //acoBox1->SetTextColor(kBlack);\r
- acoBox1AMU->AddText("FLAG MESSAGE: Warning, some modules are not working properly !!!");\r
- acoBox1AMU->AddText("Blue line: mean of hits");\r
- acoBox1AMU->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(2)->GetListOfFunctions()->Add(acoBox1AMU);\r
- isACOWarningAMU=kTRUE;\r
-\r
- }else if (flagACO_DQMAMU > 30)\r
- {\r
- acoBox2AMU->SetFillColor(kRed);\r
- acoBox2AMU->SetLineColor(kRed);\r
- acoBox2AMU->SetLineWidth(2);\r
- //acoBox2->SetTextSize(3);\r
- //acoBox2->SetTextColor(kBlack);\r
- acoBox2AMU->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
- acoBox2AMU->AddText("Blue line: mean of hits");\r
- acoBox2AMU->AddText("Between GREEN lines: ACO. O.K.");\r
- GetRawsData(2)->GetListOfFunctions()->Add(acoBox2AMU);\r
- isACOOkAMU=kFALSE;\r
-\r
- }\r
- \r
- \r
- TPaveText *acoMultiBoxAMU = new TPaveText(20,maxMulti1-0.20*maxMulti1,40,maxMulti1,"b");\r
- if (GetRawsData(3)->Integral()==0 || isACOOkAMU==kFALSE)\r
- {\r
- acoMultiBoxAMU->SetFillColor(kRed);\r
- acoMultiBoxAMU->SetLineColor(kRed);\r
- acoMultiBoxAMU->SetLineWidth(2);\r
- acoMultiBoxAMU->AddText("ACO. Not O.K., Call the experts");\r
- GetRawsData(3)->GetListOfFunctions()->Add(acoMultiBoxAMU);\r
- }\r
-/* if (GetRawsData(5)->GetBinContent(1) > 0 || isACOOk && GetRawsData(5)->Integral()!=0 && isACOOk==kTRUE){\r
- acoMultiBox->SetFillColor(kYellow);\r
- acoMultiBox->SetLineColor(kYellow);\r
- acoMultiBox->SetLineWidth(2);\r
- acoMultiBox->AddText("Warning: possible empy events only IF ACORDE is triggering, else: O.K.");\r
- GetRawsData(5)->GetListOfFunctions()->Add(acoMultiBox);\r
- }\r
-*/\r
- if (isACOOkAMU==kTRUE)\r
- {\r
- acoMultiBoxAMU->SetFillColor(kGreen);\r
- acoMultiBoxAMU->SetLineColor(kGreen);\r
- acoMultiBoxAMU->SetLineWidth(2);\r
- acoMultiBoxAMU->AddText("FLAG MESSAGE: ACO. O.K.");\r
- //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
- GetRawsData(3)->GetListOfFunctions()->Add(acoMultiBoxAMU);\r
- }\r
- if (isACOWarningAMU==kTRUE)\r
- {\r
- acoMultiBoxAMU->SetFillColor(kYellow);\r
- acoMultiBoxAMU->SetLineColor(kYellow);\r
- acoMultiBoxAMU->SetLineWidth(2);\r
- acoMultiBoxAMU->AddText("FLAG MESSAGE: ACO. O.K., warning, some modules are not working properly");\r
- //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
- GetRawsData(3)->GetListOfFunctions()->Add(acoMultiBoxAMU);\r
- }\r
-\r
- // Checks if hits distribution from SL0 and AMU are equal\r
- Float_t eff = 0.0;\r
- Int_t effFlag = 0;\r
- for (Int_t iModule = 0; iModule < 60; iModule++)\r
- {\r
- if (GetRawsData(2)->GetBinContent(iModule)==0) \r
- {\r
- eff = 0.0;\r
- continue;\r
- }else\r
- {\r
- eff = GetRawsData(0)->GetBinContent(iModule)/GetRawsData(2)->GetBinContent(iModule);\r
- GetRawsData(4)->Fill(iModule,eff);\r
- if (eff!=1) effFlag++;\r
- }\r
- }\r
- \r
- if (effFlag == 0)\r
- {\r
- TPaveText *checkTriggerBox = new TPaveText(20,0.6,40,0.8,"b");\r
- checkTriggerBox->SetFillColor(kGreen);\r
- checkTriggerBox->SetLineColor(kGreen);\r
- checkTriggerBox->SetLineWidth(2);\r
- checkTriggerBox->AddText("FLAG MESSAGE: ACO. trigger O.K.");\r
- GetRawsData(4)->GetListOfFunctions()->Add(checkTriggerBox);\r
- }else\r
- {\r
- TPaveText *checkTriggerBox1 = new TPaveText(20,0.6,40,0.8,"b");\r
- checkTriggerBox1->SetFillColor(kYellow);\r
- checkTriggerBox1->SetLineColor(kYellow);\r
- checkTriggerBox1->SetLineWidth(2);\r
- checkTriggerBox1->AddText("FLAG MESSAGE: Warning, please check the ACO trigger configuration");\r
- GetRawsData(4)->GetListOfFunctions()->Add(checkTriggerBox1);\r
-\r
- }\r
-\r
- \r
-\r
- } // end specie loop\r
+ ResetEventTrigClasses(); // reset triggers list to select all histos\r
+ // Update for DQM GUI\r
+ //\r
+ for (Int_t specie = 0; specie < AliRecoParam::kNSpecies ; specie++) {\r
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) continue ;\r
+ // \r
+ // RS Set event specie\r
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));\r
+ //\r
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS Loop over the trigger classes\r
+ //\r
+ TObjArray &harr = *GetRawsDataOfTrigClass(itc);\r
+ //\r
+ if (!harr[0] || !harr[1]) continue;\r
+ TH1* h0 = GetRawsData(0,itc);\r
+ TH1* h1 = GetRawsData(1,itc);\r
+ double integral = 0;\r
+ if (itc==-1 && (h0&&h1 && !(integral=h0->Integral()))) { // default clone\r
+ printf("No entries in ACORDE Hits histograms for trigger class %d, fatal error, please check !!!\n",itc);\r
+ TPaveText *acoBoxFatal=new TPaveText(35,0.5,55,1,"b");\r
+ acoBoxFatal->SetFillColor(kRed);\r
+ acoBoxFatal->SetLineColor(kRed);\r
+ acoBoxFatal->SetLineWidth(2);\r
+ //acoBox2->SetTextSize(3);\r
+ //acoBox2->SetTextColor(kBlack);\r
+ acoBoxFatal->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
+ acoBoxFatal->AddText("Blue line: mean of hits");\r
+ acoBoxFatal->AddText("Between GREEN lines: ACO. O.K.");\r
+ h0->GetListOfFunctions()->Add(acoBoxFatal);\r
\r
- // QA Checker standar (to be updated)\r
+ TPaveText *acoMultiBoxFatal = new TPaveText(20,0.5,40,1,"b");\r
+ acoMultiBoxFatal->SetFillColor(kRed);\r
+ acoMultiBoxFatal->SetLineColor(kRed);\r
+ acoMultiBoxFatal->SetLineWidth(2);\r
+ acoMultiBoxFatal->AddText("ACO. Not O.K., Call the experts");\r
+ h1->GetListOfFunctions()->Add(acoMultiBoxFatal);\r
+ continue;\r
+ }\r
+ Double_t mean = integral/60;\r
+ fhACOMean->SetY1(mean);\r
+ fhACOMean->SetY2(mean);\r
+ fhACOMin->SetY1(0.05*mean);\r
+ fhACOMin->SetY2(0.05*mean);\r
+ fhACOMax->SetY1(2.25*mean);\r
+ fhACOMax->SetY2(2.25*mean);\r
+ \r
+ // alarms\r
+ Double_t max = h0->GetMaximum();\r
+ if (max == 0) {\r
+ printf("Maximum of hits equal to ZERO, please check the status of ACORDE !!\n");\r
+ continue;\r
+ }\r
+ // Multiplicity histogram threshold\r
+ Double_t maxMulti = h1->GetMaximum();\r
+ if (maxMulti == 0) {\r
+ printf("Maximum of entries equal to ZERO, please check the status of ACORDE !!\n");\r
+ continue;\r
+ }\r
+ fhACOMulti->SetX1(1);\r
+ fhACOMulti->SetY1(1);\r
+ fhACOMulti->SetX2(1);\r
+ fhACOMulti->SetY2(maxMulti);\r
+ TPaveText *acoBox=new TPaveText(35,max-0.20*max,55,max,"b");\r
+ //acoBox->SetFillStyle(0);\r
+ TPaveText *acoBox1=new TPaveText(35,max-0.20*max,55,max,"b");\r
+ //acoBox1->SetFillStyle(0);\r
+ TPaveText *acoBox2=new TPaveText(35,max-0.20*max,55,max,"b");\r
+ //acoBox2->SetFillStyle(0);\r
+ Int_t flagACO_DQM = 0;\r
+ Bool_t isACOOk = kTRUE;\r
+ Bool_t isACOWarning = kFALSE;\r
+ for(Int_t iModule=0;iModule<60;iModule++) {\r
+ if ((h0->GetBinContent(iModule))/max < 0.5) flagACO_DQM++;\r
+ }\r
+ if (flagACO_DQM < 15) {\r
+ acoBox->SetFillColor(kGreen);\r
+ acoBox->SetLineColor(kGreen);\r
+ acoBox->SetLineWidth(2);\r
+ //acoBox->SetTextSize(3);\r
+ //acoBox->SetTextColor(kBlack);\r
+ acoBox->AddText("FLAG MESSAGE: O.K. !!!");\r
+ acoBox->AddText("Blue line: mean of hits");\r
+ acoBox->AddText("Between GREEN lines: ACO. O.K.");\r
+ h0->GetListOfFunctions()->Add(acoBox); \r
+ //\r
+ } \r
+ else if (flagACO_DQM > 15 && flagACO_DQM<30) {\r
+ acoBox1->SetFillColor(kYellow);\r
+ acoBox1->SetLineColor(kYellow);\r
+ acoBox1->SetLineWidth(2);\r
+ //acoBox1->SetTextSize(3);\r
+ //acoBox1->SetTextColor(kBlack);\r
+ acoBox1->AddText("FLAG MESSAGE: Warning, some modules are not working properly !!!");\r
+ acoBox1->AddText("Blue line: mean of hits");\r
+ acoBox1->AddText("Between GREEN lines: ACO. O.K.");\r
+ h0->GetListOfFunctions()->Add(acoBox1);\r
+ isACOWarning=kTRUE; \r
+ }\r
+ else if (flagACO_DQM > 30) {\r
+ acoBox2->SetFillColor(kRed);\r
+ acoBox2->SetLineColor(kRed);\r
+ acoBox2->SetLineWidth(2);\r
+ //acoBox2->SetTextSize(3);\r
+ //acoBox2->SetTextColor(kBlack);\r
+ acoBox2->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
+ acoBox2->AddText("Blue line: mean of hits");\r
+ acoBox2->AddText("Between GREEN lines: ACO. O.K.");\r
+ h0->GetListOfFunctions()->Add(acoBox2);\r
+ isACOOk=kFALSE; \r
+ }\r
+ //\r
+ \r
+ TPaveText *acoMultiBox = new TPaveText(20,maxMulti-0.20*maxMulti,40,maxMulti,"b");\r
+ if (h1->Integral()==0 || isACOOk==kFALSE) {\r
+ acoMultiBox->SetFillColor(kRed);\r
+ acoMultiBox->SetLineColor(kRed);\r
+ acoMultiBox->SetLineWidth(2);\r
+ acoMultiBox->AddText("ACO. Not O.K., Call the experts");\r
+ h1->GetListOfFunctions()->Add(acoMultiBox);\r
+ }\r
+ /* if (GetRawsData(5)->GetBinContent(1) > 0 || isACOOk && GetRawsData(5)->Integral()!=0 && isACOOk==kTRUE){\r
+ acoMultiBox->SetFillColor(kYellow);\r
+ acoMultiBox->SetLineColor(kYellow);\r
+ acoMultiBox->SetLineWidth(2);\r
+ acoMultiBox->AddText("Warning: possible empy events only IF ACORDE is triggering, else: O.K.");\r
+ GetRawsData(5)->GetListOfFunctions()->Add(acoMultiBox);\r
+ }\r
+ */\r
+ if (isACOOk==kTRUE) {\r
+ acoMultiBox->SetFillColor(kGreen);\r
+ acoMultiBox->SetLineColor(kGreen);\r
+ acoMultiBox->SetLineWidth(2);\r
+ acoMultiBox->AddText("FLAG MESSAGE: ACO. O.K.");\r
+ //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
+ h1->GetListOfFunctions()->Add(acoMultiBox);\r
+ }\r
+ if (isACOWarning==kTRUE) {\r
+ acoMultiBox->SetFillColor(kYellow);\r
+ acoMultiBox->SetLineColor(kYellow);\r
+ acoMultiBox->SetLineWidth(2);\r
+ acoMultiBox->AddText("FLAG MESSAGE: ACO. O.K., warning, some modules are not working properly");\r
+ //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
+ h1->GetListOfFunctions()->Add(acoMultiBox);\r
+ }\r
+ \r
+ // for AMU ACORDE trigger option\r
+ TH1* h2 = (TH1*)harr[2];\r
+ TH1* h3 = (TH1*)harr[3];\r
+ if (!h2 || !h3) continue;\r
+ Double_t integral1 = h2->Integral();\r
+ if (integral1==0) {\r
+ printf("No entries in ACORDE Hits histograms for trigger class %d --> fatal error, please check !!!\n",itc);\r
+ TPaveText *acoBoxFatalAMU=new TPaveText(35,0.5,55,1,"b");\r
+ acoBoxFatalAMU->SetFillColor(kRed);\r
+ acoBoxFatalAMU->SetLineColor(kRed);\r
+ acoBoxFatalAMU->SetLineWidth(2);\r
+ //acoBox2->SetTextSize(3);\r
+ //acoBox2->SetTextColor(kBlack);\r
+ acoBoxFatalAMU->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
+ acoBoxFatalAMU->AddText("Blue line: mean of hits");\r
+ acoBoxFatalAMU->AddText("Between GREEN lines: ACO. O.K.");\r
+ h2->GetListOfFunctions()->Add(acoBoxFatalAMU);\r
+ \r
+ TPaveText *acoMultiBoxFatalAMU = new TPaveText(20,0.5,40,1,"b");\r
+ acoMultiBoxFatalAMU->SetFillColor(kRed);\r
+ acoMultiBoxFatalAMU->SetLineColor(kRed);\r
+ acoMultiBoxFatalAMU->SetLineWidth(2);\r
+ acoMultiBoxFatalAMU->AddText("ACO. Not O.K., Call the experts");\r
+ h3->GetListOfFunctions()->Add(acoMultiBoxFatalAMU);\r
+ \r
+ continue;\r
+ }\r
+ Double_t mean1 = integral1/60;\r
+ fhACOMeanAMU->SetY1(mean1);\r
+ fhACOMeanAMU->SetY2(mean1);\r
+ fhACOMinAMU->SetY1(0.05*mean1);\r
+ fhACOMinAMU->SetY2(0.05*mean1);\r
+ fhACOMaxAMU->SetY1(2.25*mean1);\r
+ fhACOMaxAMU->SetY2(2.25*mean1);\r
+ \r
+ // alarms\r
+ Double_t max1 = h2->GetMaximum();\r
+ if (max1 == 0) {\r
+ printf("Maximum of hits equal to ZERO, please check the status of ACORDE !!\n");\r
+ continue;\r
+ }\r
+ // Multiplicity histogram threshold\r
+ Double_t maxMulti1 = h3->GetMaximum();\r
+ if (maxMulti1 == 0) {\r
+ printf("Maximum of entries equal to ZERO, please check the status of ACORDE !!\n");\r
+ continue;\r
+ }\r
+ fhACOMultiAMU->SetX1(1);\r
+ fhACOMultiAMU->SetY1(1);\r
+ fhACOMultiAMU->SetX2(1);\r
+ fhACOMultiAMU->SetY2(maxMulti1);\r
+ TPaveText *acoBoxAMU=new TPaveText(35,max1-0.20*max1,55,max1,"b");\r
+ //acoBox->SetFillStyle(0);\r
+ TPaveText *acoBox1AMU=new TPaveText(35,max1-0.20*max1,55,max1,"b");\r
+ //acoBox1->SetFillStyle(0);\r
+ TPaveText *acoBox2AMU=new TPaveText(35,max1-0.20*max1,55,max1,"b");\r
+ //acoBox2->SetFillStyle(0);\r
+ Int_t flagACO_DQMAMU = 0;\r
+ Bool_t isACOOkAMU = kTRUE;\r
+ Bool_t isACOWarningAMU = kFALSE;\r
+ for(Int_t iModule=0;iModule<60;iModule++) {\r
+ if ((h2->GetBinContent(iModule))/max1 < 0.5) flagACO_DQMAMU++;\r
+ }\r
+ if (flagACO_DQMAMU < 15) {\r
+ acoBoxAMU->SetFillColor(kGreen);\r
+ acoBoxAMU->SetLineColor(kGreen);\r
+ acoBoxAMU->SetLineWidth(2);\r
+ //acoBox->SetTextSize(3);\r
+ //acoBox->SetTextColor(kBlack);\r
+ acoBoxAMU->AddText("FLAG MESSAGE: O.K. !!!");\r
+ acoBoxAMU->AddText("Blue line: mean of hits");\r
+ acoBoxAMU->AddText("Between GREEN lines: ACO. O.K.");\r
+ h2->GetListOfFunctions()->Add(acoBoxAMU); \r
+ //\r
+ }\r
+ else if (flagACO_DQMAMU > 15 && flagACO_DQMAMU<30) {\r
+ acoBox1AMU->SetFillColor(kYellow);\r
+ acoBox1AMU->SetLineColor(kYellow);\r
+ acoBox1AMU->SetLineWidth(2);\r
+ //acoBox1->SetTextSize(3);\r
+ //acoBox1->SetTextColor(kBlack);\r
+ acoBox1AMU->AddText("FLAG MESSAGE: Warning, some modules are not working properly !!!");\r
+ acoBox1AMU->AddText("Blue line: mean of hits");\r
+ acoBox1AMU->AddText("Between GREEN lines: ACO. O.K.");\r
+ h2->GetListOfFunctions()->Add(acoBox1AMU);\r
+ isACOWarningAMU=kTRUE;\r
+ //\r
+ } \r
+ else if (flagACO_DQMAMU > 30) {\r
+ acoBox2AMU->SetFillColor(kRed);\r
+ acoBox2AMU->SetLineColor(kRed);\r
+ acoBox2AMU->SetLineWidth(2);\r
+ //acoBox2->SetTextSize(3);\r
+ //acoBox2->SetTextColor(kBlack);\r
+ acoBox2AMU->AddText("FLAG MESSAGE: ACO. Not Ok, Call the expert !!!");\r
+ acoBox2AMU->AddText("Blue line: mean of hits");\r
+ acoBox2AMU->AddText("Between GREEN lines: ACO. O.K.");\r
+ h2->GetListOfFunctions()->Add(acoBox2AMU);\r
+ isACOOkAMU=kFALSE;\r
+ }\r
+ //\r
+ TPaveText *acoMultiBoxAMU = new TPaveText(20,maxMulti1-0.20*maxMulti1,40,maxMulti1,"b");\r
+ if (h3->Integral()==0 || isACOOkAMU==kFALSE) {\r
+ acoMultiBoxAMU->SetFillColor(kRed);\r
+ acoMultiBoxAMU->SetLineColor(kRed);\r
+ acoMultiBoxAMU->SetLineWidth(2);\r
+ acoMultiBoxAMU->AddText("ACO. Not O.K., Call the experts");\r
+ h3->GetListOfFunctions()->Add(acoMultiBoxAMU);\r
+ }\r
+ /* if (GetRawsData(5)->GetBinContent(1) > 0 || isACOOk && GetRawsData(5)->Integral()!=0 && isACOOk==kTRUE){\r
+ acoMultiBox->SetFillColor(kYellow);\r
+ acoMultiBox->SetLineColor(kYellow);\r
+ acoMultiBox->SetLineWidth(2);\r
+ acoMultiBox->AddText("Warning: possible empy events only IF ACORDE is triggering, else: O.K.");\r
+ GetRawsData(5)->GetListOfFunctions()->Add(acoMultiBox);\r
+ }\r
+ */\r
+ if (isACOOkAMU==kTRUE) {\r
+ acoMultiBoxAMU->SetFillColor(kGreen);\r
+ acoMultiBoxAMU->SetLineColor(kGreen);\r
+ acoMultiBoxAMU->SetLineWidth(2);\r
+ acoMultiBoxAMU->AddText("FLAG MESSAGE: ACO. O.K.");\r
+ //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
+ h3->GetListOfFunctions()->Add(acoMultiBoxAMU);\r
+ }\r
+ if (isACOWarningAMU==kTRUE) {\r
+ acoMultiBoxAMU->SetFillColor(kYellow);\r
+ acoMultiBoxAMU->SetLineColor(kYellow);\r
+ acoMultiBoxAMU->SetLineWidth(2);\r
+ acoMultiBoxAMU->AddText("FLAG MESSAGE: ACO. O.K., warning, some modules are not working properly");\r
+ //acoMultiBox->AddText("NOTE: if entries below the pink line and ACO is triggering, then call the expert (possible empty events)");\r
+ h3->GetListOfFunctions()->Add(acoMultiBoxAMU);\r
+ }\r
+ \r
+ // Checks if hits distribution from SL0 and AMU are equal\r
+ Float_t eff = 0.0;\r
+ Int_t effFlag = 0;\r
+ //\r
+ TH1* h4 = (TH1*)harr[4];\r
+ if (h4) {\r
+ for (Int_t iModule = 0; iModule < 60; iModule++) {\r
+ if (h2->GetBinContent(iModule)==0) {\r
+ eff = 0.0;\r
+ continue;\r
+ }\r
+ else {\r
+ eff = h0->GetBinContent(iModule)/h2->GetBinContent(iModule);\r
+ h4->Fill(iModule,eff);\r
+ if (eff!=1) effFlag++;\r
+ }\r
+ }\r
+ \r
+ if (effFlag == 0) {\r
+ TPaveText *checkTriggerBox = new TPaveText(20,0.6,40,0.8,"b");\r
+ checkTriggerBox->SetFillColor(kGreen);\r
+ checkTriggerBox->SetLineColor(kGreen);\r
+ checkTriggerBox->SetLineWidth(2);\r
+ checkTriggerBox->AddText("FLAG MESSAGE: ACO. trigger O.K.");\r
+ h4->GetListOfFunctions()->Add(checkTriggerBox);\r
+ }\r
+ else {\r
+ TPaveText *checkTriggerBox1 = new TPaveText(20,0.6,40,0.8,"b");\r
+ checkTriggerBox1->SetFillColor(kYellow);\r
+ checkTriggerBox1->SetLineColor(kYellow);\r
+ checkTriggerBox1->SetLineWidth(2);\r
+ checkTriggerBox1->AddText("FLAG MESSAGE: Warning, please check the ACO trigger configuration");\r
+ h4->GetListOfFunctions()->Add(checkTriggerBox1);\r
+ }\r
+ } // h4\r
+ } // end of trigger classes loop\r
+ } // end specie loop\r
+ // QA Checker standar (to be updated)\r
+ //\r
AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;\r
}\r
\r
const Bool_t expert = kTRUE ; \r
const Bool_t saveCorr = kTRUE ; \r
const Bool_t image = kTRUE ; \r
-/* const char *acoModule[60]={"0_0","0_1","0_2","0_3","0_4","0_5","0_6","0_7","0_8","0_9",\r
+ /*\r
+ const char *acoModule[60]={"0_0","0_1","0_2","0_3","0_4","0_5","0_6","0_7","0_8","0_9",\r
"1_0","1_1","1_2","1_3","1_4","1_5","1_6","1_7","1_8","1_9",\r
"2_0","2_1","2_2","2_3","2_4","2_5","2_6","2_7","2_8","2_9",\r
"3_0","3_1","3_2","3_3","3_4","3_5","3_6","3_7","3_8","3_9",\r
"4_0","4_1","4_2","4_3","4_4","4_5","4_6","4_7","4_8","4_9",\r
"5_0","5_1","5_2","5_3","5_4","5_5","5_6","5_7","5_8","5_9"};\r
-*/\r
-\r
- // TH1F *fhACORDEBitPattern[4];\r
- //TH1F *fhACORDEBitPatternDQM;\r
-// fhACORDEBitPattern[0] = new TH1F("ACORDEBitPatternfromRAWSingle","Distribution of ACORDE fired modules from RAW-Single;Modules;Counts",60,-0.5,59.5);//AcordeSingleMuon BitPattern\r
-// fhACORDEBitPattern[1] = new TH1F("ACORDEBitPatternfromRAWMulti","Distribution of ACORDE fired modules from RAW-Multi;Modules;Counts",60,-0.5,59.5);//AcordeMultiMuon BitPattern\r
-// fhACORDEBitPattern[2] = new TH1F("ACORDEMultiplicityfromRAWSingle","Number of fired ACORDE modules;No. of fired ACORDE modules;No. of events in ACORDE",61,-1,60);//AcordeSingleMuon Multiplicity\r
-// fhACORDEBitPattern[3] = new TH1F("ACORDEMultiplicityfromRAWMulti","Number of fired ACORDE modules; No. of fired ACORDE modules;No. of events in ACORDE",61,-1,60);//AcordeMultiMuon Multiplicity\r
- TH1F * fhACORDEBitPatternDQM = new TH1F("ACOHitsSL0_DQM_Shifter","Distribution of ACORDE fired modules for DQM shifter; No. of module; Counts",60,-0.5,59.5);// Hits histogram for QA-shifter ACO-SL0 trigger mode\r
- TH1F * fhACORDEMultiplicitySL0DQM = new TH1F("ACOMultiSL0_DQM_Shifter","Multiplicity of ACORDE fired modules for DQM shifter; No. of fired modules; No. of events",62,-1,60); // Multiplicity histo. for QA-shifter ACO-SL0 trigger mode\r
- TH1F * fhACORDEBitPatternAMUDQM = new TH1F("ACOHitsAMU_DQM_Shifter","Distribution of ACORDE fired modules for DQM shifter; No. of module; Counts",60,-0.5,59.5);// Hits histogram for QA-shifter ACO-SL0 trigger mode\r
- TH1F * fhACORDEMultiplicityAMUDQM = new TH1F("ACOMultiAMU_DQM_Shifter","Multiplicity of ACORDE fired modules for DQM shifter; No. of fired modules; No. of events",62,-1,60); // Multiplicity histo. for QA-shifter ACO-SL0 trigger mode\r
- TH1F * fhACORDEBitPatternCheckDQM = new TH1F("ACOHitsTriggerCheck_DQMExpert","Check distribution for ACORDE trigger configuration; No. of module; Trigger hits difference",60,-0.5,59.5); // Check the trigger status of ACORDE (SL0 vs AMU)\r
- // Expert histograms\r
-// for(Int_t i=0;i<4;i++) \r
-// Add2RawsList(fhACORDEBitPattern[i],i,expert, !image, !saveCorr);\r
- // Check the hits multiplicity from trigger configuration\r
- Add2RawsList(fhACORDEBitPatternCheckDQM,4,expert,image,!saveCorr);\r
- fhACORDEBitPatternCheckDQM->SetFillColor(kOrange);\r
- // AMORE diplay settings for shifter on GUI\r
- \r
- // For SL0 ACO trigger mode\r
- \r
- Add2RawsList(fhACORDEBitPatternDQM,0,!expert,image,!saveCorr);\r
- Add2RawsList(fhACORDEMultiplicitySL0DQM,1,!expert,image,!saveCorr);\r
- \r
- // For Hits distribution on ACORDE\r
- \r
- fhACORDEBitPatternDQM->SetFillColor(kCyan-7);\r
- fhACOMean->SetLineColor(kBlue);\r
- fhACOMean->SetLineStyle(2);\r
- fhACOMean->SetLineWidth(4);\r
- fhACORDEBitPatternDQM->GetListOfFunctions()->Add(fhACOMean);\r
- fhACOMin->SetLineColor(kGreen);\r
- fhACOMin->SetLineStyle(2);\r
- fhACOMin->SetLineWidth(4);\r
- fhACORDEBitPatternDQM->GetListOfFunctions()->Add(fhACOMin);\r
- fhACOMax->SetLineColor(kGreen);\r
- fhACOMax->SetLineStyle(2);\r
- fhACOMax->SetLineWidth(4);\r
- fhACORDEBitPatternDQM->GetListOfFunctions()->Add(fhACOMax);\r
- \r
- // For ACORDE Multiplicity distribution of fired modules\r
- \r
- fhACORDEMultiplicitySL0DQM->SetFillColor(kBlue+1);\r
- fhACOMulti->SetLineColor(kMagenta);\r
- fhACOMulti->SetLineStyle(2);\r
- fhACOMulti->SetLineWidth(4);\r
- fhACORDEMultiplicitySL0DQM->GetListOfFunctions()->Add(fhACOMulti);\r
- \r
- // For AMU ACO trigger mode\r
- \r
- Add2RawsList(fhACORDEBitPatternAMUDQM,2,!expert,image,!saveCorr);\r
- Add2RawsList(fhACORDEMultiplicityAMUDQM,3,!expert,image,!saveCorr);\r
- \r
- // For Hits distribution on ACORDE\r
- \r
- fhACORDEBitPatternAMUDQM->SetFillColor(kCyan-7);\r
- fhACOMeanAMU->SetLineColor(kBlue);\r
- fhACOMeanAMU->SetLineStyle(2);\r
- fhACOMeanAMU->SetLineWidth(4);\r
- fhACORDEBitPatternAMUDQM->GetListOfFunctions()->Add(fhACOMeanAMU);\r
- fhACOMinAMU->SetLineColor(kGreen);\r
- fhACOMinAMU->SetLineStyle(2);\r
- fhACOMinAMU->SetLineWidth(4);\r
- fhACORDEBitPatternAMUDQM->GetListOfFunctions()->Add(fhACOMinAMU);\r
- fhACOMaxAMU->SetLineColor(kGreen);\r
- fhACOMaxAMU->SetLineStyle(2);\r
- fhACOMaxAMU->SetLineWidth(4);\r
- fhACORDEBitPatternAMUDQM->GetListOfFunctions()->Add(fhACOMaxAMU);\r
- \r
- // For ACORDE Multiplicity distribution of fired modules\r
- \r
- fhACORDEMultiplicityAMUDQM->SetFillColor(kBlue+1);\r
- fhACOMultiAMU->SetLineColor(kMagenta);\r
- fhACOMultiAMU->SetLineStyle(2);\r
- fhACOMultiAMU->SetLineWidth(4);\r
- fhACORDEMultiplicityAMUDQM->GetListOfFunctions()->Add(fhACOMultiAMU);\r
- \r
- /*\r
+ */\r
+ // TH1F *fhACORDEBitPattern[4];\r
+ //TH1F *fhACORDEBitPatternDQM;\r
+ // fhACORDEBitPattern[0] = new TH1F("ACORDEBitPatternfromRAWSingle","Distribution of ACORDE fired modules from RAW-Single;Modules;Counts",60,-0.5,59.5);//AcordeSingleMuon BitPattern\r
+ // fhACORDEBitPattern[1] = new TH1F("ACORDEBitPatternfromRAWMulti","Distribution of ACORDE fired modules from RAW-Multi;Modules;Counts",60,-0.5,59.5);//AcordeMultiMuon BitPattern\r
+ // fhACORDEBitPattern[2] = new TH1F("ACORDEMultiplicityfromRAWSingle","Number of fired ACORDE modules;No. of fired ACORDE modules;No. of events in ACORDE",61,-1,60);//AcordeSingleMuon Multiplicity\r
+ // fhACORDEBitPattern[3] = new TH1F("ACORDEMultiplicityfromRAWMulti","Number of fired ACORDE modules; No. of fired ACORDE modules;No. of events in ACORDE",61,-1,60);//AcordeMultiMuon Multiplicity\r
+ TH1F * fhACORDEBitPatternDQM = new TH1F("ACOHitsSL0_DQM_Shifter","Distribution of ACORDE fired modules for DQM shifter; No. of module; Counts",60,-0.5,59.5);// Hits histogram for QA-shifter ACO-SL0 trigger mode\r
+ TH1F * fhACORDEMultiplicitySL0DQM = new TH1F("ACOMultiSL0_DQM_Shifter","Multiplicity of ACORDE fired modules for DQM shifter; No. of fired modules; No. of events",62,-1,60); // Multiplicity histo. for QA-shifter ACO-SL0 trigger mode\r
+ TH1F * fhACORDEBitPatternAMUDQM = new TH1F("ACOHitsAMU_DQM_Shifter","Distribution of ACORDE fired modules for DQM shifter; No. of module; Counts",60,-0.5,59.5);// Hits histogram for QA-shifter ACO-SL0 trigger mode\r
+ TH1F * fhACORDEMultiplicityAMUDQM = new TH1F("ACOMultiAMU_DQM_Shifter","Multiplicity of ACORDE fired modules for DQM shifter; No. of fired modules; No. of events",62,-1,60); // Multiplicity histo. for QA-shifter ACO-SL0 trigger mode\r
+ TH1F * fhACORDEBitPatternCheckDQM = new TH1F("ACOHitsTriggerCheck_DQMExpert","Check distribution for ACORDE trigger configuration; No. of module; Trigger hits difference",60,-0.5,59.5); // Check the trigger status of ACORDE (SL0 vs AMU)\r
+ // Expert histograms\r
+ // for(Int_t i=0;i<4;i++)\r
+ // Add2RawsList(fhACORDEBitPattern[i],i,expert, !image, !saveCorr);\r
+ // Check the hits multiplicity from trigger configuration\r
+ Add2RawsList(fhACORDEBitPatternCheckDQM,4,expert,image,!saveCorr);\r
+ fhACORDEBitPatternCheckDQM->SetFillColor(kOrange);\r
+ // AMORE diplay settings for shifter on GUI\r
+ \r
+ // For SL0 ACO trigger mode\r
+ \r
+ Add2RawsList(fhACORDEBitPatternDQM,0,!expert,image,!saveCorr);\r
+ ForbidCloning(fhACORDEBitPatternDQM);\r
+ Add2RawsList(fhACORDEMultiplicitySL0DQM,1,!expert,image,!saveCorr);\r
+ ForbidCloning(fhACORDEMultiplicitySL0DQM);\r
+ // For Hits distribution on ACORDE\r
+ \r
+ fhACORDEBitPatternDQM->SetFillColor(kCyan-7);\r
+ fhACOMean->SetLineColor(kBlue);\r
+ fhACOMean->SetLineStyle(2);\r
+ fhACOMean->SetLineWidth(4);\r
+ fhACORDEBitPatternDQM->GetListOfFunctions()->Add(fhACOMean);\r
+ fhACOMin->SetLineColor(kGreen);\r
+ fhACOMin->SetLineStyle(2);\r
+ fhACOMin->SetLineWidth(4);\r
+ fhACORDEBitPatternDQM->GetListOfFunctions()->Add(fhACOMin);\r
+ fhACOMax->SetLineColor(kGreen);\r
+ fhACOMax->SetLineStyle(2);\r
+ fhACOMax->SetLineWidth(4);\r
+ fhACORDEBitPatternDQM->GetListOfFunctions()->Add(fhACOMax);\r
+ \r
+ // For ACORDE Multiplicity distribution of fired modules\r
+ \r
+ fhACORDEMultiplicitySL0DQM->SetFillColor(kBlue+1);\r
+ fhACOMulti->SetLineColor(kMagenta);\r
+ fhACOMulti->SetLineStyle(2);\r
+ fhACOMulti->SetLineWidth(4);\r
+ fhACORDEMultiplicitySL0DQM->GetListOfFunctions()->Add(fhACOMulti);\r
+ \r
+ // For AMU ACO trigger mode\r
+ \r
+ Add2RawsList(fhACORDEBitPatternAMUDQM,2,!expert,image,!saveCorr);\r
+ Add2RawsList(fhACORDEMultiplicityAMUDQM,3,!expert,image,!saveCorr);\r
+ \r
+ // For Hits distribution on ACORDE\r
+ \r
+ fhACORDEBitPatternAMUDQM->SetFillColor(kCyan-7);\r
+ fhACOMeanAMU->SetLineColor(kBlue);\r
+ fhACOMeanAMU->SetLineStyle(2);\r
+ fhACOMeanAMU->SetLineWidth(4);\r
+ fhACORDEBitPatternAMUDQM->GetListOfFunctions()->Add(fhACOMeanAMU);\r
+ fhACOMinAMU->SetLineColor(kGreen);\r
+ fhACOMinAMU->SetLineStyle(2);\r
+ fhACOMinAMU->SetLineWidth(4);\r
+ fhACORDEBitPatternAMUDQM->GetListOfFunctions()->Add(fhACOMinAMU);\r
+ fhACOMaxAMU->SetLineColor(kGreen);\r
+ fhACOMaxAMU->SetLineStyle(2);\r
+ fhACOMaxAMU->SetLineWidth(4);\r
+ fhACORDEBitPatternAMUDQM->GetListOfFunctions()->Add(fhACOMaxAMU);\r
+ \r
+ // For ACORDE Multiplicity distribution of fired modules\r
+ \r
+ fhACORDEMultiplicityAMUDQM->SetFillColor(kBlue+1);\r
+ fhACOMultiAMU->SetLineColor(kMagenta);\r
+ fhACOMultiAMU->SetLineStyle(2);\r
+ fhACOMultiAMU->SetLineWidth(4);\r
+ fhACORDEMultiplicityAMUDQM->GetListOfFunctions()->Add(fhACOMultiAMU);\r
+ \r
+ /*\r
for (Int_t iModule = 0; iModule<60; iModule++)\r
{\r
- fhACORDEBitPattern[0]->GetXaxis()->SetBinLabel(iModule+1,acoModule[iModule]);\r
- fhACORDEBitPattern[1]->GetXaxis()->SetBinLabel(iModule+1,acoModule[iModule]);\r
+ fhACORDEBitPattern[0]->GetXaxis()->SetBinLabel(iModule+1,acoModule[iModule]);\r
+ fhACORDEBitPattern[1]->GetXaxis()->SetBinLabel(iModule+1,acoModule[iModule]);\r
}\r
-*/\r
+ */\r
+ //\r
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line\r
}\r
+\r
//____________________________________________________________________________ \r
void AliACORDEQADataMakerRec::InitDigits()\r
{\r
fhDigitsModule = new TH1F("ACORDEBitPatternfromDigits","Distribution of ACORDE from DIGITS;Modules;Counts",60,1,60);\r
Add2DigitsList(fhDigitsModule,0,!expert,image);\r
for (Int_t i=0;i<60;i++) fhDigitsModule->GetXaxis()->SetBinLabel(i+1,acoModule[i]); \r
+ //\r
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line\r
}\r
\r
//____________________________________________________________________________ \r
{\r
// create cluster histograms in RecPoint subdir\r
// Not needed for ACORDE by now !!!\r
+ //\r
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line\r
}\r
\r
//____________________________________________________________________________\r
fhESDsSingle->GetXaxis()->SetBinLabel(i+1,acoModule[i]);\r
fhESDsMulti->GetXaxis()->SetBinLabel(i+1,acoModule[i]);\r
}\r
-\r
-\r
+ //\r
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line\r
}\r
//____________________________________________________________________________\r
void AliACORDEQADataMakerRec::MakeRaws(AliRawReader* rawReader)\r
{\r
//fills QA histos for RAW\r
-\r
+ IncEvCountCycleRaws();\r
+ IncEvCountTotalRaws();\r
rawReader->Reset();\r
AliACORDERawStream rawStream(rawReader);\r
size_t contSingle=0;\r
tmpDy>>=1;\r
}\r
contSingle=0;\r
- for(Int_t r=0;r<60;r++)\r
- {\r
- if(kroSingle[r]==1)\r
- {\r
- GetRawsData(0)->Fill(r);\r
- //GetRawsData(4)->Fill(r);\r
- contSingle++;\r
- }\r
- }GetRawsData(1)->Fill(contSingle);//GetRawsData(5)->Fill(contSingle);\r
- contMulti=0;\r
+ contMulti=0;\r
for(Int_t r=0;r<60;r++)\r
{\r
+ if(kroSingle[r]==1)\r
+ {\r
+ FillRawsData(0,r);\r
+ //FillRawsData(4,r);\r
+ contSingle++;\r
+ }\r
if(kroMulti[r]==1)\r
{\r
- GetRawsData(2)->Fill(r);\r
- //GetRawsData(6)->Fill(r);\r
- contMulti++;\r
+ FillRawsData(2,r);\r
+ //FillRawsData(6,r);\r
+ contMulti++;\r
}\r
-\r
- }GetRawsData(3)->Fill(contMulti);//GetRawsData(7)->Fill(contMulti);\r
+ \r
+ } \r
+ FillRawsData(3,contSingle); \r
+ FillRawsData(7,contMulti);\r
}\r
}\r
//____________________________________________________________________________\r
void AliACORDEQADataMakerRec::MakeDigits( TTree *digitsTree)\r
{\r
//fills QA histos for Digits\r
+ IncEvCountCycleDigits();\r
+ IncEvCountTotalDigits();\r
+\r
if (fDigitsArray) \r
fDigitsArray->Clear() ; \r
else \r
AliError("The unchecked digit doesn't exist");\r
continue ;\r
}\r
- GetDigitsData(0)->Fill(AcoDigit->GetModule()-1);\r
+ FillDigitsData(0,AcoDigit->GetModule()-1);\r
}\r
}\r
}\r
void AliACORDEQADataMakerRec::MakeESDs(AliESDEvent * esd)\r
{\r
//fills QA histos for ESD\r
-\r
+ IncEvCountCycleESDs();\r
+ IncEvCountTotalESDs();\r
+ //\r
AliESDACORDE * fESDACORDE= esd->GetACORDEData();\r
Int_t acoMulti=0;\r
for(int i=0;i<60;i++)\r
{\r
- if(fESDACORDE->GetHitChannel(i)) \r
- {\r
- GetESDsData(0)->Fill(i+1);\r
- GetESDsData(1)->Fill(i+1);\r
- acoMulti++;\r
+ if(fESDACORDE->GetHitChannel(i)) \r
+ {\r
+ FillESDsData(0,i+1);\r
+ FillESDsData(1,i+1);\r
+ acoMulti++;\r
}\r
- }GetESDsData(2)->Fill(acoMulti);\r
+ } FillESDsData(2,acoMulti);\r
\r
}\r
#include "AliQADataMakerRec.h"
#include <TLine.h>
+
class AliACORDEQADataMakerRec: public AliQADataMakerRec {
public:
AliACORDEQADataMakerRec() ; // constructor
AliACORDEQADataMakerRec(const AliACORDEQADataMakerRec& qadm) ;
AliACORDEQADataMakerRec& operator = (const AliACORDEQADataMakerRec& qadm) ;
- virtual ~AliACORDEQADataMakerRec();// destructor
+ virtual ~AliACORDEQADataMakerRec(); // destructor
private:
virtual void InitRaws() ; //book Digit QA histo
virtual void MakeRaws(AliRawReader* rawReader) ;
virtual void MakeESDs(AliESDEvent * esd) ; //Fill hit QA histo
virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** list) ;
- virtual void StartOfDetectorCycle() ;
-
- //For DQM shifter histogram
- // SL0 ACO trigger mode
- TLine* fhACOMean;
- TLine* fhACOMin;
- TLine* fhACOMax;
- TLine* fhACOMulti;
- // AMU trigger mode
- TLine* fhACOMeanAMU;
- TLine* fhACOMinAMU;
- TLine* fhACOMaxAMU;
- TLine* fhACOMultiAMU;
- // Trigger check (4 words from hits multiplicity)
- TLine* fhACOTriggerCheck;
-
+ virtual void StartOfDetectorCycle();
+ //
+ //For DQM shifter histogram
+ // SL0 ACO trigger mode
+ TLine* fhACOMean;
+ TLine* fhACOMin;
+ TLine* fhACOMax;
+ TLine* fhACOMulti;
+ // AMU trigger mode
+ TLine* fhACOMeanAMU;
+ TLine* fhACOMinAMU;
+ TLine* fhACOMaxAMU;
+ TLine* fhACOMultiAMU;
+ // Trigger check (4 words from hits multiplicity)
+ TLine* fhACOTriggerCheck;
+ //
ClassDef(AliACORDEQADataMakerRec,1) // description
};
{
//Detector specific actions at end of cycle
// do the QA checking
+ ResetEventTrigClasses(); // reset triggers list to select all histos
AliDebug(AliQAv1::GetQADebugLevel(), "ACORDE---->Detector specific actions at END of cycle\n................\n");
AliQAChecker::Instance()->Run(AliQAv1::kACORDE, task, list) ;
void AliACORDEQADataMakerSim::InitHits()
{
// create Hits histograms in Hits subdir
-
+
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
TH1F * fHitsACORDE;
-
- fHitsACORDE = new TH1F("ACORDEBitPatternfromHits","Distribution of ACORDE fired modules from HITS",60,1,60);
- Add2HitsList(fHitsACORDE,0,!expert,image);
-
- const char *acoModule[60]={"0_0","0_1","0_2","0_3","0_4","0_5","0_6","0_7","0_8","0_9",
- "1_0","1_1","1_2","1_3","1_4","1_5","1_6","1_7","1_8","1_9",
- "2_0","2_1","2_2","2_3","2_4","2_5","2_6","2_7","2_8","2_9",
- "3_0","3_1","3_2","3_3","3_4","3_5","3_6","3_7","3_8","3_9",
- "4_0","4_1","4_2","4_3","4_4","4_5","4_6","4_7","4_8","4_9",
- "5_0","5_1","5_2","5_3","5_4","5_5","5_6","5_7","5_8","5_9"};
-
-
- fHitsACORDE->SetXTitle("Modules");
- fHitsACORDE->SetYTitle("Counts");
- for (Int_t i=0;i<60;i++)
- {
- fHitsACORDE->GetXaxis()->SetBinLabel(i+1,acoModule[i]);
- }
-
-
-
+
+ fHitsACORDE = new TH1F("ACORDEBitPatternfromHits","Distribution of ACORDE fired modules from HITS",60,1,60);
+ Add2HitsList(fHitsACORDE,0,!expert,image);
+
+ const char *acoModule[60]={"0_0","0_1","0_2","0_3","0_4","0_5","0_6","0_7","0_8","0_9",
+ "1_0","1_1","1_2","1_3","1_4","1_5","1_6","1_7","1_8","1_9",
+ "2_0","2_1","2_2","2_3","2_4","2_5","2_6","2_7","2_8","2_9",
+ "3_0","3_1","3_2","3_3","3_4","3_5","3_6","3_7","3_8","3_9",
+ "4_0","4_1","4_2","4_3","4_4","4_5","4_6","4_7","4_8","4_9",
+ "5_0","5_1","5_2","5_3","5_4","5_5","5_6","5_7","5_8","5_9"};
+
+
+ fHitsACORDE->SetXTitle("Modules");
+ fHitsACORDE->SetYTitle("Counts");
+ for (Int_t i=0;i<60;i++)
+ {
+ fHitsACORDE->GetXaxis()->SetBinLabel(i+1,acoModule[i]);
+ }
+ //
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
+
//____________________________________________________________________________
void AliACORDEQADataMakerSim::InitDigits()
{
"3_0","3_1","3_2","3_3","3_4","3_5","3_6","3_7","3_8","3_9",
"4_0","4_1","4_2","4_3","4_4","4_5","4_6","4_7","4_8","4_9",
"5_0","5_1","5_2","5_3","5_4","5_5","5_6","5_7","5_8","5_9"};
-
-
- fhDigitsModule->SetXTitle("Modules");
- fhDigitsModule->SetYTitle("Counts");
- for (Int_t i=0;i<60;i++)
- {
- fhDigitsModule->GetXaxis()->SetBinLabel(i+1,acoModule[i]);
- }
-
-
+
+
+ fhDigitsModule->SetXTitle("Modules");
+ fhDigitsModule->SetYTitle("Counts");
+ for (Int_t i=0;i<60;i++)
+ {
+ fhDigitsModule->GetXaxis()->SetBinLabel(i+1,acoModule[i]);
+ }
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
-//____________________________________________________________________________
+//____________________________________________________________________________
void AliACORDEQADataMakerSim::MakeHits(TTree *hitTree)
{
// Here we fill the QA histos for Hits declared above
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
if (fHitsArray)
fHitsArray->Clear() ;
AliError("The unchecked hit doesn't exist");
continue ;
}
- GetHitsData(0)->Fill(AcoHit->GetModule());
+ FillHitsData(0,AcoHit->GetModule());
}
}
}
void AliACORDEQADataMakerSim::MakeDigits( TTree *digitsTree)
{
//fills QA histos for Digits
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+
if (fDigitsArray)
fDigitsArray->Clear() ;
else
AliError("The unchecked digit doesn't exist");
continue ;
}
- GetDigitsData(0)->Fill(AcoDigit->GetModule());
+ FillDigitsData(0,AcoDigit->GetModule());
}
}
}
// GetRawsData(kNEventsPerTower)->Scale(1./fCycleCounter);
// do the QA checking
+ ResetEventTrigClasses(); // reset triggers list to select all histos
AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;
}
TH1I * h4 = new TH1I("hESDCaloCellM", "ESDs CaloCell multiplicity in EMCAL;# of Clusters;Entries", 200, 0, 1000) ;
h4->Sumw2() ;
Add2ESDsList(h4, kESDCaloCellM, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL;# of Digits;Entries", 200, 0, 2000) ;
h1->Sumw2() ;
Add2DigitsList(h1, 1, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1I* h2 = new TH1I("hEMCALRpDigM","EMCAL RecPoint Digit Multiplicities;# of Digits;Entries",20,0,20);
h2->Sumw2();
Add2RecPointsList(h2,kRecPDigM, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
h15->SetDirectory(0);
Add2RawsList(h15, k2DRatioAmp, !expert, image, !saveCorr) ;
- TH1F * h16 = new TH1F("hRatioDist", "Amplitude_{current run}/Amplitude_{reference run} ratio distribution", nTot, 0., 2.);
+ TH1F * h16 = new TH1F("hRatioDist", "Amplitude_{current run}/Amplitude_{reference run} ratio distribution", nTot, 0., 2.);
h16->SetMinimum(0.1);
h16->SetMaximum(100.);
gStyle->SetOptStat(0);
Add2RawsList(hL11, kLEDMonRatioDist, !expert, image, !saveCorr) ;
GetCalibRefFromOCDB();
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
for ( Int_t index = 0; index < esd->GetNumberOfCaloClusters() ; index++ ) {
AliESDCaloCluster * clu = esd->GetCaloCluster(index) ;
if( clu->IsEMCAL() ) {
- GetESDsData(kESDCaloClusE)->Fill(clu->E()) ;
+ FillESDsData(kESDCaloClusE,clu->E()) ;
nTot++ ;
}
}
- GetESDsData(kESDCaloClusM)->Fill(nTot) ;
+ FillESDsData(kESDCaloClusM,nTot) ;
//fill calo cells
AliESDCaloCells* cells = esd->GetEMCALCells();
- GetESDsData(kESDCaloCellM)->Fill(cells->GetNumberOfCells()) ;
+ FillESDsData(kESDCaloCellM,cells->GetNumberOfCells()) ;
for ( Int_t index = 0; index < cells->GetNumberOfCells() ; index++ ) {
- GetESDsData(kESDCaloCellA)->Fill(cells->GetAmplitude(index)) ;
+ FillESDsData(kESDCaloCellA,cells->GetAmplitude(index)) ;
}
-
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
}
//____________________________________________________________________________
void AliEMCALQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
- // Check that all the reference histograms exist before we try to use them - otherwise call InitRaws
+ // Check that all the reference histograms exist before we try to use them - otherwise call InitRaws
+ // RS: Attention: the counters are increments after custom modification of eventSpecie
if (!fCalibRefHistoPro || !fCalibRefHistoH2F || !fLEDMonRefHistoPro || !fHighEmcHistoH2F) {
InitRaws();
}
if (rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent) {
SetEventSpecie(AliRecoParam::kCalib) ;
}
-
+
const Int_t nTowersPerSM = AliEMCALGeoParams::fgkEMCALRows * AliEMCALGeoParams::fgkEMCALCols; // number of towers in a SuperModule; 24x48
const Int_t nRows = AliEMCALGeoParams::fgkEMCALRows; // number of rows per SuperModule
const Int_t nStripsPerSM = AliEMCALGeoParams::fgkEMCALLEDRefs; // number of strips per SuperModule
if(iTRUIdInSM < n2x2PerTRU) {
Int_t iTRUAbsId = iTRUIdInSM + n2x2PerTRU * iTRUId;
// Fill the histograms
- GetRawsData(kNL0TRU)->Fill(iTRUAbsId);
- GetRawsData(kTimeL0TRU)->Fill(iTRUAbsId, startBin);
+ FillRawsData(kNL0TRU,iTRUAbsId);
+ FillRawsData(kTimeL0TRU,iTRUAbsId, startBin);
}
}
}
if ( in.IsLowGain() ) {
nTotalSMLG[iSM]++;
if ( (amp > fMinSignalLG) && (amp < fMaxSignalLG) ) {
- GetRawsData(kSigLG)->Fill(towerId, amp);
- GetRawsData(kTimeLG)->Fill(towerId, time);
+ FillRawsData(kSigLG,towerId, amp);
+ FillRawsData(kTimeLG,towerId, time);
}
if (nPed > 0) {
for (Int_t i=0; i<nPed; i++) {
- GetRawsData(kPedLG)->Fill(towerId, pedSamples[i]);
+ FillRawsData(kPedLG,towerId, pedSamples[i]);
}
}
} // gain==0
else if ( in.IsHighGain() ) {
nTotalSMHG[iSM]++;
if ( (amp > fMinSignalHG) && (amp < fMaxSignalHG) ) {
- GetRawsData(kSigHG)->Fill(towerId, amp);
- GetRawsData(kTimeHG)->Fill(towerId, time);
+ FillRawsData(kSigHG,towerId, amp);
+ FillRawsData(kTimeHG,towerId, time);
}
if (nPed > 0) {
for (Int_t i=0; i<nPed; i++) {
- GetRawsData(kPedHG)->Fill(towerId, pedSamples[i]);
+ FillRawsData(kPedHG,towerId, pedSamples[i]);
}
}
} // gain==1
+ in.GetColumn();
nTotalSMTRU[iSM]++;
if ( (amp > fMinSignalTRU) && (amp < fMaxSignalTRU) ) {
- GetRawsData(kSigTRU)->Fill(iTRU2x2Id, amp);
- GetRawsData(kTimeTRU)->Fill(iTRU2x2Id, time);
+ FillRawsData(kSigTRU,iTRU2x2Id, amp);
+ FillRawsData(kTimeTRU,iTRU2x2Id, time);
}
if (nPed > 0) {
for (Int_t i=0; i<nPed; i++) {
- GetRawsData(kPedTRU)->Fill(iTRU2x2Id, pedSamples[i]);
+ FillRawsData(kPedTRU,iTRU2x2Id, pedSamples[i]);
}
}
}
if ( gain == 0 ) {
nTotalSMLGLEDMon[iSM]++;
if ( (amp > fMinSignalLGLEDMon) && (amp < fMaxSignalLGLEDMon) ) {
- GetRawsData(kSigLGLEDMon)->Fill(stripId, amp);
- GetRawsData(kTimeLGLEDMon)->Fill(stripId, time);
+ FillRawsData(kSigLGLEDMon,stripId, amp);
+ FillRawsData(kTimeLGLEDMon,stripId, time);
}
if (nPed > 0) {
for (Int_t i=0; i<nPed; i++) {
- GetRawsData(kPedLGLEDMon)->Fill(stripId, pedSamples[i]);
+ FillRawsData(kPedLGLEDMon,stripId, pedSamples[i]);
}
}
} // gain==0
else if ( gain == 1 ) {
nTotalSMHGLEDMon[iSM]++;
if ( (amp > fMinSignalHGLEDMon) && (amp < fMaxSignalHGLEDMon) ) {
- GetRawsData(kSigHGLEDMon)->Fill(stripId, amp);
- GetRawsData(kTimeHGLEDMon)->Fill(stripId, time);
+ FillRawsData(kSigHGLEDMon,stripId, amp);
+ FillRawsData(kTimeHGLEDMon,stripId, time);
}
if (nPed > 0) {
for (Int_t i=0; i<nPed; i++) {
- GetRawsData(kPedHGLEDMon)->Fill(stripId, pedSamples[i]);
+ FillRawsData(kPedHGLEDMon,stripId, pedSamples[i]);
}
}
} // low or high gain
}//end while over DDL's, of input stream
- // TProfile * p = dynamic_cast<TProfile *>(GetRawsData(kSigHG)) ;
- ConvertProfile2H(dynamic_cast<TProfile *>(GetRawsData(kSigHG)), fHighEmcHistoH2F) ;
- Double_t binContent = 0. ;
-
//calculate the ratio of the amplitude and fill the histograms, only if the events type is Calib
- if (rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent) {
- //reset ratio histograms
- GetRawsData(k2DRatioAmp)->Reset("ICE");
- GetRawsData(kRatioDist)->Reset("ICE");
- GetRawsData(kLEDMonRatio)->Reset("ICE");
- GetRawsData(kLEDMonRatioDist)->Reset("ICE");
- GetRawsData(k2DRatioAmp)->ResetStats();
- GetRawsData(kRatioDist)->ResetStats();
- GetRawsData(kLEDMonRatio)->ResetStats();
- GetRawsData(kLEDMonRatioDist)->ResetStats();
-
- for(Int_t ix = 1; ix <= fHighEmcHistoH2F->GetNbinsX(); ix++) {
- for(Int_t iy = 1; iy <= fHighEmcHistoH2F->GetNbinsY(); iy++) {
- if(fCalibRefHistoH2F->GetBinContent(ix, iy))binContent = fHighEmcHistoH2F->GetBinContent(ix, iy)/fCalibRefHistoH2F->GetBinContent(ix, iy) ;
- GetRawsData(k2DRatioAmp)->SetBinContent(ix, iy, binContent);
- GetRawsData(kRatioDist)->Fill(GetRawsData(k2DRatioAmp)->GetBinContent(ix, iy));
+ // RS: operation on the group of histos kSigHG,k2DRatioAmp,kRatioDist,kLEDMonRatio,kLEDMonRatio,kSigLGLEDMon
+ const int hGrp[] = {kSigHG,k2DRatioAmp,kRatioDist,kLEDMonRatio,kLEDMonRatio,kSigLGLEDMon};
+ if ( rawReader->GetType() == AliRawEventHeaderBase::kCalibrationEvent &&
+ CheckCloningConsistency(fRawsQAList, hGrp, sizeof(hGrp)/sizeof(int)) ) { // RS converting original code to loop over all matching triggers
+ int nTrig =IsClonedPerTrigClass(kSigHG,fRawsQAList) ? GetNEventTrigClasses() : 0; // loop over triggers only if histos were cloned
+ //
+ for (int itr=-1;itr<nTrig;itr++) { // start from -1 to acknowledge original histos if they were kept
+ TObjArray* trArr = GetMatchingRawsHistosSet(hGrp, sizeof(hGrp)/sizeof(int) ,itr);
+ if (!trArr) continue; // no histos for current trigger
+ //
+ Double_t binContent = 0.;
+ TProfile* prSigHG = (TProfile *)trArr->At(0); //kSigHG
+ TH1* th2DRatioAmp = (TH1*) trArr->At(1); //k2DRatioAmp
+ TH1* thRatioDist = (TH1*) trArr->At(2); //kRatioDist
+ TH1* thLEDMonRatio = (TH1*) trArr->At(3); //kLEDMonRatio
+ TH1* thLEDMonRatioDist = (TH1*) trArr->At(4); //kLEDMonRatio
+ TH1* hSigLGLEDMon = (TH1*) trArr->At(5); //kSigLGLEDMon
+ th2DRatioAmp->Reset("ICE");
+ thRatioDist->Reset("ICE");
+ thLEDMonRatio->Reset("ICE");
+ thLEDMonRatioDist->Reset("ICE");
+ th2DRatioAmp->ResetStats();
+ thRatioDist->ResetStats();
+ thLEDMonRatio->ResetStats();
+ thLEDMonRatioDist->ResetStats();
+ ConvertProfile2H(prSigHG, fHighEmcHistoH2F);
+ //
+ for(Int_t ix = 1; ix <= fHighEmcHistoH2F->GetNbinsX(); ix++) {
+ for(Int_t iy = 1; iy <= fHighEmcHistoH2F->GetNbinsY(); iy++) {
+ if(fCalibRefHistoH2F->GetBinContent(ix, iy))
+ binContent = fHighEmcHistoH2F->GetBinContent(ix, iy)/fCalibRefHistoH2F->GetBinContent(ix, iy);
+ th2DRatioAmp->SetBinContent(ix, iy, binContent);
+ thRatioDist->Fill(binContent);
+ }
+ }
+ //
+ //Now for LED monitor system, to calculate the ratio as well
+ Double_t binError = 0. ;
+ // for the binError, we add the relative errors, squared
+ Double_t relativeErrorSqr = 0. ;
+ //
+ for(int ib = 1; ib <= fLEDMonRefHistoPro->GetNbinsX(); ib++) {
+ //
+ if(fLEDMonRefHistoPro->GetBinContent(ib) != 0) {
+ binContent = hSigLGLEDMon->GetBinContent(ib) / fLEDMonRefHistoPro->GetBinContent(ib);
+ relativeErrorSqr = TMath::Power( (fLEDMonRefHistoPro->GetBinError(ib) / fLEDMonRefHistoPro->GetBinContent(ib)), 2);
+ if( hSigLGLEDMon->GetBinContent(ib) != 0) {
+ relativeErrorSqr += TMath::Power( (hSigLGLEDMon->GetBinError(ib)/hSigLGLEDMon->GetBinContent(ib)), 2);
+ }
+ }
+ else {
+ binContent = 0;
+ relativeErrorSqr = 0;
+ }
+ hSigLGLEDMon->SetBinContent(ib, binContent);
+
+ binError = sqrt(relativeErrorSqr) * binContent;
+ thLEDMonRatio->SetBinError(ib, binError);
+ thLEDMonRatioDist->Fill(thLEDMonRatio->GetBinContent(ib));
}
- }
-
- //Now for LED monitor system, to calculate the ratio as well
- Double_t binError = 0. ;
- // for the binError, we add the relative errors, squared
- Double_t relativeErrorSqr = 0. ;
-
- for(int ib = 1; ib <= fLEDMonRefHistoPro->GetNbinsX(); ib++) {
-
- if(fLEDMonRefHistoPro->GetBinContent(ib) != 0) {
- binContent = GetRawsData(kSigLGLEDMon)->GetBinContent(ib) / fLEDMonRefHistoPro->GetBinContent(ib);
-
- relativeErrorSqr = TMath::Power( (fLEDMonRefHistoPro->GetBinError(ib) / fLEDMonRefHistoPro->GetBinContent(ib)), 2);
- if(GetRawsData(kSigLGLEDMon)->GetBinContent(ib) != 0) {
- relativeErrorSqr += TMath::Power( (GetRawsData(kSigLGLEDMon)->GetBinError(ib)/GetRawsData(kSigLGLEDMon)->GetBinContent(ib)), 2);
- }
- }
- else {
- binContent = 0;
- relativeErrorSqr = 0;
- }
- GetRawsData(kLEDMonRatio)->SetBinContent(ib, binContent);
-
- binError = sqrt(relativeErrorSqr) * binContent;
- GetRawsData(kLEDMonRatio)->SetBinError(ib, binError);
- GetRawsData(kLEDMonRatioDist)->Fill(GetRawsData(kLEDMonRatio)->GetBinContent(ib));
- }
-
- }
+ } // loop over eventual trigger clones
+ }
// let's also fill the SM and event counter histograms
Int_t nTotalHG = 0;
Int_t nTotalLG = 0;
nTotalTRU += nTotalSMTRU[iSM];
nTotalLGLEDMon += nTotalSMLGLEDMon[iSM];
nTotalHGLEDMon += nTotalSMHGLEDMon[iSM];
- GetRawsData(kNsmodLG)->Fill(iSM, nTotalSMLG[iSM]);
- GetRawsData(kNsmodHG)->Fill(iSM, nTotalSMHG[iSM]);
- GetRawsData(kNsmodTRU)->Fill(iSM, nTotalSMTRU[iSM]);
- GetRawsData(kNsmodLGLEDMon)->Fill(iSM, nTotalSMLGLEDMon[iSM]);
- GetRawsData(kNsmodHGLEDMon)->Fill(iSM, nTotalSMHGLEDMon[iSM]);
+ FillRawsData(kNsmodLG,iSM, nTotalSMLG[iSM]);
+ FillRawsData(kNsmodHG,iSM, nTotalSMHG[iSM]);
+ FillRawsData(kNsmodTRU,iSM, nTotalSMTRU[iSM]);
+ FillRawsData(kNsmodLGLEDMon,iSM, nTotalSMLGLEDMon[iSM]);
+ FillRawsData(kNsmodHGLEDMon,iSM, nTotalSMHGLEDMon[iSM]);
}
-
- GetRawsData(kNtotLG)->Fill(nTotalLG);
- GetRawsData(kNtotHG)->Fill(nTotalHG);
- GetRawsData(kNtotTRU)->Fill(nTotalTRU);
- GetRawsData(kNtotLGLEDMon)->Fill(nTotalLGLEDMon);
- GetRawsData(kNtotHGLEDMon)->Fill(nTotalHGLEDMon);
-
+ FillRawsData(kNtotLG,nTotalLG);
+ FillRawsData(kNtotHG,nTotalHG);
+ FillRawsData(kNtotTRU,nTotalTRU);
+ FillRawsData(kNtotLGLEDMon,nTotalLGLEDMon);
+ FillRawsData(kNtotHGLEDMon,nTotalHGLEDMon);
+
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
SetEventSpecie(saveSpecie) ;
// just in case the next rawreader consumer forgets to reset; let's do it here again..
rawReader->Reset() ;
-
+
return;
}
void AliEMCALQADataMakerRec::MakeDigits()
{
// makes data from Digits
-
- GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
+ FillDigitsData(1,fDigitsArray->GetEntriesFast()) ;
TIter next(fDigitsArray) ;
AliEMCALDigit * digit ;
while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) {
- GetDigitsData(0)->Fill( digit->GetAmplitude()) ;
+ FillDigitsData(0, digit->GetAmplitude()) ;
}
-
+ //
}
//____________________________________________________________________________
void AliEMCALQADataMakerRec::MakeDigits(TTree * digitTree)
{
// makes data from Digit Tree
+ // RS: Attention: the counters are increments in the MakeDigits()
if (fDigitsArray)
fDigitsArray->Clear("C") ;
else
fDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
TBranch * branch = digitTree->GetBranch("EMCAL") ;
- if ( ! branch ) {
- AliWarning("EMCAL branch in Digit Tree not found") ;
- } else {
- branch->SetAddress(&fDigitsArray) ;
- branch->GetEntry(0) ;
- MakeDigits() ;
- }
-
+ if ( ! branch ) { AliWarning("EMCAL branch in Digit Tree not found"); return; }
+ //
+ branch->SetAddress(&fDigitsArray) ;
+ branch->GetEntry(0) ;
+ MakeDigits() ;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
emcbranch->SetAddress(&emcRecPoints);
emcbranch->GetEntry(0);
- GetRecPointsData(kRecPM)->Fill(emcRecPoints->GetEntriesFast()) ;
+ FillRecPointsData(kRecPM,emcRecPoints->GetEntriesFast()) ;
TIter next(emcRecPoints) ;
AliEMCALRecPoint * rp ;
while ( (rp = dynamic_cast<AliEMCALRecPoint *>(next())) ) {
- GetRecPointsData(kRecPE)->Fill(rp->GetEnergy()) ;
- GetRecPointsData(kRecPDigM)->Fill(rp->GetMultiplicity());
+ FillRecPointsData(kRecPE,rp->GetEnergy()) ;
+ FillRecPointsData(kRecPDigM,rp->GetMultiplicity());
}
emcRecPoints->Delete();
delete emcRecPoints;
-
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
}
//____________________________________________________________________________
{
//Detector specific actions at end of cycle
// do the QA checking
+ ResetEventTrigClasses(); // reset triggers list to select all histos
AliQAChecker::Instance()->Run(AliQAv1::kEMCAL, task, list) ;
}
TH1I * h1 = new TH1I("hEmcalHitsMul", "Hits multiplicity distribution in EMCAL;# of Hits;Entries", 1000, 0, 10000) ;
h1->Sumw2() ;
Add2HitsList(h1, 1, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hEmcalDigitsMul", "Digits multiplicity distribution in EMCAL;# of Digits;Entries", 200, 0, 2000) ;
h1->Sumw2() ;
Add2DigitsList(h1, 1, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hEmcalSDigitsMul", "SDigits multiplicity distribution in EMCAL;# of SDigits;Entries", 500, 0, 5000) ;
h1->Sumw2() ;
Add2SDigitsList(h1, 1, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
{
//make QA data from Hits
- GetHitsData(1)->Fill(fHitsArray->GetEntriesFast()) ;
+ FillHitsData(1,fHitsArray->GetEntriesFast()) ;
TIter next(fHitsArray) ;
AliEMCALHit * hit ;
while ( (hit = dynamic_cast<AliEMCALHit *>(next())) ) {
- GetHitsData(0)->Fill( hit->GetEnergy()) ;
+ FillHitsData(0, hit->GetEnergy()) ;
}
-
}
//____________________________________________________________________________
void AliEMCALQADataMakerSim::MakeHits(TTree * hitTree)
{
// make QA data from Hit Tree
-
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 {
- branch->SetAddress(&fHitsArray) ;
- for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
- branch->GetEntry(ientry) ;
- MakeHits() ;
- fHitsArray->Clear() ;
- }
+ if ( ! branch ) { AliWarning("EMCAL branch in Hit Tree not found") ; return;}
+ //
+ branch->SetAddress(&fHitsArray) ;
+ for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
+ branch->GetEntry(ientry) ;
+ MakeHits() ;
+ fHitsArray->Clear() ;
}
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
void AliEMCALQADataMakerSim::MakeDigits()
{
// makes data from Digits
-
- GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
+
+ FillDigitsData(1,fDigitsArray->GetEntriesFast()) ;
TIter next(fDigitsArray) ;
AliEMCALDigit * digit ;
while ( (digit = dynamic_cast<AliEMCALDigit *>(next())) ) {
- GetDigitsData(0)->Fill( digit->GetAmp()) ;
+ FillDigitsData(0, digit->GetAmp()) ;
}
-
}
//____________________________________________________________________________
void AliEMCALQADataMakerSim::MakeDigits(TTree * digitTree)
{
// makes data from Digit Tree
+
if (fDigitsArray)
fDigitsArray->Clear("C") ;
else
fDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
TBranch * branch = digitTree->GetBranch("EMCAL") ;
- if ( ! branch ) {
- AliWarning("EMCAL branch in Digit Tree not found") ;
- } else {
- branch->SetAddress(&fDigitsArray) ;
- branch->GetEntry(0) ;
- MakeDigits() ;
- }
-
+ if ( ! branch ) { AliWarning("EMCAL branch in Digit Tree not found") ; return; }
+ //
+ branch->SetAddress(&fDigitsArray) ;
+ branch->GetEntry(0) ;
+ MakeDigits() ;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
}
//____________________________________________________________________________
AliEMCALSDigitizer* sDigitizer = new AliEMCALSDigitizer();
- GetSDigitsData(1)->Fill(fSDigitsArray->GetEntriesFast()) ;
+ FillSDigitsData(1,fSDigitsArray->GetEntriesFast()) ;
TIter next(fSDigitsArray) ;
AliEMCALDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliEMCALDigit *>(next())) ) {
- GetSDigitsData(0)->Fill( sDigitizer->Calibrate(sdigit->GetAmp())) ;
+ FillSDigitsData(0, sDigitizer->Calibrate(sdigit->GetAmp())) ;
}
-
delete sDigitizer;
}
fSDigitsArray = new TClonesArray("AliEMCALDigit", 1000) ;
TBranch * branch = sdigitTree->GetBranch("EMCAL") ;
- if ( ! branch ) {
- AliWarning("EMCAL branch in SDigit Tree not found") ;
- } else {
- branch->SetAddress(&fSDigitsArray) ;
- branch->GetEntry(0) ;
- MakeSDigits() ;
- }
-
+ if ( ! branch ) { AliWarning("EMCAL branch in SDigit Tree not found"); return;}
+ //
+ branch->SetAddress(&fSDigitsArray);
+ branch->GetEntry(0);
+ MakeSDigits();
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
{
// Detector specific actions at end of cycle
// do the QA checking
+ ResetEventTrigClasses(); // reset triggers list to select all histos
AliLog::Message(5,"FMD: end of detector cycle",
"AliFMDQADataMakerRec","AliFMDQADataMakerRec",
"AliFMDQADataMakerRec::EndOfDetectorCycle",
TH1* hist = MakeELossHist();
Add2ESDsList(hist, 0, !expert, image);
-
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//_____________________________________________________________________
TH1* hist = MakeADCHist();
Add2DigitsList(hist, 0, !expert, image);
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
-
//_____________________________________________________________________
void AliFMDQADataMakerRec::InitRecPoints()
{
TH1* hist = MakeELossHist();
Add2RecPointsList(hist,0, !expert, image);
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last linea
}
//_____________________________________________________________________
}
}
}
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
#if 0
// Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
if(m == AliESDFMD::kInvalidMult) return true;
- fM->GetESDsData(0)->Fill(m);
+ fM->FillESDsData(0,m);
return true;
}
AliFMDQADataMakerRec* fM;
Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
if(mult == AliESDFMD::kInvalidMult) continue;
- GetESDsData(0)->Fill(mult);
+ FillESDsData(0,mult);
}
}
}
}
#endif
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
}
for(Int_t i=0;i<fDigitsArray->GetEntriesFast();i++) {
//Raw ADC counts
AliFMDDigit* digit = static_cast<AliFMDDigit*>(fDigitsArray->At(i));
- GetDigitsData(0)->Fill(digit->Counts());
+ FillDigitsData(0,digit->Counts());
}
}
// Parameters:
// digitTree Tree of digits
//
-
if (fDigitsArray)
fDigitsArray->Clear();
else
branch->SetAddress(&fDigitsArray);
branch->GetEntry(0);
MakeDigits();
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
}
//_____________________________________________________________________
Short_t board = pars->GetAltroMap()->Sector2Board(ring, sec);
Int_t index1 = GetHalfringIndex(det, ring, 0, 1);
+ FillRawsData(index1,digit->Counts());
Int_t index2 = GetHalfringIndex(det, ring, board/16,0);
- // AliInfo(Form("FMD%d%c[0x%02x]->%2d,%2d",
- // det, ring, board, index1, index2));
- GetRawsData(index1)->Fill(digit->Counts());
- GetRawsData(index2)->Fill(digit->Counts());
+ FillRawsData(index2,digit->Counts());
+
}
- GetRawsData(1)->Fill(1, fmdReader.GetNErrors(0));
- GetRawsData(1)->Fill(2, fmdReader.GetNErrors(1));
- GetRawsData(1)->Fill(3, fmdReader.GetNErrors(2));
+ //
+ FillRawsData(1,1, fmdReader.GetNErrors(0));
+ FillRawsData(1,2, fmdReader.GetNErrors(1));
+ FillRawsData(1,3, fmdReader.GetNErrors(2));
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
}
//_____________________________________________________________________
TIter next(RecPointsAddress) ;
AliFMDRecPoint * rp ;
while ((rp = static_cast<AliFMDRecPoint*>(next()))) {
-
- GetRecPointsData(0)->Fill(rp->Edep()/pars->GetEdepMip()) ;
-
+ FillRecPointsData(0,rp->Edep()/pars->GetEdepMip());
}
-
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//_____________________________________________________________________
{
//Detector specific actions at end of cycle
// do the QA checking
+ ResetEventTrigClasses(); // reset triggers list to select all histos
AliLog::Message(5,"FMD: end of detector cycle",
"AliFMDQADataMakerSim","AliFMDQADataMakerSim",
"AliFMDQADataMakerSim::EndOfDetectorCycle",
1024,0,1024);
hADCCounts->SetXTitle("ADC counts");
Add2SDigitsList(hADCCounts, 0, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________
hEnergyOfHits->SetXTitle("Edep");
hEnergyOfHits->SetYTitle("Counts");
Add2HitsList(hEnergyOfHits, 0, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//_____________________________________________________________________
1024,0,1024);
hADCCounts->SetXTitle("ADC counts");
Add2DigitsList(hADCCounts, 0, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//_____________________________________________________________________
TIter next(fHitsArray);
AliFMDHit * hit;
- while ((hit = static_cast<AliFMDHit *>(next())))
- GetHitsData(0)->Fill(hit->Edep()/hit->Length()*0.032);
+ while ((hit = static_cast<AliFMDHit *>(next()))) FillHitsData(0,hit->Edep()/hit->Length()*0.032);
+ //
}
//_____________________________________________________________________
}
branch->SetAddress(&fHitsArray) ;
-
+ //
for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
branch->GetEntry(ientry);
MakeHits(); //tmp);
fHitsArray->Clear() ;
- }
+ }
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//_____________________________________________________________________
for(Int_t i = 0 ; i < fDigitsArray->GetEntriesFast() ; i++) {
//Raw ADC counts
AliFMDDigit* digit = static_cast<AliFMDDigit*>(fDigitsArray->At(i));
- GetDigitsData(0)->Fill(digit->Counts());
+ FillDigitsData(0,digit->Counts());
}
+ //
}
//_____________________________________________________________________
//
// Parameters:
// digitTree Tree holding digits.
+ // RS: counters are incremented in MakeDigits()
if (!fDigitsArray)
fDigitsArray = new TClonesArray("AliFMDDigit", 1000) ;
branch->GetEntry(0) ;
MakeDigits() ;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//_____________________________________________________________________
// none
if(!fSDigitsArray) return;
- for(Int_t i = 0 ; i < fSDigitsArray->GetEntriesFast() ; i++) {
+ for(Int_t i = 0 ; i < fSDigitsArray->GetEntriesFast() ; i++) {
//Raw ADC counts
AliFMDSDigit* sdigit = static_cast<AliFMDSDigit*>(fSDigitsArray->At(i));
- GetSDigitsData(0)->Fill(sdigit->Counts());
+ FillSDigitsData(0,sdigit->Counts());
}
+ //
}
//_____________________________________________________________________
//
// Parameters:
// digitTree Tree holding digits.
-
+ //
if (!fSDigitsArray)
fSDigitsArray = new TClonesArray("AliFMDSDigit", 1000) ;
fSDigitsArray->Clear() ;
branch->SetAddress(&fSDigitsArray) ;
branch->GetEntry(0) ;
MakeSDigits() ;
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//_____________________________________________________________________
void AliHLTTPCQADataMaker::EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray** /*list*/)
{
// see header file for class documentation
-
- if(GetESDsData(kPHLT)->GetEntries()){
- GetESDsData(kPRatio)->Sumw2();
- GetESDsData(kPRatio)->Add(GetESDsData(kPOffline));
- GetESDsData(kPRatio)->Divide(GetESDsData(kPHLT));
- }
-
- if(GetESDsData(kPHLTFired)->GetEntries()){
- GetESDsData(kPRatioFired)->Sumw2();
- GetESDsData(kPRatioFired)->Add(GetESDsData(kPOfflineFired));
- GetESDsData(kPRatioFired)->Divide(GetESDsData(kPHLTFired));
+ for (int itc=-1;itc=GetNTrigClasses();itc++) {
+ TH1* hp = GetESDsData(kPHLT,itc);
+ TH1* hr = GetESDsData(kPRatio,itc);
+ TH1* ho = GetESDsData(kPOffline,itc);
+ //
+ if (hp && hr && ho && hp->GetEntries()) {
+ hp->Sumw2();
+ hr->Add(ho);
+ hr->Divide(hp);
+ }
+ //
+ hp = GetESDsData(kPHLTFired,itc);
+ hr = GetESDsData(kPRatioFired,itc);
+ ho = GetESDsData(kPOfflineFired,itc);
+ //
+ if (hp && hr && ho && hp->GetEntries()) {
+ hp->Sumw2();
+ hr->Add(ho);
+ hr->Divide(hp);
+ }
}
-
-
}
void AliHLTTPCQADataMaker::MakeRaws(AliRawReader * rawReader)
const Int_t nESDTracks = esd->GetNumberOfTracks();
const Int_t nHLTesdTracks = hltesd->GetNumberOfTracks();
- GetESDsData(kMultiplicity)->Fill(nESDTracks, nHLTesdTracks);
+ FillESDsData(kMultiplicity,nESDTracks, nHLTesdTracks);
Int_t nClsHLT = 0;
Int_t nClsOffline = 0;
for(Int_t i = 0; i < nESDTracks; i++){
AliESDtrack * esdTrk = esd->GetTrack(i);
- GetESDsData(kPOffline)->Fill(esdTrk->P());
- GetESDsData(kPtOffline)->Fill(esdTrk->GetSignedPt());
- GetESDsData(kNClsPerTrkOffline)->Fill(esdTrk->GetTPCNcls());
- GetESDsData(kPhiOffline)->Fill(esdTrk->Phi()*TMath::RadToDeg());
- GetESDsData(kEtaOffline)->Fill(esdTrk->Eta());
+ FillESDsData(kPOffline,esdTrk->P());
+ FillESDsData(kPtOffline,esdTrk->GetSignedPt());
+ FillESDsData(kNClsPerTrkOffline,esdTrk->GetTPCNcls());
+ FillESDsData(kPhiOffline,esdTrk->Phi()*TMath::RadToDeg());
+ FillESDsData(kEtaOffline,esdTrk->Eta());
nClsOffline+=esdTrk->GetTPCNcls();
}
for(Int_t i = 0; i < nHLTesdTracks; i++){
AliESDtrack * hltEsdTrk = hltesd->GetTrack(i);
- GetESDsData(kPHLT)->Fill(hltEsdTrk->P());
- GetESDsData(kPtHLT)->Fill(hltEsdTrk->GetSignedPt());
- GetESDsData(kNClsPerTrkHLT)->Fill(hltEsdTrk->GetTPCNcls());
- GetESDsData(kPhiHLT)->Fill(hltEsdTrk->Phi()*TMath::RadToDeg());
- GetESDsData(kEtaHLT)->Fill(hltEsdTrk->Eta());
+ FillESDsData(kPHLT,hltEsdTrk->P());
+ FillESDsData(kPtHLT,hltEsdTrk->GetSignedPt());
+ FillESDsData(kNClsPerTrkHLT,hltEsdTrk->GetTPCNcls());
+ FillESDsData(kPhiHLT,hltEsdTrk->Phi()*TMath::RadToDeg());
+ FillESDsData(kEtaHLT,hltEsdTrk->Eta());
nClsHLT += hltEsdTrk->GetTPCNcls();
}
if(nHLTesdTracks)
nClsHLT /= nHLTesdTracks;
- GetESDsData(kNCls)->Fill(nClsOffline, nClsHLT);
+ FillESDsData(kNCls,nClsOffline, nClsHLT);
if(hltesd->IsHLTTriggerFired()){
- GetESDsData(kMultiplicityFired)->Fill(nESDTracks, nHLTesdTracks);
- GetESDsData(kNClsFired)->Fill(nClsOffline, nClsHLT);
+ FillESDsData(kMultiplicityFired,nESDTracks, nHLTesdTracks);
+ FillESDsData(kNClsFired,nClsOffline, nClsHLT);
for(Int_t i = 0; i < nESDTracks; i++){
AliESDtrack * esdTrk = esd->GetTrack(i);
- GetESDsData(kPOfflineFired)->Fill(esdTrk->P());
- GetESDsData(kPtOfflineFired)->Fill(esdTrk->GetSignedPt());
- GetESDsData(kNClsPerTrkOfflineFired)->Fill(esdTrk->GetTPCNcls());
- GetESDsData(kPhiOfflineFired)->Fill(esdTrk->Phi()*TMath::RadToDeg());
- GetESDsData(kEtaOfflineFired)->Fill(esdTrk->Eta());
+ FillESDsData(kPOfflineFired,esdTrk->P());
+ FillESDsData(kPtOfflineFired,esdTrk->GetSignedPt());
+ FillESDsData(kNClsPerTrkOfflineFired,esdTrk->GetTPCNcls());
+ FillESDsData(kPhiOfflineFired,esdTrk->Phi()*TMath::RadToDeg());
+ FillESDsData(kEtaOfflineFired,esdTrk->Eta());
}
for(Int_t i = 0; i < nHLTesdTracks; i++){
AliESDtrack * hltEsdTrk = hltesd->GetTrack(i);
- GetESDsData(kPHLTFired)->Fill(hltEsdTrk->P());
- GetESDsData(kPtHLTFired)->Fill(hltEsdTrk->GetSignedPt());
- GetESDsData(kNClsPerTrkHLTFired)->Fill(hltEsdTrk->GetTPCNcls());
- GetESDsData(kPhiHLTFired)->Fill(hltEsdTrk->Phi()*TMath::RadToDeg());
- GetESDsData(kEtaHLTFired)->Fill(hltEsdTrk->Eta());
+ FillESDsData(kPHLTFired,hltEsdTrk->P());
+ FillESDsData(kPtHLTFired,hltEsdTrk->GetSignedPt());
+ FillESDsData(kNClsPerTrkHLTFired,hltEsdTrk->GetTPCNcls());
+ FillESDsData(kPhiHLTFired,hltEsdTrk->Phi()*TMath::RadToDeg());
+ FillESDsData(kEtaHLTFired,hltEsdTrk->Eta());
}
void AliHMPIDQADataMaker::InitHits()
{
// create Hits histograms in Hits subdir
- TH1F *hHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC",500,0,4000);
- Add2HitsList(hHitQdc,0);
- TH2F *hHitMap[7];
- for(Int_t iCh=0;iCh<7;iCh++) {
- hHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit}",iCh),162,-1,161,146,-1,145);
+ TH1F *hHitQdc=new TH1F("HitQdc","HMPID Hit Qdc all chamber;QDC",500,0,4000);
+ Add2HitsList(hHitQdc,0);
+ TH2F *hHitMap[7];
+ for(Int_t iCh=0;iCh<7;iCh++) {
+ hHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit}",iCh),162,-1,161,146,-1,145);
Add2HitsList(hHitMap[iCh],iCh+1);
- }
-
+ }
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
void AliHMPIDQADataMaker::InitDigits()
{
// create Digits histograms in Digits subdir
- TH1F *hDigPcEvt = new TH1F("hDigPcEvt","PC occupancy",156,-1,77);
- TH1F *hDigQ = new TH1F("Q ","Charge of digits (ADC) ",3000,0,3000);
- TH1F *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
-
- TProfile *tDigHighQ = new TProfile("tDigHighQ","Highest charge in chamber ",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
- TProfile *tDigChEvt = new TProfile("tDigChEvt","Chamber occupancy per event (profile)",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
-
-Add2DigitsList(hDigPcEvt,0);
-Add2DigitsList(hDigQ ,1);
-Add2DigitsList(hDigChEvt,2);
-Add2DigitsList(tDigHighQ,3);
-Add2DigitsList(tDigChEvt,4);
+ TH1F *hDigPcEvt = new TH1F("hDigPcEvt","PC occupancy",156,-1,77);
+ TH1F *hDigQ = new TH1F("Q ","Charge of digits (ADC) ",3000,0,3000);
+ TH1F *hDigChEvt = new TH1F("hDigChEvt","Chamber occupancy per event",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
+
+ TProfile *tDigHighQ = new TProfile("tDigHighQ","Highest charge in chamber ",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
+ TProfile *tDigChEvt = new TProfile("tDigChEvt","Chamber occupancy per event (profile)",AliHMPIDParam::kMaxCh+1,AliHMPIDParam::kMinCh,AliHMPIDParam::kMaxCh+1);
+
+ Add2DigitsList(hDigPcEvt,0);
+ Add2DigitsList(hDigQ ,1);
+ Add2DigitsList(hDigChEvt,2);
+ Add2DigitsList(tDigHighQ,3);
+ Add2DigitsList(tDigChEvt,4);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
void AliHMPIDQADataMaker::InitSDigits()
{
// create SDigits histograms in SDigits subdir
- TH1F *hSDigits = new TH1F("hHmpidSDigits", "SDigits Q distribution in HMPID", 500, 0., 5000.) ;
-
-Add2SDigitsList(hSDigits,0);
+ TH1F *hSDigits = new TH1F("hHmpidSDigits", "SDigits Q distribution in HMPID", 500, 0., 5000.) ;
+ Add2SDigitsList(hSDigits,0);
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
Add2RecPointsList(hCluFlg , 2);
Add2RecPointsList(hCluSize, 3);
Add2RecPointsList(hCluQ , 4);
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
void AliHMPIDQADataMaker::InitRaws()
{
-//
-// Booking QA histo for Raw data
-//
+ //
+ // Booking QA histo for Raw data
+ //
TH1F *hqPad[14];
for(Int_t iddl =0; iddl<14; iddl++) {
hqPad[iddl] = new TH1F(Form("hqPadDDL%i",iddl), Form("Pad Q Entries at DDL %i",iddl), 500,0,5000);
hSumErr->GetXaxis()->SetBinLabel((2*ilabel+1),Form("%i %s",ilabel+1,hnames[ilabel]));
}
-Add2RawsList(hSumErr,14);
+ Add2RawsList(hSumErr,14);
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
{
//
//Booking ESDs histograms
- TH2F* hCkovP = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]" , 150, 0, 7 ,100, 0, 1) ;
- TH2F* hSigP = new TH2F("SigP" ,"#sigma_{#theta_c} [mrad];[GeV]", 150, 0, 7 ,100, 0, 1) ;
- TH2F* hMipXY = new TH2F("MipXY" ,"mip position" , 260, 0,130 ,252, 0,126) ;
- TH2F* hDifXY = new TH2F("DifXY" ,"diff" , 200, -10, 10 ,200,-10,10) ;
- TH1F* hPid[5];
- hPid[0] = new TH1F("PidE" ,"electron response" , 101, -0.005,1.005) ;
- hPid[1] = new TH1F("PidMu","#mu response" , 101, -0.005,1.005) ;
- hPid[2] = new TH1F("PidPi","#pi response" , 101, -0.005,1.005) ;
- hPid[3] = new TH1F("PidK" ,"K response" , 101, -0.005,1.005) ;
- hPid[4] = new TH1F("PidP" ,"p response" ,101, -0.005,1.005) ;
-
-Add2ESDsList(hCkovP,0);
-Add2ESDsList(hSigP ,1);
-Add2ESDsList(hMipXY,2);
-Add2ESDsList(hDifXY,3);
-for(Int_t i=0; i< 5; i++) Add2ESDsList(hPid[i],i+4);
+ TH2F* hCkovP = new TH2F("CkovP" , "#theta_{c}, [rad];P, [GeV]" , 150, 0, 7 ,100, 0, 1) ;
+ TH2F* hSigP = new TH2F("SigP" ,"#sigma_{#theta_c} [mrad];[GeV]", 150, 0, 7 ,100, 0, 1) ;
+ TH2F* hMipXY = new TH2F("MipXY" ,"mip position" , 260, 0,130 ,252, 0,126) ;
+ TH2F* hDifXY = new TH2F("DifXY" ,"diff" , 200, -10, 10 ,200,-10,10) ;
+ TH1F* hPid[5];
+ hPid[0] = new TH1F("PidE" ,"electron response" , 101, -0.005,1.005) ;
+ hPid[1] = new TH1F("PidMu","#mu response" , 101, -0.005,1.005) ;
+ hPid[2] = new TH1F("PidPi","#pi response" , 101, -0.005,1.005) ;
+ hPid[3] = new TH1F("PidK" ,"K response" , 101, -0.005,1.005) ;
+ hPid[4] = new TH1F("PidP" ,"p response" ,101, -0.005,1.005) ;
+
+ Add2ESDsList(hCkovP,0);
+ Add2ESDsList(hSigP ,1);
+ Add2ESDsList(hMipXY,2);
+ Add2ESDsList(hDifXY,3);
+ for(Int_t i=0; i< 5; i++) Add2ESDsList(hPid[i],i+4);
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
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());
+ if(hit->Pid()<500000) FillHitsData(0,hit->Q()) ;
+ if(hit->Pid()<500000) FillHitsData(hit->Ch()+1,hit->LorsX(),hit->LorsY());
}
}
-
+ //
}
//___________________________________________________________________________
void AliHMPIDQADataMaker::MakeHits(TTree * data)
data->GetEntry(iEnt);
MakeHits(pHits);
}//entries loop
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
+
//____________________________________________________________________________
void AliHMPIDQADataMaker::MakeDigits(TClonesArray * data)
{
for(Int_t i =0; i< chamber->GetEntries(); i++)
{
TClonesArray * digits = dynamic_cast<TClonesArray*>(chamber->At(i));
- GetDigitsData(2)->Fill(i,digits->GetEntriesFast()/(48.*80.*6.));
- GetDigitsData(4)->Fill(i,digits->GetEntriesFast()/(48.*80.*6.));
+ FillDigitsData(2,i,digits->GetEntriesFast()/(48.*80.*6.));
+ FillDigitsData(4,i,digits->GetEntriesFast()/(48.*80.*6.));
Double_t highQ=0;
TIter next(digits);
AliHMPIDDigit * digit;
while ( (digit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
- GetDigitsData(0)->Fill(10.*i+digit->Pc(),1./(48.*80.));
- GetDigitsData(1)->Fill(digit->Q());
+ FillDigitsData(0,10.*i+digit->Pc(),1./(48.*80.));
+ FillDigitsData(1,digit->Q());
if(digit->Q()>highQ) highQ = digit->Q();
}
- GetDigitsData(3)->Fill(i,highQ);
-
+ FillDigitsData(3,i,highQ);
}
}
}
}
data->GetEntry(0);
- MakeDigits((TClonesArray *)pObjDig);
+ MakeDigits((TClonesArray *)pObjDig);
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
+
//____________________________________________________________________________
void AliHMPIDQADataMaker::MakeRaws(AliRawReader *rawReader)
for(Int_t iCh=AliHMPIDParam::kMinCh;iCh<=AliHMPIDParam::kMaxCh;iCh++) {
AliHMPIDRawStream stream(rawReader);
while(stream.Next())
- {
-
+ {
UInt_t ddl=stream.GetDDLNumber(); //returns 0,1,2 ... 13
if((UInt_t)(2*iCh)==ddl || (UInt_t)(2*iCh+1)==ddl) {
for(Int_t row = 1; row <= AliHMPIDRawStream::kNRows; row++){
for(Int_t dil = 1; dil <= AliHMPIDRawStream::kNDILOGICAdd; dil++){
for(Int_t pad = 0; pad < AliHMPIDRawStream::kNPadAdd; pad++){
if(stream.GetCharge(ddl,row,dil,pad) < 1) continue;
- GetRawsData(ddl)->Fill(stream.GetCharge(ddl,row,dil,pad));
+ FillRawsData(ddl,stream.GetCharge(ddl,row,dil,pad));
// Printf("charge %i",stream.GetCharge(ddl,row,dil,pad));
}//pad
}//dil
for(Int_t iErr =1; iErr<(Int_t)AliHMPIDRawStream::kSumErr; iErr++){
Int_t errflag = stream.GetErrors(iErr);
- if(errflag < 0) GetRawsData(14)->Fill((Int_t)AliHMPIDRawStream::kSumErr+0.5);
- else if(errflag == 0) GetRawsData(14)->Fill((Int_t)AliHMPIDRawStream::kSumErr-0.5);
- else GetRawsData(14)->Fill(iErr-0.5);
+ if(errflag < 0) FillRawsData(14,(Int_t)AliHMPIDRawStream::kSumErr+0.5);
+ else if(errflag == 0) FillRawsData(14,(Int_t)AliHMPIDRawStream::kSumErr-0.5);
+ else FillRawsData(14,iErr-0.5);
}
stream.Delete();
}//chamber loop
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//___________________________________________________________________________
TIter next(sdigits) ;
AliHMPIDDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
- GetSDigitsData(0)->Fill(sdigit->Q());
+ FillSDigitsData(0,sdigit->Q());
}
}
}
//___________________________________________________________________________
void AliHMPIDQADataMaker::MakeSDigits(TTree * data)
{
- //
- // Opening the SDigit Tree
- //
- TClonesArray * sdigits = new TClonesArray("AliHMPIDDigit", 1000) ;
+ //
+ // Opening the SDigit Tree
+ //
+ TClonesArray * sdigits = new TClonesArray("AliHMPIDDigit", 1000) ;
TBranch * branch = data->GetBranch("HMPID") ;
if ( ! branch ) {
branch->SetAddress(&sdigits) ;
branch->GetEntry(0) ;
MakeSDigits(sdigits) ;
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
void AliHMPIDQADataMaker::MakeRecPoints(TTree * clustersTree)
branch->SetAddress(&clusters);
branch->GetEntry(0);
- GetRecPointsData(0)->Fill(i,clusters->GetEntries());
+ FillRecPointsData(0,i,clusters->GetEntries());
TIter next(clusters);
AliHMPIDCluster *clu;
while ( (clu = dynamic_cast<AliHMPIDCluster *>(next())) ) {
- GetRecPointsData(1)->Fill(clu->Chi2());
- GetRecPointsData(2)->Fill(clu->Status());
- GetRecPointsData(3)->Fill(clu->Size());
- GetRecPointsData(4)->Fill(clu->Q());
+ FillRecPointsData(1,clu->Chi2());
+ FillRecPointsData(2,clu->Status());
+ FillRecPointsData(3,clu->Size());
+ FillRecPointsData(4,clu->Q());
}
}
clusters->Delete();
delete clusters;
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
//
for(Int_t iTrk = 0 ; iTrk < esd->GetNumberOfTracks() ; iTrk++){
AliESDtrack *pTrk = esd->GetTrack(iTrk) ;
- GetESDsData(0)->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal());
- GetESDsData(1)->Fill( pTrk->GetP(),TMath::Sqrt(pTrk->GetHMPIDchi2()));
+ FillESDsData(0,pTrk->GetP(),pTrk->GetHMPIDsignal());
+ FillESDsData(1, pTrk->GetP(),TMath::Sqrt(pTrk->GetHMPIDchi2()));
Float_t xm,ym; Int_t q,np;
pTrk->GetHMPIDmip(xm,ym,q,np); //mip info
- GetESDsData(2)->Fill(xm,ym);
+ FillESDsData(2,xm,ym);
Float_t xRad,yRad,th,ph;
pTrk->GetHMPIDtrk(xRad,yRad,th,ph); //track info at the middle of the radiator
Float_t xPc = xRad+9.25*TMath::Tan(th)*TMath::Cos(ph); // temporar: linear extrapol (B=0!)
Float_t yPc = yRad+9.25*TMath::Tan(th)*TMath::Sin(ph); // temporar: "
- GetESDsData(3)->Fill(xm-xPc,ym-yPc); //track info
+ FillESDsData(3,xm-xPc,ym-yPc); //track info
Double_t pid[5] ; pTrk->GetHMPIDpid(pid) ;
- for(Int_t i = 0 ; i < 5 ; i++) GetESDsData(4+i)->Fill(pid[i]) ;
+ for(Int_t i = 0 ; i < 5 ; i++) FillESDsData(4+i,pid[i]) ;
}
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
void AliHMPIDQADataMaker::StartOfDetectorCycle()
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDQADataMakerRec::AliHMPIDQADataMakerRec() :
- AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"),fEvtRaw(0), fLineDdlDatSizeLow(0x0), fLineDdlDatSizeUp(0x0), fLineDdlPadOCcLow(0x0), fLineDdlPadOCcUp(0x0), fChannel(0)
+ AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kHMPID), "HMPID Quality Assurance Data Maker"), fLineDdlDatSizeLow(0x0), fLineDdlDatSizeUp(0x0), fLineDdlPadOCcLow(0x0), fLineDdlPadOCcUp(0x0), fChannel(0)
{
// ctor
for(Int_t i=0; i<6; i++) fModline[i]=0x0;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AliHMPIDQADataMakerRec::AliHMPIDQADataMakerRec(const AliHMPIDQADataMakerRec& qadm) :
- AliQADataMakerRec(),fEvtRaw(qadm.fEvtRaw), fLineDdlDatSizeLow(qadm.fLineDdlDatSizeLow), fLineDdlDatSizeUp(qadm.fLineDdlDatSizeUp), fLineDdlPadOCcLow(qadm.fLineDdlPadOCcLow), fLineDdlPadOCcUp(qadm.fLineDdlPadOCcUp), fChannel(qadm.fChannel)
+ AliQADataMakerRec(),fLineDdlDatSizeLow(qadm.fLineDdlDatSizeLow), fLineDdlDatSizeUp(qadm.fLineDdlDatSizeUp), fLineDdlPadOCcLow(qadm.fLineDdlPadOCcLow), fLineDdlPadOCcUp(qadm.fLineDdlPadOCcUp), fChannel(qadm.fChannel)
{
//copy ctor
for(Int_t i=0; i<6; i++) fModline[i]=qadm.fModline[i];
Add2DigitsList(hDigPcEvt,1,expert, !image);
for(Int_t iMap=0; iMap < 7; iMap++) Add2DigitsList(hDigMap[iMap],2+iMap,expert, !image);
for(Int_t iH =0; iH < 42 ; iH++) Add2DigitsList(hDigQ[iH] ,9+iH,expert,!image);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Add2RecPointsList(hCluQSect[iCh*6+iSect],2+14+42+iCh*6+iSect, !expert, image);
}
}
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
+
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::InitRaws()
{
for(Int_t iddl=0;iddl<14;iddl++) fHmpPadOccPrf->GetXaxis()->SetBinLabel(iddl+1,Form("DDL_%d",1535+iddl+1));
fHmpPadOccPrf->SetStats(0);fHmpPadOccPrf->SetMinimum(0);fHmpPadOccPrf->SetMarkerStyle(20);
Add2RawsList(fHmpPadOccPrf,14+14+42+42+6,expert,!image,saveCorr); //expert, no image
-
-
//___ for DQM shifter and eLogBook ___ stop
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::InitESDs()
Add2ESDsList(hDifXY,2, !expert, image);
Add2ESDsList(hMvsP,3, expert, !image);
for(Int_t i=0; i< 5; i++) Add2ESDsList(hPid[i],i+4, expert, !image);
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::MakeRaws(AliRawReader *rawReader)
UInt_t ddl=stream.GetDDLNumber(); //returns 0,1,2 ... 13
if(ddl > 13) continue;
- // GetRawsData(14+14+42+42+1)->Fill(ddl+1,stream.GetDdlDataSize());
- GetRawsData(14+14+42+42+5)->Fill(ddl+1,stream.GetDdlDataSize());
+ // FillRawsData(14+14+42+42+1,ddl+1,stream.GetDdlDataSize());
+ FillRawsData(14+14+42+42+5,ddl+1,stream.GetDdlDataSize());
if(stream.GetDdlDataSize() > 0)
{
isHMPin++;
//___ fill error histo
for(Int_t iErr =1; iErr<(Int_t)AliHMPIDRawStream::kSumErr; iErr++){
Int_t numOfErr = stream.GetErrors(ddl,iErr);
- GetRawsData(ddl)->Fill(iErr,numOfErr);
- ((TH2I*)GetRawsData(14+14+42+42))->Fill(iErr,ddl,iErr); //
+ FillRawsData(ddl,iErr,numOfErr);
+ FillRawsData(14+14+42+42,iErr,ddl,iErr); //
}
numPadsInDdl= stream.GetNPads();
ddlOcc[ddl] = numPadsInDdl;
- GetRawsData(14+14+42+42+6)->Fill(ddl+1,numPadsInDdl/11520.0*100.0);
+ FillRawsData(14+14+42+42+6,ddl+1,numPadsInDdl/11520.0*100.0);
//___ loop on pads from raw data from a ddl
for(Int_t iPad=0;iPad<numPadsInDdl;iPad++) {
AliHMPIDDigit dig(stream.GetPadArray()[iPad],stream.GetChargeArray()[iPad]);dig.Raw(word,Nddl,r,d,a);
//for DQM shifter
- ((TH2F*)GetRawsData(14+14+42+42+3))->Fill(dig.PadChX(), dig.Ch()*144+dig.PadChY(),dig.Q());
- ((TH2F*)GetRawsData(14+14+42+42+4))->Fill(dig.Q(),(ddl/2*6)+dig.PadChY()/24,dig.Q());
+ FillRawsData(14+14+42+42+3,dig.PadChX(), dig.Ch()*144+dig.PadChY(),dig.Q());
+ FillRawsData(14+14+42+42+4,dig.Q(),(ddl/2*6)+dig.PadChY()/24,dig.Q());
- GetRawsData(ddl+14)->Fill(r,d);
- GetRawsData(28+stream.Pc(Nddl,r,d,a)+6*AliHMPIDParam::DDL2C(ddl))->Fill(stream.PadPcX(Nddl,r,d,a),stream.PadPcY(Nddl,r,d,a));
- GetRawsData(70+stream.Pc(Nddl,r,d,a)+6*AliHMPIDParam::DDL2C(ddl))->Fill(stream.GetChargeArray()[iPad]);
- // GetRawsData(14+14+42+42+6)->Fill(ddl+1,1);
+ FillRawsData(ddl+14,r,d);
+ FillRawsData(28+stream.Pc(Nddl,r,d,a)+6*AliHMPIDParam::DDL2C(ddl),stream.PadPcX(Nddl,r,d,a),stream.PadPcY(Nddl,r,d,a));
+ FillRawsData(70+stream.Pc(Nddl,r,d,a)+6*AliHMPIDParam::DDL2C(ddl),stream.GetChargeArray()[iPad]);
+ // FillRawsData(14+14+42+42+6,ddl+1,1);
}//pad loop
}
}//next
- if(isHMPin > 0) fEvtRaw++;
+ if(isHMPin > 0) { // RS: instead of former fEvtRaw
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ }
}//MakeRaws
+
+
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::MakeDigits()
{
//
Int_t i = fChannel ;
- GetDigitsData(0)->Fill(i,fDigitsArray->GetEntriesFast()/(48.*80.*6.));
+ FillDigitsData(0,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());
+ FillDigitsData(1,10.*i+digit->Pc(),1./(48.*80.));
+ FillDigitsData(2+i,digit->PadChX(),digit->PadChY());
+ FillDigitsData(9+i*6+digit->Pc(),digit->Q());
}
}
branch->GetEntry(0);
MakeDigits();
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
TBranch *branch = clustersTree->GetBranch(Form("HMPID%d",iCh));
branch->SetAddress(&fRecPointsArray);
branch->GetEntry(0);
- GetRecPointsData(0)->Fill(iCh,fRecPointsArray->GetEntries());
+ FillRecPointsData(0,iCh,fRecPointsArray->GetEntries());
TIter next(fRecPointsArray);
AliHMPIDCluster *clu;
while ( (clu = dynamic_cast<AliHMPIDCluster *>(next())) ) {
- GetRecPointsData(1)->Fill(clu->Status(),iCh);
+ FillRecPointsData(1,clu->Status(),iCh);
Int_t sect = pPar->InHVSector(clu->Y());
- if(clu->Q()>100) GetRecPointsData(2+iCh)->Fill(clu->Size());
+ if(clu->Q()>100) FillRecPointsData(2+iCh,clu->Size());
else {
- GetRecPointsData(2+7+iCh)->Fill(clu->Size());
- GetRecPointsData(2+14+iCh*6+sect)->Fill(clu->Q());
+ FillRecPointsData(2+7+iCh,clu->Size());
+ FillRecPointsData(2+14+iCh*6+sect,clu->Q());
}
- GetRecPointsData(2+14+42+iCh*6+sect)->Fill(clu->Q());
+ FillRecPointsData(2+14+42+iCh*6+sect,clu->Q());
}
}
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
+
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
for(Int_t iTrk = 0 ; iTrk < esd->GetNumberOfTracks() ; iTrk++){
AliESDtrack *pTrk = esd->GetTrack(iTrk) ;
- GetESDsData(0)->Fill(pTrk->GetP(),pTrk->GetHMPIDsignal());
- GetESDsData(1)->Fill( pTrk->GetP(),TMath::Sqrt(pTrk->GetHMPIDchi2()));
+ FillESDsData(0,pTrk->GetP(),pTrk->GetHMPIDsignal());
+ FillESDsData(1, pTrk->GetP(),TMath::Sqrt(pTrk->GetHMPIDchi2()));
Float_t xm,ym; Int_t q,np;
pTrk->GetHMPIDmip(xm,ym,q,np); //mip info
Float_t xRad,yRad,th,ph;
pTrk->GetHMPIDtrk(xRad,yRad,th,ph); //track info at the middle of the radiator
Float_t xPc = xRad+9.25*TMath::Tan(th)*TMath::Cos(ph); // temporar: linear extrapol (B=0!)
Float_t yPc = yRad+9.25*TMath::Tan(th)*TMath::Sin(ph); // temporar: "
- GetESDsData(2)->Fill(xm-xPc,ym-yPc); //track info
+ FillESDsData(2,xm-xPc,ym-yPc); //track info
if(pTrk->GetHMPIDsignal()>0) {
Double_t a = 1.292*1.292*TMath::Cos(pTrk->GetHMPIDsignal())*TMath::Cos(pTrk->GetHMPIDsignal())-1.;
if(a > 0) {
Double_t mass = pTrk->P()*TMath::Sqrt(1.292*1.292*TMath::Cos(pTrk->GetHMPIDsignal())*TMath::Cos(pTrk->GetHMPIDsignal())-1.);
- GetESDsData(3)->Fill( pTrk->GetP(),mass);
+ FillESDsData(3, pTrk->GetP(),mass);
}
}
Double_t pid[5] ; pTrk->GetHMPIDpid(pid) ;
- for(Int_t i = 0 ; i < 5 ; i++) GetESDsData(4+i)->Fill(pid[i]) ;
+ for(Int_t i = 0 ; i < 5 ; i++) FillESDsData(4+i,pid[i]) ;
}
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
+
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void AliHMPIDQADataMakerRec::StartOfDetectorCycle()
{
{
//Detector specific actions at end of cycle
// do the QA checking
- if(task==AliQAv1::kRAWS) {
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; 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
- if(fEvtRaw>0) h->Scale(1.0/(Float_t)fEvtRaw);
- }//ddl loop
-
- TH2F *h2 = (TH2F*)histos[specie]->At(14+14+42+42+3);
- if(fEvtRaw>0) h2->Scale(1.0/(Float_t)fEvtRaw);
-
- TH2F *h3 = (TH2F*)histos[specie]->At(14+14+42+42+4);
- if(fEvtRaw>0) h3->Scale(1.0/(Float_t)fEvtRaw);
-
-
- Double_t binval=0,binerr=0;
-
- TH1F *h4 = (TH1F*)histos[specie]->At(14+14+42+42+1);
- TProfile *h4prf = (TProfile*)histos[specie]->At(14+14+42+42+5);
- for(Int_t iddl=1;iddl<=14;iddl++)
- {
- binval=h4prf->GetBinContent(iddl); binerr=h4prf->GetBinError(iddl);
- h4->SetBinContent(iddl,binval); h4->SetBinError(iddl,binerr);
- }
- //if(fEvtRaw>0) h4->Scale(1./(Float_t)fEvtRaw);
-
- TH1F *h5 = (TH1F*)histos[specie]->At(14+14+42+42+2);
- TProfile *h5prf = (TProfile*)histos[specie]->At(14+14+42+42+6);
- for(Int_t iddl=1;iddl<=14;iddl++)
- {
- binval=h5prf->GetBinContent(iddl); binerr=h5prf->GetBinError(iddl);
- h5->SetBinContent(iddl,binval); h5->SetBinError(iddl,binerr);
- }
-
- //if(fEvtRaw>0) h5->Scale(1./(Float_t)fEvtRaw/11520.0*100.0);
-
- }//specie loop
- }//RAWS
-
+ ResetEventTrigClasses(); // reset triggers list to select all histos
+ TH1* htmp = 0;
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ if(task==AliQAv1::kRAWS) {
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ if (! IsValidEventSpecie(specie, histos) ) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ Int_t nEvtRaw = GetEvCountCycleRaws(itc);
+ if (nEvtRaw>0) {
+ //ddl histos scaled by the number of events
+ for(Int_t iddl=0;iddl<14;iddl++) if ( (htmp=GetData(histos, 14+iddl,itc)) ) htmp->Scale(1.0/(Float_t)nEvtRaw);
+ if ( (htmp=GetData(histos, 14+14+42+42+3, itc)) ) htmp->Scale(1.0/(Float_t)nEvtRaw);
+ if ( (htmp=GetData(histos, 14+14+42+42+4, itc)) ) htmp->Scale(1.0/(Float_t)nEvtRaw);
+ }
+ Double_t binval=0,binerr=0;
+ TH1F *h4 = (TH1F*) GetData(histos, 14+14+42+42+1, itc);
+ TProfile *h4prf = (TProfile*)GetData(histos, 14+14+42+42+5, itc);
+ if (h4 && h4prf) {
+ for(Int_t iddl=1;iddl<=14;iddl++) {
+ binval=h4prf->GetBinContent(iddl); binerr=h4prf->GetBinError(iddl);
+ h4->SetBinContent(iddl,binval); h4->SetBinError(iddl,binerr);
+ }
+ }
+ //if (nEvtRaw>0) h4->Scale(1./(Float_t)nEvtRaw);
+ //
+ TH1F *h5 = (TH1F*) GetData(histos, 14+14+42+42+2, itc);
+ TProfile *h5prf = (TProfile*)GetData(histos, 14+14+42+42+6, itc);
+ if (h4 && h4prf) {
+ for(Int_t iddl=1;iddl<=14;iddl++) {
+ binval=h5prf->GetBinContent(iddl); binerr=h5prf->GetBinError(iddl);
+ h5->SetBinContent(iddl,binval); h5->SetBinError(iddl,binerr);
+ }
+ }
+ //if(nEvtRaw>0) h5->Scale(1./(Float_t)nEvtRaw/11520.0*100.0);
+ }//specie loop
+ }//RAWS
+ //
+ } // RS: loop over eventual clones per trigger class
+ //
AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, histos);
-
-
+ //
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
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
TLine *fLineDdlDatSizeLow; // line for minimum data size limit
TLine *fLineDdlDatSizeUp; // line for maximum data size limit
TLine *fLineDdlPadOCcLow; // line for minimum occupancy limit
Int_t fChannel ; //!
- ClassDef(AliHMPIDQADataMakerRec,3) // description
+ ClassDef(AliHMPIDQADataMakerRec,4) // description
};
hHitMap[iCh]=new TH2F(Form("HMPID HitMap%i",iCh),Form("Ch%i;x_{Hit};y_{Hit};Entries",iCh),162,-1,161,146,-1,145);
Add2HitsList(hHitMap[iCh],iCh+1,expert,!image);
}
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
Add2DigitsList(hDigPcEvt,1,expert, !image);
for(Int_t iMap=0; iMap < 7; iMap++) Add2DigitsList(hDigMap[iMap],2+iMap,expert, !image);
for(Int_t iH =0; iH < 42 ; iH++) Add2DigitsList(hDigQ[iH] ,9+iH,expert,!image);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1F *hSDigits = new TH1F("hHmpidSDigits", "SDigits Q distribution in HMPID;QDC;Entries", 500, 0., 5000.) ;
Add2SDigitsList(hSDigits,0, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line}
}
//____________________________________________________________________________
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());
+ if(hit->Pid()<500000) FillHitsData(0,hit->Q()) ;
+ if(hit->Pid()<500000) FillHitsData(hit->Ch()+1,hit->LorsX(),hit->LorsY());
}
}
//
Int_t i = fChannel ;
- GetDigitsData(0)->Fill(i,fDigitsArray->GetEntriesFast()/(48.*80.*6.));
+ FillDigitsData(0,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());
+ FillDigitsData(1,10.*i+digit->Pc(),1./(48.*80.));
+ FillDigitsData(2+i,digit->PadChX(),digit->PadChY());
+ FillDigitsData(9+i*6+digit->Pc(),digit->Q());
}
}
//___________________________________________________________________________
TIter next(fSDigitsArray) ;
AliHMPIDDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliHMPIDDigit *>(next())) ) {
- GetSDigitsData(0)->Fill(sdigit->Q());
+ FillSDigitsData(0,sdigit->Q());
}
}
//___________________________________________________________________________
{
//Detector specific actions at end of cycle
// do the QA checking
+ ResetEventTrigClasses(); // reset triggers list to select all histos
AliQAChecker::Instance()->Run(AliQAv1::kHMPID, task, obj) ;
}
//____________________________________________________________________________
AliITSQADataMakerRec::AliITSQADataMakerRec(Bool_t kMode, Short_t subDet, Short_t ldc) :
AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kITS), "ITS Quality Assurance Data Maker"),
-fkOnline(kMode),
-fSubDetector(subDet),
-fLDC(ldc),
-fRunNumber(0),
-fEventNumber(0),
-fSelectedTaskIndex(AliQAv1::kNULLTASKINDEX),
-fSPDDataMaker(NULL),
-fSDDDataMaker(NULL),
-fSSDDataMaker(NULL)
+ fkOnline(kMode),
+ fSubDetector(subDet),
+ fLDC(ldc),
+ fRunNumber(0),
+ fEventNumber(0),
+ fSelectedTaskIndex(AliQAv1::kNULLTASKINDEX),
+ fSPDDataMaker(NULL),
+ fSDDDataMaker(NULL),
+ fSSDDataMaker(NULL)
{
//ctor used to discriminate OnLine-Offline analysis
if(fSubDetector < 0 || fSubDetector > 3) {
- AliError("Error: fSubDetector number out of range; return\n");
+ AliError("Error: fSubDetector number out of range; return\n");
}
// Initialization for RAW data
if(fSubDetector == 0 || fSubDetector == 1) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SPD DataMakerRec\n");
- fSPDDataMaker = new AliITSQASPDDataMakerRec(this,fkOnline);
+ fSPDDataMaker = new AliITSQASPDDataMakerRec(this,fkOnline);
}
if(fSubDetector == 0 || fSubDetector == 2) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SDD DataMakerRec\n");
- fSDDDataMaker = new AliITSQASDDDataMakerRec(this,fkOnline);
+ fSDDDataMaker = new AliITSQASDDDataMakerRec(this,fkOnline);
}
if(fSubDetector == 0 || fSubDetector == 3) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Create SSD DataMakerRec\n");
- fSSDDataMaker = new AliITSQASSDDataMakerRec(this,fkOnline);
+ fSSDDataMaker = new AliITSQASSDDataMakerRec(this,fkOnline);
}
}
//____________________________________________________________________________
AliITSQADataMakerRec::AliITSQADataMakerRec(const AliITSQADataMakerRec& qadm) :
-AliQADataMakerRec(),
-fkOnline(qadm.fkOnline),
-fSubDetector(qadm.fSubDetector),
-fLDC(qadm.fLDC),
-fRunNumber(qadm.fRunNumber),
-fEventNumber(qadm.fEventNumber),
-fSelectedTaskIndex(qadm.fSelectedTaskIndex),
-fSPDDataMaker(NULL),
-fSDDDataMaker(NULL),
-fSSDDataMaker(NULL)
+ AliQADataMakerRec(),
+ fkOnline(qadm.fkOnline),
+ fSubDetector(qadm.fSubDetector),
+ fLDC(qadm.fLDC),
+ fRunNumber(qadm.fRunNumber),
+ fEventNumber(qadm.fEventNumber),
+ fSelectedTaskIndex(qadm.fSelectedTaskIndex),
+ fSPDDataMaker(NULL),
+ fSDDDataMaker(NULL),
+ fSSDDataMaker(NULL)
{
//copy ctor
{
//Detector specific actions at start of cycle
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of ITS Cycle\n");
+ ResetEventTrigClasses(); // reset triggers list to select all histos
+ ResetEvCountCycle();
+ //
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->StartOfDetectorCycle();
void AliITSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
// launch the QA checking
-
+ ResetEventTrigClasses();
+ //
AliInfo(Form("End of Dedetctor Cycle called for %s\n",AliQAv1::GetTaskName(task).Data() ));
+ //
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-
- if(AliQAv1::Instance()->IsEventSpecieSet(specie)){
- Int_t idnumber=list[specie]->GetUniqueID();
- //printf("specie %s \t id number == %d\n",AliRecoParam::GetEventSpecieName(specie),idnumber);
- if(idnumber==40||idnumber==0){
- //AliInfo(Form("No check for %s\n",AliQAv1::GetTaskName(task).Data() ))
- continue;
- } //skip kDigitsR and not filled TobjArray specie
- else{
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n");
- if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list[/*GetEventSpecie()*/specie]);
- if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list[/*GetEventSpecie()*/specie]);
- if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list[/*GetEventSpecie()*/specie]);
-
-
- AliQAChecker *qac = AliQAChecker::Instance();
- AliITSQAChecker *qacb = (AliITSQAChecker *) qac->GetDetQAChecker(0);
- Int_t subdet=GetSubDet();
- qacb->SetSubDet(subdet);
-
- if(subdet== 0 ){
- qacb->SetTaskOffset(fSPDDataMaker->GetOffset(task,specie), fSDDDataMaker->GetOffset(task,specie), fSSDDataMaker->GetOffset(task,specie)); //Setting the offset for the QAChecker list
- qacb->SetHisto(fSPDDataMaker->GetTaskHisto(task), fSDDDataMaker->GetTaskHisto(task), fSSDDataMaker->GetTaskHisto(task));
- }
- else
- if(subdet!=0){
- Int_t offset=GetDetTaskOffset(subdet, task,specie);
- qacb->SetDetTaskOffset(subdet,offset);
- Int_t histo=GetDetTaskHisto(subdet, task);
- qacb->SetDetHisto(subdet,histo);
- }
-
- qac->Run( AliQAv1::kITS , task, list);
-
- }//end else unique id
- }//end else event specie
+ //
+ if(!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ Int_t idnumber=list[specie]->GetUniqueID();
+ //printf("specie %s \t id number == %d\n",AliRecoParam::GetEventSpecieName(specie),idnumber);
+ if(idnumber==40||idnumber==0){
+ //AliInfo(Form("No check for %s\n",AliQAv1::GetTaskName(task).Data() ))
+ continue;
+ } //skip kDigitsR and not filled TobjArray specie
+ else{
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list[specie])\n");
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->EndOfDetectorCycle(task, list);//[/*GetEventSpecie()*/specie]);
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->EndOfDetectorCycle(task, list);//[/*GetEventSpecie()*/specie]);
+ if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->EndOfDetectorCycle(task, list);//[/*GetEventSpecie()*/specie]);
+
+
+ AliQAChecker *qac = AliQAChecker::Instance();
+ AliITSQAChecker *qacb = (AliITSQAChecker *) qac->GetDetQAChecker(0);
+ Int_t subdet=GetSubDet();
+ qacb->SetSubDet(subdet);
+
+ if(subdet== 0 ){
+ qacb->SetTaskOffset(fSPDDataMaker->GetOffset(task,specie), fSDDDataMaker->GetOffset(task,specie), fSSDDataMaker->GetOffset(task,specie)); //Setting the offset for the QAChecker list
+ qacb->SetHisto(fSPDDataMaker->GetTaskHisto(task), fSDDDataMaker->GetTaskHisto(task), fSSDDataMaker->GetTaskHisto(task));
+ }
+ else
+ if(subdet!=0){
+ Int_t offset=GetDetTaskOffset(subdet, task,specie);
+ qacb->SetDetTaskOffset(subdet,offset);
+ Int_t histo=GetDetTaskHisto(subdet, task);
+ qacb->SetDetHisto(subdet,histo);
+ }
+
+ qac->Run( AliQAv1::kITS , task, list);
+
+ }//end else unique id
+
}//end for
}
//____________________________________________________________________________
//void AliITSQADataMakerRec::EndOfDetectorCycle(const char * /*fgDataName*/)
//{
- //eventually used for different AliQAChecker::Instance()->Run
+//eventually used for different AliQAChecker::Instance()->Run
//}
//____________________________________________________________________________
//if(fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
-
-
if(fSubDetector == 0 || fSubDetector == 1) {
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRaws\n");
fSPDDataMaker->InitRaws();
fSSDDataMaker->InitRaws();
}
fRawsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(10);
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
}
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeRaws(rawReader);
-
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
fSSDDataMaker->InitDigits();
}
fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(40);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
}
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digitsTree);
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
//if(fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries()) return;
- if(fSubDetector == 0 || fSubDetector == 1) {
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRecPoints\n");
- fSPDDataMaker->InitRecPoints();
- }
- if(fSubDetector == 0 || fSubDetector == 2) {
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRecPoints\n");
- fSDDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(), AliRecoParam::AConvert(fEventSpecie));
- fSDDDataMaker->InitRecPoints();
- }
- if(fSubDetector == 0 || fSubDetector == 3) {
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRecPoints\n");
- fSSDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
- fSSDDataMaker->InitRecPoints();
- }
+ if(fSubDetector == 0 || fSubDetector == 1) {
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SPD InitRecPoints\n");
+ fSPDDataMaker->InitRecPoints();
+ }
+ if(fSubDetector == 0 || fSubDetector == 2) {
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SDD InitRecPoints\n");
+ fSDDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(), AliRecoParam::AConvert(fEventSpecie));
+ fSDDDataMaker->InitRecPoints();
+ }
+ if(fSubDetector == 0 || fSubDetector == 3) {
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM:: SSD InitRecPoints\n");
+ fSSDDataMaker->SetOffset(AliQAv1::kRECPOINTS, fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
+ fSSDDataMaker->InitRecPoints();
+ }
fRecPointsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(20);
- if(fSubDetector == 0){
- Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
- const Bool_t expert = kTRUE ;
- const Bool_t image = kTRUE ;
- TH2F* hPhiEta[6];
- for (Int_t iLay=0;iLay<6;iLay++) {
- hPhiEta[iLay]=new TH2F(Form("Phi_vs_Eta_ITS_Layer%d",iLay+1),Form("Phi_vs_Eta_ITS_Layer%d",iLay+1),30,-1.5,1.5,200,0.,2*TMath::Pi());
- hPhiEta[iLay]->GetXaxis()->SetTitle("Pseudorapidity");
- hPhiEta[iLay]->GetYaxis()->SetTitle("#varphi [rad]");
- Add2RecPointsList(hPhiEta[iLay], iLay + offset, !expert, image);
-
- //delete hPhiEta[iLay];
- }
+ if(fSubDetector == 0){
+ Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+ TH2F* hPhiEta[6];
+ for (Int_t iLay=0;iLay<6;iLay++) {
+ hPhiEta[iLay]=new TH2F(Form("Phi_vs_Eta_ITS_Layer%d",iLay+1),Form("Phi_vs_Eta_ITS_Layer%d",iLay+1),30,-1.5,1.5,200,0.,2*TMath::Pi());
+ hPhiEta[iLay]->GetXaxis()->SetTitle("Pseudorapidity");
+ hPhiEta[iLay]->GetYaxis()->SetTitle("#varphi [rad]");
+ Add2RecPointsList(hPhiEta[iLay], iLay + offset, !expert, image);
+ //delete hPhiEta[iLay];
+ }
- }
-
+ }
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
else { eta = -TMath::Log(TMath::Tan(theta/2.));}
}
// printf("=========================>hlt rcp->GetLayer() = %d \n",rcp->GetLayer());
- (GetRecPointsData( rcp->GetLayer() + offset - 6))->Fill(eta,phi);
+ FillRecPointsData(rcp->GetLayer() + offset - 6,eta,phi);
}
}
}
-
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
void AliITSQADataMakerRec::FillRecPoint(AliITSRecPoint rcp)
{
- // Fill QA for recpoints
- Float_t cluGlo[3] = {0.,0.,0.};
- Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
+ // Fill QA for recpoints
+ Float_t cluGlo[3] = {0.,0.,0.};
+ Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
// Check id histograms already created for this Event Specie
- rcp.GetGlobalXYZ(cluGlo);
- Double_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]+cluGlo[2]*cluGlo[2]);
- Double_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
- Double_t theta = TMath::ACos(cluGlo[2]/rad);
- Double_t eta = 100.;
- if(AreEqual(rad,0.)==kFALSE) {
- if(theta<=1.e-14){eta=30.;}
- else {eta = -TMath::Log(TMath::Tan(theta/2.));}
- }
- (GetRecPointsData( rcp.GetLayer() + offset - 6))->Fill(eta,phi);
+ rcp.GetGlobalXYZ(cluGlo);
+ Double_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]+cluGlo[2]*cluGlo[2]);
+ Double_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
+ Double_t theta = TMath::ACos(cluGlo[2]/rad);
+ Double_t eta = 100.;
+ if(AreEqual(rad,0.)==kFALSE) {
+ if(theta<=1.e-14){eta=30.;}
+ else {eta = -TMath::Log(TMath::Tan(theta/2.));}
+ }
+ FillRecPointsData( rcp.GetLayer() + offset - 6, eta,phi);
}
TH2F *AliITSQADataMakerRec::GetITSGlobalHisto(Int_t layer)
{
- Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
- return ((TH2F *) GetRecPointsData( layer + offset - 6));//local distribution
+ Int_t offset = fRecPointsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries();
+ return ((TH2F *) GetRecPointsData( layer + offset - 6));//local distribution
}
//____________________________________________________________________________
TH2F* hSPDTrackletsvsFiredChips0 =
new TH2F("hSPDTrackletsvsFiredChips0","N SPD Tracklets vs N FiredChips Layer0",
- 300,0.,300.,300,0.,300.);
+ 300,0.,300.,300,0.,300.);
hSPDTrackletsvsFiredChips0->GetXaxis()->SetTitle("N FiredChips Layer0");
hSPDTrackletsvsFiredChips0->GetYaxis()->SetTitle("N SPD Tracklets");
hSPDTrackletsvsFiredChips0->Sumw2();
TH2F* hSPDTrackletsvsFiredChips1 =
new TH2F("hSPDTrackletsvsFiredChips1","N SPD Tracklets vs N FiredChips Layer1",
- 300,0.,300.,300,0.,300.);
+ 300,0.,300.,300,0.,300.);
hSPDTrackletsvsFiredChips1->GetXaxis()->SetTitle("N FiredChips Layer1");
hSPDTrackletsvsFiredChips1->GetYaxis()->SetTitle("N SPD Tracklets");
hSPDTrackletsvsFiredChips1->Sumw2();
TH2F* hSPDFiredChips1vsFiredChips0 =
new TH2F("hSPDFiredChips1vsFiredChips0","N FiredChips Layer1 vs N FiredChips Layer0",
- 300,0.,300.,300,0.,300.);
+ 300,0.,300.,300,0.,300.);
hSPDFiredChips1vsFiredChips0->GetXaxis()->SetTitle("N FiredChips Layer0");
hSPDFiredChips1vsFiredChips0->GetYaxis()->SetTitle("N FiredChips Layer1");
hSPDFiredChips1vsFiredChips0->Sumw2();
Add2ESDsList(hESDSkippedLayers, 23, expertHistogram);
fESDsQAList[AliRecoParam::AConvert(fEventSpecie)]->SetUniqueID(30);
- return;
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
// Make QA data from ESDs
// Check id histograms already created for this Event Specie
-// if ( ! GetESDsData(0) )
-// InitESDs() ;
+ // if ( ! GetESDsData(0) )
+ // InitESDs() ;
const Int_t nESDTracks = esd->GetNumberOfTracks();
Int_t nITSrefit5 = 0;
if(nclsITS>=5 && itsrefit) nITSrefit5++;
if(tpcin) {
- GetESDsData(0)->Fill(nclsITS);
+ FillESDsData(0,nclsITS);
}
if(itsin && !tpcin){
- GetESDsData(2)->Fill(nclsITS);
+ FillESDsData(2,nclsITS);
}
for(Int_t layer=0; layer<6; layer++) {
if(TESTBIT(track->GetITSClusterMap(),layer)) {
if(tpcin) {
- GetESDsData(1)->Fill(layer);
+ FillESDsData(1,layer);
} else {
- GetESDsData(3)->Fill(layer);
+ FillESDsData(3,layer);
}
}
track->GetITSModuleIndexInfo(layer,idet,status,xloc,zloc);
- if(status==3) GetESDsData(23)->SetBinContent(layer,1);
+ if(status==3) SetESDsDataBinContent(23,layer,1);
}
} // end loop on tracks
Int_t mult = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetNumberOfTracklets();
AliInfo(Form("Multiplicity %d ; Number of SPD vert contributors %d",mult,vtxSPD->GetNContributors()));
if(mult>0)
- GetESDsData(7)->Fill((Float_t)(vtxSPD->GetNContributors())/(Float_t)mult);
+ FillESDsData(7,(Float_t)(vtxSPD->GetNContributors())/(Float_t)mult);
if(nITSrefit5>0)
- GetESDsData(11)->Fill((Float_t)(vtxTrk->GetNIndices())/(Float_t)nITSrefit5);
+ FillESDsData(11,(Float_t)(vtxTrk->GetNIndices())/(Float_t)nITSrefit5);
if(vtxSPD->GetNContributors()>0) {
- GetESDsData(4)->Fill(vtxSPD->GetXv());
- GetESDsData(5)->Fill(vtxSPD->GetYv());
- GetESDsData(6)->Fill(vtxSPD->GetZv());
+ FillESDsData(4,vtxSPD->GetXv());
+ FillESDsData(5,vtxSPD->GetYv());
+ FillESDsData(6,vtxSPD->GetZv());
}
if(vtxTrk->GetNContributors()>0) {
- GetESDsData(8)->Fill(vtxTrk->GetXv());
- GetESDsData(9)->Fill(vtxTrk->GetYv());
- GetESDsData(10)->Fill(vtxTrk->GetZv());
+ FillESDsData(8,vtxTrk->GetXv());
+ FillESDsData(9,vtxTrk->GetYv());
+ FillESDsData(10,vtxTrk->GetZv());
}
if(vtxSPD->GetNContributors()>0 &&
vtxTrk->GetNContributors()>0) {
- GetESDsData(12)->Fill(vtxSPD->GetXv()-vtxTrk->GetXv());
- GetESDsData(13)->Fill(vtxSPD->GetYv()-vtxTrk->GetYv());
- GetESDsData(14)->Fill(vtxSPD->GetZv()-vtxTrk->GetZv());
+ FillESDsData(12,vtxSPD->GetXv()-vtxTrk->GetXv());
+ FillESDsData(13,vtxSPD->GetYv()-vtxTrk->GetYv());
+ FillESDsData(14,vtxSPD->GetZv()-vtxTrk->GetZv());
}
// SPD Tracklets
- GetESDsData(15)->Fill(mult);
+ FillESDsData(15,mult);
Short_t nFiredChips0 = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetNumberOfFiredChips(0);
Short_t nFiredChips1 = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetNumberOfFiredChips(1);
- GetESDsData(16)->Fill(nFiredChips0,mult);
- GetESDsData(17)->Fill(nFiredChips1,mult);
- GetESDsData(18)->Fill(nFiredChips0,nFiredChips1);
+ FillESDsData(16,nFiredChips0,mult);
+ FillESDsData(17,nFiredChips1,mult);
+ FillESDsData(18,nFiredChips0,nFiredChips1);
// Loop over tracklets
for (Int_t itr=0; itr<mult; ++itr) {
Float_t deThetaTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetDeltaTheta(itr);
Float_t phiTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetPhi(itr);
Float_t thetaTr = ((AliMultiplicity*)(esd->GetMultiplicity()))->GetTheta(itr);
- GetESDsData(19)->Fill(dePhiTr);
- GetESDsData(20)->Fill(phiTr);
- GetESDsData(21)->Fill(deThetaTr);
- GetESDsData(22)->Fill(thetaTr);
+ FillESDsData(19,dePhiTr);
+ FillESDsData(20,phiTr);
+ FillESDsData(21,deThetaTr);
+ FillESDsData(22,thetaTr);
} // end loop on tracklets
-
- return;
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//_________________________________________________________________
}
//____________________________________________________________________
-
Bool_t AliITSQADataMakerRec::ListExists(AliQAv1::TASKINDEX_t task) const
{
//Check the existence of a list for a given task
{
//Detector specific actions at start of cycle
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of ITS Cycle\n");
-
+ ResetEventTrigClasses(); // reset triggers list to select all histos
+ ResetEvCountCycle();
+ //
if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->StartOfDetectorCycle();
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->StartOfDetectorCycle();
//____________________________________________________________________________
void AliITSQADataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
-
+ //
AliInfo(Form("End of Dedetctor Cycle called for %s\n",AliQAv1::GetTaskName(task).Data() ));
-
+ ResetEventTrigClasses(); // reset triggers list to select all histos
+ //
// launch the QA checking
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! IsValidEventSpecie(specie, list) ){
- continue ;
- }
+ if (! IsValidEventSpecie(specie, list) ) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //
+ Int_t idnumber=list[specie]->GetUniqueID();
+ //printf("specie %s \t id number == %d\n",AliRecoParam::GetEventSpecieName(specie),idnumber);
+ if(idnumber==0) {
+ //AliInfo(Form("No check for %s\n",AliQAv1::GetTaskName(task).Data() ))
+ continue;
+ } //skip kDigitsR and not filled TobjArray specie
else{
- Int_t idnumber=list[specie]->GetUniqueID();
- //printf("specie %s \t id number == %d\n",AliRecoParam::GetEventSpecieName(specie),idnumber);
- if(idnumber==0)
- {
- //AliInfo(Form("No check for %s\n",AliQAv1::GetTaskName(task).Data() ))
- continue;
- } //skip kDigitsR and not filled TobjArray specie
- else{
- 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]);
-
-
- AliQAChecker *qac = AliQAChecker::Instance();
- AliITSQAChecker *qacb = (AliITSQAChecker *) qac->GetDetQAChecker(0);
- Int_t subdet=GetSubDet();
- qacb->SetSubDet(subdet);
-
- if(subdet== 0 ){
- qacb->SetTaskOffset(fSPDDataMaker->GetOffset(task,specie),fSDDDataMaker->GetOffset(task,specie),fSSDDataMaker->GetOffset(task,specie)); //Setting the offset for the QAChecker list
+ 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]);
+ //
+ AliQAChecker *qac = AliQAChecker::Instance();
+ AliITSQAChecker *qacb = (AliITSQAChecker *) qac->GetDetQAChecker(0);
+ Int_t subdet=GetSubDet();
+ qacb->SetSubDet(subdet);
+
+ if(subdet== 0 ){
+ qacb->SetTaskOffset(fSPDDataMaker->GetOffset(task,specie),fSDDDataMaker->GetOffset(task,specie),fSSDDataMaker->GetOffset(task,specie)); //Setting the offset for the QAChecker list
qacb->SetHisto(fSPDDataMaker->GetTaskHisto(task), fSDDDataMaker->GetTaskHisto(task), fSSDDataMaker->GetTaskHisto(task));
+ }
+ else
+ if(subdet!=0){
+ Int_t offset=GetDetTaskOffset(subdet, task);
+ qacb->SetDetTaskOffset(subdet,offset);
+ Int_t histo=GetDetTaskHisto(subdet, task);
+ qacb->SetDetHisto(subdet,histo);
}
- else
- if(subdet!=0){
- Int_t offset=GetDetTaskOffset(subdet, task);
- qacb->SetDetTaskOffset(subdet,offset);
- Int_t histo=GetDetTaskHisto(subdet, task);
- qacb->SetDetHisto(subdet,histo);
- }
- qac->Run( AliQAv1::kITS , task, list);
- }//end else unique id
- }//end else event specie
+ qac->Run( AliQAv1::kITS , task, list);
+ }//end else unique id
}//end for
}
fSSDDataMaker->SetOffset(AliQAv1::kDIGITS, fDigitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
fSSDDataMaker->InitDigits();
}
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
void AliITSQADataMakerSim::MakeDigits()
{
// Fill QA for digits
- if(fSubDetector == 0 || fSubDetector == 1)
- fSPDDataMaker->MakeDigits() ;
-
-
- if(fSubDetector == 0 || fSubDetector == 2)
- fSDDDataMaker->MakeDigits() ;
-
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeDigits();
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeDigits();
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits();
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
void AliITSQADataMakerSim::MakeDigits(TTree * digits)
{
// Fill QA for digits
- if(fSubDetector == 0 || fSubDetector == 1)
- fSPDDataMaker->MakeDigits(digits) ;
-
- if(fSubDetector == 0 || fSubDetector == 2)
- fSDDDataMaker->MakeDigits(digits) ;
-
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeDigits(digits);
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeDigits(digits);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeDigits(digits);
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
fSSDDataMaker->SetOffset(AliQAv1::kSDIGITS, fSDigitsQAList [AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
fSSDDataMaker->InitSDigits();
}
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
void AliITSQADataMakerSim::MakeSDigits()
{
// Fill QA for sdigits
- if(fSubDetector == 0 || fSubDetector == 1)
- fSPDDataMaker->MakeSDigits() ;
-
-
- if(fSubDetector == 0 || fSubDetector == 2)
- fSDDDataMaker->MakeSDigits() ;
-
-
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeSDigits();
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeSDigits();
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeSDigits();
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
void AliITSQADataMakerSim::MakeSDigits(TTree * sdigits)
{
// Fill QA for recpoints
- if(fSubDetector == 0 || fSubDetector == 1){
- fSPDDataMaker->MakeSDigits(sdigits) ;
- }
-
- if(fSubDetector == 0 || fSubDetector == 2){
- fSDDDataMaker->MakeSDigits(sdigits) ;
- }
-
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeSDigits(sdigits);
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeSDigits(sdigits);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeSDigits(sdigits);
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
fSSDDataMaker->SetOffset(AliQAv1::kHITS, fHitsQAList[AliRecoParam::AConvert(fEventSpecie)]->GetEntries(),AliRecoParam::AConvert(fEventSpecie));
fSSDDataMaker->InitHits();
}
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
void AliITSQADataMakerSim::MakeHits()
{
// Fill QA for hits
- if(fSubDetector == 0 || fSubDetector == 1) {
- fSPDDataMaker->MakeHits() ;
- }
-
- if(fSubDetector == 0 || fSubDetector == 2) {
- fSDDDataMaker->MakeHits() ;
- }
-
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeHits();
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeHits();
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeHits();
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
void AliITSQADataMakerSim::MakeHits(TTree * hits)
{
// Fill QA for hits
- if(fSubDetector == 0 || fSubDetector == 1) {
- fSPDDataMaker->MakeHits(hits) ;
- }
- if(fSubDetector == 0 || fSubDetector == 2) {
- fSDDDataMaker->MakeHits(hits) ;
- }
-
+ if(fSubDetector == 0 || fSubDetector == 1) fSPDDataMaker->MakeHits(hits);
+ if(fSubDetector == 0 || fSubDetector == 2) fSDDDataMaker->MakeHits(hits);
if(fSubDetector == 0 || fSubDetector == 3) fSSDDataMaker->MakeHits(hits);
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//_________________________________________________________________
//return the offset for each subdetector
switch(subdet)
{
-
Int_t offset;
case 1:
offset=fSPDDataMaker->GetOffset(task);
// --- ROOT system ---
#include <TProfile2D.h>
-#include <TH2D.h>
+#include <TH2F.h>
#include <TH1F.h>
#include <TBranch.h>
#include <TTree.h>
fGenDigitsOffset(0),
fGenRecPointsOffset(0),
fTimeBinSize(1),
-fNEvent(0),
-fNEventRP(0),
fDDLModuleMap(0),
fCalibration(0),
fHistoCalibration(0)
fGenDigitsOffset(qadm.fGenDigitsOffset),
fGenRecPointsOffset(qadm.fGenRecPointsOffset),
fTimeBinSize(qadm.fTimeBinSize),
-fNEvent(qadm.fNEvent),
-fNEventRP(qadm.fNEventRP),
fDDLModuleMap(qadm.fDDLModuleMap),
fCalibration(qadm.fCalibration),
fHistoCalibration(qadm.fHistoCalibration)
{
//Start of a QA cycle
-
+ //
AliDebug(AliQAv1::GetQADebugLevel(),Form("Start of SDD Cycle with event specie %s for task %s\n",AliRecoParam::GetEventSpecieName(fAliITSQADataMakerRec->GetEventSpecie()),AliQAv1::GetTaskName(fAliITSQADataMakerRec->GetTaskIndexSelected()).Data()));
- if(!fCalibration)
- {
- //fAliITSQADataMakerRec->GetRawsData(9+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- CreateTheCalibration();
+ if(!fCalibration) {
+ //fAliITSQADataMakerRec->GetRawsData(9+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
+ CreateTheCalibration();
}
if(fAliITSQADataMakerRec->GetEventSpecie()==0) return;//not the kDefault EventSpecie
- //Detector specific actions at start of cycle
- if(fAliITSQADataMakerRec->GetTaskIndexSelected()==AliQAv1::kRAWS){
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SDD Cycle\n");
- if(fAliITSQADataMakerRec->ListExists(AliQAv1::kRAWS)==kFALSE)return;
-
- AliDebug(AliQAv1::GetQADebugLevel(),Form("Reset of Raw Data normalized histograms with eventspecie %s ",AliRecoParam::GetEventSpecieName(fAliITSQADataMakerRec->GetEventSpecie())));
- fAliITSQADataMakerRec->GetRawsData(10+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- fAliITSQADataMakerRec->GetRawsData(3+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- fAliITSQADataMakerRec->GetRawsData(4+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- fAliITSQADataMakerRec->GetRawsData(5+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
-
- }
- if(fAliITSQADataMakerRec->GetTaskIndexSelected()==AliQAv1::kRECPOINTS){
- if(fAliITSQADataMakerRec->ListExists(AliQAv1::kRECPOINTS)==kFALSE)return;
-
- AliDebug(AliQAv1::GetQADebugLevel(),Form("Reset of RecPoints normalized histograms with eventspecie %s ",AliRecoParam::GetEventSpecieName(fAliITSQADataMakerRec->GetEventSpecie())));
-
- fAliITSQADataMakerRec->GetRecPointsData(9+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- fAliITSQADataMakerRec->GetRecPointsData(10+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- fAliITSQADataMakerRec->GetRecPointsData(11+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
-
- }
+ //Detector specific actions at start of cycle
+ if(fAliITSQADataMakerRec->GetTaskIndexSelected()==AliQAv1::kRAWS){
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SDD Cycle\n");
+ if(fAliITSQADataMakerRec->ListExists(AliQAv1::kRAWS)==kFALSE)return;
+ //
+ int offsRW = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Reset of Raw Data normalized histograms with eventspecie %s ",AliRecoParam::GetEventSpecieName(fAliITSQADataMakerRec->GetEventSpecie())));
+ fAliITSQADataMakerRec->ResetRawsData(10+offsRW );
+ fAliITSQADataMakerRec->ResetRawsData(3+ offsRW);
+ fAliITSQADataMakerRec->ResetRawsData(4+ offsRW);
+ fAliITSQADataMakerRec->ResetRawsData(5+ offsRW);
+ //
+ }
+ if(fAliITSQADataMakerRec->GetTaskIndexSelected()==AliQAv1::kRECPOINTS){
+ if(fAliITSQADataMakerRec->ListExists(AliQAv1::kRECPOINTS)==kFALSE)return;
+
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Reset of RecPoints normalized histograms with eventspecie %s ",AliRecoParam::GetEventSpecieName(fAliITSQADataMakerRec->GetEventSpecie())));
+ int offsRP = fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
+ fAliITSQADataMakerRec->ResetRecPointsData(9+ offsRP);
+ fAliITSQADataMakerRec->ResetRecPointsData(10+ offsRP);
+ fAliITSQADataMakerRec->ResetRecPointsData(11+ offsRP);
+ fAliITSQADataMakerRec->ResetRecPointsData(27+ offsRP);
+
+ }
}
//____________________________________________________________________________
-void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray* /*list*/)
+void AliITSQASDDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** /*list*/)
{
//end of a QA cycle
+
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
Double_t entriescalibration1= 0.;
Double_t entriescalibrationL3=0.;
Double_t entriescalibrationL4=0.;
-
+ int offsRW = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
+ int offsRP = fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
+ //
if(fHistoCalibration){
- entriescalibration1= ((TH1D*)(fHistoCalibration->At(0)))->GetEntries();
- entriescalibrationL3=((TH2D*)(fHistoCalibration->At(1)))->GetEntries();
- entriescalibrationL4=((TH2D*)(fHistoCalibration->At(2)))->GetEntries();
+ entriescalibration1= ((TH1F*)(fHistoCalibration->At(0)))->GetEntries();
+ entriescalibrationL3=((TH2F*)(fHistoCalibration->At(1)))->GetEntries();
+ entriescalibrationL4=((TH2F*)(fHistoCalibration->At(2)))->GetEntries();
}
else{ AliWarning("Calibration TObjArray is NULL! No Normalization and calibtaion plot will be filled\n");}
- if(task==AliQAv1::kRAWS){
- // printf("fNevent %d \n",fNEvent);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRawsData(10+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(1,fNEvent);
-
- if(fNEvent!=0){
-
- Double_t entriesmodpattern=((TH1D*)fAliITSQADataMakerRec->GetRawsData(0 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetEntries();
- Double_t entriesL3=((TH2D*)fAliITSQADataMakerRec->GetRawsData(1 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetEntries();
- Double_t entriesL4=((TH2D*)fAliITSQADataMakerRec->GetRawsData(2 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetEntries();
-
- Double_t normentriesmodpattern=0.;
- Double_t normentriesL3= 0.;
- Double_t normentriesL4= 0.;
-
- if(entriescalibration1!=0.)normentriesmodpattern=entriesmodpattern/(entriescalibration1*fNEvent);
- if(entriesL3!=0.) normentriesL3= entriesL3/(entriescalibrationL3*fNEvent);
- if(entriesL4!=0.) normentriesL4= entriesL4/(entriescalibrationL4*fNEvent);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRawsData(10+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(2,normentriesmodpattern);
- ((TH1F*)fAliITSQADataMakerRec->GetRawsData(10+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(3,normentriesL3);
- ((TH1F*)fAliITSQADataMakerRec->GetRawsData(10+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(4,normentriesL4);
-
- if(fHistoCalibration){
- ((TH1D*)fAliITSQADataMakerRec->GetRawsData(3 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH1D*)fAliITSQADataMakerRec->GetRawsData(0 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH1D*) (fHistoCalibration->At(0))),1.,(Double_t)fNEvent);
-
- ((TH2D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH2D*)fAliITSQADataMakerRec->GetRawsData(1 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH2D*)(fHistoCalibration->At(1))),1.,(Double_t)fNEvent);
-
- ((TH2D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH2D*)fAliITSQADataMakerRec->GetRawsData(2 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH2D*)(fHistoCalibration->At(2))),1.,(Double_t)fNEvent);
- }
- }
- Int_t xbin3 = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin3 = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
-
- for(Int_t i=0; i<xbin3; i++) {
- for(Int_t j=0; j<ybin3; j++) {
- ((TH1D*)fAliITSQADataMakerRec->GetRawsData(6 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Fill(((TH1D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetBinContent(i,j));
- }
- }
-
- Int_t xbin4 = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin4 = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
-
- for(Int_t i=0; i<xbin4; i++) {
- for(Int_t j=0; j<ybin4; j++) {
- ((TH1D*)fAliITSQADataMakerRec->GetRawsData(7 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Fill(((TH1D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetBinContent(i,j));
+ //
+ for (int trCl=-1;trCl<fAliITSQADataMakerRec->GetNTrigClasses();trCl++) { // RS Loop over all trigger classes (+ global counter, -1)
+ //
+ if(task==AliQAv1::kRAWS) {
+ TObjArray &harr = *fAliITSQADataMakerRec->GetRawsDataOfTrigClass(trCl);
+ int nEvent = GetNumberOfEvents(AliQAv1::kRAWS,trCl);
+ // printf("fNevent %d \n",nEvent);
+ TH1* h10 = (TH1*)harr[10+offsRW];
+ if (h10) h10->SetBinContent(1,nEvent);
+ //
+ if(nEvent!=0) {
+ if (h10 && harr[0+offsRW] && harr[1+offsRW] && harr[2]) { // were they all cloned?
+ //
+ Double_t entriesmodpattern = ((TH1*)harr[0+offsRW])->GetEntries();
+ Double_t entriesL3 = ((TH1*)harr[1+offsRW])->GetEntries();
+ Double_t entriesL4 = ((TH1*)harr[2+offsRW])->GetEntries();
+ //
+ Double_t normentriesmodpattern=0.;
+ Double_t normentriesL3= 0.;
+ Double_t normentriesL4= 0.;
+
+ if(entriescalibration1!=0.)normentriesmodpattern=entriesmodpattern/(entriescalibration1*nEvent);
+ if(entriesL3!=0.) normentriesL3= entriesL3/(entriescalibrationL3*nEvent);
+ if(entriesL4!=0.) normentriesL4= entriesL4/(entriescalibrationL4*nEvent);
+ //
+ h10->SetBinContent(2,normentriesmodpattern);
+ h10->SetBinContent(3,normentriesL3);
+ h10->SetBinContent(4,normentriesL4);
+ //
+ if(fHistoCalibration){
+ if (harr[3+offsRW] && harr[0+offsRW]) ((TH1*)harr[3+offsRW])->Divide( (TH1*)harr[0+offsRW],((TH1F*)(fHistoCalibration->At(0))),1.,nEvent);
+ if (harr[4+offsRW] && harr[1+offsRW]) ((TH1*)harr[4+offsRW])->Divide( (TH1*)harr[1+offsRW],((TH1F*)(fHistoCalibration->At(1))),1.,nEvent);
+ if (harr[5+offsRW] && harr[2+offsRW]) ((TH1*)harr[5+offsRW])->Divide( (TH1*)harr[2+offsRW],((TH1F*)(fHistoCalibration->At(2))),1.,nEvent);
+ }
+ }
}
- }
-
- if(fHistoCalibration){
- for(Int_t inumb=8;inumb<10;inumb++)
- {
- for(Int_t ii=1; ii<fAliITSQADataMakerRec->GetRawsData(inumb + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetNbinsX()+1;ii++)
- {
- for(Int_t jj=1; jj<fAliITSQADataMakerRec->GetRawsData(inumb+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetNbinsY()+1;jj++)
- {
-
- if(((TH1D*)(fHistoCalibration->At(inumb-7)))->GetBinContent(ii,jj) != 0. )
- {
- fAliITSQADataMakerRec->GetRawsData(inumb+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->SetBinContent(ii,jj,1);
- }
- else if(((TH1D*)(fHistoCalibration->At(inumb-7)))->GetBinContent(ii,jj) == 0. )
- {
- fAliITSQADataMakerRec->GetRawsData(inumb+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->SetBinContent(ii,jj,0);
- }
- //printf("%d \t %d \t %d \t %02f \n",inumb,ii,jj,fAliITSQADataMakerRec->GetRawsData(inumb+ fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetBinContent(ii,jj));
- }//end x axis
- }//end y axis
+ //
+ TH1* htmp4 = (TH1*)harr[4+offsRW];
+ Int_t xbin3 = htmp4 ? ((TH1*)harr[4+offsRW])->GetNbinsX() : 0;
+ Int_t ybin3 = htmp4 ? ((TH1*)harr[4+offsRW])->GetNbinsY() : 0;
+ //
+ TH1* htmp6 = ((TH1*)harr[6+offsRW]);
+ if (htmp6 && htmp4) for(Int_t i=0; i<xbin3; i++) for(Int_t j=0; j<ybin3; j++) htmp6->Fill(htmp4->GetBinContent(i,j));
+ //
+ TH1* htmp5 = (TH1*)harr[5+offsRW];
+ Int_t xbin4 = htmp5 ? htmp5->GetNbinsX() : 0;
+ Int_t ybin4 = htmp5 ? htmp5->GetNbinsY() : 0;
+ //
+ TH1* htmp7 = (TH1*)harr[7+offsRW];
+ if (htmp7 && htmp5) for(Int_t i=0; i<xbin4; i++) for(Int_t j=0; j<ybin4; j++) htmp7->Fill(htmp5->GetBinContent(i,j));
+ //
+ if(fHistoCalibration){
+ for(Int_t inumb=8;inumb<10;inumb++) {
+ TH1* htmp = (TH1*)harr[inumb + offsRW];
+ if (!htmp) continue;
+ TH1* hcal = (TH1*)fHistoCalibration->At(inumb-7);
+ for(Int_t ii=1; ii<htmp->GetNbinsX()+1;ii++) {
+ for(Int_t jj=1; jj<htmp->GetNbinsY()+1;jj++) {
+ if( hcal->GetBinContent(ii,jj) != 0. ) htmp->SetBinContent(ii,jj,1);
+ else if( hcal->GetBinContent(ii,jj) == 0. ) htmp->SetBinContent(ii,jj,0);
+ }//end x axis
+ }//end y axis
}//end for inumb
- }
-
-
- }//end raws
-
- if(task==AliQAv1::kRECPOINTS){
-
-
- Double_t chargeL3=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(0+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMean();
- Double_t errchargeL3=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(0+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMeanError();
-
- Double_t chargeL4=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(1+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMean();
- Double_t errchargeL4=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(1+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMeanError();
-
-
- Double_t radiusL3=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(13+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMean();
- Double_t errradiusL3=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(13+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMeanError();
-
- Double_t radiusL4=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(14+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMean();
- Double_t errradiusL4=((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(14+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetMeanError();
-
-
-
- // printf("fNeventRP %d \n",fNEventRP);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(1,fNEventRP);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(31,chargeL3);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinError(31,errchargeL3);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(47,chargeL4);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinError(47,errchargeL4);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(32,radiusL3);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinError(32,errradiusL3);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(48,radiusL4);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinError(48,errradiusL4);
-
-
- Double_t entriesmodpattern=((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(6 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetEntries();
- Double_t entriesL3=((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(7 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetEntries();
- Double_t entriesL4=((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(8 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetEntries();
+ }
+ //
+ }//end raws
+ //
+ //
+ if(task==AliQAv1::kRECPOINTS) {
+ //
+ TObjArray &harr = *fAliITSQADataMakerRec->GetRecPointsDataOfTrigClass(trCl);
+ //
+ TH1* htmp0 = (TH1*)harr[0+offsRP];
+ TH1* htmp1 = (TH1*)harr[1+offsRP];
+ TH1* htmp13 = (TH1*)harr[13+offsRP];
+ TH1* htmp14 = (TH1*)harr[14+offsRP];
+ //
+ int nEventRP = GetNumberOfEvents(AliQAv1::kRECPOINTS,trCl);
+ if (htmp0 && htmp1 && htmp13 && htmp14) {
+ Double_t chargeL3 = htmp0->GetMean();
+ Double_t errchargeL3 = htmp0->GetMeanError();
+ //
+ Double_t chargeL4 = htmp1->GetMean();
+ Double_t errchargeL4 = htmp1->GetMeanError();
+ //
+ Double_t radiusL3 = htmp13->GetMean();
+ Double_t errradiusL3 = htmp13->GetMeanError();
+
+ Double_t radiusL4= htmp14->GetMean();
+ Double_t errradiusL4= htmp14->GetMeanError();
+ //
+ // printf("fNeventRP %d \n",nEventRP);
+ TH1* htmp27 = (TH1*)harr[27+offsRP];
+ if (htmp27) {
+ htmp27->SetBinContent(1,nEventRP);
+
+ htmp27->SetBinContent(31,chargeL3);
+ htmp27->SetBinError(31,errchargeL3);
+
+ htmp27->SetBinContent(47,chargeL4);
+ htmp27->SetBinError(47,errchargeL4);
+
+ htmp27->SetBinContent(32,radiusL3);
+ htmp27->SetBinError(32,errradiusL3);
+
+ htmp27->SetBinContent(48,radiusL4);
+ htmp27->SetBinError(48,errradiusL4);
+ }
+ //
+ TH1 *htmp6=(TH1*)harr[6+offsRP],*htmp7=(TH1*)harr[7+offsRP],*htmp8=(TH1*)harr[8+offsRP];
+ Double_t entriesmodpattern = htmp6 ? htmp6->GetEntries() : 0;
+ Double_t entriesL3 = htmp7 ? htmp7->GetEntries() : 0;
+ Double_t entriesL4 = htmp8 ? htmp8->GetEntries() : 0;
- //printf("entries modpatternrp = %02f \t L3= %02f \t L4 =%02f \n",entriesmodpattern,entriesL3,entriesL4 );
+ //printf("entries modpatternrp = %02f \t L3= %02f \t L4 =%02f \n",entriesmodpattern,entriesL3,entriesL4 );
- if(fNEventRP!=0){
-
-
-
- Double_t normentriesmodpattern=0.;
- Double_t normentriesL3= 0.;
- Double_t normentriesL4= 0.;
-
- if(entriescalibration1!=0.)normentriesmodpattern=entriesmodpattern/(entriescalibration1*fNEventRP);
- if(entriesL3!=0.) normentriesL3= entriesL3/(entriescalibrationL3*fNEventRP);
- if(entriesL4!=0.) normentriesL4= entriesL4/(entriescalibrationL4*fNEventRP);
-
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(2,normentriesmodpattern);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(3,normentriesL3);
- ((TH1F*)fAliITSQADataMakerRec->GetRecPointsData(27+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->SetBinContent(4,normentriesL4);
-
- // printf("NORM entries modpatternrp = %02f \t L3= %02f \t L4 =%02f \n",normentriesmodpattern,normentriesL3,normentriesL4 );
-
- if(fHistoCalibration){
- ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(9 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(6 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH1D*) (fHistoCalibration->At(0))),1.,(Double_t)fNEventRP);
-
- ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(10+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(7 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH2D*)(fHistoCalibration->At(1))),1.,(Double_t)fNEventRP);
-
- ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(11+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(8 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH2D*)(fHistoCalibration->At(2))),1.,(Double_t)fNEventRP);
+ if(nEventRP!=0) {
+ Double_t normentriesmodpattern=0.;
+ Double_t normentriesL3= 0.;
+ Double_t normentriesL4= 0.;
+
+ if(entriescalibration1!=0.) normentriesmodpattern=entriesmodpattern/(entriescalibration1*nEventRP);
+ if(entriesL3!=0.) normentriesL3= entriesL3/(entriescalibrationL3*nEventRP);
+ if(entriesL4!=0.) normentriesL4= entriesL4/(entriescalibrationL4*nEventRP);
- // ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(21+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(7 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH2D*)(fHistoCalibration->At(1))),1.,(Double_t)fNEventRP);
+ if (htmp27) {
+ htmp27->SetBinContent(2,normentriesmodpattern);
+ htmp27->SetBinContent(3,normentriesL3);
+ htmp27->SetBinContent(4,normentriesL4);
+ }
+ // printf("NORM entries modpatternrp = %02f \t L3= %02f \t L4 =%02f \n",normentriesmodpattern,normentriesL3,normentriesL4 );
- // ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(22+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(8 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]),((TH2D*)(fHistoCalibration->At(2))),1.,(Double_t)fNEventRP);
- }
- }
- Int_t xbin3 = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(10 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin3 = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(10 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
-
- for(Int_t i=0; i<xbin3; i++) {
- for(Int_t j=0; j<ybin3; j++) {
- ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(19 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Fill(((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(10 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetBinContent(i,j));
- }
- }
-
- Int_t xbin4 = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(11 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin4 = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(11 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
-
- for(Int_t i=0; i<xbin4; i++) {
- for(Int_t j=0; j<ybin4; j++) {
- ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(20 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Fill(((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(11 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetBinContent(i,j));
- }
- }
-
- // RecPoints 2 Raws Ratio
- if(fAliITSQADataMakerRec->ListExists(AliQAv1::kRAWS)==kTRUE)
- {
- Int_t xbin3RP = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(21 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin3RP = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(21 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
- Int_t xbin3R = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin3R = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
- if((xbin3RP == xbin3R) && (ybin3RP == ybin3R)) {
- ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(21 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide(((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(10 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])),((TH2D*)fAliITSQADataMakerRec->GetRawsData(4 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])));
- for(Int_t i=0; i<xbin3R; i++) {
- for(Int_t j=0; j<ybin3R; j++) {
- ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(23 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Fill(((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(21 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetBinContent(i,j));
- }
+ if(fHistoCalibration) {
+ if (harr[9 +offsRP] && htmp6) ((TH1*)harr[9 +offsRP])->Divide(htmp6, (TH1*)fHistoCalibration->At(0),nEventRP);
+ if (harr[10+offsRP] && htmp7) ((TH1*)harr[10+offsRP])->Divide(htmp7, (TH1*)fHistoCalibration->At(1),nEventRP);
+ if (harr[11+offsRP] && htmp8) ((TH1*)harr[11+offsRP])->Divide(htmp8, (TH1*)fHistoCalibration->At(2),nEventRP);
+ //if (harr[21+offsRP] && htmp7) ((TH1*)harr[21+offsRP])->Divide(htmp7, (TH1*)fHistoCalibration->At(1),nEventRP);
+ //if (harr[22+offsRP] && htmp8) ((TH1*)harr[22+offsRP])->Divide(htmp8, (TH1*)fHistoCalibration->At(2),nEventRP);
}
- } else
- AliWarning("Number of bins for Raws and RecPoints (Layer 3) do not match\n");
-
- Int_t xbin4RP = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(22 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin4RP = ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(22 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
- Int_t xbin4R = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsX();
- Int_t ybin4R = ((TH1D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetNbinsY();
- if((xbin4RP == xbin4R) && (ybin4RP == ybin4R)) {
- ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(22 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide(((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(11 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])),((TH2D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])));
- // ((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(22 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Divide(((TH2D*)fAliITSQADataMakerRec->GetRawsData(5 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])));
- for(Int_t i=0; i<xbin4R; i++) {
- for(Int_t j=0; j<ybin4R; j++) {
- ((TH1D*)fAliITSQADataMakerRec->GetRecPointsData(24 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->Fill(((TH2D*)fAliITSQADataMakerRec->GetRecPointsData(22 + fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]))->GetBinContent(i,j));
- }
+ }
+ TH1* htmp10 = (TH1*)harr[10+offsRP];
+ Int_t xbin3 = htmp10 ? htmp10->GetNbinsX() : 0;
+ Int_t ybin3 = htmp10 ? htmp10->GetNbinsY() : 0;
+ //
+ TH1* htmp19 = (TH1*)harr[19+offsRP];
+ if (htmp19&&htmp10) for(Int_t i=0; i<xbin3; i++) for(Int_t j=0; j<ybin3; j++) htmp19->Fill(htmp10->GetBinContent(i,j));
+ //
+ TH1* htmp11 = (TH1*)harr[11+offsRP];
+ Int_t xbin4 = htmp11 ? htmp11->GetNbinsX() : 0;
+ Int_t ybin4 = htmp11 ? htmp11->GetNbinsY() : 0;
+ //
+ TH1* htmp20 = (TH1*)harr[20+offsRP];
+ if (htmp11&&htmp20) for(Int_t i=0; i<xbin4; i++) for(Int_t j=0; j<ybin4; j++) htmp20->Fill(htmp11->GetBinContent(i,j));
+ }
+ //
+
+ // RecPoints 2 Raws Ratio
+ if(fAliITSQADataMakerRec->ListExists(AliQAv1::kRAWS)==kTRUE) {
+ //
+ TH1* htmp21 = (TH1*)harr[21+offsRP];
+ TH1* htmp23 = (TH1*)harr[23+offsRP];
+ TH1* htmp10 = (TH1*)harr[10+offsRP];
+ TH1* htmp4rw = fAliITSQADataMakerRec->GetRawsData(4 + offsRW,trCl);
+ if (htmp21 && htmp23 && htmp10 && htmp4rw) {
+ Int_t xbin3RP = htmp21->GetNbinsX();
+ Int_t ybin3RP = htmp21->GetNbinsY();
+ Int_t xbin3R = htmp4rw->GetNbinsX();
+ Int_t ybin3R = htmp4rw->GetNbinsY();
+ if((xbin3RP == xbin3R) && (ybin3RP == ybin3R)) {
+ htmp21->Divide(htmp10,htmp4rw);
+ for(Int_t i=0; i<xbin3R; i++) for(Int_t j=0; j<ybin3R; j++) htmp23->Fill(htmp21->GetBinContent(i,j));
}
- } else
- AliWarning("Number of bins for Raws and RecPoints (Layer 4) do not match\n");
+ else AliWarning("Number of bins for Raws and RecPoints (Layer 3) do not match\n");
+ }
+ //
+ TH1* htmp22 = (TH1*)harr[22+offsRP];
+ TH1* htmp24 = (TH1*)harr[24+offsRP];
+ TH1* htmp11 = (TH1*)harr[11+offsRP];
+ TH1* htmp5rw = fAliITSQADataMakerRec->GetRawsData(5 + offsRW,trCl);
+ if (htmp22 && htmp24 && htmp11 && htmp5rw) {
+ Int_t xbin4RP = htmp22->GetNbinsX();
+ Int_t ybin4RP = htmp22->GetNbinsY();
+ Int_t xbin4R = htmp5rw->GetNbinsX();
+ Int_t ybin4R = htmp5rw->GetNbinsY();
+ if((xbin4RP == xbin4R) && (ybin4RP == ybin4R)) {
+ htmp22->Divide(htmp11,htmp5rw);
+ for(Int_t i=0; i<xbin4R; i++) for(Int_t j=0; j<ybin4R; j++) htmp24->Fill(htmp22->GetBinContent(i,j));
+ }
+ else AliWarning("Number of bins for Raws and RecPoints (Layer 4) do not match\n");
+ }
}
- else{AliWarning("Ratio between RecPoints and Raws not executed because the raw list has not been created\n");}
- }//end recpoints
-
+ else{AliWarning("Ratio between RecPoints and Raws not executed because the raw list has not been created\n");}
+ }//end recpoints
+ //
+ } // RS Loop over all trigger classes (+ global counter, -1)
+ //
}
//____________________________________________________________________________
Int_t lay, lad, det;
Int_t indexlast = 0;
Int_t index1 = 0;
-
- fSDDhRawsTask = 0;
- if(fkOnline){AliInfo("Book Online Histograms for SDD\n");}
+ int offsRW = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
+ fSDDhRawsTask = 0;
+ if(fkOnline){AliInfo("Book Online Histograms for SDD\n");}
else {AliInfo("Book Offline Histograms for SDD\n ");}
- TH1D *h0 = new TH1D("SDDModPattern","HW Modules pattern",fgknSDDmodules,239.5,499.5); //0
+ TH1F *h0 = new TH1F("SDDModPattern","HW Modules pattern",fgknSDDmodules,239.5,499.5); //0
h0->GetXaxis()->SetTitle("Module Number");
h0->GetYaxis()->SetTitle("Counts");
h0->SetOption("bar1");
h0->SetBarOffset(0.01);
h0->SetBarWidth(0.95);
h0->SetFillColor(45);
- rv = fAliITSQADataMakerRec->Add2RawsList(h0,0+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(h0,0+offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
//zPhi distribution using ladder and modules numbers
- TH2D *hphil3 = new TH2D("SDDphizL3","SDD #varphiz Layer3 ",12,0.5,6.5,14,0.5,14.5);//1
+ TH2F *hphil3 = new TH2F("SDDphizL3","SDD #varphiz Layer3 ",12,0.5,6.5,14,0.5,14.5);//1
hphil3->GetXaxis()->SetTitle("z[Module Number L3 ]");
hphil3->GetYaxis()->SetTitle("#varphi[ Ladder Number L3]");
hphil3->SetStats(0);
- rv = fAliITSQADataMakerRec->Add2RawsList(hphil3,1+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hphil3,1+offsRW, !expert, image, !saveCorr);
fSDDhRawsTask++;
- TH2D *hphil4 = new TH2D("SDDphizL4","SDD #varphiz Layer4 ",16,0.5,8.5,22,0.5,22.5); //2
+ TH2F *hphil4 = new TH2F("SDDphizL4","SDD #varphiz Layer4 ",16,0.5,8.5,22,0.5,22.5); //2
hphil4->GetXaxis()->SetTitle("z[Module Number L4]");
hphil4->GetYaxis()->SetTitle("#varphi[Ladder Number L4]");
hphil4->SetStats(0);
- rv = fAliITSQADataMakerRec->Add2RawsList(hphil4,2+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hphil4,2+offsRW, !expert, image, !saveCorr);
fSDDhRawsTask++;
//normalized histograms
- TH1D *h0norm = new TH1D("SDDModPatternNORM","NORM HW Modules pattern",fgknSDDmodules,239.5,499.5); //3
+ TH1F *h0norm = new TH1F("SDDModPatternNORM","NORM HW Modules pattern",fgknSDDmodules,239.5,499.5); //3
h0norm->GetXaxis()->SetTitle("Module Number");
h0norm->GetYaxis()->SetTitle("Counts");
h0norm->SetOption("bar1");
h0norm->SetBarWidth(0.95);
h0norm->SetFillColor(46);
//h0norm->SetStats(0);
- rv = fAliITSQADataMakerRec->Add2RawsList(h0norm,3+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(h0norm,3+offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
//zPhi distribution using ladder and modules numbers
- TH2D *hphil3norm = new TH2D("SDDphizL3NORM","NORM SDD #varphiz Layer3 ",12,0.5,6.5,14,0.5,14.5);//4
+ TH2F *hphil3norm = new TH2F("SDDphizL3NORM","NORM SDD #varphiz Layer3 ",12,0.5,6.5,14,0.5,14.5);//4
hphil3norm->GetXaxis()->SetTitle("z[Module Number L3 ]");
hphil3norm->GetYaxis()->SetTitle("#varphi[ Ladder Number L3]");
hphil3norm->SetStats(0);
- rv = fAliITSQADataMakerRec->Add2RawsList(hphil3norm,4+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hphil3norm,4+offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
- TH2D *hphil4norm = new TH2D("SDDphizL4NORM","NORM SDD #varphiz Layer4 ",16,0.5,8.5,22,0.5,22.5); //5
+ TH2F *hphil4norm = new TH2F("SDDphizL4NORM","NORM SDD #varphiz Layer4 ",16,0.5,8.5,22,0.5,22.5); //5
hphil4norm->GetXaxis()->SetTitle("z[Module Number L4]");
hphil4norm->GetYaxis()->SetTitle("#varphi[Ladder Number L4]");
hphil4norm->SetStats(0);
- rv = fAliITSQADataMakerRec->Add2RawsList(hphil4norm,5+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hphil4norm,5+offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
Float_t hMax = 0.2;
TH1F *oL3 = new TH1F("SDDL3_RelativeOccupancy","Layer 3 Relative Occupancy",200,0.,hMax);
- rv = fAliITSQADataMakerRec->Add2RawsList(oL3,6+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr); //6
+ rv = fAliITSQADataMakerRec->Add2RawsList(oL3,6+offsRW, expert, !image, !saveCorr); //6
fSDDhRawsTask++;
TH1F *oL4 = new TH1F("SDDL4_RelativeOccupancy","Layer 4 Relative Occupancy",200,0.,hMax);
- rv = fAliITSQADataMakerRec->Add2RawsList(oL4,7+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr); //7
+ rv = fAliITSQADataMakerRec->Add2RawsList(oL4,7+offsRW, expert, !image, !saveCorr); //7
fSDDhRawsTask++;
//zPhi distribution using ladder and modules numbers
- TH2D *hcalibl3 = new TH2D("SDDphizCalibL3","SDDCalibL3 ",12,0.5,6.5,14,0.5,14.5);//8
+ TH2F *hcalibl3 = new TH2F("SDDphizCalibL3","SDDCalibL3 ",12,0.5,6.5,14,0.5,14.5);//8
hcalibl3->GetXaxis()->SetTitle("z[Module Number L3]");
hcalibl3->GetYaxis()->SetTitle("#varphi[ Ladder Number L3]");
hcalibl3->SetStats(0);
hcalibl3->SetMaximum(2);
- rv = fAliITSQADataMakerRec->Add2RawsList(hcalibl3,8+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hcalibl3,8+offsRW, !expert, image, !saveCorr);
fSDDhRawsTask++;
- TH2D *hcalibl4 = new TH2D("SDDphizCalibL4","SDDCalibL4 ",16,0.5,8.5,22,0.5,22.5); //9
+ TH2F *hcalibl4 = new TH2F("SDDphizCalibL4","SDDCalibL4 ",16,0.5,8.5,22,0.5,22.5); //9
hcalibl4->GetXaxis()->SetTitle("z[Module Number L4]");
hcalibl4->GetYaxis()->SetTitle("#varphi[Ladder Number L4]");
hcalibl4->SetStats(0);
hcalibl4->SetMaximum(2);
- rv = fAliITSQADataMakerRec->Add2RawsList(hcalibl4,9+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hcalibl4,9+offsRW, !expert, image, !saveCorr);
fSDDhRawsTask++;
TH1F *hsummarydata = new TH1F("SDDRawDataCheck","SDDRawDataCheck",46,-0.5,45.5);//10 summary of raw data checks
hsummarydata->GetXaxis()->SetBinLabel(46,"dr_overthl4");
hsummarydata->GetXaxis()->LabelsOption("v");
- rv = fAliITSQADataMakerRec->Add2RawsList(hsummarydata,10+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hsummarydata,10+offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
fOnlineOffsetRaws = fSDDhRawsTask;
//online part
if(fkOnline){
//DDL Pattern
- TH2D *hddl = new TH2D("SDDDDLPattern","SDD DDL Pattern ",24,-0.5,11.5,24,-0.5,23.5); //11
+ TH2F *hddl = new TH2F("SDDDDLPattern","SDD DDL Pattern ",24,-0.5,11.5,24,-0.5,23.5); //11
hddl->GetXaxis()->SetTitle("Channel");
hddl->GetYaxis()->SetTitle("DDL Number");
- rv = fAliITSQADataMakerRec->Add2RawsList(hddl,fOnlineOffsetRaws+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hddl,fOnlineOffsetRaws+offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
Int_t indexlast1 = 0;
TProfile2D *fModuleChargeMapFSE = new TProfile2D(Form("SDDchargeMapFSE_L%d_%d_%d_%d",lay,lad,det,iside),Form("SDDChargeMapForSingleEvent_L%d_%d_%d_%d",lay,lad,det,iside) ,256/fTimeBinSize,-0.5,255.5,256,-0.5,255.5);
fModuleChargeMapFSE->GetXaxis()->SetTitle("Time Bin");
fModuleChargeMapFSE->GetYaxis()->SetTitle("Anode");
- rv = fAliITSQADataMakerRec->Add2RawsList(fModuleChargeMapFSE,indexlast1 + index1 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(fModuleChargeMapFSE,indexlast1 + index1 + offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
index1++;
}
TProfile2D *fModuleChargeMap = new TProfile2D(Form("SDDchargeMap_L%d_%d_%d_%d",lay,lad,det,iside),Form("SDDChargeMap_L%d_%d_%d_%d",lay,lad,det,iside),256/fTimeBinSize,-0.5,255.5,256,-0.5,255.5);
fModuleChargeMap->GetXaxis()->SetTitle("Time Bin");
fModuleChargeMap->GetYaxis()->SetTitle("Anode Number");
- rv = fAliITSQADataMakerRec->Add2RawsList(fModuleChargeMap,indexlast1 + index1 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(fModuleChargeMap,indexlast1 + index1 + offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
index1++;
}
hsize->SetBit(TH1::kCanRebin);
hsize->GetXaxis()->SetTitle("Event Size [kB]");
hsize->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RawsList(hsize,indexlast1 + index1 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image, !saveCorr);
+ rv = fAliITSQADataMakerRec->Add2RawsList(hsize,indexlast1 + index1 + offsRW, expert, !image, !saveCorr);
fSDDhRawsTask++;
} // kONLINE
cout << fSDDhRawsTask << " SDD Raws histograms booked" << endl;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Raws histograms booked\n",fSDDhRawsTask));
+ //
return rv ;
}
{
// Fill QA for RAW - SDD -
Int_t rv = 0;
+ int offsRW = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
// Check id histograms already created for this Event Specie
- fNEvent++;
if(!fDDLModuleMap){CreateTheMap();}
if(rawReader->GetType() != 7) return rv; // skips non physical triggers
AliDebug(AliQAv1::GetQADebugLevel(),"entering MakeRaws\n");
if(fkOnline) {
for(Int_t moduleSDD =0; moduleSDD<fgknSDDmodules; moduleSDD++){
for(Int_t iside=0;iside<fgknSide;iside++) {
- if(fSDDhRawsTask > fOnlineOffsetRaws + 1 + index) fAliITSQADataMakerRec->GetRawsData(fOnlineOffsetRaws + 1 + index +fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
+ if(fSDDhRawsTask > fOnlineOffsetRaws + 1 + index) fAliITSQADataMakerRec->ResetRawsData(fOnlineOffsetRaws + 1 + index +offsRW);
// 4 because the 2D histos for single events start after the fourth position
index++;
}
Short_t iside = stream->GetChannel();
//printf(" \n%i %i %i %i \n ",lay, lad, det,iside );
- fAliITSQADataMakerRec->GetRawsData( 0 + fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()] )->Fill(isddmod);
- if(lay==3) fAliITSQADataMakerRec->GetRawsData(1+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(det+0.5*iside-0.25,lad); //phiz l3 not norm
- if(lay==4) fAliITSQADataMakerRec->GetRawsData(2+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(det+0.5*iside-0.25,lad); //phiz l4 not norm
+ fAliITSQADataMakerRec->FillRawsData( 0 + offsRW,isddmod);
+ if(lay==3) fAliITSQADataMakerRec->FillRawsData(1+offsRW,det+0.5*iside-0.25,lad); //phiz l3 not norm
+ if(lay==4) fAliITSQADataMakerRec->FillRawsData(2+offsRW,det+0.5*iside-0.25,lad); //phiz l4 not norm
if(fkOnline) {
- fAliITSQADataMakerRec->GetRawsData(fOnlineOffsetRaws+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill((stream->GetCarlosId())+0.5*iside -0.5,iddl);
- // printf("content ddlmap %d, %d = %f \n",(stream->GetCarlosId()+0.5*iside -0.5),iddl,fAliITSQADataMakerRec->GetRawsData(3+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetBinContent(1+(det-1)*2;lad));
- //printf("content ddlmap %d, %d = %f \n",(stream->GetCarlosId())+0.5*iside -0.5,iddl,fAliITSQADataMakerRec->GetRawsData(3+fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetBinContent(1+(stream->GetCarlosId()-1)*2,iddl));
+ fAliITSQADataMakerRec->FillRawsData(fOnlineOffsetRaws+offsRW, (stream->GetCarlosId())+0.5*iside -0.5,iddl);
+ // printf("content ddlmap %d, %d = %f \n",(stream->GetCarlosId()+0.5*iside -0.5),iddl,fAliITSQADataMakerRec->GetRawsData(3+offsRW)->GetBinContent(1+(det-1)*2;lad));
+ //printf("content ddlmap %d, %d = %f \n",(stream->GetCarlosId())+0.5*iside -0.5,iddl,fAliITSQADataMakerRec->GetRawsData(3+offsRW)->GetBinContent(1+(stream->GetCarlosId()-1)*2,iddl));
activeModule = moduleSDD;
index1 = activeModule * 2 + iside;
}
if(fSDDhRawsTask > fOnlineOffsetRaws +1 + index1) {
- ((TProfile2D *)(fAliITSQADataMakerRec->GetRawsData(fOnlineOffsetRaws +1 + index1 +fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])))->Fill(coord2, coord1, signal);
- ((TProfile2D *)(fAliITSQADataMakerRec->GetRawsData(fOnlineOffsetRaws +1 + index1 + 260*2 +fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])))->Fill(coord2, coord1, signal);
+ fAliITSQADataMakerRec->FillRawsData(fOnlineOffsetRaws +1 + index1 +offsRW , coord2, coord1, signal);
+ fAliITSQADataMakerRec->FillRawsData(fOnlineOffsetRaws +1 + index1 + 260*2 +offsRW, coord2, coord1, signal);
}
}//online
cnt++;
if(!(cnt%10000)) AliDebug(AliQAv1::GetQADebugLevel(),Form(" %d raw digits read",cnt));
}//end next()
- if(fkOnline){((TH1F*)(fAliITSQADataMakerRec->GetRawsData(fOnlineOffsetRaws +1 + 260*4 +fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()])))->Fill(size/1024.);//KB
+ if(fkOnline){
+ fAliITSQADataMakerRec->FillRawsData(fOnlineOffsetRaws +1 + 260*4 +offsRW,size/1024.);//KB
}
AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",cnt));
delete []ddldata;
ddldata=NULL;
+ //
return rv ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
Int_t rv = 0 ;
+ int offsD = fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
// fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
//fSDDhTask must be incremented by one unit every time a histogram is ADDED to the QA List
TH1F* h0=new TH1F("SDD DIGITS Module Pattern","SDD DIGITS Module Pattern",260,239.5,499.5); //hmod
h0->GetXaxis()->SetTitle("SDD Module Number");
h0->GetYaxis()->SetTitle("# DIGITS");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h0,fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h0,offsD, !expert, image);
fSDDhDigitsTask ++;
- // printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , fSDDhDigitsTask );
+ // printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(offsD)->GetName() , fSDDhDigitsTask );
TH1F* h1=new TH1F("SDD Anode Distribution","DIGITS Anode Distribution",512,-0.5,511.5); //hanocc
h1->GetXaxis()->SetTitle("Anode Number");
h1->GetYaxis()->SetTitle("# DIGITS");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h1,1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h1,1+offsD, !expert, image);
fSDDhDigitsTask ++;
- //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , fSDDhDigitsTask );
+ //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(1+offsD)->GetName() , fSDDhDigitsTask );
TH1F* h2=new TH1F("SDD Tbin Distribution","DIGITS Tbin Distribution",256,-0.5,255.5); //htbocc
h2->GetXaxis()->SetTitle("Tbin Number");
h2->GetYaxis()->SetTitle("# DIGITS");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h2,2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h2,2+offsD, !expert, image);
fSDDhDigitsTask ++;
- //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , fSDDhDigitsTask );
+ //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(2+offsD)->GetName() , fSDDhDigitsTask );
TH1F* h3=new TH1F("SDD ADC Counts Distribution","DIGITS ADC Counts Distribution",200,0.,1024.); //hsig
h3->GetXaxis()->SetTitle("ADC Value");
h3->GetYaxis()->SetTitle("# DIGITS");
- rv = fAliITSQADataMakerRec->Add2DigitsList(h3,3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(h3,3+offsD, !expert, image);
fSDDhDigitsTask ++;
- //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->GetName() , fSDDhDigitsTask );
+ //printf("Add %s \t the task offset is %i\n",fAliITSQADataMakerRec->GetDigitsData(3+offsD)->GetName() , fSDDhDigitsTask );
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Digits histograms booked\n",fSDDhDigitsTask));
+ //
return rv ;
}
//fITS->SetTreeAddress();
//TClonesArray *iITSdigits = fITS->DigitsAddress(1);
-
Int_t rv = 0 ;
-
+ int offsD = fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
TBranch *branchD = digits->GetBranch("ITSDigitsSDD");
if (!branchD) {
Int_t nmod=i+240;
digits->GetEvent(nmod);
Int_t ndigits = iITSdigits->GetEntries();
- fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nmod,ndigits);
+ fAliITSQADataMakerRec->FillDigitsData(offsD,nmod,ndigits);
for (Int_t idig=0; idig<ndigits; idig++) {
AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);
Int_t iz=dig->GetCoord1(); // cell number z
Int_t ix=dig->GetCoord2(); // cell number x
Int_t sig=dig->GetSignal();
- fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(iz);
- fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(ix);
- fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(sig);
+ fAliITSQADataMakerRec->FillDigitsData(1+offsD,iz);
+ fAliITSQADataMakerRec->FillDigitsData(2+offsD,ix);
+ fAliITSQADataMakerRec->FillDigitsData(3+offsD,sig);
}
}
+ //
return rv ;
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
Int_t rv = 0 ;
+ int offsRP = fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
// fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
//AliInfo(Form("fAliITSQADataMakerRec->GetEventSpecie() %d\n",fAliITSQADataMakerRec->GetEventSpecie()));
- //AliInfo(Form("fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] %d\n",fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]));
+ //AliInfo(Form("offsRP %d\n",offsRP));
TH1F *h0 = new TH1F("SDDLay3TotCh","Layer 3 total charge",250,-0.5, 499.5); //position number 0
//h0->SetBit(TH1::kCanRebin);
h0->GetXaxis()->SetTitle("KeV");
h0->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h0, 0 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);//NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h0, 0 +offsRP, !expert, image);//NON expert image
fSDDhRecPointsTask++;
TH1F *h1 = new TH1F("SDDLay4TotCh","Layer 4 total charge",250,-0.5, 499.5);//position number 1
//h1->SetBit(TH1::kCanRebin);
h1->GetXaxis()->SetTitle("Kev");
h1->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h1, 1 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);//NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h1, 1 +offsRP, !expert, image);//NON expert image
fSDDhRecPointsTask++;
TH2F *h2 = new TH2F("SDDGlobalCoordDistribYX","YX Global Coord Distrib",56,-28,28,56,-28,28);//position number 2
h2->GetYaxis()->SetTitle("Y[cm]");
h2->GetXaxis()->SetTitle("X[cm]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h2,2+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);// NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h2,2+offsRP, !expert, image);// NON expert image
fSDDhRecPointsTask++;
TH2F *h3 = new TH2F("SDDGlobalCoordDistribRZ","RZ Global Coord Distrib",128,-32,32,56,12,26);//position number 3
h3->GetYaxis()->SetTitle("R[cm]");
h3->GetXaxis()->SetTitle("Z[cm]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h3,3+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);// NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h3,3+offsRP, !expert, image);// NON expert image
fSDDhRecPointsTask++;
TH2F *h4 = new TH2F("SDDGlobalCoordDistribL3PHIZ","#varphi Z Global Coord Distrib L3",96,-23,23,112,-TMath::Pi(),TMath::Pi());//position number 4
h4->GetYaxis()->SetTitle("#phi[rad]");
h4->GetXaxis()->SetTitle("Z[cm]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h4,4+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);//NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h4,4+offsRP, !expert, image);//NON expert image
fSDDhRecPointsTask++;
TH2F *h5 = new TH2F("SDDGlobalCoordDistribL4PHIZ","#varphi Z Global Coord Distrib L4",128,-31,31,176,-TMath::Pi(),TMath::Pi());//position number 5
h5->GetYaxis()->SetTitle("#phi[rad]");
h5->GetXaxis()->SetTitle("Z[cm]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h5,5+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);//NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h5,5+offsRP, !expert, image);//NON expert image
fSDDhRecPointsTask++;
- TH1D *h6 = new TH1D("SDDModPatternRP","Modules pattern RP",fgknSDDmodules,239.5,499.5); //position number 6
+ TH1F *h6 = new TH1F("SDDModPatternRP","Modules pattern RP",fgknSDDmodules,239.5,499.5); //position number 6
h6->GetXaxis()->SetTitle("Module number"); //spd offset = 240
h6->GetYaxis()->SetTitle("Entries");
h6->SetOption("bar1");
h6->SetBarOffset(0.01);
h6->SetBarWidth(0.95);
h6->SetFillColor(39);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h6,6 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h6,6 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
- TH2D *h7 = new TH2D("SDDModPatternL3RP","Modules pattern L3 RP",12,0.5,6.5,14,0.5,14.5); //position number 7
+ TH2F *h7 = new TH2F("SDDModPatternL3RP","Modules pattern L3 RP",12,0.5,6.5,14,0.5,14.5); //position number 7
h7->GetXaxis()->SetTitle("z[#Module L3 ]");
h7->GetYaxis()->SetTitle("#varphi[#Ladder L3]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h7,7 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h7,7 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
- TH2D *h8 = new TH2D("SDDModPatternL4RP","Modules pattern L4 RP",16,0.5,8.5,22,0.5,22.5); //position number 8
+ TH2F *h8 = new TH2F("SDDModPatternL4RP","Modules pattern L4 RP",16,0.5,8.5,22,0.5,22.5); //position number 8
h8->GetXaxis()->SetTitle("[#Module L3 ]");
h8->GetYaxis()->SetTitle("#varphi[#Ladder L4]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h8,8 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h8,8 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
//------------------------norm--------------------------//
- TH1D *h9 = new TH1D("SDDModPatternRPNORM","Modules pattern RP NORM",fgknSDDmodules,239.5,499.5); //position number 9
+ TH1F *h9 = new TH1F("SDDModPatternRPNORM","Modules pattern RP NORM",fgknSDDmodules,239.5,499.5); //position number 9
h9->GetXaxis()->SetTitle("Module number"); //spd offset = 240
h9->GetYaxis()->SetTitle("Entries");
h9->SetOption("bar1");
h9->SetBarOffset(0.01);
h9->SetBarWidth(0.95);
h9->SetFillColor(49);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h9,9 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h9,9 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
- TH2D *h10 = new TH2D("SDDModPatternL3RPNORM","Modules pattern L3 RP NORM",12,0.5,6.5,14,0.5,14.5); //position number 10
+ TH2F *h10 = new TH2F("SDDModPatternL3RPNORM","Modules pattern L3 RP NORM",12,0.5,6.5,14,0.5,14.5); //position number 10
h10->GetXaxis()->SetTitle("z[#Module L3 ]");
h10->GetYaxis()->SetTitle("#varphi[#Ladder L3]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h10,10 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h10,10 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
- TH2D *h11 = new TH2D("SDDModPatternL4RPNORM","Modules pattern L4 RP NORM",16,0.5,8.5,22,0.5,22.5); //position number 11
+ TH2F *h11 = new TH2F("SDDModPatternL4RPNORM","Modules pattern L4 RP NORM",16,0.5,8.5,22,0.5,22.5); //position number 11
h11->GetXaxis()->SetTitle("[#Module L4 ]");
h10->GetYaxis()->SetTitle("#varphi[#Ladder L4]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h11,11 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h11,11 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
//--------------------------------------------------------//
TH2F *h12 = new TH2F("SDDLocalCoordDistrib","Local Coord Distrib",160,-4,4,160,-4,4);//position number 12
h12->GetXaxis()->SetTitle("X local coord, drift, cm");
h12->GetYaxis()->SetTitle("Z local coord, anode, cm");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h12,12 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h12,12 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
//AliInfo("Create SDD recpoints histos\n");
h13->GetXaxis()->SetTitle("r[cm]");
h13->GetXaxis()->CenterTitle();
h13->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h13,13 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h13,13 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
TH1F *h14 = new TH1F("SDDrdistrib_Layer4" ,"SDD r distribution Layer4" ,100,23.,25.);// and position number 14 (L4)
h14->GetXaxis()->SetTitle("r[cm]");
h14->GetXaxis()->CenterTitle();
h14->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h14,14 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h14,14 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
for(Int_t iLay=0; iLay<=1; iLay++){
h15->GetXaxis()->SetTitle("#varphi[rad]");
h15->GetXaxis()->CenterTitle();
h15->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h15,iLay+15+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h15,iLay+15+offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
}
h17->GetXaxis()->SetTitle("drift time[ns]");
h17->GetXaxis()->CenterTitle();
h17->GetYaxis()->SetTitle("Entries");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h17,iLay+17+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], !expert, image);// NON expert image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h17,iLay+17+offsRP, !expert, image);// NON expert image
fSDDhRecPointsTask++;
}
Float_t hMax = 0.2;
TH1F *oL3 = new TH1F("SDDL3_RelativeOccupancy","Layer 3 Relative Occupancy (RecPoints)",200,0.,hMax);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(oL3,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); // 19
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(oL3,fSDDhRecPointsTask+offsRP, expert, !image); // 19
fSDDhRecPointsTask++;
TH1F *oL4 = new TH1F("SDDL4_RelativeOccupancy","Layer 4 Relative Occupancy (RecPoints)",200,0.,hMax);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(oL4,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); // 20
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(oL4,fSDDhRecPointsTask+offsRP, expert, !image); // 20
fSDDhRecPointsTask++;
- TH2D *h21 = new TH2D("SDDL3_Rec2Raw_2D","L3 RecPoints to Raws 2D",12,0.5,6.5,14,0.5,14.5); //position number 21
+ TH2F *h21 = new TH2F("SDDL3_Rec2Raw_2D","L3 RecPoints to Raws 2D",12,0.5,6.5,14,0.5,14.5); //position number 21
h21->GetXaxis()->SetTitle("z[#Module L3 ]");
h21->GetYaxis()->SetTitle("#varphi[#Ladder L3]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h21,21 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h21,21 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
- TH2D *h22 = new TH2D("SDDL4_Rec2Raw_2D","L4 RecPoints to Raws 2D",16,0.5,8.5,22,0.5,22.5); //position number 22
+ TH2F *h22 = new TH2F("SDDL4_Rec2Raw_2D","L4 RecPoints to Raws 2D",16,0.5,8.5,22,0.5,22.5); //position number 22
h22->GetXaxis()->SetTitle("[#Module L4 ]");
h22->GetYaxis()->SetTitle("#varphi[#Ladder L4]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h22,22 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h22,22 +offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
hMax = 0.3;
TH1F *R2RL3 = new TH1F("SDDL3_Rec2Raw","L3 RecPoints to Raws ratio",150,0.,hMax);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(R2RL3,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); // 23
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(R2RL3,fSDDhRecPointsTask+offsRP, expert, !image); // 23
fSDDhRecPointsTask++;
TH1F *R2RL4 = new TH1F("SDDL4_Rec2Raw","L4 RecPoints to Raws ratio",150,0.,hMax);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(R2RL4,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); // 24
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(R2RL4,fSDDhRecPointsTask+offsRP, expert, !image); // 24
fSDDhRecPointsTask++;
TH1F *dedxL3 = new TH1F("SDDL3_dedx","L3 dE/dX",100,0.,1.);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(dedxL3,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); // 25
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(dedxL3,fSDDhRecPointsTask+offsRP, expert, !image); // 25
fSDDhRecPointsTask++;
TH1F *dedxL4 = new TH1F("SDDL4_dedx","L4 dE/dX",100,0.,1.);
- rv = fAliITSQADataMakerRec->Add2RecPointsList(dedxL4,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image); // 26
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(dedxL4,fSDDhRecPointsTask+offsRP, expert, !image); // 26
fSDDhRecPointsTask++;
hsummarydatarp->GetXaxis()->LabelsOption("v");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(hsummarydatarp,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(hsummarydatarp,fSDDhRecPointsTask+offsRP, expert, !image);// expert NO image
fSDDhRecPointsTask++;
- fOnlineOffsetRecPoints = fSDDhRecPointsTask;
- if(fkOnline){
- TH2F *h19 = new TH2F("SDDGlobalCoordDistribYXFSE","YX Global Coord Distrib FSE",112,-28,28,112,-28,28);//position number 27
- h19->GetYaxis()->SetTitle("Y[cm]");
- h19->GetXaxis()->SetTitle("X[cm]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h19,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
- fSDDhRecPointsTask++;
-
- TH2F *h20 = new TH2F("SDDGlobalCoordDistribRZFSE","RZ Global Coord Distrib FSE",128,-32,32,56,12,26);//position number 28
- h20->GetYaxis()->SetTitle("R[cm]");
- h20->GetXaxis()->SetTitle("Z[cm]");
- rv = fAliITSQADataMakerRec->Add2RecPointsList(h20,fSDDhRecPointsTask+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()], expert, !image);// expert NO image
- fSDDhRecPointsTask++;
- }//online
+ fOnlineOffsetRecPoints = fSDDhRecPointsTask;
+ if(fkOnline){
+ TH2F *h19 = new TH2F("SDDGlobalCoordDistribYXFSE","YX Global Coord Distrib FSE",112,-28,28,112,-28,28);//position number 27
+ h19->GetYaxis()->SetTitle("Y[cm]");
+ h19->GetXaxis()->SetTitle("X[cm]");
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h19,fSDDhRecPointsTask+offsRP, expert, !image);// expert NO image
+ fSDDhRecPointsTask++;
+
+ TH2F *h20 = new TH2F("SDDGlobalCoordDistribRZFSE","RZ Global Coord Distrib FSE",128,-32,32,56,12,26);//position number 28
+ h20->GetYaxis()->SetTitle("R[cm]");
+ h20->GetXaxis()->SetTitle("Z[cm]");
+ rv = fAliITSQADataMakerRec->Add2RecPointsList(h20,fSDDhRecPointsTask+offsRP, expert, !image);// expert NO image
+ fSDDhRecPointsTask++;
+ }//online
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SDD Recs histograms booked\n",fSDDhRecPointsTask));
-
+ //
return rv ;
}
{
// Fill QA for RecPoints - SDD -
Int_t rv = 0 ;
- fNEventRP++;
Int_t lay, lad, det;
//AliInfo("get the branch with the ITS clusters !\n");
AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
AliError("can't get SDD clusters !");
return rv;
}
-
+ int offsRP = fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
Int_t npoints = 0;
Float_t cluglo[3]={0.,0.,0.};
if(fkOnline){
- for(Int_t i=28;i<30;i++){
- fAliITSQADataMakerRec->GetRecPointsData(i+fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Reset();
- }
- }
+ for(Int_t i=28;i<30;i++) fAliITSQADataMakerRec->ResetRecPointsData(i+offsRP);
+ }
// AliITSgeomTGeo::GetModuleIndex() issues an error in case the arguments
// are illegal and returns -1
Int_t firMod=TMath::Max(0,AliITSgeomTGeo::GetModuleIndex(3,1,1));
AliITSRecPoint *recp = (AliITSRecPoint*)recpoints->At(j);
Int_t index = recp->GetDetectorIndex();
lay=recp->GetLayer();
- if(lay < 2 || lay > 3) continue;
- Int_t modnumb=index+AliITSgeomTGeo::GetModuleIndex(lay+1,1,1);
- AliITSgeomTGeo::GetModuleId(modnumb, lay, lad, det);
-// AliInfo(Form("modnumb %d, lay %d, lad %d, det %d \n",module, lay, lad, det));
- fAliITSQADataMakerRec->GetRecPointsData(6 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(modnumb);//modpatternrp
+ if(lay < 2 || lay > 3) continue;
+ Int_t modnumb=index+AliITSgeomTGeo::GetModuleIndex(lay+1,1,1);
+ AliITSgeomTGeo::GetModuleId(modnumb, lay, lad, det);
+ // AliInfo(Form("modnumb %d, lay %d, lad %d, det %d \n",module, lay, lad, det));
+ fAliITSQADataMakerRec->FillRecPointsData(6 +offsRP,modnumb);//modpatternrp
recp->GetGlobalXYZ(cluglo);
Float_t rad=TMath::Sqrt(cluglo[0]*cluglo[0]+cluglo[1]*cluglo[1]);
Float_t phi=TMath::ATan2(cluglo[1],cluglo[0]);
Float_t drifttime=recp->GetDriftTime();
- fAliITSQADataMakerRec->GetRecPointsData(12 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(recp->GetDetLocalX(),recp->GetDetLocalZ());//local distribution
- fAliITSQADataMakerRec->GetRecPointsData(2 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluglo[0],cluglo[1]);//global distribution YX
- fAliITSQADataMakerRec->GetRecPointsData(3 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluglo[2],rad);//global distribution rz
- if(fkOnline) {
- fAliITSQADataMakerRec->GetRecPointsData(28 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluglo[0],cluglo[1]);//global distribution YX FSE
- fAliITSQADataMakerRec->GetRecPointsData(29 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluglo[2],rad);//global distribution rz FSE
- }
- Int_t iside=recp->GetDriftSide();
- lay=recp->GetLayer();
- if(lay == 2) {
- fAliITSQADataMakerRec->GetRecPointsData(0 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(recp->GetQ()) ;//total charge of layer 3
- fAliITSQADataMakerRec->GetRecPointsData(7 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(det+0.5*iside-0.5,lad);//mod pattern layer 3
- fAliITSQADataMakerRec->GetRecPointsData(13 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad);//r distribution layer 3
- fAliITSQADataMakerRec->GetRecPointsData(15 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(phi);// phi distribution layer 3
- fAliITSQADataMakerRec->GetRecPointsData(4 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluglo[2],phi);// zphi distribution layer
- fAliITSQADataMakerRec->GetRecPointsData(17 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(drifttime);// time distribution layer 3
- fAliITSQADataMakerRec->GetRecPointsData(25 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(recp->GetdEdX());// charge distribution layer 3
- } else if(lay == 3) {
- fAliITSQADataMakerRec->GetRecPointsData(1 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(recp->GetQ()) ;//total charge layer 4
- fAliITSQADataMakerRec->GetRecPointsData(8 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(det+0.5*iside-0.5,lad);//mod pattern layer 4
- fAliITSQADataMakerRec->GetRecPointsData(14 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad);//r distribution
- fAliITSQADataMakerRec->GetRecPointsData(16 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(phi);//phi distribution
- fAliITSQADataMakerRec->GetRecPointsData(5 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluglo[2],phi);// zphi distribution layer 4
- fAliITSQADataMakerRec->GetRecPointsData(18 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(drifttime);// time distribution layer 4
- fAliITSQADataMakerRec->GetRecPointsData(26 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(recp->GetdEdX());// charge distribution layer 4
+ fAliITSQADataMakerRec->FillRecPointsData(12 +offsRP,recp->GetDetLocalX(),recp->GetDetLocalZ());//local distribution
+ fAliITSQADataMakerRec->FillRecPointsData(2 +offsRP,cluglo[0],cluglo[1]);//global distribution YX
+ fAliITSQADataMakerRec->FillRecPointsData(3 +offsRP,cluglo[2],rad);//global distribution rz
+ if(fkOnline) {
+ fAliITSQADataMakerRec->FillRecPointsData(28 +offsRP,cluglo[0],cluglo[1]);//global distribution YX FSE
+ fAliITSQADataMakerRec->FillRecPointsData(29 +offsRP,cluglo[2],rad);//global distribution rz FSE
+ }
+ Int_t iside=recp->GetDriftSide();
+ lay=recp->GetLayer();
+ if(lay == 2) {
+ fAliITSQADataMakerRec->FillRecPointsData(0 +offsRP, recp->GetQ()) ;//total charge of layer 3
+ fAliITSQADataMakerRec->FillRecPointsData(7 +offsRP, det+0.5*iside-0.5,lad);//mod pattern layer 3
+ fAliITSQADataMakerRec->FillRecPointsData(13 +offsRP, rad);//r distribution layer 3
+ fAliITSQADataMakerRec->FillRecPointsData(15 +offsRP, phi);// phi distribution layer 3
+ fAliITSQADataMakerRec->FillRecPointsData(4 +offsRP, cluglo[2],phi);// zphi distribution layer
+ fAliITSQADataMakerRec->FillRecPointsData(17 +offsRP, drifttime);// time distribution layer 3
+ fAliITSQADataMakerRec->FillRecPointsData(25 +offsRP, recp->GetdEdX());// charge distribution layer 3
+ } else if(lay == 3) {
+ fAliITSQADataMakerRec->FillRecPointsData(1 +offsRP, recp->GetQ()) ;//total charge layer 4
+ fAliITSQADataMakerRec->FillRecPointsData(8 +offsRP, det+0.5*iside-0.5,lad);//mod pattern layer 4
+ fAliITSQADataMakerRec->FillRecPointsData(14 +offsRP, rad);//r distribution
+ fAliITSQADataMakerRec->FillRecPointsData(16 +offsRP, phi);//phi distribution
+ fAliITSQADataMakerRec->FillRecPointsData(5 +offsRP, cluglo[2],phi);// zphi distribution layer 4
+ fAliITSQADataMakerRec->FillRecPointsData(18 +offsRP, drifttime);// time distribution layer 4
+ fAliITSQADataMakerRec->FillRecPointsData(26 +offsRP, recp->GetdEdX());// charge distribution layer 4
}
}
}
+ //
return rv ;
}
//_______________________________________________________________
-
-Int_t AliITSQASDDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task, Int_t specie)const
+Int_t AliITSQASDDDataMakerRec::GetOffset(AliQAv1::TASKINDEX_t task, Int_t specie) const
{
// Returns offset number according to the specified task
Int_t offset=0;
}
//_______________________________________________________________
-
void AliITSQASDDDataMakerRec::SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset, Int_t specie) {
// Set offset number according to the specified task
if( task == AliQAv1::kRAWS ) {fGenRawsOffset[specie]=offset;}
}
//_______________________________________________________________
-
Int_t AliITSQASDDDataMakerRec::GetTaskHisto(AliQAv1::TASKINDEX_t task)
{
//return the number of histo booked for a given Task
//_______________________________________________________________
-
-
void AliITSQASDDDataMakerRec::CreateTheMap()
{
//Create the SDD DDL Module Map
}
//_______________________________________________________________
-
-
void AliITSQASDDDataMakerRec::CreateTheCalibration()
{
//Take from the OCDB the calibration information for the SDD
fillmodhisto1-=badmodhisto1;
fillmodhisto2side0-=badmodhisto2side0;
fillmodhisto2side1-=badmodhisto2side1;
- ((TH1D*)(fHistoCalibration->At(0)))->SetBinContent(imod+1,fillmodhisto1);
- ((TH2D*)(fHistoCalibration->At(1)))->SetBinContent(index,lad,fillmodhisto2side0);
- ((TH2D*)(fHistoCalibration->At(1)))->SetBinContent(index+1,lad,fillmodhisto2side1);
+ ((TH1F*)(fHistoCalibration->At(0)))->SetBinContent(imod+1,fillmodhisto1);
+ ((TH2F*)(fHistoCalibration->At(1)))->SetBinContent(index,lad,fillmodhisto2side0);
+ ((TH2F*)(fHistoCalibration->At(1)))->SetBinContent(index+1,lad,fillmodhisto2side1);
}//end layer 3
else if(lay==4){
badmodhisto1=badmodhisto3side0+badmodhisto3side1;
fillmodhisto1-=badmodhisto1;
fillmodhisto3side0-=badmodhisto3side0;
fillmodhisto3side1-=badmodhisto3side1;
- ((TH1D*)(fHistoCalibration->At(0)))->SetBinContent(imod+1,fillmodhisto1);
- ((TH2D*)(fHistoCalibration->At(2)))->SetBinContent(index,lad,fillmodhisto3side0);
- ((TH2D*)(fHistoCalibration->At(2)))->SetBinContent(index+1,lad,fillmodhisto3side1);
+ ((TH1F*)(fHistoCalibration->At(0)))->SetBinContent(imod+1,fillmodhisto1);
+ ((TH2F*)(fHistoCalibration->At(2)))->SetBinContent(index,lad,fillmodhisto3side0);
+ ((TH2F*)(fHistoCalibration->At(2)))->SetBinContent(index+1,lad,fillmodhisto3side1);
}//end layer 4
}//end else bad module
}//end module for
}
//____________________________________________________________________
-
void AliITSQASDDDataMakerRec::InitCalibrationArray()
{
//create the histograms with the calibration informations. The histograms are stored in a TObjArray
- TH1D *pattern1 = new TH1D("CALSDDModPattern","Calibration HW Modules pattern",fgknSDDmodules,239.5,499.5);
+ TH1F *pattern1 = new TH1F("CALSDDModPattern","Calibration HW Modules pattern",fgknSDDmodules,239.5,499.5);
pattern1->SetDirectory(0) ;
- TH2D *patternl3 = new TH2D("CALSDDphizL3","Calibration SDD #varphiz Layer3 ",12,0.5,6.5,14,0.5,14.5);
+ TH2F *patternl3 = new TH2F("CALSDDphizL3","Calibration SDD #varphiz Layer3 ",12,0.5,6.5,14,0.5,14.5);
patternl3->SetDirectory(0) ;
- TH2D *patternl4 = new TH2D("CALSDDphizL4"," Calibration SDD #varphiz Layer4 ",16,0.5,8.5,22,0.5,22.5);
+ TH2F *patternl4 = new TH2F("CALSDDphizL4"," Calibration SDD #varphiz Layer4 ",16,0.5,8.5,22,0.5,22.5);
patternl4->SetDirectory(0) ;
if(!fHistoCalibration)fHistoCalibration = new TObjArray(3);
}
//____________________________________________________________________
-
void AliITSQASDDDataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
{
//reset the SDD calibration histograms
fCalibration=NULL;
- ((TH1D*)(fHistoCalibration->At(0)))->Reset();
- ((TH2D*)(fHistoCalibration->At(1)))->Reset();
- ((TH2D*)(fHistoCalibration->At(2)))->Reset();
+ ((TH1F*)(fHistoCalibration->At(0)))->Reset();
+ ((TH2F*)(fHistoCalibration->At(1)))->Reset();
+ ((TH2F*)(fHistoCalibration->At(2)))->Reset();
//delete fHistoCalibration;
//fHistoCalibration=NULL;
//____________________________________________________________________
-Int_t AliITSQASDDDataMakerRec::GetNumberOfEvents(AliQAv1::TASKINDEX_t task)
+Int_t AliITSQASDDDataMakerRec::GetNumberOfEvents(AliQAv1::TASKINDEX_t task, Int_t trigCl)
{
- //return the number of the processed events for a given task fod SDD only
-
- if(task==AliQAv1::kRAWS){return fNEvent;}
- else if(task==AliQAv1::kRECPOINTS){return fNEventRP;}
- else{ AliWarning("The selected TASKINDEX is not valid!! return 0\n"); return 0;}
-
-
+ //return the number of the processed events for a given task and trigger class (-1 for all)
+ return fAliITSQADataMakerRec->GetEvCountCycle(task, trigCl);
}
virtual Int_t MakeDigits(TTree *clustersTree);
virtual Int_t MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
virtual void CreateTheMap();
virtual void CreateTheCalibration();
virtual void InitCalibrationArray();
Int_t GetOffset(AliQAv1::TASKINDEX_t task,Int_t specie=0)const;
void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset, Int_t specie = 0);
Int_t GetTaskHisto(AliQAv1::TASKINDEX_t task);
- Int_t GetNumberOfEvents(AliQAv1::TASKINDEX_t task);
+ Int_t GetNumberOfEvents(AliQAv1::TASKINDEX_t task, Int_t trigCl=-1);
virtual void ResetDetector(AliQAv1::TASKINDEX_t task);
AliITSDDLModuleMapSDD* GetDDLSDDModuleMap()const{return fDDLModuleMap; };
Int_t *fGenDigitsOffset; // QAchecking RecPoints offset
Int_t *fGenRecPointsOffset; // QAchecking RecPoints offset
Int_t fTimeBinSize; // time bin width in number of clocks
- Int_t fNEvent; // Number of Events (raw data)
- Int_t fNEventRP; // Number of Events (rec points)
AliITSDDLModuleMapSDD *fDDLModuleMap; // SDD Detector configuration for the decoding
TObjArray *fCalibration; //Array of Calibration Object
TObjArray *fHistoCalibration; //Array of the Calibration histograms for the normalization
}\r
\r
//____________________________________________________________________________ \r
-void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)\r
+void AliITSQASDDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray** /*list*/)\r
{\r
// launch the QA checking\r
+ //\r
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n"); \r
//AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);\r
}\r
Int_t nmod=i+240;\r
digits->GetEvent(nmod);\r
Int_t ndigits = iITSdigits->GetEntries();\r
- fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nmod,ndigits);\r
+ fAliITSQADataMakerSim->FillDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],nmod,ndigits);\r
for (Int_t idig=0; idig<ndigits; idig++) {\r
AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);\r
Int_t iz=dig->GetCoord1(); // cell number z\r
Int_t ix=dig->GetCoord2(); // cell number x\r
Int_t sig=dig->GetSignal();\r
- fAliITSQADataMakerSim->GetDigitsData(1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(iz);\r
- fAliITSQADataMakerSim->GetDigitsData(2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(ix);\r
- fAliITSQADataMakerSim->GetDigitsData(3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(sig);\r
+ fAliITSQADataMakerSim->FillDigitsData(1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],iz);\r
+ fAliITSQADataMakerSim->FillDigitsData(2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],ix);\r
+ fAliITSQADataMakerSim->FillDigitsData(3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],sig);\r
}\r
}\r
+ //\r
return rv ; \r
}\r
\r
brchSDigits->SetAddress( &sdig );\r
brchSDigits->GetEvent(nmod);\r
Int_t nsdig=sdig->GetEntries();\r
- fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nmod,nsdig);\r
+ fAliITSQADataMakerSim->FillSDigitsData(fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],nmod,nsdig);\r
for(Int_t i=0;i<nsdig;i++){\r
AliITSpListItem *cell=(AliITSpListItem*)sdig->At(i);\r
Float_t sig=cell->GetSignal();\r
Int_t idx=cell->GetIndex();\r
Int_t ia,it;\r
list->GetCell(idx,ia,it);\r
- fAliITSQADataMakerSim->GetSDigitsData(1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(ia);\r
- fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(it);\r
- fAliITSQADataMakerSim->GetSDigitsData(3+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(sig);\r
+ fAliITSQADataMakerSim->FillSDigitsData(1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],ia);\r
+ fAliITSQADataMakerSim->FillSDigitsData(2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],it);\r
+ fAliITSQADataMakerSim->FillSDigitsData(3+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],sig);\r
}\r
sdig->Clear();\r
}\r
+ //\r
return rv ; \r
}\r
\r
// Fill QA for HITS - SDD -\r
Int_t rv = 0 ; \r
\r
- AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");\r
+ AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");\r
fITS->SetTreeAddress();\r
Int_t nmodules;\r
if(!(fITS->InitModules(-1,nmodules))){\r
////printf("--w--AliITSQASDDDataMakerSim::MakeHits nhits = %d\n",nhits);\r
for (Int_t iHit=0;iHit<nhits;iHit++) {\r
AliITShit *hit = (AliITShit*) arrHits->At(iHit);\r
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nmod);\r
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],nmod);\r
Double_t xl,yl,zl,xl0,yl0,zl0;\r
Double_t tof,tof0;\r
hit->GetPositionL(xl,yl,zl,tof);\r
hit->GetPositionL0(xl0,yl0,zl0,tof0);\r
Float_t dyloc=TMath::Abs(yl-yl0)*10000.;\r
- fAliITSQADataMakerSim->GetHitsData(1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(dyloc);\r
+ fAliITSQADataMakerSim->FillHitsData(1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],dyloc);\r
Float_t edep=hit->GetIonization()*1000000;\r
if(dyloc>200.){ \r
- fAliITSQADataMakerSim->GetHitsData(2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(edep);\r
- fAliITSQADataMakerSim->GetHitsData(3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(dyloc);\r
+ fAliITSQADataMakerSim->FillHitsData(2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],edep);\r
+ fAliITSQADataMakerSim->FillHitsData(3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],dyloc);\r
}\r
}\r
}\r
+ //\r
return rv ; \r
}\r
\r
AliITSQASDDDataMakerSim& operator = (const AliITSQASDDDataMakerSim& qac);\r
\r
virtual void StartOfDetectorCycle();\r
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);\r
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);\r
virtual ~AliITSQASDDDataMakerSim() {;} // dtor\r
virtual Int_t InitDigits();\r
virtual Int_t InitSDigits();\r
}
//____________________________________________________________________________
-void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray* list)
+void AliITSQASPDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
// launch the QA checking
+ //
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
if(!list){
- AliError(" Histogram list is NULL");
- return;
- }
-
- Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
-
- if(task == AliQAv1::kRAWS) {
- if(!list->At(0+shift)) {
- AliError(" no histogram 0 at the end of detector cycle in raws");
- return;
- }
- ((TH2I*)list->At(5+shift))->Reset(); // clean up MEB histo (needed at the first cycle for small statistics)
-
- ((TH1F*)list->At(7+shift))->Divide(((TH1F*)list->At(1+shift)),((TH1F*)list->At(0+shift)));
- ((TH1F*)list->At(8+shift))->Divide(((TH1F*)list->At(2+shift)),((TH1F*)list->At(0+shift)));// missing FO ratio (per event)
- ((TH1F*)list->At(9+shift))->Divide(((TH1F*)list->At(3+shift)),((TH1F*)list->At(4+shift)));// noisy FO ratio (per event)
-
- for(Int_t i=0; i<1200; i++){
- // threshold for protection in case of technical runs (->few entries per chip)
- Short_t thre=20; // 20 is ok in run 104792 (where the problem occured).
- if((((TH1F*)list->At(0+shift)))->GetBinContent(i+1)<thre) continue; // expected FO yield
- if((((TH1F*)list->At(4+shift)))->GetBinContent(i+1)<thre) continue; // the total FO yield.
-
-
- if(((TH1F*)list->At(8+shift))->GetBinContent(i+1)>0.5 && ((TH1F*)list->At(9+shift))->GetBinContent(i+1)>0.5){
- Int_t eq=i/60;
- Int_t hs=(i%60)/10;
- Int_t chip = (i%60)%10;
- Int_t sect = 999; Int_t chipbin = 999;
- if(eq<10) {sect = eq; chipbin = 19-chip;}
- else {sect = eq-10; chipbin = chip;}
- ((TH2I*)list->At(5+shift))->Fill(sect*6+hs,chipbin);
- }
+ AliError(" Histogram list is NULL");
+ return;
}
-
- } // QA Task Index == RAWS
+ //
+ Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
+ for (int trCl=-1;trCl<fAliITSQADataMakerRec->GetNTrigClasses();trCl++) { // RS Loop over all trigger classes (+ global counter, -1)
+ if(task == AliQAv1::kRAWS) {
+ TObjArray &harr = *fAliITSQADataMakerRec->GetRawsDataOfTrigClass(trCl); // extract the clones for given trigger class
+ //
+ if (harr[5+shift]) ((TH1*)harr[5+shift])->Reset(); // clean up MEB histo (needed at the first cycle for small statistics)
+ if (harr[7+shift]&&harr[1+shift]&&harr[0+shift]) ((TH1*)harr[7+shift])->Divide((TH1*)harr[1+shift],(TH1*)harr[0+shift]);
+ if (harr[8+shift]&&harr[2+shift]&&harr[0+shift]) ((TH1*)harr[8+shift])->Divide((TH1*)harr[2+shift],(TH1*)harr[0+shift]); // missing FO ratio (per event)
+ if (harr[9+shift]&&harr[3+shift]&&harr[4+shift]) ((TH1*)harr[9+shift])->Divide((TH1*)harr[3+shift],(TH1*)harr[4+shift]); // noisy FO ratio (per event)
+ //
+ TH1 *h0 = (TH1*)harr[0+shift];
+ TH1 *h4 = (TH1*)harr[4+shift];
+ TH2 *h5 = (TH2*)harr[5+shift];
+ TH1 *h8 = (TH1*)harr[8+shift];
+ TH1 *h9 = (TH1*)harr[9+shift];
+ //
+ if (h0 && h4 && h5 && h8 && h9) {
+ for(Int_t i=0; i<1200; i++) {
+ // threshold for protection in case of technical runs (->few entries per chip)
+ Short_t thre=20; // 20 is ok in run 104792 (where the problem occured).
+ if (h0->GetBinContent(i+1)<thre) continue; // expected FO yield
+ if (h4->GetBinContent(i+1)<thre) continue; // the total FO yield.
+ //
+ if(h8->GetBinContent(i+1)>0.5 && h9->GetBinContent(i+1)>0.5) {
+ Int_t eq=i/60;
+ Int_t hs=(i%60)/10;
+ Int_t chip = (i%60)%10;
+ Int_t sect = 999; Int_t chipbin = 999;
+ if(eq<10) {sect = eq; chipbin = 19-chip;}
+ else {sect = eq-10; chipbin = chip;}
+ h5->Fill(sect*6+hs,chipbin);
+ }
+ }
+ }
+ } // QA Task Index == RAWS
+ } // RS: loop over trigger classes
}
//____________________________________________________________________________
if(!rawReader) {
AliError("rawReader is NULL");
return -1;
- }
-
+ }
rawReader->Reset();
AliITSRawStreamSPD rawStreamSPD(rawReader);
rawStreamSPD.ActivateAdvancedErrorLog(kTRUE,fAdvLogger);
-
// shift for online histos
Int_t shift = fGenRawsOffset[fAliITSQADataMakerRec->GetEventSpecie()];
if (iHalfStave>=0 && iHalfStave<2) iLayer=0;
else iLayer=1;
- fAliITSQADataMakerRec->GetRawsData(0+offset)->Fill(iLayer);
+ fAliITSQADataMakerRec->FillRawsData(0+offset,iLayer);
if (iLayer==0) {
- fAliITSQADataMakerRec->GetRawsData(1+offset)->Fill(module);
+ fAliITSQADataMakerRec->FillRawsData(1+offset,module);
nDigitsL1++;
} else {
- fAliITSQADataMakerRec->GetRawsData(2+offset)->Fill(module);
+ fAliITSQADataMakerRec->FillRawsData(2+offset,module);
nDigitsL2++;
}
if(iEq<10) {
- fAliITSQADataMakerRec->GetRawsData(3+offset)->Fill(iHalfStave+iEq*6,iChip);
+ fAliITSQADataMakerRec->FillRawsData(3+offset,iHalfStave+iEq*6,iChip);
}
else {
- fAliITSQADataMakerRec->GetRawsData(4+offset)->Fill(iHalfStave+(iEq-10)*6,iChip);
+ fAliITSQADataMakerRec->FillRawsData(4+offset,iHalfStave+(iEq-10)*6,iChip);
}
if(iLayer==0) {
if(iEq<10) {
- fAliITSQADataMakerRec->GetRawsData(30+offset)->Fill(19-iChip,iHalfStave+iEq*2);
- fAliITSQADataMakerRec->GetRawsData(32+offset)->Fill(19-iChip);
- fAliITSQADataMakerRec->GetRawsData(34+offset)->Fill(iHalfStave+iEq*2);
+ fAliITSQADataMakerRec->FillRawsData(30+offset,19-iChip,iHalfStave+iEq*2);
+ fAliITSQADataMakerRec->FillRawsData(32+offset,19-iChip);
+ fAliITSQADataMakerRec->FillRawsData(34+offset,iHalfStave+iEq*2);
}
else {
- fAliITSQADataMakerRec->GetRawsData(30+offset)->Fill(iChip,iHalfStave+(iEq-10)*2);
- fAliITSQADataMakerRec->GetRawsData(32+offset)->Fill(iChip);
- fAliITSQADataMakerRec->GetRawsData(34+offset)->Fill(iHalfStave+(iEq-10)*2);
+ fAliITSQADataMakerRec->FillRawsData(30+offset,iChip,iHalfStave+(iEq-10)*2);
+ fAliITSQADataMakerRec->FillRawsData(32+offset,iChip);
+ fAliITSQADataMakerRec->FillRawsData(34+offset,iHalfStave+(iEq-10)*2);
}
}
else {
if(iEq<10) {
- fAliITSQADataMakerRec->GetRawsData(31+offset)->Fill(19-iChip,iHalfStave-2+iEq*4);
- fAliITSQADataMakerRec->GetRawsData(33+offset)->Fill(19-iChip);
- fAliITSQADataMakerRec->GetRawsData(35+offset)->Fill(iHalfStave-2+iEq*4);
+ fAliITSQADataMakerRec->FillRawsData(31+offset,19-iChip,iHalfStave-2+iEq*4);
+ fAliITSQADataMakerRec->FillRawsData(33+offset,19-iChip);
+ fAliITSQADataMakerRec->FillRawsData(35+offset,iHalfStave-2+iEq*4);
}
else {
- fAliITSQADataMakerRec->GetRawsData(31+offset)->Fill(iChip,iHalfStave-2+(iEq-10)*4);
- fAliITSQADataMakerRec->GetRawsData(33+offset)->Fill(iChip);
- fAliITSQADataMakerRec->GetRawsData(35+offset)->Fill(iHalfStave-2+(iEq-10)*4);
+ fAliITSQADataMakerRec->FillRawsData(31+offset,iChip,iHalfStave-2+(iEq-10)*4);
+ fAliITSQADataMakerRec->FillRawsData(33+offset,iChip);
+ fAliITSQADataMakerRec->FillRawsData(35+offset,iHalfStave-2+(iEq-10)*4);
}
}
- fAliITSQADataMakerRec->GetRawsData(5+iEq+offset)->Fill(colM+(module%2)*160,rowM+iHalfStave*256);
+ fAliITSQADataMakerRec->FillRawsData(5+iEq+offset,colM+(module%2)*160,rowM+iHalfStave*256);
}
}
for (Int_t ieq=0; ieq<20; ieq++) {
nErrorsDDL[ieq] = 0;
for (UInt_t ierr=0; ierr<fAdvLogger->GetNrErrorCodes(); ierr++) {
- fAliITSQADataMakerRec->GetRawsData(ieq+(kAmoreFoOffset+1)+shift)->Fill(ierr,fAdvLogger->GetNrErrors(ierr,ieq));
+ fAliITSQADataMakerRec->FillRawsData(ieq+(kAmoreFoOffset+1)+shift,ierr,fAdvLogger->GetNrErrors(ierr,ieq));
if(ierr>0) {
nErrorsDDL[ieq] = nErrorsDDL[ieq] + fAdvLogger->GetNrErrors(ierr,ieq);
}
- ((TH2F*)fAliITSQADataMakerRec->GetRawsData(kAmoreFoOffset+shift))->Fill(ieq,ierr,fAdvLogger->GetNrErrors(ierr,ieq));
+ fAliITSQADataMakerRec->FillRawsData(kAmoreFoOffset+shift,ieq,ierr,fAdvLogger->GetNrErrors(ierr,ieq));
}
for (Int_t ihs=0; ihs<6; ihs++) {
for (Int_t ichip=0; ichip<10; ichip++) {
- if(isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(0+shift)->Fill(ieq*60+ihs*10+ichip); // online
- if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip)) fAliITSQADataMakerRec->GetRawsData(4+shift)->Fill(ieq*60+ihs*10+ichip); // online
+ if(isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(0+shift,ieq*60+ihs*10+ichip); // online
+ if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip)) fAliITSQADataMakerRec->FillRawsData(4+shift,ieq*60+ihs*10+ichip); // online
// now filling the 3 possibile combinations
- if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(1+shift)->Fill(ieq*60+ihs*10+ichip); // online
- if(!rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(2+shift)->Fill(ieq*60+ihs*10+ichip); // online
- if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && !isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->GetRawsData(3+shift)->Fill(ieq*60+ihs*10+ichip); // online
+ if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(1+shift,ieq*60+ihs*10+ichip); // online
+ if(!rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(2+shift,ieq*60+ihs*10+ichip); // online
+ if(rawStreamSPD.GetFastOrSignal(ieq,ihs,ichip) && !isOnlineFiredChip[ieq*60+ihs*10+ichip]) fAliITSQADataMakerRec->FillRawsData(3+shift,ieq*60+ihs*10+ichip); // online
chipKey = rawStreamSPD.GetOfflineChipKeyFromOnline(ieq,ihs,ichip);
Int_t sect = 999;
if(ieq<10) {sect = ieq; chipbin = 19-ichip;}
else {sect = ieq-10; chipbin = ichip;}
- fAliITSQADataMakerRec->GetRawsData(28+offset)->Fill(sect*6+ihs,chipbin);
- fAliITSQADataMakerRec->GetRawsData(29+offset)->Fill(chipKey);
+ fAliITSQADataMakerRec->FillRawsData(28+offset,sect*6+ihs,chipbin);
+ fAliITSQADataMakerRec->FillRawsData(29+offset,chipKey);
}
}
}
}
- if(fAliITSQADataMakerRec->GetRawsData(6+shift)) {
- fAliITSQADataMakerRec->GetRawsData(6+shift)->Fill(nFastOr[0],nFastOr[1]); // online
- }
+ fAliITSQADataMakerRec->FillRawsData(6+shift,nFastOr[0],nFastOr[1]); // online
fAdvLogger->Reset();
- fAliITSQADataMakerRec->GetRawsData(25+offset)->Fill(nDigitsL1);
- fAliITSQADataMakerRec->GetRawsData(26+offset)->Fill(nDigitsL2);
- fAliITSQADataMakerRec->GetRawsData(27+offset)->Fill(nDigitsL1,nDigitsL2);
-
+ fAliITSQADataMakerRec->FillRawsData(25+offset,nDigitsL1);
+ fAliITSQADataMakerRec->FillRawsData(26+offset,nDigitsL2);
+ fAliITSQADataMakerRec->FillRawsData(27+offset,nDigitsL1,nDigitsL2);
+ //
AliDebug(AliQAv1::GetQADebugLevel(),Form("Event completed, %d raw digits read",nDigitsL1+nDigitsL2));
return rv ;
}
Int_t AliITSQASPDDataMakerRec::MakeDigits(TTree *digits)
{
// Fill QA for DIGIT - SPD -
+
Int_t rv = 0 ;
-
-// AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
-// fITS->SetTreeAddress();
-// TClonesArray *iITSdigits = fITS->DigitsAddress(0); // 0->SPD
+ // AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
+ // fITS->SetTreeAddress();
+ // TClonesArray *iITSdigits = fITS->DigitsAddress(0); // 0->SPD
TBranch *branchD = digits->GetBranch("ITSDigitsSPD");
if (!branchD) {
AliError("can't get the branch with the SPD ITS digits !");
digits->GetEvent(imod);
Int_t ndigits = iITSdigits->GetEntries();
if (imod<80) {
- fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(0.5,ndigits);
- fAliITSQADataMakerRec->GetDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(imod,ndigits);
+ fAliITSQADataMakerRec->FillDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],0.5,ndigits);
+ fAliITSQADataMakerRec->FillDigitsData(1+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],imod,ndigits);
nDigitsL1+=ndigits;
}
else {
- fAliITSQADataMakerRec->GetDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(1,ndigits);
- fAliITSQADataMakerRec->GetDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(imod,ndigits);
+ fAliITSQADataMakerRec->FillDigitsData(0+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],1,ndigits);
+ fAliITSQADataMakerRec->FillDigitsData(2+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],imod,ndigits);
nDigitsL2+=ndigits;
}
for (Int_t idig=0; idig<ndigits; ++idig) {
AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);
Int_t col=dig->GetCoord1(); // cell number z
Int_t row=dig->GetCoord2(); // cell number x
- fAliITSQADataMakerRec->GetDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(col);
- fAliITSQADataMakerRec->GetDigitsData(4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(row);
+ fAliITSQADataMakerRec->FillDigitsData(3+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],col);
+ fAliITSQADataMakerRec->FillDigitsData(4+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],row);
}
}
- fAliITSQADataMakerRec->GetDigitsData(5+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL1);
- fAliITSQADataMakerRec->GetDigitsData(6+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL2);
- fAliITSQADataMakerRec->GetDigitsData(7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nDigitsL1,nDigitsL2);
+ fAliITSQADataMakerRec->FillDigitsData(5+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nDigitsL1);
+ fAliITSQADataMakerRec->FillDigitsData(6+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nDigitsL2);
+ fAliITSQADataMakerRec->FillDigitsData(7+fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nDigitsL1,nDigitsL2);
+ //
return rv ;
}
Int_t AliITSQASPDDataMakerRec::MakeRecPoints(TTree * clusterTree)
{
// Fill QA for RecPoints - SPD -
+
Int_t rv = 0 ;
AliITSRecPointContainer* rpcont=AliITSRecPointContainer::Instance();
TClonesArray *recpoints = NULL;
(AliITSRecPoint*)recpoints->UncheckedAt(nCluster);
if (cluster->GetLayer()>1)continue;
Int_t lay=cluster->GetLayer();
- fAliITSQADataMakerRec->GetRecPointsData(0 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(lay);
+ fAliITSQADataMakerRec->FillRecPointsData(0 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],lay);
cluster->GetGlobalXYZ(cluGlo);
Float_t rad=TMath::Sqrt(cluGlo[0]*cluGlo[0]+cluGlo[1]*cluGlo[1]);
Float_t phi= TMath::Pi() + TMath::ATan2(-cluGlo[1],-cluGlo[0]);
if (lay==0) {
- fAliITSQADataMakerRec->GetRecPointsData(1 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(iIts);
- fAliITSQADataMakerRec->GetRecPointsData(2 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalX());
- fAliITSQADataMakerRec->GetRecPointsData(3 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalZ());
- fAliITSQADataMakerRec->GetRecPointsData(4 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[0]);
- fAliITSQADataMakerRec->GetRecPointsData(5 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[1]);
- fAliITSQADataMakerRec->GetRecPointsData(6 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2]);
- fAliITSQADataMakerRec->GetRecPointsData(7 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad);
- fAliITSQADataMakerRec->GetRecPointsData(8 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(phi);
- fAliITSQADataMakerRec->GetRecPointsData(9 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNz(),cluster->GetNy());
- fAliITSQADataMakerRec->GetRecPointsData(10 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNpixels());
- fAliITSQADataMakerRec->GetRecPointsData(11 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetSPDclusterType());
- fAliITSQADataMakerRec->GetRecPointsData(12 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2],phi);
+ fAliITSQADataMakerRec->FillRecPointsData(1 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],iIts);
+ fAliITSQADataMakerRec->FillRecPointsData(2 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalX());
+ fAliITSQADataMakerRec->FillRecPointsData(3 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalZ());
+ fAliITSQADataMakerRec->FillRecPointsData(4 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[0]);
+ fAliITSQADataMakerRec->FillRecPointsData(5 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[1]);
+ fAliITSQADataMakerRec->FillRecPointsData(6 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2]);
+ fAliITSQADataMakerRec->FillRecPointsData(7 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],rad);
+ fAliITSQADataMakerRec->FillRecPointsData(8 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],phi);
+ fAliITSQADataMakerRec->FillRecPointsData(9 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNz(),cluster->GetNy());
+ fAliITSQADataMakerRec->FillRecPointsData(10 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNpixels());
+ fAliITSQADataMakerRec->FillRecPointsData(11 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetSPDclusterType());
+ fAliITSQADataMakerRec->FillRecPointsData(12 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2],phi);
} else {
- fAliITSQADataMakerRec->GetRecPointsData(13 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(iIts);
- fAliITSQADataMakerRec->GetRecPointsData(14 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalX());
- fAliITSQADataMakerRec->GetRecPointsData(15 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetDetLocalZ());
- fAliITSQADataMakerRec->GetRecPointsData(16 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[0]);
- fAliITSQADataMakerRec->GetRecPointsData(17 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[1]);
- fAliITSQADataMakerRec->GetRecPointsData(18 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2]);
- fAliITSQADataMakerRec->GetRecPointsData(19 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad);
- fAliITSQADataMakerRec->GetRecPointsData(20 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(phi);
- fAliITSQADataMakerRec->GetRecPointsData(21 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNz(),cluster->GetNy());
- fAliITSQADataMakerRec->GetRecPointsData(22 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetNpixels());
- fAliITSQADataMakerRec->GetRecPointsData(23 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluster->GetSPDclusterType());
- fAliITSQADataMakerRec->GetRecPointsData(24 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[2],phi);
+ fAliITSQADataMakerRec->FillRecPointsData(13 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],iIts);
+ fAliITSQADataMakerRec->FillRecPointsData(14 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalX());
+ fAliITSQADataMakerRec->FillRecPointsData(15 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetDetLocalZ());
+ fAliITSQADataMakerRec->FillRecPointsData(16 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[0]);
+ fAliITSQADataMakerRec->FillRecPointsData(17 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[1]);
+ fAliITSQADataMakerRec->FillRecPointsData(18 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2]);
+ fAliITSQADataMakerRec->FillRecPointsData(19 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],rad);
+ fAliITSQADataMakerRec->FillRecPointsData(20 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],phi);
+ fAliITSQADataMakerRec->FillRecPointsData(21 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNz(),cluster->GetNy());
+ fAliITSQADataMakerRec->FillRecPointsData(22 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetNpixels());
+ fAliITSQADataMakerRec->FillRecPointsData(23 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluster->GetSPDclusterType());
+ fAliITSQADataMakerRec->FillRecPointsData(24 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[2],phi);
}
- fAliITSQADataMakerRec->GetRecPointsData(25 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(rad,phi);
- fAliITSQADataMakerRec->GetRecPointsData(26 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(cluGlo[0],cluGlo[1]);
+ fAliITSQADataMakerRec->FillRecPointsData(25 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],rad,phi);
+ fAliITSQADataMakerRec->FillRecPointsData(26 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],cluGlo[0],cluGlo[1]);
nClusters[lay]++;
} // end of cluster loop
} // end of its "subdetector" loop
for (Int_t iLay=0; iLay<2; iLay++)
- fAliITSQADataMakerRec->GetRecPointsData(27 +iLay +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nClusters[iLay]);
-
- fAliITSQADataMakerRec->GetRecPointsData(29 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()])->Fill(nClusters[0],nClusters[1]);
+ fAliITSQADataMakerRec->FillRecPointsData(27 +iLay +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nClusters[iLay]);
+ fAliITSQADataMakerRec->FillRecPointsData(29 +fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()],nClusters[0],nClusters[1]);
+ //
return rv ;
}
virtual Int_t MakeDigits() {return 0;}
virtual Int_t MakeDigits(TTree *clustersTree);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
virtual ~AliITSQASPDDataMakerRec(); // dtor
Int_t GetOffset(AliQAv1::TASKINDEX_t task,Int_t specie=0) const;
void SetOffset(AliQAv1::TASKINDEX_t task, Int_t offset, Int_t specie = 0);
}
//____________________________________________________________________________
-void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/)
+void AliITSQASPDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray** /*list*/)
{
// launch the QA checking
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
digits->GetEvent(imod);
Int_t ndigits = iITSdigits->GetEntries();
if (imod<80) {
- fAliITSQADataMakerSim->GetDigitsData(0+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(0.5,ndigits);
- fAliITSQADataMakerSim->GetDigitsData(1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,ndigits);
+ fAliITSQADataMakerSim->FillDigitsData(0+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],0.5,ndigits);
+ fAliITSQADataMakerSim->FillDigitsData(1+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],imod,ndigits);
nDigitsL1+=ndigits;
}
else {
- fAliITSQADataMakerSim->GetDigitsData(0+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(1,ndigits);
- fAliITSQADataMakerSim->GetDigitsData(2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,ndigits);
+ fAliITSQADataMakerSim->FillDigitsData(0+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],1,ndigits);
+ fAliITSQADataMakerSim->FillDigitsData(2+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],imod,ndigits);
nDigitsL2+=ndigits;
}
for (Int_t idig=0; idig<ndigits; ++idig) {
AliITSdigit *dig=(AliITSdigit*)iITSdigits->UncheckedAt(idig);
Int_t col=dig->GetCoord1(); // cell number z
Int_t row=dig->GetCoord2(); // cell number x
- fAliITSQADataMakerSim->GetDigitsData(3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(col);
- fAliITSQADataMakerSim->GetDigitsData(4+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(row);
+ fAliITSQADataMakerSim->FillDigitsData(3+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],col);
+ fAliITSQADataMakerSim->FillDigitsData(4+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],row);
}
}
- fAliITSQADataMakerSim->GetDigitsData(5+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nDigitsL1);
- fAliITSQADataMakerSim->GetDigitsData(6+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nDigitsL2);
- fAliITSQADataMakerSim->GetDigitsData(7+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(nDigitsL1,nDigitsL2);
+ fAliITSQADataMakerSim->FillDigitsData(5+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],nDigitsL1);
+ fAliITSQADataMakerSim->FillDigitsData(6+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],nDigitsL2);
+ fAliITSQADataMakerSim->FillDigitsData(7+fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()],nDigitsL1,nDigitsL2);
+ //
return rv ;
}
{
// Fill QA for SDIGIT - SPD -
Int_t rv = 0 ;
-
static TClonesArray * sdig ;
if (! sdig )
sdig = new TClonesArray( "AliITSpListItem",1000 );
brchSDigits->GetEvent(imod);
Int_t nsdig=sdig->GetEntries();
if (imod<80) {
- fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(0.5,nsdig);
- fAliITSQADataMakerSim->GetSDigitsData(1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nsdig);
+ fAliITSQADataMakerSim->FillSDigitsData(0+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],0.5,nsdig);
+ fAliITSQADataMakerSim->FillSDigitsData(1+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],imod,nsdig);
}
else {
- fAliITSQADataMakerSim->GetSDigitsData(0+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(1,nsdig);
- fAliITSQADataMakerSim->GetSDigitsData(2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nsdig);
+ fAliITSQADataMakerSim->FillSDigitsData(0+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],1,nsdig);
+ fAliITSQADataMakerSim->FillSDigitsData(2+fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()],imod,nsdig);
}
sdig->Clear() ;
}
+ //
return rv ;
}
TObjArray *arrHits = module->GetHits();
Int_t nhits = arrHits->GetEntriesFast();
if (imod<80) {
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(0.5,nhits);
- fAliITSQADataMakerSim->GetHitsData(1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nhits);
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],0.5,nhits);
+ fAliITSQADataMakerSim->FillHitsData(1+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],imod,nhits);
} else {
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(1,nhits);
- fAliITSQADataMakerSim->GetHitsData(2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(imod,nhits);
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],1,nhits);
+ fAliITSQADataMakerSim->FillHitsData(2+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],imod,nhits);
}
for (Int_t iHit=0; iHit<nhits; ++iHit) {
AliITShit *hit = (AliITShit*) arrHits->At(iHit);
hit->GetPositionL(xl,yl,zl,tof);
hit->GetPositionL0(xl0,yl0,zl0,tof0);
Float_t dyloc=TMath::Abs(yl-yl0)*10000.;
- fAliITSQADataMakerSim->GetHitsData(3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(dyloc);
+ fAliITSQADataMakerSim->FillHitsData(3+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],dyloc);
Float_t edep=hit->GetIonization()*1000000;
if(dyloc>180.){
- fAliITSQADataMakerSim->GetHitsData(4+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()])->Fill(edep);
+ fAliITSQADataMakerSim->FillHitsData(4+fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()],edep);
}
}
}
+ //
return rv ;
}
AliITSQASPDDataMakerSim& operator = (const AliITSQASPDDataMakerSim& qac);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
virtual ~AliITSQASPDDataMakerSim() {;} // dtor
virtual Int_t InitDigits();
virtual Int_t InitSDigits();
// INFN Torino
// --- ROOT system ---
-#include <TH2D.h>
+#include <TH2F.h>
#include <TTree.h>
#include <TMath.h>
#include <TString.h>
AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(AliITSQADataMakerRec *aliITSQADataMakerRec, Bool_t kMode, Int_t ldc) :
TObject(),
-fAliITSQADataMakerRec(aliITSQADataMakerRec),
-fSSDEvent(0),
-fSSDEventPerCycle(0),
-fkOnline(kMode),
-fLDC(ldc),
-fSSDRawsOffset(0), fSSDRawsDAOffset(0),
-fSSDRawsCommonLevelOffset(0),
-fSSDhRawsTask(0),
-fSSDhDigitsTask(0),
-fSSDhRecPointsTask(0),
-fGenRawsOffset(0),
-fGenDigitsOffset(0),
-fGenRecPointsOffset(0),
-fCDBManager(0) {
+ fAliITSQADataMakerRec(aliITSQADataMakerRec),
+ fkOnline(kMode),
+ fLDC(ldc),
+ fSSDRawsOffset(0), fSSDRawsDAOffset(0),
+ fSSDRawsCommonLevelOffset(0),
+ fSSDhRawsTask(0),
+ fSSDhDigitsTask(0),
+ fSSDhRecPointsTask(0),
+ fGenRawsOffset(0),
+ fGenDigitsOffset(0),
+ fGenRecPointsOffset(0),
+ fCDBManager(0) {
// Default constructor
//initilize the raw signal vs strip number histograms
- fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies];
- fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies];
- fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies];
- for(Int_t i=0; i<AliRecoParam::kNSpecies; i++) {
- fGenRawsOffset[i] = 0;
- fGenRecPointsOffset[i] = 0;
- fGenDigitsOffset[i]=0;
- }
+ fGenRawsOffset = new Int_t[AliRecoParam::kNSpecies];
+ fGenRecPointsOffset = new Int_t[AliRecoParam::kNSpecies];
+ fGenDigitsOffset = new Int_t[AliRecoParam::kNSpecies];
+ for(Int_t i=0; i<AliRecoParam::kNSpecies; i++) {
+ fGenRawsOffset[i] = 0;
+ fGenRecPointsOffset[i] = 0;
+ fGenDigitsOffset[i]=0;
+ }
if(fkOnline) {
fCDBManager = AliCDBManager::Instance();
//fCDBManager->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
gTitle = "SSD_RawSignal_Layer"; gTitle += gLayer;
gTitle += "_Ladder"; gTitle += gLadder;
gTitle += "_Module"; gTitle += gModule;
- fHistSSDRawSignalModule[gHistCounterRawSignal] = new TH1D(gTitle.Data(),gTitle.Data(),
+ fHistSSDRawSignalModule[gHistCounterRawSignal] = new TH1F(gTitle.Data(),gTitle.Data(),
2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
gHistCounterRawSignal += 1;
gTitle = "SSD_CM_PSide_Layer"; gTitle += gLayer;
gTitle += "_Ladder"; gTitle += gLadder;
gTitle += "_Module"; gTitle += gModule;
- fHistSSDCMModule[gHistCounterCM] = new TH1D(gTitle.Data(),gTitle.Data(),
+ fHistSSDCMModule[gHistCounterCM] = new TH1F(gTitle.Data(),gTitle.Data(),
100,-50.,50.);
fHistSSDCMModule[gHistCounterCM]->GetXaxis()->SetTitle("CM");
gHistCounterCM += 1;
gTitle = "SSD_CM_NSide_Layer"; gTitle += gLayer;
gTitle += "_Ladder"; gTitle += gLadder;
gTitle += "_Module"; gTitle += gModule;
- fHistSSDCMModule[gHistCounterCM] = new TH1D(gTitle.Data(),gTitle.Data(),
+ fHistSSDCMModule[gHistCounterCM] = new TH1F(gTitle.Data(),gTitle.Data(),
100,-50.,50.);
fHistSSDCMModule[gHistCounterCM]->GetXaxis()->SetTitle("CM");
gHistCounterCM += 1;
AliITSQASSDDataMakerRec::AliITSQASSDDataMakerRec(const AliITSQASSDDataMakerRec& qadm) :
TObject(),
fAliITSQADataMakerRec(qadm.fAliITSQADataMakerRec),
-fSSDEvent(qadm.fSSDEvent),
-fSSDEventPerCycle(qadm.fSSDEventPerCycle),
fkOnline(qadm.fkOnline),
fLDC(qadm.fLDC),
fSSDRawsOffset(qadm.fSSDRawsOffset), fSSDRawsDAOffset(qadm.fSSDRawsDAOffset),
fGenDigitsOffset(qadm.fGenDigitsOffset),
fGenRecPointsOffset(qadm.fGenRecPointsOffset),
fCDBManager(qadm.fCDBManager) {
- //copy ctor
- fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ;
- fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
+//copy ctor
+fAliITSQADataMakerRec->SetName((const char*)qadm.fAliITSQADataMakerRec->GetName()) ;
+fAliITSQADataMakerRec->SetTitle((const char*)qadm.fAliITSQADataMakerRec->GetTitle());
}
//__________________________________________________________________
AliITSQASSDDataMakerRec& AliITSQASSDDataMakerRec::operator = (const AliITSQASSDDataMakerRec& qac )
{
- // Equal operator.
- this->~AliITSQASSDDataMakerRec();
- new(this) AliITSQASSDDataMakerRec(qac);
- return *this;
+// Equal operator.
+this->~AliITSQASSDDataMakerRec();
+new(this) AliITSQASSDDataMakerRec(qac);
+return *this;
}
*/
//__________________________________________________________________
//if ( fAliITSQADataMakerRec->GetRawsData(0) == NULL ) // Raws not defined
//return ;
- //for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- //if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
-//cout << "StartOfDetectorCycle: Event specie " << specie << " is set" << endl;
+ //for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ //if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
+ //cout << "StartOfDetectorCycle: Event specie " << specie << " is set" << endl;
- //Detector specific actions at start of cycle
- AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SSD Cycle\n");
- //Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
+ //Detector specific actions at start of cycle
+ AliDebug(AliQAv1::GetQADebugLevel(),"AliITSQADM::Start of SSD Cycle\n");
+ //Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
- //}//event specie loop
+ //}//event specie loop
}
//____________________________________________________________________________
-void AliITSQASSDDataMakerRec::ResetRawsMonitoredObjects() {
+void AliITSQASSDDataMakerRec::ResetRawsMonitoredObjects()
+{
//Resetting the raw data monitored objects
//Data size per DDL
//for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
//if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
- /*((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+4)))->Reset();
- //Data size per LDC
- ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+22)))->Reset();*/
+ /*((TH1F *)(fAliITSQADataMakerRec->ResetRawsData(fGenRawsOffset[specie]+4)));
+ //Data size per LDC
+ ((TH1F *)(fAliITSQADataMakerRec->ResetRawsData(fGenRawsOffset[specie]+22)));*/
Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
//cout << "(AliITSQASSDDataMakerRec::ResetRawsMonitoredObjects): Event specie " << specie << " is set" << endl;
//online part
}//module loop
//for(Int_t iSSDOffset = 0; iSSDOffset < fSSDRawsCommonLevelOffset; iSSDOffset++)
- //(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+iSSDOffset))->Reset();
+ //(fAliITSQADataMakerRec->ResetRawsData(fGenRawsOffset[specie]+iSSDOffset));
//for(Int_t iSSDOffset = fSSDRawsCommonLevelOffset; iSSDOffset < fSSDRawsOffset; iSSDOffset++)
- //(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+iSSDOffset))->Reset();
+ //(fAliITSQADataMakerRec->ResetRawsData(fGenRawsOffset[specie]+iSSDOffset));
Int_t gHistPositionOccupancyPerLadder = 0;
Int_t gLayer = 0, gLadder = 0, gModule = 0;
gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
//P-SIDE OCCUPANCY
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->Reset();
+ int offs = fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES;
+ fAliITSQADataMakerRec->ResetRawsData(offs+gHistPositionOccupancyPerLadder);
//N-SIDE OCCUPANCY
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->Reset();
-
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->Reset();
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->Reset();
+ fAliITSQADataMakerRec->ResetRawsData(offs+gHistPositionOccupancyPerLadder+1);
+ //
+ fAliITSQADataMakerRec->ResetRawsData(offs+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6);
+ fAliITSQADataMakerRec->ResetRawsData(offs+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1);
}//module loop
}//online flag
- //}//event species loop
+ //
}
//____________________________________________________________________________
-void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray* /*list*/)
+void AliITSQASSDDataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** /*list*/)
{
-
- //for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- //if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
- //if (!AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(specie))) continue;
-
+ // finalize ssd cycle
+ //
Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
- fAliITSQADataMakerRec->SetEventSpecie(AliRecoParam::ConvertIndex(specie));
//cout << "(AliITSQASSDDataMakerRec::EndOfDetectorCycle): Event specie " << specie << " is set" << endl;
// launch the QA checking
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
AliDebug(AliQAv1::GetQADebugLevel(), Form("Offset: %d\n",fGenRawsOffset[specie]));
//Printf("Offset: %d\n",fGenRawsOffset[specie]);
-
+
if(task == AliQAv1::kRAWS) {
-
- // if (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]) != NULL ) {
- //AliInfo(Form("Event type entries: %d - Physics events: %d"),((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->GetEntries(),((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->GetBinContent(((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->FindBin(7)));
- //cout<<"(EndOfDetectorCycle) Event type entries: "<<((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->GetEntries()<< " type 7: " << ((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->GetBinContent(((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->FindBin(7)) << endl;
-
- //AliInfo(Form("SSD Data Size entries: %d"),((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+1))->GetEntries());
- //cout<<"SSD Data Size entries: "<<((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+1))->GetEntries()<<endl;
-
- //Data size per DDL
- for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
- Double_t gSizePerDDL = ((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+5+i))->GetMean();
- //cout<<"DDL: "<<i+512<<" - Size: "<<gSizePerDDL<<" - Mean: "<<
- //(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+5+i))->GetMean()<<endl;
- //cout<<"Entries: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+5+i))->GetEntries()<<endl;
- ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+4)))->SetBinContent(i+1,gSizePerDDL);
- //cout<<"After filling DDL: "<<i+512<<" - Size: "<<((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+4)))->GetBinContent(i+1)<<endl;
- }
-
-
- //Data size per LDC
- for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
- Double_t gSizePerLDC = ((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+23+i))->GetMean();
- ((TH1D *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+22)))->SetBinContent(i+1,gSizePerLDC);
- //cout<<"LDC: "<<i+170<<" - Size: "<<gSizePerLDC<<" - Mean: "<<
- //" - Size: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+23+i))->GetMean()<<endl;
- }
-
- //cout<<"Data size/ DDL entries: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+4))->GetEntries()<< " mean: " << ((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+4))->GetMean()<<endl;
- // cout<<"Data size/ LDC entries: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+22))->GetEntries()<< " mean: " << ((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+22))->GetMean()<<endl;
-
- //online part
- if(fkOnline) {
- //Output of the DA
- MonitorOCDBObjects();
- //Monitor common mode values
- MonitorCMValues();
-
- Int_t gHistPositionOccupancyPerModule = 0;
- Int_t gLayer = 0, gLadder = 0, gModule = 0;
- //occupancy per module
- for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
- AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
-
- gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
- for(Int_t iBins = 1; iBins < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBins++)
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)->SetBinContent(iBins,fOccupancyMatrix[iModule][iBins-1]);
-
- if(fSSDEventPerCycle != 0)
- ((TH1F *)(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule)))->Scale(100./fSSDEventPerCycle);
- }//module loop
-
- //AliInfo(Form("Entries occupancy 511/3: %d"),((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+222))->GetEntries());
- // cout<<"Entries occupancy 511/3 : "<<((TH1D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+222))->GetEntries()<<endl;
-
- //occupancy per ladder
- Int_t gHistPositionOccupancyPerLadder = 0;
- Int_t lLadderLocationY = 0;
- Double_t occupancy = 0.0, occupancyThreshold = 0.0, occupancyAverage = 0.0;
- for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
- AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
-
- gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
- gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
-
- //P-SIDE OCCUPANCY
- occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,0,0);
- occupancyThreshold = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,1,3);
- occupancyAverage = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),0,2,0);
-
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder)->SetBinContent(gModule,occupancy);
- lLadderLocationY = 3*gLadder; // sideP=1 sideN=0
- if(gLayer == 5) {
- //occupancy per module - no threshold
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY,occupancy);
- //occupancy per module - threshold @ 3%
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2))->SetBinContent(gModule,lLadderLocationY,occupancyThreshold);
- //average occupancy per module
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4))->SetBinContent(gModule,lLadderLocationY,occupancyAverage);
- }
- else if(gLayer == 6) {
- //occupancy per module - no threshold
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY,occupancy);
- //occupancy per module - threshold @ 3%
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->SetBinContent(gModule,lLadderLocationY,occupancyThreshold);
- //average occupancy per module
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5))->SetBinContent(gModule,lLadderLocationY,occupancyAverage);
- }
-
- //N-SIDE OCCUPANCY
- occupancy = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,0,0);
- occupancyThreshold = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,1,3);
- occupancyAverage = GetOccupancyModule((TH1 *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule),1,2,0);
-
- fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1)->SetBinContent(gModule,occupancy);
- if(gLayer == 5) {
- //occupancy per module - no threshold
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->SetBinContent(gModule,lLadderLocationY-1,occupancy);
- //occupancy per module - threshold @ 3%
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2))->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold);
- //average occupancy per module
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4))->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage);
- }
- else if(gLayer == 6) {
- //occupancy per module - no threshold
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1))->SetBinContent(gModule,lLadderLocationY-1,occupancy);
- //occupancy per module - threshold @ 3%
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold);
- //average occupancy per module
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5))->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage);
+ //
+ for (int trCl=-1;trCl<fAliITSQADataMakerRec->GetNTrigClasses();trCl++) { // RS Loop over all trigger classes (+ global counter, -1)
+ //
+ TObjArray &harr = *fAliITSQADataMakerRec->GetRawsDataOfTrigClass(trCl);
+ int offs = fGenRawsOffset[specie];
+ int nSSDEventPerCycle = fAliITSQADataMakerRec->GetEvCountCycleRaws(trCl);
+ //
+ //Data size per DDL
+ for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
+ if (!(harr[offs+5+i] && harr[offs+4+i])) continue;
+ Double_t gSizePerDDL = ((TH1*)harr[offs+5+i])->GetMean();
+ //cout<<"DDL: "<<i+512<<" - Size: "<<gSizePerDDL<<" - Mean: "<<gSizePerDDL<<endl;
+ //cout<<"Entries: "<<((TH1*)harr[offs+5+i])->GetEntries()<<endl;
+ ((TH1*)harr[offs+4+i])->SetBinContent(i+1,gSizePerDDL);
+ //cout<<"After filling DDL: "<<i+512<<" - Size: "<< ((TH1F*)harr[offs+4+i])->GetBinContent(i+1)<<endl;
+ }
+ //
+ //Data size per LDC
+ for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
+ if ( !(harr[offs+23+i]&&harr[offs+22+i])) continue;
+ Double_t gSizePerLDC = ((TH1*)harr[offs+23+i])->GetMean();
+ ((TH1*)harr[offs+22+i])->SetBinContent(i+1,gSizePerLDC);
+ //cout<<"LDC: "<<i+170<<" - Size: "<<gSizePerLDC<<" - Mean: "<<" - Size: "<<((TH1*)harr[offs+23+i])->GetMean()<<endl;
+ }
+ //
+ //if (harr[offs+4]) cout<<"Data size/ DDL entries: "<<((TH1*)harr[offs+4 ])->GetEntries()<< " mean: " << ((TH1*)harr[offs+4])->GetMean()<<endl;
+ //if (harr[offs+22]) cout<<"Data size/ LDC entries: "<<((TH1*)harr[offs+22])->GetEntries()<< " mean: " << ((TH1*)harr[offs+22])->GetMean()<<endl;
+ //
+ //online part
+ if(fkOnline) {
+ //Output of the DA
+ MonitorOCDBObjects(trCl);
+ //Monitor common mode values
+ MonitorCMValues(trCl);
+ //
+ Int_t gHistPositionOccupancyPerModule = 0;
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;
+ //occupancy per module
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
+ AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
+ gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
+ TH1* htmp = (TH1*)harr[offs+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule];
+ if (htmp) {
+ for(Int_t iBins = 1; iBins < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBins++) htmp->SetBinContent(iBins,fOccupancyMatrix[iModule][iBins-1]);
+ if(nSSDEventPerCycle != 0) htmp->Scale(100./nSSDEventPerCycle);
+ }//module loop
}
- }//module loop
- }//online flag for SSD
-
- //AliInfo(Form("Entries 2d occupancy no thres- lay 5: %d"),((TH2D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6))->GetEntries());
- //cout<<"entries 2d occupancy thres- lay 6: "<<((TH2D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->GetEntries()<< " mean: " << ((TH2D*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3))->GetMean() << endl; //Somehow the other occupancy maps do give nonzero values for GetMean() here
-
- fSSDEventPerCycle = 0;
-
- //cout<<"Data size/ DDL entries: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[1]+4))->GetEntries()<< " mean: " << ((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[1]+4))->GetMean()<<endl;
-
- //Reset of the raws
- ResetRawsMonitoredObjects();
-
+ //
+ //occupancy per ladder
+ Int_t gHistPositionOccupancyPerLadder = 0;
+ Int_t lLadderLocationY = 0;
+ Double_t occupancy = 0.0, occupancyThreshold = 0.0, occupancyAverage = 0.0;
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
+ AliITSgeomTGeo::GetModuleId(iModule+500,gLayer,gLadder,gModule);
+ //
+ gHistPositionOccupancyPerModule = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
+ gHistPositionOccupancyPerLadder = (gLayer == 5) ? 2*(gLadder - 1) : 2*(gLadder - 1 + fgkSSDLADDERSLAYER5);
+ //
+ TH1* htmpo = (TH1*)harr[offs+fSSDRawsCommonLevelOffset+gHistPositionOccupancyPerModule];
+ TH1* h1t = 0;
+ TH2* h2t = 0;
+ if (htmpo) {
+ //P-SIDE OCCUPANCY
+ occupancy = GetOccupancyModule(htmpo,0,0,0);
+ occupancyThreshold = GetOccupancyModule(htmpo,0,1,3);
+ occupancyAverage = GetOccupancyModule(htmpo,0,2,0);
+ if ( (h1t=(TH1*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder]) ) h1t->SetBinContent(gModule,occupancy);
+ lLadderLocationY = 3*gLadder; // sideP=1 sideN=0
+ if(gLayer == 5) {
+ //occupancy per module - no threshold
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6]) ) h2t->SetBinContent(gModule,lLadderLocationY,occupancy);
+ //occupancy per module - threshold @ 3%
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2]) ) h2t->SetBinContent(gModule,lLadderLocationY,occupancyThreshold);
+ //average occupancy per module
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4]) ) h2t->SetBinContent(gModule,lLadderLocationY,occupancyAverage);
+ }
+ else if(gLayer == 6) {
+ //occupancy per module - no threshold
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1]) ) h2t->SetBinContent(gModule,lLadderLocationY,occupancy);
+ //occupancy per module - threshold @ 3%
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3]) ) h2t->SetBinContent(gModule,lLadderLocationY,occupancyThreshold);
+ //average occupancy per module
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+5]) ) h2t->SetBinContent(gModule,lLadderLocationY,occupancyAverage);
+ }
+ //
+ //N-SIDE OCCUPANCY
+ //
+ occupancy = GetOccupancyModule(htmpo,1,0,0);
+ occupancyThreshold = GetOccupancyModule(htmpo,1,1,3);
+ occupancyAverage = GetOccupancyModule(htmpo,1,2,0);
+ if ( (h1t=(TH1*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+gHistPositionOccupancyPerLadder+1]) ) h1t->SetBinContent(gModule,occupancy);
+ if(gLayer == 5) {
+ //occupancy per module - no threshold
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6]) ) h2t->SetBinContent(gModule,lLadderLocationY-1,occupancy);
+ //occupancy per module - threshold @ 3%
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+2]) ) h2t->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold);
+ //average occupancy per module
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4]) ) h2t->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage);
+ }
+ else if(gLayer == 6) {
+ //occupancy per module - no threshold
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+1]) ) h2t->SetBinContent(gModule,lLadderLocationY-1,occupancy);
+ //occupancy per module - threshold @ 3%
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3]) ) h2t->SetBinContent(gModule,lLadderLocationY-1,occupancyThreshold);
+ //average occupancy per module
+ if ( (h2t=(TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+4]) ) h2t->SetBinContent(gModule,lLadderLocationY-1,occupancyAverage);
+ }
+ } // htmpo
+ }//module loop
+ }//online flag for SSD
+ //
+ //TH2* h2tmp = (TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6];
+ //if (h2tmp) AliInfo(Form("Entries 2d occupancy no thres- lay 5: %d"),h2tmp->GetEntries());
+ //h2tmp = (TH2*)harr[offs+fSSDRawsCommonLevelOffset+fgkSSDMODULES+2*fgkSSDLADDERSLAYER5+2*fgkSSDLADDERSLAYER6+3];
+ //cout<<"entries 2d occupancy thres- lay 6: "<<h2tmp->GetEntries()<< " mean: " << h2tmp->GetMean() << endl; //Somehow the other occupancy maps do give nonzero values for GetMean() here
+ //
+ // TH1* h1tmp = (TH1*)harr[fGenRawsOffset[1]+4];
+ // if (h1tmp) cout<<"Data size/ DDL entries: "<<h1tmp->GetEntries()<< " mean: " << h1tmp->GetMean()<<endl;
+ //Reset of the raws
+ } // RS Loop over all trigger classes (+ global counter, -1)
//AliQAChecker::Instance()->Run( AliQAv1::kITS , task, list);
+ //
+ ResetRawsMonitoredObjects();
}//raw data end of cycle
-
- //} //event specie loop
+ //
+
+ //
}
//____________________________________________________________________________
//if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
//cout << "(AliITSQASSDDataMakerRec::InitRaws): Event specie " << specie << " is set" << endl;
- //cout << "(AliITSQASSDDataMakerRec::InitRaws): Offset " << fGenRawsOffset[specie] << endl;
+ //cout << "(AliITSQASSDDataMakerRec::InitRaws): Offset " << offsRw << endl;
+ int offsRw = fGenRawsOffset[specie];
if(fkOnline) {
else {
AliDebug(AliQAv1::GetQADebugLevel(), "Book Offline Histograms for SSD\n ");
}
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD): %d\n",fGenRawsOffset[specie]));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD): %d\n",offsRw));
TString gTitle;
TString gName;
//book online-offline QA histos
- TH1D *fHistSSDEventType = new TH1D("fHistSSDEventType",
+ TH1F *fHistSSDEventType = new TH1F("fHistSSDEventType",
"SSD Event Type;Event type;Events",
31,-1,30);
fHistSSDEventType->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDEventType,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- //cout<<"(AliITSQASSDDataMakerRec::InitRaws): "<<fGenRawsOffset[specie]+fSSDRawsOffset-1<<" - Name: "<<(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->GetName()<<endl;
- TH1D *fHistSSDDataSize = new TH1D("fHistSSDDataSize",
+ //cout<<"(AliITSQASSDDataMakerRec::InitRaws): "<<offsRw+fSSDRawsOffset-1<<" - Name: "<<(fAliITSQADataMakerRec->GetRawsData(offsRw))->GetName()<<endl;
+ TH1F *fHistSSDDataSize = new TH1F("fHistSSDDataSize",
"SSD Data Size;(SSD data size) [KB];Events",
1000,0,500);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSize,
- fGenRawsOffset[specie]+fSSDRawsOffset, !expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, !expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- TH1D *fHistSSDDataSizePercentage = new TH1D("fHistSSDDataSizePercentage",
+ TH1F *fHistSSDDataSizePercentage = new TH1F("fHistSSDDataSizePercentage",
"SSD Data Size Percentage;SSD data size [%];Events",
1000,0,100);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePercentage,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- TH1D *fHistSSDDDLId = new TH1D("fHistSSDDDLId",
+ TH1F *fHistSSDDDLId = new TH1F("fHistSSDDDLId",
"SSD DDL Id;DDL id;Events",16,511.5,527.5);
fHistSSDDDLId->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDDLId,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- TH1D *fHistSSDDataSizePerDDL = new TH1D("fHistSSDDataSizePerDDL",
+ TH1F *fHistSSDDataSizePerDDL = new TH1F("fHistSSDDataSizePerDDL",
"SSD Data Size Per DDL;DDL id;<SSD data size> [KB]",
16,511.5,527.5);
fHistSSDDataSizePerDDL->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerDDL,
- fGenRawsOffset[specie]+fSSDRawsOffset, !expert, image, !saveCorr);
+ offsRw+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
- TH1D *fHistSSDDataSizeDDL[fgkNumOfDDLs];
+ TH1F *fHistSSDDataSizeDDL[fgkNumOfDDLs];
for(Int_t i = 1; i < fgkNumOfDDLs+1; i++) {
gName = Form("fHistSSDDataSizeDDL%d", i+511) ;
gTitle = Form("SSD Data Size DDL %d", i+511) ;
- fHistSSDDataSizeDDL[i-1] = new TH1D(gName.Data(),
+ fHistSSDDataSizeDDL[i-1] = new TH1F(gName.Data(),
Form("%s;(SSD data size) [KB];Events", gTitle.Data()),
100,0,50);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeDDL[i-1],
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
}
- TH1D *fHistSSDLDCId = new TH1D("fHistSSDLDCId","SSD LDC Id;LDC id;Events",8,169.5,177.5);
+ TH1F *fHistSSDLDCId = new TH1F("fHistSSDLDCId","SSD LDC Id;LDC id;Events",8,169.5,177.5);
fHistSSDLDCId->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDLDCId,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- TH1D *fHistSSDDataSizePerLDC = new TH1D("fHistSSDDataSizePerLDC",
+ TH1F *fHistSSDDataSizePerLDC = new TH1F("fHistSSDDataSizePerLDC",
"SSD Data Size Per LDC;LDC id;<SSD data size> [KB]",
8,169.5,177.5);
fHistSSDDataSizePerLDC->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizePerLDC,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, image, !saveCorr); fSSDRawsOffset += 1;
- TH1D *fHistSSDDataSizeLDC[fgkNumOfLDCs];
+ offsRw+fSSDRawsOffset, expert, image, !saveCorr); fSSDRawsOffset += 1;
+ TH1F *fHistSSDDataSizeLDC[fgkNumOfLDCs];
for(Int_t i = 1; i < fgkNumOfLDCs+1; i++) {
gName = "fHistSSDDataSizeLDC";
if(i == 1) gName += "170";
if(i == 8) gName += "177";
gTitle = "SSD Data Size LDC "; gTitle += gName.Data();
- fHistSSDDataSizeLDC[i-1] = new TH1D(gName.Data(),
+ fHistSSDDataSizeLDC[i-1] = new TH1F(gName.Data(),
Form("%s;SSD data size [KB];Events", gTitle.Data()),
1000,0,100);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDDataSizeLDC[i-1],
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
}
fSSDRawsCommonLevelOffset = fSSDRawsOffset;
if(fkOnline) {
Int_t gLayer = 0, gLadder = 0, gModule = 0;
//occupancy per SSD module
- TH1D *fHistSSDOccupancyModule[fgkSSDMODULES];
+ TH1F *fHistSSDOccupancyModule[fgkSSDMODULES];
for(Int_t i = 500; i < fgkSSDMODULES + 500; i++) {
AliITSgeomTGeo::GetModuleId(i,gLayer,gLadder,gModule);
gName = "fHistSSD_Occupancy_Layer";
gName += "_Module"; gName += gModule;
gTitle += "_Module"; gTitle += gModule;
- fHistSSDOccupancyModule[i-500] = new TH1D(gName.Data(),Form("%s;N_{strip};Occupancy [%%]", gTitle.Data()),
+ fHistSSDOccupancyModule[i-500] = new TH1F(gName.Data(),Form("%s;N_{strip};Occupancy [%%]", gTitle.Data()),
2*fgkNumberOfPSideStrips,0,2*fgkNumberOfPSideStrips);
fHistSSDOccupancyModule[i-500]->GetXaxis()->SetTitleColor(1);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyModule[i-500],
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
}
//Occupancy per SSD ladder
Int_t occupancyCounter = 0;
- TH1D *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
+ TH1F *fHistSSDOccupancyLadder[2*(fgkSSDLADDERSLAYER5 + fgkSSDLADDERSLAYER6)];
for(Int_t iLayer = 5; iLayer < 7; iLayer++) {
for(Int_t iLadder = 1; iLadder < AliITSgeomTGeo::GetNLadders(iLayer) + 1; iLadder++) {
//P-side occupancy plots
}
gName += "_PSide";
gTitle += "_PSide";
- fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gName.Data(),
+ fHistSSDOccupancyLadder[occupancyCounter] = new TH1F(gName.Data(),
Form("%s;Module number;Occupancy [%%]", gTitle.Data()),
AliITSgeomTGeo::GetNDetectors(iLayer),
0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
occupancyCounter += 1; fSSDRawsOffset += 1;
//N-side occupancy plots
gName = "fHistSSD_Occupancy_Layer";
}
gName += "_NSide";
gTitle += "_NSide";
- fHistSSDOccupancyLadder[occupancyCounter] = new TH1D(gName.Data(),
+ fHistSSDOccupancyLadder[occupancyCounter] = new TH1F(gName.Data(),
Form("%s;Module number;Occupancy [%%]", gTitle.Data()),
AliITSgeomTGeo::GetNDetectors(iLayer),
0.5,AliITSgeomTGeo::GetNDetectors(iLayer)+0.5);
fHistSSDOccupancyLadder[occupancyCounter]->GetXaxis()->SetTitleColor(1);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLadder[occupancyCounter],
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
occupancyCounter += 1; fSSDRawsOffset += 1;
}//ladder loop
}//layer loop
//top level occupancy plots
//occupancy per module - no threshold
- TH2D *fHistSSDOccupancyLayer5 = new TH2D("fHistSSDOccupancyLayer5",
+ TH2F *fHistSSDOccupancyLayer5 = new TH2F("fHistSSDOccupancyLayer5",
"SSD Occupancy (Layer 5) - No threshold;N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER5,
0,fgkSSDMODULESPERLADDERLAYER5,
}
fHistSSDOccupancyLayer5->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- TH2D *fHistSSDOccupancyLayer6 = new TH2D("fHistSSDOccupancyLayer6",
+ TH2F *fHistSSDOccupancyLayer6 = new TH2F("fHistSSDOccupancyLayer6",
"Occupancy per module (Layer 6) - No threshold;N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER6,
0,fgkSSDMODULESPERLADDERLAYER6,
}
fHistSSDOccupancyLayer6->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
//occupancy per module - threshold @ 3%
- TH2D *fHistSSDOccupancyThresholdLayer5 = new TH2D("fHistSSDOccupancyThresholdLayer5",
+ TH2F *fHistSSDOccupancyThresholdLayer5 = new TH2F("fHistSSDOccupancyThresholdLayer5",
"Occupancy per module (Layer 5) - Threshold 3%;N_{modules};N_{Ladders};Entries",
fgkSSDMODULESPERLADDERLAYER5,
0,fgkSSDMODULESPERLADDERLAYER5,
}
fHistSSDOccupancyThresholdLayer5->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
- TH2D *fHistSSDOccupancyThresholdLayer6 = new TH2D("fHistSSDOccupancyThresholdLayer6",
+ TH2F *fHistSSDOccupancyThresholdLayer6 = new TH2F("fHistSSDOccupancyThresholdLayer6",
"Occupancy per module (Layer 6) - Threshold 3%;N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER6,
0,fgkSSDMODULESPERLADDERLAYER6,
}
fHistSSDOccupancyThresholdLayer6->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDOccupancyThresholdLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1;
//Average occupancy per module
- TH2D *fHistSSDAverageOccupancyLayer5 = new TH2D("fHistSSDAverageOccupancyLayer5",
+ TH2F *fHistSSDAverageOccupancyLayer5 = new TH2F("fHistSSDAverageOccupancyLayer5",
"Average occupancy per module (Layer 5);N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER5,
0,fgkSSDMODULESPERLADDERLAYER5,
}
fHistSSDAverageOccupancyLayer5->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, !expert, image, !saveCorr);
+ offsRw+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
- TH2D *fHistSSDAverageOccupancyLayer6 = new TH2D("fHistSSDAverageOccupancyLayer6",
+ TH2F *fHistSSDAverageOccupancyLayer6 = new TH2F("fHistSSDAverageOccupancyLayer6",
"Average occupancy per module (Layer 6);N_{modules};N_{Ladders}",
fgkSSDMODULESPERLADDERLAYER6,
0,fgkSSDMODULESPERLADDERLAYER6,
}
fHistSSDAverageOccupancyLayer6->SetStats(kFALSE);
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDAverageOccupancyLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, !expert, image, !saveCorr);
+ offsRw+fSSDRawsOffset, !expert, image, !saveCorr);
fSSDRawsOffset += 1;
//Output of the DA
- TH2D *fHistSSDPSideBadChannelMapLayer5 = new TH2D("fHistSSDPSideBadChannelMapLayer5",
+ TH2F *fHistSSDPSideBadChannelMapLayer5 = new TH2F("fHistSSDPSideBadChannelMapLayer5",
"Layer 5;N_{module};N_{ladder}",
22,1,23,
34,500,534);
fHistSSDPSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
fHistSSDPSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDPSideBadChannelMapLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- TH2D *fHistSSDNSideBadChannelMapLayer5 = new TH2D("fHistSSDNSideBadChannelMapLayer5",
+ TH2F *fHistSSDNSideBadChannelMapLayer5 = new TH2F("fHistSSDNSideBadChannelMapLayer5",
"Layer 5;N_{module};N_{ladder}",
22,1,23,
34,500,534);
fHistSSDNSideBadChannelMapLayer5->GetZaxis()->SetTitleOffset(1.6);
fHistSSDNSideBadChannelMapLayer5->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDNSideBadChannelMapLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- TH2D *fHistSSDPSideBadChannelMapLayer6 = new TH2D("fHistSSDPSideBadChannelMapLayer6",
+ TH2F *fHistSSDPSideBadChannelMapLayer6 = new TH2F("fHistSSDPSideBadChannelMapLayer6",
"Layer 6;N_{module};N_{ladder}",
25,1,26,
38,600,638);
fHistSSDPSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
fHistSSDPSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (p-side)[%]");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDPSideBadChannelMapLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- TH2D *fHistSSDNSideBadChannelMapLayer6 = new TH2D("fHistSSDNSideBadChannelMapLayer6",
+ TH2F *fHistSSDNSideBadChannelMapLayer6 = new TH2F("fHistSSDNSideBadChannelMapLayer6",
"Layer 6;N_{module};N_{ladder}",
25,1,26,
38,600,638);
fHistSSDNSideBadChannelMapLayer6->GetZaxis()->SetTitleOffset(1.6);
fHistSSDNSideBadChannelMapLayer6->GetZaxis()->SetTitle("Bad channels (n-side)[%]");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDNSideBadChannelMapLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- //Common mode values
- TH2D *fHistSSDPSideCommonModeMapLayer5 = new TH2D("fHistSSDPSideCommonModeMapLayer5",
+ //Common mode values
+ TH2F *fHistSSDPSideCommonModeMapLayer5 = new TH2F("fHistSSDPSideCommonModeMapLayer5",
"Layer 5 - CM (P-side);N_{module};N_{ladder}",
22,1,23,
34,500,534);
fHistSSDPSideCommonModeMapLayer5->GetZaxis()->SetTitleOffset(1.6);
fHistSSDPSideCommonModeMapLayer5->GetZaxis()->SetTitle("RMS(CM) (P-side)");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDPSideCommonModeMapLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- TH2D *fHistSSDNSideCommonModeMapLayer5 = new TH2D("fHistSSDNSideCommonModeMapLayer5",
+ TH2F *fHistSSDNSideCommonModeMapLayer5 = new TH2F("fHistSSDNSideCommonModeMapLayer5",
"Layer 5 - CM (N-side);N_{module};N_{ladder}",
22,1,23,
34,500,534);
fHistSSDNSideCommonModeMapLayer5->GetZaxis()->SetTitleOffset(1.6);
fHistSSDNSideCommonModeMapLayer5->GetZaxis()->SetTitle("RMS(CM) (N-side)");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDNSideCommonModeMapLayer5,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- TH2D *fHistSSDPSideCommonModeMapLayer6 = new TH2D("fHistSSDPSideCommonModeMapLayer6",
+ TH2F *fHistSSDPSideCommonModeMapLayer6 = new TH2F("fHistSSDPSideCommonModeMapLayer6",
"Layer 6 - CM (P-side);N_{module};N_{ladder}",
25,1,26,
38,600,638);
fHistSSDPSideCommonModeMapLayer6->GetZaxis()->SetTitleOffset(1.6);
fHistSSDPSideCommonModeMapLayer6->GetZaxis()->SetTitle("RMS(CM) (P-side)");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDPSideCommonModeMapLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
- TH2D *fHistSSDNSideCommonModeMapLayer6 = new TH2D("fHistSSDNSideCommonModeMapLayer6",
+ TH2F *fHistSSDNSideCommonModeMapLayer6 = new TH2F("fHistSSDNSideCommonModeMapLayer6",
"Layer 6 - CM (N-side);N_{module};N_{ladder}",
25,1,26,
38,600,638);
fHistSSDNSideCommonModeMapLayer6->GetZaxis()->SetTitleOffset(1.6);
fHistSSDNSideCommonModeMapLayer6->GetZaxis()->SetTitle("RMS(CM) (N-side)");
rv = fAliITSQADataMakerRec->Add2RawsList(fHistSSDNSideCommonModeMapLayer6,
- fGenRawsOffset[specie]+fSSDRawsOffset, expert, !image, !saveCorr);
+ offsRw+fSSDRawsOffset, expert, !image, !saveCorr);
fSSDRawsOffset += 1; fSSDRawsDAOffset += 1;
}//online flag
fSSDhRawsTask = 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[specie]+fSSDhRawsTask));
- AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset[specie]+fSSDRawsOffset));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",offsRw+fSSDhRawsTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",offsRw+fSSDRawsOffset));
/*
- fSSDhTask = 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[specie]+fSSDhTask));
- AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",fGenRawsOffset[specie]+fSSDRawsOffset));
- */
+ fSSDhTask = fSSDRawsOffset;
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Raws histograms booked\n",fSSDhTask));
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Number of histograms (SPD+SDD+SSD): %d\n",offsRw+fSSDhTask));
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Number of histograms (SPD+SDD+SSD): %d\n",offsRw+fSSDRawsOffset));
+ */
//} //event species loop
}
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader) {
+Int_t AliITSQASSDDataMakerRec::MakeRaws(AliRawReader* rawReader)
+{
// Fill QA for RAW - SSD -
Int_t rv = 0 ;
-
Int_t gStripNumber;
Int_t gHistPosition;
Int_t gLayer = 0,gLadder = 0, gModule = 0;
Double_t sumSSDDataSize = 0.0;
Double_t eventSize = -1.0;
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
- //cout << "MakeRaws: Event specie " << specie << " is set" << endl;
-
- //AliInfo(Form("fGenRawsOffset[specie] %d\n",fGenRawsOffset[specie]));
+ // RS: I've commented this loop over species: makes no sense in the event loop
+ // for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ // if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
+ int specie = fAliITSQADataMakerRec->GetEventSpecie();
+ //cout << "MakeRaws: Event specie " << specie << " is set" << endl;
+ //
+ int offsRw = fGenRawsOffset[specie];
+ //
+ //AliInfo(Form("offsRw %d\n",offsRw));
+ if(fkOnline) {
+ //reset the signal vs strip number histograms
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
+ fHistSSDRawSignalModule[iModule]->Reset();
+ }//online flag
+
+ rawReader->Select("ITSSSD",-1,-1);
+ rawReader->Reset(); //rawReader->NextEvent();
+ //AliInfo(Form("offsRw %d\n",offsRw));
+ fAliITSQADataMakerRec->FillRawsData(offsRw,rawReader->GetType());
+
+ AliITSRawStreamSSD gSSDStream(rawReader);
+ AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;
+ if(rootReader) {
+ const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
+ if(header)
+ eventSize = header->GetEventSize();
+ }
+ while (gSSDStream.Next()) {
+ if(gSSDStream.GetModuleID() < 0) continue;
+ /*cout<<"DDL: "<<rawReader->GetDDLID()<<
+ " - LDC: "<<rawReader->GetLDCId()<<
+ " - Size: "<<rawReader->GetDataSize()<<
+ " - Equipment size: "<<rawReader->GetEquipmentSize()<<endl;*/
+ Int_t ddlid = rawReader->GetDDLID();
+ if(ddlid<0){
+ AliError("GetDDLID returns a negative value");
+ continue;
+ }
+ gSizePerDDL[ddlid] = rawReader->GetDataSize();
+ //gSizePerLDC[rawReader->GetLDCId()-8] = rawReader->GetDataSize();
+ AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
+ gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
if(fkOnline) {
- //reset the signal vs strip number histograms
- for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++)
- fHistSSDRawSignalModule[iModule]->Reset();
+ if(gSSDStream.GetStrip() < 0) {
+ //Printf("Layer: %d - Ladder: %d - Module: %d - Strip: %d - Signal: %lf",gLayer,gLadder,gModule,gSSDStream.GetStrip(),gSSDStream.GetSignal());
+ if(TMath::Abs(gSSDStream.GetStrip()) < 7)
+ fHistSSDCMModule[gHistPosition]->Fill(gSSDStream.GetSignal());
+ if(TMath::Abs(gSSDStream.GetStrip()) > 6)
+ fHistSSDCMModule[fgkSSDMODULES+gHistPosition]->Fill(gSSDStream.GetSignal());
+ }//CM values
+ else {
+ gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));
+ fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());
+ //fAliITSQADataMakerRec->FillRawsData(offsRw+gHistPosition+fSSDRawsCommonLevelOffset,gStripNumber,gSSDStream.GetSignal());
+ }//normal strip signal
}//online flag
-
- rawReader->Select("ITSSSD",-1,-1);
- rawReader->Reset(); //rawReader->NextEvent();
- //AliInfo(Form("fGenRawsOffset[specie] %d\n",fGenRawsOffset[specie]));
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->Fill(rawReader->GetType());
-
- if(rawReader->GetType() == 7) {
- fSSDEvent += 1;
- fSSDEventPerCycle += 1;
- }
-
- AliITSRawStreamSSD gSSDStream(rawReader);
- AliRawReaderRoot *rootReader = (AliRawReaderRoot *)rawReader;
- if(rootReader) {
- const AliRawEventHeaderBase *header = rootReader->GetEventHeader();
- if(header)
- eventSize = header->GetEventSize();
- }
- while (gSSDStream.Next()) {
- if(gSSDStream.GetModuleID() < 0) continue;
- /*cout<<"DDL: "<<rawReader->GetDDLID()<<
- " - LDC: "<<rawReader->GetLDCId()<<
- " - Size: "<<rawReader->GetDataSize()<<
- " - Equipment size: "<<rawReader->GetEquipmentSize()<<endl;*/
- Int_t ddlid = rawReader->GetDDLID();
- if(ddlid<0){
- AliError("GetDDLID returns a negative value");
- continue;
- }
- gSizePerDDL[ddlid] = rawReader->GetDataSize();
- //gSizePerLDC[rawReader->GetLDCId()-8] = rawReader->GetDataSize();
- AliITSgeomTGeo::GetModuleId(gSSDStream.GetModuleID(),gLayer,gLadder,gModule);
- gHistPosition = (gLayer == 5) ? ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER5 + gModule - 1) : ((gLadder - 1)*fgkSSDMODULESPERLADDERLAYER6 + gModule + fgkSSDMODULESLAYER5 - 1);
- if(fkOnline) {
- if(gSSDStream.GetStrip() < 0) {
- //Printf("Layer: %d - Ladder: %d - Module: %d - Strip: %d - Signal: %lf",gLayer,gLadder,gModule,gSSDStream.GetStrip(),gSSDStream.GetSignal());
- if(TMath::Abs(gSSDStream.GetStrip()) < 7)
- fHistSSDCMModule[gHistPosition]->Fill(gSSDStream.GetSignal());
- if(TMath::Abs(gSSDStream.GetStrip()) > 6)
- fHistSSDCMModule[fgkSSDMODULES+gHistPosition]->Fill(gSSDStream.GetSignal());
- }//CM values
- else {
- gStripNumber = (gSSDStream.GetSideFlag() == 0) ? gSSDStream.GetStrip() : -gSSDStream.GetStrip() + 2*fgkNumberOfPSideStrips;
- //AliDebug(AliQAv1::GetQADebugLevel(), Form("ModulePosition: %d - Layer: %d - Ladder: %d - Module: %d\n",gHistPosition,gLayer,gLadder,gModule));
- fHistSSDRawSignalModule[gHistPosition]->Fill(gStripNumber,gSSDStream.GetSignal());
- //fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+gHistPosition+fSSDRawsCommonLevelOffset)->Fill(gStripNumber,gSSDStream.GetSignal());
- }//normal strip signal
- }//online flag
- }//streamer loop
-
- //event size calculation and filling info
- for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
- sumSSDDataSize += gSizePerDDL[i];
- if(gSizePerDDL[i] > 0) {
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+3))->Fill(i+512);
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+5+i))->Fill(gSizePerDDL[i]/1e+03);
-
-
- //if(i == 5)
- //cout<<gSizePerDDL[i]/1e+03<<endl;
- //cout<<"Event: "<<fSSDEventPerCycle<<" - DDL: "<<i+512<<
- //" - Data size: "<<gSizePerDDL[i]/1e+03<<endl;
- }
- //(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+4))->Fill(i+512,gSizePerDDL[i]/1e+06);
+ }//streamer loop
+
+ //event size calculation and filling info
+ for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
+ sumSSDDataSize += gSizePerDDL[i];
+ if(gSizePerDDL[i] > 0) {
+ fAliITSQADataMakerRec->FillRawsData(offsRw+3,i+512);
+ fAliITSQADataMakerRec->FillRawsData(offsRw+5+i,gSizePerDDL[i]/1e+03);
+ //if(i == 5)
+ //cout<<gSizePerDDL[i]/1e+03<<endl;
+ //cout<<"Event: "<<nSSDEventPerCycle<<" - DDL: "<<i+512<<
+ //" - Data size: "<<gSizePerDDL[i]/1e+03<<endl;
}
- for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
- //LDC 170
- if(i == 0)
- gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9];
- //LDC 171
- if(i == 1)
- gSizePerLDC[i] = gSizePerDDL[10] + gSizePerDDL[11];
- //LDC 172
- if(i == 2)
- gSizePerLDC[i] = gSizePerDDL[12] + gSizePerDDL[13];
- //LDC 173
- if(i == 3)
- gSizePerLDC[i] = gSizePerDDL[14] + gSizePerDDL[15];
- //LDC 174
- if(i == 4)
- gSizePerLDC[i] = gSizePerDDL[0] + gSizePerDDL[1];
- //LDC 175
- if(i == 5)
- gSizePerLDC[i] = gSizePerDDL[2] + gSizePerDDL[3];
+ //(fAliITSQADataMakerRec->FillRawsData(offsRw+4),i+512,gSizePerDDL[i]/1e+06);
+ }
+ for(Int_t i = 0; i < fgkNumOfLDCs; i++) {
+ //LDC 170
+ if(i == 0)
+ gSizePerLDC[i] = gSizePerDDL[8] + gSizePerDDL[9];
+ //LDC 171
+ if(i == 1)
+ gSizePerLDC[i] = gSizePerDDL[10] + gSizePerDDL[11];
+ //LDC 172
+ if(i == 2)
+ gSizePerLDC[i] = gSizePerDDL[12] + gSizePerDDL[13];
+ //LDC 173
+ if(i == 3)
+ gSizePerLDC[i] = gSizePerDDL[14] + gSizePerDDL[15];
+ //LDC 174
+ if(i == 4)
+ gSizePerLDC[i] = gSizePerDDL[0] + gSizePerDDL[1];
+ //LDC 175
+ if(i == 5)
+ gSizePerLDC[i] = gSizePerDDL[2] + gSizePerDDL[3];
//LDC 176
- if(i == 6)
- gSizePerLDC[i] = gSizePerDDL[4] + gSizePerDDL[5];
- //LDC 177
- if(i == 7)
- gSizePerLDC[i] = gSizePerDDL[6] + gSizePerDDL[7];
-
- if(gSizePerLDC[i] > 0)
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+21))->Fill(i+170);
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+23+i))->Fill(gSizePerLDC[i]/1e+03);
- //cout<<"Event: "<<fSSDEventPerCycle<<" - LDC: "<<i+170<<
- //" - Data size: "<<gSizePerLDC[i]<<endl;
-
- //(fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+22))->Fill(i+6,gSizePerLDC[i]/1e+06);
- }
-
- // for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
- // Double_t gSizePerDDL = ((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+5+i))->GetMean();
- //if(i == 5)
- //cout<<"DDL: "<<i+512<<" - Size: "<<gSizePerDDL<<
- //" - Mean: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+5+i))->GetMean()<<endl;
- // }
-
- if(sumSSDDataSize)
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+1))->Fill(sumSSDDataSize/1e+03);
- if(eventSize)
- (fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+2))->Fill(100.*sumSSDDataSize/eventSize);
+ if(i == 6)
+ gSizePerLDC[i] = gSizePerDDL[4] + gSizePerDDL[5];
+ //LDC 177
+ if(i == 7)
+ gSizePerLDC[i] = gSizePerDDL[6] + gSizePerDDL[7];
- //Occupancy calculation
- if(fkOnline) {
- for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
- GetOccupancyStrip(fHistSSDRawSignalModule[iModule],fOccupancyMatrix[iModule]);
- //if(iModule == 156) {
- //cout<<"========================================"<<endl;
- //AliITSgeomTGeo::GetModuleId(656,gLayer,gLadder,gModule);
- /*for(Int_t iBin = 1; iBin < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBin++) {
- if((iBin >= 750)&&(iBin <= 780))
- cout<<"Event: "<<fSSDEventPerCycle<<" - Ladder: "<<gLadder+499<<
- " - Module: "<<gModule<<" - Strip: "<<iBin<<
- " - Signal: "<<fHistSSDRawSignalModule[iModule]->GetBinContent(iBin)<<endl;
- }*///strip loop --> to be removed
- //}//module cut --> to be removed
- }//module loop
- }//online flag for SSD
-
- //cout<<"Event type entries: "<<((TH1*)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]))->GetEntries()<<endl;
- //cout<<"DDL id entries at MR: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+3))->GetEntries()<< endl;
- //cout<<"LDC id entries at MR: "<<((TH1D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+21))->GetEntries()<< endl;
+ if(gSizePerLDC[i] > 0) fAliITSQADataMakerRec->FillRawsData(offsRw+21,i+170);
+ fAliITSQADataMakerRec->FillRawsData(offsRw+23+i,gSizePerLDC[i]/1e+03);
+ //cout<<"Event: "<<nSSDEventPerCycle<<" - LDC: "<<i+170<<
+ //" - Data size: "<<gSizePerLDC[i]<<endl;
- } //event species loop
+ //(fAliITSQADataMakerRec->FillRawsData(offsRw+22),i+6,gSizePerLDC[i]/1e+06);
+ }
+ // RS Invalid
+ // for(Int_t i = 0; i < fgkNumOfDDLs; i++) {
+ // Double_t gSizePerDDL = ((TH1F *)fAliITSQADataMakerRec->GetRawsData(offsRw+5+i))->GetMean();
+ //if(i == 5)
+ //cout<<"DDL: "<<i+512<<" - Size: "<<gSizePerDDL<<
+ //" - Mean: "<<((TH1F *)fAliITSQADataMakerRec->GetRawsData(offsRw+5+i))->GetMean()<<endl;
+ // }
+
+ if(sumSSDDataSize) fAliITSQADataMakerRec->FillRawsData(offsRw+1,sumSSDDataSize/1e+03);
+ if(eventSize) fAliITSQADataMakerRec->FillRawsData(offsRw+2,100.*sumSSDDataSize/eventSize);
+
+ //Occupancy calculation
+ if(fkOnline) {
+ for(Int_t iModule = 0; iModule < fgkSSDMODULES; iModule++) {
+ GetOccupancyStrip(fHistSSDRawSignalModule[iModule],fOccupancyMatrix[iModule]);
+ //if(iModule == 156) {
+ //cout<<"========================================"<<endl;
+ //AliITSgeomTGeo::GetModuleId(656,gLayer,gLadder,gModule);
+ /*for(Int_t iBin = 1; iBin < fHistSSDRawSignalModule[iModule]->GetXaxis()->GetNbins(); iBin++) {
+ if((iBin >= 750)&&(iBin <= 780))
+ cout<<"Event: "<<nSSDEventPerCycle<<" - Ladder: "<<gLadder+499<<
+ " - Module: "<<gModule<<" - Strip: "<<iBin<<
+ " - Signal: "<<fHistSSDRawSignalModule[iModule]->GetBinContent(iBin)<<endl;
+ }*///strip loop --> to be removed
+ //}//module cut --> to be removed
+ }//module loop
+ }//online flag for SSD
+
+ // RS Invalid
+ //cout<<"Event type entries: "<<((TH1*)fAliITSQADataMakerRec->GetRawsData(offsRw))->GetEntries()<<endl;
+ //cout<<"DDL id entries at MR: "<<((TH1F *)fAliITSQADataMakerRec->GetRawsData(offsRw+3))->GetEntries()<< endl;
+ //cout<<"LDC id entries at MR: "<<((TH1F *)fAliITSQADataMakerRec->GetRawsData(offsRw+21))->GetEntries()<< endl;
+
+ // } //event species loop // commented by RS
+ //
return rv ;
}
else if(mode == 2)
lOccupancy = 100.*sumOccupancy/fgkNumberOfPSideStrips;
- /* if(histname.Contains("Layer5_Ladder507_Module3"))
- cout<<"Fired strips: "<<lNumFiredBins<<
- " - Occupancy: "<<lOccupancy<<endl;*/
-;
+ /* if(histname.Contains("Layer5_Ladder507_Module3"))
+ cout<<"Fired strips: "<<lNumFiredBins<<
+ " - Occupancy: "<<lOccupancy<<endl;*/
+ ;
//AliDebug(AliQAv1::GetQADebugLevel(), Form("Fired strips: %d - Total strips: %d - Occupancy :%lf\n",lNumFiredBins,lHisto->GetNbinsX(),lOccupancy));
return lOccupancy;
}
//____________________________________________________________________________
- void AliITSQASSDDataMakerRec::MonitorCMValues() {
+void AliITSQASSDDataMakerRec::MonitorCMValues(Int_t trCl)
+{
//Monitor in AMORE the CM values
- //for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- //if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
- //cout << "MonitorCMValues: Event specie " << specie << " is set" << endl;
- Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
- fAliITSQADataMakerRec->SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ //if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
+ //cout << "MonitorCMValues: Event specie " << specie << " is set" << endl;
+ Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
+ int offsRw = fGenRawsOffset[specie];
- //compute the rms of the CM values
- Int_t gLayer = 0, gLadder = 0, gModule = 0;
- Double_t rmsPsideCM = 0.0, rmsNsideCM = 0.0;
- for(Int_t i = 0; i < fgkSSDMODULES; i++) {
- rmsPsideCM = 0.0; rmsNsideCM = 0.0;
- AliITSgeomTGeo::GetModuleId(i+500,gLayer,gLadder,gModule);
- //Printf("%s - %s",((TH1*)list->At(i))->GetName(),
- //((TH1*)list->At(1698+i))->GetName());
- rmsPsideCM = fHistSSDCMModule[i]->GetRMS();
- rmsNsideCM = fHistSSDCMModule[fgkSSDMODULES+i]->GetRMS();
- //Printf("rmsPside: %lf - rmsNside: %lf",rmsPsideCM,rmsNsideCM);
- if(gLayer == 5) {
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+4))->SetBinContent(gModule,gLadder,rmsPsideCM);
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+5))->SetBinContent(gModule,gLadder,rmsNsideCM);
- }
- if(gLayer == 6) {
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+6))->SetBinContent(gModule,gLadder,rmsPsideCM);
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+7))->SetBinContent(gModule,gLadder,rmsNsideCM);
- }
- }//module loop
+ //compute the rms of the CM values
+ Int_t gLayer = 0, gLadder = 0, gModule = 0;
+ Double_t rmsPsideCM = 0.0, rmsNsideCM = 0.0;
+ for(Int_t i = 0; i < fgkSSDMODULES; i++) {
+ rmsPsideCM = 0.0; rmsNsideCM = 0.0;
+ AliITSgeomTGeo::GetModuleId(i+500,gLayer,gLadder,gModule);
+ //Printf("%s - %s",((TH1*)list->At(i))->GetName(),
+ //((TH1*)list->At(1698+i))->GetName());
+ rmsPsideCM = fHistSSDCMModule[i]->GetRMS();
+ rmsNsideCM = fHistSSDCMModule[fgkSSDMODULES+i]->GetRMS();
+ //Printf("rmsPside: %lf - rmsNside: %lf",rmsPsideCM,rmsNsideCM);
+ if(gLayer == 5) {
+ TH2* h4 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+4,trCl);
+ if (h4) h4->SetBinContent(gModule,gLadder,rmsPsideCM);
+ TH2* h5 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+5,trCl);
+ if (h5) h5->SetBinContent(gModule,gLadder,rmsNsideCM);
+ }
+ if(gLayer == 6) {
+ TH2* h6 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+6,trCl);
+ if (h6) h6->SetBinContent(gModule,gLadder,rmsPsideCM);
+ TH2* h7 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+7,trCl);
+ if (h7) h7->SetBinContent(gModule,gLadder,rmsNsideCM);
+ }
+ }//module loopcdcd
//}//event species loop
- }
+}
//____________________________________________________________________________
-void AliITSQASSDDataMakerRec::MonitorOCDBObjects() {
+void AliITSQASSDDataMakerRec::MonitorOCDBObjects(Int_t trCl)
+{
//Monitor in AMORE the output of the DA
//Currently only the bad channel list is monitored
//Todo: Noise - Pedestal
//if (!AliQAv1::Instance()->IsEventSpecieSet(specie)) continue;
//cout << "MonitorOCDBObjects: Event specie " << specie << " is set" << endl;
Int_t specie = fAliITSQADataMakerRec->GetEventSpecie();
+ int offsRw = fGenRawsOffset[specie];
fAliITSQADataMakerRec->SetEventSpecie(AliRecoParam::ConvertIndex(specie));
- //((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset))->Reset();
- //((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+1))->Reset();
- //((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+2))->Reset();
- //((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+3))->Reset();
+ //((TH2F *)fAliITSQADataMakerRec->ResetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset));
+ //((TH2F *)fAliITSQADataMakerRec->ResetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+1));
+ //((TH2F *)fAliITSQADataMakerRec->ResetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+2));
+ //((TH2F *)fAliITSQADataMakerRec->ResetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+3));
AliCDBEntry *entryBadChannelsSSD = fCDBManager->Get("ITS/Calib/BadChannelsSSD");
if(!entryBadChannelsSSD)AliError("OCDB entry for the bad channel list is not valid!");
/*if((module == 10)&&(ladder == 10)) {
cout<<"Npside bad: "<<nPSideChannelsLayer5<<" - Total: "<<fgkNumberOfPSideStrips<<" - Percentage: "<<(100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips)<<endl;
}*/
- if(nPSideChannelsLayer5 > 0)
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset))->SetBinContent(module,ladder,100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips);
- else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset))->SetBinContent(module,ladder,0.0001);
- if(nNSideChannelsLayer5 > 0)
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+1))->SetBinContent(module,ladder,100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips);
- else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+1))->SetBinContent(module,ladder,0.0001);
+ TH2* h0 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset,trCl);
+ if (h0) {
+ if(nPSideChannelsLayer5 > 0) h0->SetBinContent(module,ladder,100.*nPSideChannelsLayer5/fgkNumberOfPSideStrips);
+ else h0->SetBinContent(module,ladder,0.0001);
+ }
+ TH2* h1 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+1,trCl);
+ if (h1) {
+ if(nNSideChannelsLayer5 > 0) h1->SetBinContent(module,ladder,100.*nNSideChannelsLayer5/fgkNumberOfPSideStrips);
+ else h1->SetBinContent(module,ladder,0.0001);
+ }
}//layer 5
if(layer == 6) {
- if(nPSideChannelsLayer6 > 0)
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+2))->SetBinContent(module,ladder,100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips);
- else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+2))->SetBinContent(module,ladder,0.0001);
- if(nNSideChannelsLayer6 > 0)
- ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+3))->SetBinContent(module,ladder,100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips);
- else ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+3))->SetBinContent(module,ladder,0.0001);
+ TH2* h2 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+2,trCl);
+ if (h2) {
+ if(nPSideChannelsLayer6 > 0) h2->SetBinContent(module,ladder,100.*nPSideChannelsLayer6/fgkNumberOfPSideStrips);
+ else h2->SetBinContent(module,ladder,0.0001);
+ }
+ TH2* h3 = (TH2*)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+3,trCl);
+ if (h3) {
+ if(nNSideChannelsLayer6 > 0) h3->SetBinContent(module,ladder,100.*nNSideChannelsLayer6/fgkNumberOfPSideStrips);
+ else h3->SetBinContent(module,ladder,0.0001);
+ }
}//layer 6
}//module loop
-
- //cout << "entries bad channel layer 5 n side " << ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset+1))->GetEntries() << " - Bad channels P side layer 5 module 10 ladder 10: " << ((TH2D *)fAliITSQADataMakerRec->GetRawsData(fGenRawsOffset[specie]+fSSDRawsOffset-fSSDRawsDAOffset))->GetBinContent(10,10)<<endl;
+
+ //cout << "entries bad channel layer 5 n side " << ((TH2F *)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset+1))->GetEntries() << " - Bad channels P side layer 5 module 10 ladder 10: " << ((TH2F *)fAliITSQADataMakerRec->GetRawsData(offsRw+fSSDRawsOffset-fSSDRawsDAOffset))->GetBinContent(10,10)<<endl;
//} //event species loop
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
Int_t rv = 0 ;
-// fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
+ // fGenDigitsOffset = (fAliITSQADataMakerRec->fDigitsQAList[AliRecoParam::kDefault])->GetEntries();
// custom code here
TH1F *fHistSSDModule = new TH1F("fHistSSDDigitsModule",
";SSD Module Number;N_{DIGITS}",
1698,499.5,2197.5);
- rv = fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModule,
- fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0, !expert, image);
+ rv = fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModule,
+ fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0, !expert, image);
fSSDhDigitsTask += 1;
TH2F *fHistSSDModuleStrip = new TH2F("fHistSSDDigitsModuleStrip",
";N_{Strip};N_{Module}",
1540,0,1540,1698,499.5,2197.5);
rv = fAliITSQADataMakerRec->Add2DigitsList(fHistSSDModuleStrip,
- fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1, !expert, image);
+ fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1, !expert, image);
fSSDhDigitsTask += 1;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Digits histograms booked\n",fSSDhDigitsTask));
}
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerRec::MakeDigits(TTree *digits) {
+Int_t AliITSQASSDDataMakerRec::MakeDigits(TTree *digits)
+{
// Fill QA for DIGIT - SSD -
-// AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
-// fITS->SetTreeAddress();
-// TClonesArray *iSSDdigits = fITS->DigitsAddress(2);
+ // AliITS *fITS = (AliITS*)gAlice->GetModule("ITS");
+ // fITS->SetTreeAddress();
+ // TClonesArray *iSSDdigits = fITS->DigitsAddress(2);
+ //
Int_t rv = 0 ;
TBranch *branchD = digits->GetBranch("ITSDigitsSSD");
if (!branchD) {
digits->GetEvent(iModule);
Int_t ndigits = iSSDdigits->GetEntries();
//printf("Module = %i \t ndigits = %i\t offset = %i \n",iModule,ndigits,fAliITSQADataMakerRec->GetEventSpecie() );
- fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0)->Fill(iModule,ndigits);
+ fAliITSQADataMakerRec->FillDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0,iModule,ndigits);
if(ndigits != 0)
AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
AliITSdigit *dig = (AliITSdigit*)iSSDdigits->UncheckedAt(iDigit);
Int_t fStripNumber = (dig->GetCoord1() == 0) ? dig->GetCoord2() : dig->GetCoord2() + fgkNumberOfPSideStrips;
- ((TH2F *)fAliITSQADataMakerRec->GetDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
+ fAliITSQADataMakerRec->FillDigitsData(fGenDigitsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1,fStripNumber,iModule,dig->GetSignal());
}//digit loop
}//module loop
+ //
return rv ;
}
Int_t rv = 0 ;
//AliInfo(Form("fAliITSQADataMakerRec->GetEventSpecie() %d\n",fAliITSQADataMakerRec->GetEventSpecie()));
//AliInfo(Form("fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] %d\n",fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()]));
-// fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
+ // fGenRecPointsOffset = (fAliITSQADataMakerRec->fRecPointsQAList[AliRecoParam::kDefault])->GetEntries();
//AliDebug(AliQAv1::GetQADebugLevel(), Form("**-------*-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints offset %d \t %d \n",fGenOffset,fGenRecPointsOffset));
Int_t nModuleOffset = 500;
Int_t nITSTotalModules = AliITSgeomTGeo::GetNModules();
nModuleOffset - 0.5,
nITSTotalModules-fgkSSDMODULESLAYER6+0.5);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDModuleIdLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDModuleIdLayer6 = new TH1F("fHistSSDModuleIdLayer6",
"Module Id - Layer 6;Module Id;Entries",
nModuleOffset+fgkSSDMODULESLAYER5 - 0.5,
nITSTotalModules + 0.5);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDModuleIdLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDClusterPerEventLayer5 = new TH1F("fHistSSDClusterPerEventLayer5",
"N_{clusters} - Layer 5;N_{clusters};Entries;",
100,0.1,5000);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterPerEventLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 2, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 2, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDClusterPerEventLayer6 = new TH1F("fHistSSDClusterPerEventLayer6",
"N_{clusters} - Layer 6;N_{clusters};Entries;",
100,0.1,5000);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterPerEventLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 3, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 3, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDLocalXLayer5 = new TH1F("fHistSSDLocalXLayer5",
"Local x coord.- Layer 5;x [cm];Entries;",
100,-4.,4.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalXLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 4, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 4, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDLocalXLayer6 = new TH1F("fHistSSDLocalXLayer6",
"Local x coord.- Layer 6;x [cm];Entries;",
100,-4.,4.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalXLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 5, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 5, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDLocalZLayer5 = new TH1F("fHistSSDLocalZLayer5",
"Local z coord.- Layer 5;z [cm];Entries;",
100,-4.,4.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalZLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 6, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 6, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDLocalZLayer6 = new TH1F("fHistSSDLocalZLayer6",
"Local z coord.- Layer 6;z [cm];Entries;",
100,-4.,4.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDLocalZLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 7, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 7, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDGlobalXLayer5 = new TH1F("fHistSSDGlobalXLayer5",
"Global x - Layer 5;x [cm];Entries;",
100,-40.,40.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalXLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 8, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 8, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDGlobalXLayer6 = new TH1F("fHistSSDGlobalXLayer6",
"Global x - Layer 6;x [cm];Entries;",
100,-45.,45.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalXLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 9, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 9, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDGlobalYLayer5 = new TH1F("fHistSSDGlobalYLayer5",
"Global y - Layer 5;y [cm];Entries;",
100,-40.,40);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalYLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 10, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 10, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDGlobalYLayer6 = new TH1F("fHistSSDGlobalYLayer6",
"Global y - Layer 6;y [cm];Entries;",
100,-45.,45.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalYLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 11, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 11, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDGlobalZLayer5 = new TH1F("fHistSSDGlobalZLayer5",
"Global z - Layer 5;z [cm];Entries;",
100,-45.,45);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalZLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 12, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 12, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDGlobalZLayer6 = new TH1F("fHistSSDGlobalZLayer6",
"Global z - Layer 6;z [cm];Entries;",
100,-55.,55.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDGlobalZLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 13, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 13, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDPhiLayer5 = new TH1F("fHistSSDPhiLayer5",
"#phi - Layer 5;#phi [rad];Entries;",
100,-TMath::Pi(),TMath::Pi());
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDPhiLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 14, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 14, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDPhiLayer6 = new TH1F("fHistSSDPhiLayer6",
"#phi - Layer 6;#phi [rad];Entries;",
100,-TMath::Pi(),TMath::Pi());
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDPhiLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 15, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 15, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDThetaLayer5 = new TH1F("fHistSSDThetaLayer5",
"#theta - Layer 5;#theta [rad];Entries;",
100,-TMath::Pi(),TMath::Pi());
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDThetaLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 16, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 16, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDThetaLayer6 = new TH1F("fHistSSDThetaLayer6",
"#theta - Layer 6;#theta [rad];Entries;",
100,-TMath::Pi(),TMath::Pi());
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDThetaLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 17, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 17, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDRadiusLayer5 = new TH1F("fHistSSDRadiusLayer5",
"r - Layer 5;r [cm];Entries;",
100,35.,50.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDRadiusLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 18, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 18, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDRadiusLayer6 = new TH1F("fHistSSDRadiusLayer6",
"r - Layer 6;r [cm];Entries;",
100,35.,50.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDRadiusLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 19, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 19, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDClusterTypeLayer5 = new TH1F("fHistSSDClusterTypeLayer5",
"CL type - Layer 5;Cluster type;Entries;",
150,0,150);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterTypeLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 20, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 20, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDClusterTypeLayer6 = new TH1F("fHistSSDClusterTypeLayer6",
"CL type - Layer 6;Cluster type;Entries;",
150,0,150);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterTypeLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 21, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 21, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargeRatioLayer5 = new TH1F("fHistSSDChargeRatioLayer5",
"Charge ratio - Layer 5;q_{ratio};Entries;",
100,-2.0,2.0);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatioLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 22, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 22, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargeRatioLayer6 = new TH1F("fHistSSDChargeRatioLayer6",
"Charge ratio - Layer 6;q_{ratio};Entries;",
100,-2.0,2.0);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatioLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 23, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 23, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargekeVLayer5 = new TH1F("fHistSSDChargekeVLayer5",
"Charge - Layer 5;q [keV];Entries;",
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargekeVLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 24, !expert, image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 24, !expert, image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargekeVLayer6 = new TH1F("fHistSSDChargekeVLayer6",
"Charge - Layer 6;q [keV];Entries;",
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargekeVLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 25, !expert, image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 25, !expert, image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargePSideLayer5 = new TH1F("fHistSSDChargePSideLayer5",
"Charge P- Layer 5;q_{P} [keV];Entries;",
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePSideLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 26, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 26, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargePSideLayer6 = new TH1F("fHistSSDChargePSideLayer6",
"Charge P- Layer 6;q_{P} [keV];Entries;",
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePSideLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 27, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 27, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargeNSideLayer5 = new TH1F("fHistSSDChargeNSideLayer5",
"Charge N- Layer 5;q_{N} [keV];Entries;",
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeNSideLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 28, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 28, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargeNSideLayer6 = new TH1F("fHistSSDChargeNSideLayer6",
"Charge N- Layer 6;q_{N} [keV];Entries;",
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeNSideLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 29, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 29, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargeRatio2Layer5 = new TH1F("fHistSSDChargeRatio2Layer5",
"Charge Ratio qN/qP - Layer 5;q_{N}/q_{P};Entries;",
100,0,2);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatio2Layer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 30, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 30, expert, !image);
fSSDhRecPointsTask += 1;
TH1F *fHistSSDChargeRatio2Layer6 = new TH1F("fHistSSDChargeRatio2Layer6",
"Charge Ratio qN/qP - Layer 6;q_{N}/q_{P};Entries;",
100,0,2);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeRatio2Layer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 31, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 31, expert, !image);
fSSDhRecPointsTask += 1;
TH2F *fHistSSDChargePNSideLayer5 = new TH2F("fHistSSDChargePNSideLayer5",
"Charge correlation - Layer 5;q_{P} [keV];q_{N} [keV]",
100,0.,300.,
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePNSideLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 32, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 32, expert, !image);
fSSDhRecPointsTask += 1;
TH2F *fHistSSDChargePNSideLayer6 = new TH2F("fHistSSDChargePNSideLayer6",
"Charge correlation - Layer 6;q_{P} [keV];q_{N} [keV]",
100,0.,300.,
100,0.,300.);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargePNSideLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 33, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 33, expert, !image);
fSSDhRecPointsTask += 1;
TH2F *fHistSSDChargeMapLayer5 = new TH2F("fHistSSDChargeMapLayer5",
"Charge map;N_{modules};N_{Ladders}",
3*fgkSSDLADDERSLAYER5,
-0.5,fgkSSDLADDERSLAYER5+0.5);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeMapLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 34, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 34, expert, !image);
fSSDhRecPointsTask += 1;
TH2F *fHistSSDChargeMapLayer6 = new TH2F("fHistSSDChargeMapLayer6",
"Charge map;N_{modules};N_{Ladders}",
3*fgkSSDLADDERSLAYER6,
-0.5,fgkSSDLADDERSLAYER6+0.5);
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDChargeMapLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 35, expert, !image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 35, expert, !image);
fSSDhRecPointsTask += 1;
TH2F *fHistSSDClusterMapLayer5 = new TH2F("fHistSSDClusterMapLayer5",
"Layer 5;N_{module};N_{ladder}",
fHistSSDClusterMapLayer5->GetZaxis()->SetTitleOffset(1.4);
fHistSSDClusterMapLayer5->GetZaxis()->SetTitle("N_{clusters}");
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterMapLayer5,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 36, !expert, image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 36, !expert, image);
fSSDhRecPointsTask += 1;
TH2F *fHistSSDClusterMapLayer6 = new TH2F("fHistSSDClusterMapLayer6",
"Layer 6;N_{module};N_{ladder}",
fHistSSDClusterMapLayer6->GetZaxis()->SetTitleOffset(1.4);
fHistSSDClusterMapLayer6->GetZaxis()->SetTitle("N_{clusters}");
rv = fAliITSQADataMakerRec->Add2RecPointsList(fHistSSDClusterMapLayer6,
- fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 37, !expert, image);
+ fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 37, !expert, image);
fSSDhRecPointsTask += 1;
//printf ("%d SSD Recs histograms booked\n",fSSDhRecPointsTask);
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD Recs histograms booked\n",fSSDhRecPointsTask));
{
// Fill QA for recpoints - SSD -
//printf("*-*-*-*-*-*-*---*-*-*-------*-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints called \n");
+ //
Int_t rv = 0 ;
Int_t gLayer = 0, gLadder = 0, gModule = 0;
Int_t lLadderLocationY = 0;
Double_t chargeNSide = clusterCharge*(1. - chargeRatio);
if(layer == 4) {
//printf("-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints Filling 4 called \n");
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 20)->Fill(recp->GetType());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 20,recp->GetType());
if(recp->GetType() != 1) continue;
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0)->Fill(module);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 4)->Fill(recp->GetDetLocalX());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 6)->Fill(recp->GetDetLocalZ());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 8)->Fill(cluglo[0]);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 10)->Fill(cluglo[1]);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 12)->Fill(cluglo[2]);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 14)->Fill(phi);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 16)->Fill(theta);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 18)->Fill(radius);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 22)->Fill(recp->GetChargeRatio());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 24)->Fill(recp->GetQ());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 26)->Fill(chargePSide);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 28)->Fill(chargeNSide);
- if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 30)->Fill(chargeNSide/chargePSide);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 32)->Fill(chargePSide,chargeNSide);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 34)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());
- ((TH2F *)fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 36))->Fill(gModule,499+gLadder,1);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 0,module);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 4,recp->GetDetLocalX());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 6,recp->GetDetLocalZ());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 8,cluglo[0]);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 10,cluglo[1]);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 12,cluglo[2]);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 14,phi);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 16,theta);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 18,radius);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 22,recp->GetChargeRatio());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 24,recp->GetQ());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 26,chargePSide);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 28,chargeNSide);
+ if(chargePSide != 0.) fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 30,chargeNSide/chargePSide);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 32,chargePSide,chargeNSide);
+ fAliITSQADataMakerRec->SetRecPointsDataBinContent(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 34,gModule,lLadderLocationY,recp->GetQ());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 36,gModule,499+gLadder,1);
nClustersLayer5 += 1;
}//layer 5 histograms
if(layer == 5) {
//printf("-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints Filling 5 called \n");
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 21)->Fill(recp->GetType());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 21,recp->GetType());
if(recp->GetType() != 1) continue;
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1)->Fill(module);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 5)->Fill(recp->GetDetLocalX());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 7)->Fill(recp->GetDetLocalZ());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 9)->Fill(cluglo[0]);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 11)->Fill(cluglo[1]);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 13)->Fill(cluglo[2]);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 15)->Fill(phi);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 17)->Fill(theta);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 19)->Fill(radius);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 23)->Fill(recp->GetChargeRatio());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 25)->Fill(recp->GetQ());
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 27)->Fill(chargePSide);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 29)->Fill(chargeNSide);
- if(chargePSide != 0.) fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 31)->Fill(chargeNSide/chargePSide);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 33)->Fill(chargePSide,chargeNSide);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 35)->SetBinContent(gModule,lLadderLocationY,recp->GetQ());
- ((TH2F *)fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 37))->Fill(gModule,599+gLadder,1);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 1,module);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 5,recp->GetDetLocalX());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 7,recp->GetDetLocalZ());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 9,cluglo[0]);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 11,cluglo[1]);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 13,cluglo[2]);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 15,phi);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 17,theta);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 19,radius);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 23,recp->GetChargeRatio());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 25,recp->GetQ());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 27,chargePSide);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 29,chargeNSide);
+ if(chargePSide != 0.) fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 31,chargeNSide/chargePSide);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 33,chargePSide,chargeNSide);
+ fAliITSQADataMakerRec->SetRecPointsDataBinContent(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 35,gModule,lLadderLocationY,recp->GetQ());
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 37,gModule,599+gLadder,1);
nClustersLayer6 += 1;
}//layer 6 histograms
}//rec. points loop
}//module loop
//printf("-*-*-*-*-*-***************AliITSQASSDataMakerRec::MakeRecpoints Filling called \n");
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 2)->Fill(nClustersLayer5);
- fAliITSQADataMakerRec->GetRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 3)->Fill(nClustersLayer6);
-
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 2,nClustersLayer5);
+ fAliITSQADataMakerRec->FillRecPointsData(fGenRecPointsOffset[fAliITSQADataMakerRec->GetEventSpecie()] + 3,nClustersLayer6);
+ //
return rv ;
}
//____________________________________________________________________________
void AliITSQASSDDataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
{
- if(task==AliQAv1::kRAWS)ResetRawsMonitoredObjects();
-
+ if(task==AliQAv1::kRAWS) {
+ ResetRawsMonitoredObjects();
+ }
}
#include "AliQADataMakerRec.h"
class TObjArray;
-class TH1D;
+class TH1F;
class AliRawReader;
class AliITSQADataMakerRec;
virtual Int_t MakeDigits(TTree *digitsTree);
virtual Int_t MakeRecPoints(TTree *clustersTree);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * /*list*/);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** /*list*/);
virtual ~AliITSQASSDDataMakerRec(); // dtor
Int_t GetOffset(AliQAv1::TASKINDEX_t task,Int_t specie=0);
Int_t stripside,
Int_t mode,
Double_t threshold);
- void MonitorOCDBObjects();
- void MonitorCMValues();
+ void MonitorOCDBObjects(Int_t trCl=-1);
+ void MonitorCMValues(Int_t trCl=-1);
static const Int_t fgkNumOfLDCs = 8; //number of SSD LDCs
static const Int_t fgkNumOfDDLs = 16; //number of SSD DDLs
static const Int_t fgkNumberOfPSideStrips = 768; //number of P-side strips
AliITSQADataMakerRec *fAliITSQADataMakerRec; //pointer to the main ctor
- Int_t fSSDEvent; //event counter
- Int_t fSSDEventPerCycle; //event counter per cycle
Bool_t fkOnline; //online (1) or offline (0) use
Int_t fLDC; //LDC number (0 for offline, 1 to 4 for online)
Int_t fSSDRawsOffset; //SSD raw data plot offset
Int_t *fGenRawsOffset; //qachecking raws offset
Int_t *fGenDigitsOffset; //qachecking recpoints offset
Int_t *fGenRecPointsOffset; //qachecking recpoints offset
- TH1D *fHistSSDRawSignalModule[fgkSSDMODULES]; //raw signal vs strip number - SSD
- TH1D *fHistSSDCMModule[2*fgkSSDMODULES]; //SSD common mode noise
+ TH1F *fHistSSDRawSignalModule[fgkSSDMODULES]; //raw signal vs strip number - SSD
+ TH1F *fHistSSDCMModule[2*fgkSSDMODULES]; //SSD common mode noise
Int_t fOccupancyMatrix[fgkSSDMODULES][2*fgkNumberOfPSideStrips]; //occupancy values per strip
AliCDBManager *fCDBManager; //CDB manager
}
//____________________________________________________________________________
-void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray* /*list*/) {
+void AliITSQASSDDataMakerSim::EndOfDetectorCycle(AliQAv1::TASKINDEX_t /*task*/, TObjArray** /*list*/) {
// launch the QA checking
AliDebug(AliQAv1::GetQADebugLevel(),"AliITSDM instantiates checker with Run(AliQAv1::kITS, task, list)\n");
}
//____________________________________________________________________________
-Int_t AliITSQASSDDataMakerSim::MakeDigits(TTree *digits) {
+Int_t AliITSQASSDDataMakerSim::MakeDigits(TTree *digits)
+{
// Fill QA for DIGIT - SSD -
Int_t rv = 0 ;
iSSDdigits->Clear();
digits->GetEvent(iModule);
Int_t ndigits = iSSDdigits->GetEntries();
- fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 0)->Fill(iModule,ndigits);
+ fAliITSQADataMakerSim->FillDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 0,iModule,ndigits);
if(ndigits != 0)
AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
for (Int_t iDigit = 0; iDigit < ndigits; iDigit++) {
AliITSdigit *dig = (AliITSdigit*)iSSDdigits->UncheckedAt(iDigit);
Int_t fStripNumber = (dig->GetCoord1() == 0) ? dig->GetCoord2() : dig->GetCoord2() + fgkNumberOfPSideStrips;
- ((TH2F *)fAliITSQADataMakerSim->GetDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 1))->Fill(fStripNumber,iModule,dig->GetSignal());
+ fAliITSQADataMakerSim->FillDigitsData(fGenOffsetD[fAliITSQADataMakerSim->GetEventSpecie()] + 1,fStripNumber,iModule,dig->GetSignal());
}//digit loop
}//module loop
+ //
return rv ;
}
fSSDhSTask += 1;
AliDebug(AliQAv1::GetQADebugLevel(),Form("%d SSD SDigits histograms booked\n",fSSDhSTask));
+ //
return rv ;
}
iSSDsdigits->Clear();
sdigits->GetEvent(iModule);
Int_t ndigits = iSSDsdigits->GetEntries();
- fAliITSQADataMakerSim->GetSDigitsData(fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()] + 0)->Fill(iModule,ndigits);
+ fAliITSQADataMakerSim->FillSDigitsData(fGenOffsetS[fAliITSQADataMakerSim->GetEventSpecie()] + 0,iModule,ndigits);
if(ndigits != 0)
AliDebug(AliQAv1::GetQADebugLevel(),Form("Module: %d - Digits: %d",iModule,ndigits));
// dig=0;
// }//digit loop
}//module loop
+ //
return rv ;
}
for (Int_t iHit = 0; iHit < nhits; iHit++) {
AliITShit *hit = (AliITShit*) arrHits->At(iHit);
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 0)->Fill(iModule);
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 1)->Fill(hit->GetXG());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 2)->Fill(hit->GetYG());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 3)->Fill(hit->GetZG());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 4)->Fill(hit->GetXL());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 5)->Fill(hit->GetYL());
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 6)->Fill(hit->GetZL());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 0,iModule);
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 1,hit->GetXG());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 2,hit->GetYG());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 3,hit->GetZG());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 4,hit->GetXL());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 5,hit->GetYL());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 6,hit->GetZL());
if(hit->GetIonization())
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 7)->Fill(TMath::Log10(hit->GetIonization()));
- fAliITSQADataMakerSim->GetHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 8)->Fill(hit->GetXG(),hit->GetYG());
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 7,TMath::Log10(hit->GetIonization()));
+ fAliITSQADataMakerSim->FillHitsData(fGenOffsetH[fAliITSQADataMakerSim->GetEventSpecie()] + 8,hit->GetXG(),hit->GetYG());
}//hit loop
}//module loop
return rv ;
AliITSQASSDDataMakerSim& operator = (const AliITSQASSDDataMakerSim& qac);
virtual void StartOfDetectorCycle();
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray * list);
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list);
virtual ~AliITSQASSDDataMakerSim() {;} // dtor
virtual Int_t InitDigits();
virtual Int_t InitSDigits();
void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray** list)
{
/// Detector specific actions at end of cycle
-
+ //
+ ResetEventTrigClasses(); // RS
+ //
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
{
if (! IsValidEventSpecie(specie, list) ) continue;
if ( fTracker ) fTracker->InitRaws();
if ( fTrigger ) fTrigger->InitRaws();
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//__________________________________________________________________
/// Initialized Digits spectra
if ( fTracker ) fTracker->InitDigits();
if ( fTrigger ) fTrigger->InitDigits();
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
/// create Reconstructed Points histograms in RecPoints subdir
if ( fTracker ) fTracker->InitRecPoints();
if ( fTrigger ) fTrigger->InitRecPoints();
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
///create ESDs histograms in ESDs subdir
if ( fTracker ) fTracker->InitESDs();
if ( fTrigger ) fTrigger->InitESDs();
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
fTrigger->MakeRaws(rawReader);
}
}
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//__________________________________________________________________
if ( fTracker ) fTracker->MakeDigits(digitsTree);
if ( fTrigger ) fTrigger->MakeDigits(digitsTree);
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
if ( fTracker ) fTracker->MakeRecPoints(clustersTree);
if ( fTrigger ) fTrigger->MakeRecPoints(clustersTree);
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
if ( fTracker ) fTracker->MakeESDs(esd);
if ( fTrigger ) fTrigger->MakeESDs(esd);
-
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
//____________________________________________________________________________
void AliMUONQADataMakerRec::StartOfDetectorCycle()
{
- /// Detector specific actions at start of cycle
+ /// Detector specific actions at start of cycle
+
}
TH1F* h1 = new TH1F("hHitPtot", "P distribution in Hits;P [erg];Counts ", 300, 0., 300.);
Add2HitsList(h1, 1, !expert, image);
- return;
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//__________________________________________________________________
TH1F* h1 = new TH1F("hSDigitsCharge", "Charge distribution in SDigits;Charge [??];Counts", 4096, 0, 4095);
Add2SDigitsList(h1, 1, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//__________________________________________________________________
TH1I* h1 = new TH1I("hDigitsADC", "ADC distribution in Digits;ACD value;Counts", 4096, 0, 4095);
Add2DigitsList(h1, 1, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//__________________________________________________________________
while ( ( hit = static_cast<AliMUONHit*>(next()) ) )
{
- GetHitsData(0)->Fill(hit->DetElemId());
- GetHitsData(1)->Fill(hit->Momentum());
+ FillHitsData(0,hit->DetElemId());
+ FillHitsData(1,hit->Momentum());
}
-
-
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//__________________________________________________________________
while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
{
- GetSDigitsData(0)->Fill(dig->DetElemId());
- GetSDigitsData(1)->Fill(dig->Charge());
+ FillSDigitsData(0,dig->DetElemId());
+ FillSDigitsData(1,dig->Charge());
}
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//__________________________________________________________________
while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
{
- GetDigitsData(0)->Fill(dig->DetElemId());
- GetDigitsData(1)->Fill(dig->ADC());
+ FillDigitsData(0,dig->DetElemId());
+ FillDigitsData(1,dig->ADC());
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
{
///Detector specific actions at end of cycle
// do the QA checking
- AliQAChecker::Instance()->Run(AliQAv1::kMUON, task, list) ;
+ ResetEventTrigClasses();
+ AliQAChecker::Instance()->Run(AliQAv1::kMUON, task, list) ;
}
void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleESDs(Int_t, TObjArray**)
{
/// Normalize ESD histograms
-
- if (!GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)) return;
-
- AliCodeTimerAuto("",0);
-
- Double_t nTracks = GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)->GetEntries();
- if (nTracks <= 0) return;
-
- TH1* hESDnClustersPerCh = GetESDsData(AliMUONQAIndices::kESDnClustersPerCh);
- TH1* hESDnClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnClustersPerDE);
- TH1* hESDClusterChargePerChMean = GetESDsData(AliMUONQAIndices::kESDClusterChargePerChMean);
- TH1* hESDClusterChargePerChSigma = GetESDsData(AliMUONQAIndices::kESDClusterChargePerChSigma);
- TH1* hESDClusterSizePerChMean = GetESDsData(AliMUONQAIndices::kESDClusterSizePerChMean);
- TH1* hESDClusterSizePerChSigma = GetESDsData(AliMUONQAIndices::kESDClusterSizePerChSigma);
- TH1* hESDResidualXPerChMean = GetESDsData(AliMUONQAIndices::kESDResidualXPerChMean);
- TH1* hESDResidualXPerChSigma = GetESDsData(AliMUONQAIndices::kESDResidualXPerChSigma);
- TH1* hESDResidualYPerChMean = GetESDsData(AliMUONQAIndices::kESDResidualYPerChMean);
- TH1* hESDResidualYPerChSigma = GetESDsData(AliMUONQAIndices::kESDResidualYPerChSigma);
- TH1* hESDLocalChi2XPerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerChMean);
- TH1* hESDLocalChi2YPerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerChMean);
- TH1* hESDLocalChi2PerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2PerChMean);
- TH1* hESDClusterChargePerDE = GetESDsData(AliMUONQAIndices::kESDClusterChargePerDE);
- TH1* hESDClusterSizePerDE = GetESDsData(AliMUONQAIndices::kESDClusterSizePerDE);
- TH1* hESDResidualXPerDEMean = GetESDsData(AliMUONQAIndices::kESDResidualXPerDEMean);
- TH1* hESDResidualXPerDESigma = GetESDsData(AliMUONQAIndices::kESDResidualXPerDESigma);
- TH1* hESDResidualYPerDEMean = GetESDsData(AliMUONQAIndices::kESDResidualYPerDEMean);
- TH1* hESDResidualYPerDESigma = GetESDsData(AliMUONQAIndices::kESDResidualYPerDESigma);
- TH1* hESDLocalChi2XPerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerDEMean);
- TH1* hESDLocalChi2YPerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerDEMean);
- TH1* hESDLocalChi2PerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2PerDEMean);
- TH1* hESDnTotClustersPerCh = GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh);
- TH1* hESDnTotClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE);
- TH1* hESDnTotFullClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE);
- TH1* hESDSumClusterChargePerDE = GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE);
- TH1* hESDSumClusterSizePerDE = GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE);
- TH1* hESDSumResidualXPerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE);
- TH1* hESDSumResidualYPerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE);
- TH1* hESDSumResidualX2PerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE);
- TH1* hESDSumResidualY2PerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE);
- TH1* hESDSumLocalChi2XPerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE);
- TH1* hESDSumLocalChi2YPerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE);
- TH1* hESDSumLocalChi2PerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE);
-
- hESDnClustersPerCh->Reset();
- hESDnClustersPerDE->Reset();
- hESDnClustersPerCh->Add(hESDnTotClustersPerCh, 1./nTracks);
- hESDnClustersPerDE->Add(hESDnTotClustersPerDE, 1./nTracks);
-
- // loop over chambers
- for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
-
- TH1* hESDClusterChargeInCh = GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+iCh);
- Double_t sigmaCharge = hESDClusterChargeInCh->GetRMS();
- hESDClusterChargePerChMean->SetBinContent(iCh+1, hESDClusterChargeInCh->GetMean());
- hESDClusterChargePerChMean->SetBinError(iCh+1, hESDClusterChargeInCh->GetMeanError());
- hESDClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
- hESDClusterChargePerChSigma->SetBinError(iCh+1, hESDClusterChargeInCh->GetRMSError());
-
- TH1* hESDClusterSizeInCh = GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+iCh);
- Double_t sigmaSize = hESDClusterSizeInCh->GetRMS();
- hESDClusterSizePerChMean->SetBinContent(iCh+1, hESDClusterSizeInCh->GetMean());
- hESDClusterSizePerChMean->SetBinError(iCh+1, hESDClusterSizeInCh->GetMeanError());
- hESDClusterSizePerChSigma->SetBinContent(iCh+1, sigmaSize);
- hESDClusterSizePerChSigma->SetBinError(iCh+1, hESDClusterSizeInCh->GetRMSError());
-
- TH1* hESDResidualXInCh = GetESDsData(AliMUONQAIndices::kESDResidualXInCh+iCh);
- Double_t sigmaResidualX = hESDResidualXInCh->GetRMS();
- hESDResidualXPerChMean->SetBinContent(iCh+1, hESDResidualXInCh->GetMean());
- hESDResidualXPerChMean->SetBinError(iCh+1, hESDResidualXInCh->GetMeanError());
- hESDResidualXPerChSigma->SetBinContent(iCh+1, sigmaResidualX);
- hESDResidualXPerChSigma->SetBinError(iCh+1, hESDResidualXInCh->GetRMSError());
-
- TH1* hESDResidualYInCh = GetESDsData(AliMUONQAIndices::kESDResidualYInCh+iCh);
- Double_t sigmaResidualY = hESDResidualYInCh->GetRMS();
- hESDResidualYPerChMean->SetBinContent(iCh+1, hESDResidualYInCh->GetMean());
- hESDResidualYPerChMean->SetBinError(iCh+1, hESDResidualYInCh->GetMeanError());
- hESDResidualYPerChSigma->SetBinContent(iCh+1, sigmaResidualY);
- hESDResidualYPerChSigma->SetBinError(iCh+1, hESDResidualYInCh->GetRMSError());
-
- TH1* hESDLocalChi2XInCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+iCh);
- Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS();
- hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean());
- hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError());
-
- TH1* hESDLocalChi2YInCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+iCh);
- Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS();
- hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean());
- hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError());
-
- TH1* hESDLocalChi2InCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+iCh);
- Double_t sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS();
- hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean());
- hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError());
-
- // loop over DE into chamber iCh
- AliMpDEIterator it;
- it.First(iCh);
- while ( !it.IsDone()) {
-
- Int_t iDE = it.CurrentDEId();
-
- Double_t nClusters = hESDnTotClustersPerDE->GetBinContent(iDE+1);
- if (nClusters > 1) {
-
- hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters);
- hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
-
- Double_t meanResX = hESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters;
- hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX);
- hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters));
- hESDResidualXPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX));
- hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters));
-
- Double_t meanResY = hESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters;
- hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY);
- hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters));
- hESDResidualYPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY));
- hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters));
-
- hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters);
- hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters));
-
- hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters);
- hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters));
-
- hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)/nClusters);
- hESDLocalChi2PerDEMean->SetBinError(iDE+1, sigmaLocalChi2/TMath::Sqrt(nClusters));
-
- } else {
-
- hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1));
- hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax());
-
- hESDResidualXPerDEMean->SetBinContent(iDE+1, hESDSumResidualXPerDE->GetBinContent(iDE+1));
- hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
- hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.);
- hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
-
- hESDResidualYPerDEMean->SetBinContent(iDE+1, hESDSumResidualYPerDE->GetBinContent(iDE+1));
- hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
- hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.);
- hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
-
- hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1));
- hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax());
-
- hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1));
- hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax());
-
- hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1));
- hESDLocalChi2PerDEMean->SetBinError(iDE+1, hESDLocalChi2InCh->GetXaxis()->GetXmax());
-
+ //
+ Bool_t firstFill = kTRUE;
+ //
+ for (int itc=-1;itc<Master()->GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ TH1* hESDnClustersPerTr = Master()->GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack, itc);
+ if (! hESDnClustersPerTr) continue;
+ Double_t nTracks = hESDnClustersPerTr->GetEntries();
+ if (nTracks <= 0) continue;
+ //
+ if (firstFill) { AliCodeTimerAuto("",0); firstFill = kFALSE;}
+
+ TH1* hESDnClustersPerCh = Master()->GetESDsData(AliMUONQAIndices::kESDnClustersPerCh,itc);
+ TH1* hESDnClustersPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDnClustersPerDE,itc);
+ TH1* hESDClusterChargePerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargePerChMean,itc);
+ TH1* hESDClusterChargePerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargePerChSigma,itc);
+ TH1* hESDClusterSizePerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizePerChMean,itc);
+ TH1* hESDClusterSizePerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizePerChSigma,itc);
+ TH1* hESDResidualXPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerChMean,itc);
+ TH1* hESDResidualXPerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerChSigma,itc);
+ TH1* hESDResidualYPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerChMean,itc);
+ TH1* hESDResidualYPerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerChSigma,itc);
+ TH1* hESDLocalChi2XPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerChMean,itc);
+ TH1* hESDLocalChi2YPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerChMean,itc);
+ TH1* hESDLocalChi2PerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2PerChMean,itc);
+ TH1* hESDClusterChargePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargePerDE,itc);
+ TH1* hESDClusterSizePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizePerDE,itc);
+ TH1* hESDResidualXPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerDEMean,itc);
+ TH1* hESDResidualXPerDESigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerDESigma,itc);
+ TH1* hESDResidualYPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerDEMean,itc);
+ TH1* hESDResidualYPerDESigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerDESigma,itc);
+ TH1* hESDLocalChi2XPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerDEMean,itc);
+ TH1* hESDLocalChi2YPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerDEMean,itc);
+ TH1* hESDLocalChi2PerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2PerDEMean,itc);
+ TH1* hESDnTotClustersPerCh = Master()->GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh,itc);
+ TH1* hESDnTotClustersPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE,itc);
+ TH1* hESDnTotFullClustersPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE,itc);
+ TH1* hESDSumClusterChargePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE,itc);
+ TH1* hESDSumClusterSizePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE,itc);
+ TH1* hESDSumResidualXPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE,itc);
+ TH1* hESDSumResidualYPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE,itc);
+ TH1* hESDSumResidualX2PerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE,itc);
+ TH1* hESDSumResidualY2PerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE,itc);
+ TH1* hESDSumLocalChi2XPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE,itc);
+ TH1* hESDSumLocalChi2YPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE,itc);
+ TH1* hESDSumLocalChi2PerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE,itc);
+ //
+ if (hESDnClustersPerCh && hESDnTotClustersPerCh) {
+ hESDnClustersPerCh->Reset();
+ hESDnClustersPerCh->Add(hESDnTotClustersPerCh, 1./nTracks);
+ }
+ if (hESDnClustersPerDE && hESDnTotClustersPerDE) {
+ hESDnClustersPerDE->Reset();
+ hESDnClustersPerDE->Add(hESDnTotClustersPerDE, 1./nTracks);
+ }
+ //
+ // loop over chambers
+ for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
+ //
+ double sigmaCharge=0,sigmaSize=0,sigmaResidualX=0,sigmaResidualY=0,sigmaLocalChi2X=0,sigmaLocalChi2Y=0,sigmaLocalChi2=0;
+ //
+ TH1* hESDClusterChargeInCh = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+iCh,itc);
+ if (hESDClusterChargeInCh) {
+ sigmaCharge = hESDClusterChargeInCh->GetRMS();
+ if (hESDClusterChargePerChMean) {
+ hESDClusterChargePerChMean->SetBinContent(iCh+1, hESDClusterChargeInCh->GetMean());
+ hESDClusterChargePerChMean->SetBinError(iCh+1, hESDClusterChargeInCh->GetMeanError());
+ }
+ if (hESDClusterChargePerChSigma) {
+ hESDClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
+ hESDClusterChargePerChSigma->SetBinError(iCh+1, hESDClusterChargeInCh->GetRMSError());
+ }
}
-
- Double_t nFullClusters = hESDnTotFullClustersPerDE->GetBinContent(iDE+1);
- if (nFullClusters > 1) {
-
- hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters);
- hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters));
-
- } else {
-
- hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1));
- hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax());
-
+ //
+ TH1* hESDClusterSizeInCh = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+iCh,itc);
+ if (hESDClusterSizeInCh) {
+ sigmaSize = hESDClusterSizeInCh->GetRMS();
+ if (hESDClusterSizePerChMean) {
+ hESDClusterSizePerChMean->SetBinContent(iCh+1, hESDClusterSizeInCh->GetMean());
+ hESDClusterSizePerChMean->SetBinError(iCh+1, hESDClusterSizeInCh->GetMeanError());
+ }
+ if (hESDClusterSizePerChSigma) {
+ hESDClusterSizePerChSigma->SetBinContent(iCh+1, sigmaSize);
+ hESDClusterSizePerChSigma->SetBinError(iCh+1, hESDClusterSizeInCh->GetRMSError());
+ }
+ }
+ //
+ TH1* hESDResidualXInCh = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXInCh+iCh,itc);
+ if (hESDResidualXInCh) {
+ sigmaResidualX = hESDResidualXInCh->GetRMS();
+ if (hESDResidualXPerChMean) {
+ hESDResidualXPerChMean->SetBinContent(iCh+1, hESDResidualXInCh->GetMean());
+ hESDResidualXPerChMean->SetBinError(iCh+1, hESDResidualXInCh->GetMeanError());
+ }
+ if (hESDResidualXPerChSigma) {
+ hESDResidualXPerChSigma->SetBinContent(iCh+1, sigmaResidualX);
+ hESDResidualXPerChSigma->SetBinError(iCh+1, hESDResidualXInCh->GetRMSError());
+ }
+ }
+ //
+ TH1* hESDResidualYInCh = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYInCh+iCh,itc);
+ if (hESDResidualYInCh) {
+ sigmaResidualY = hESDResidualYInCh->GetRMS();
+ if (hESDResidualYPerChMean) {
+ hESDResidualYPerChMean->SetBinContent(iCh+1, hESDResidualYInCh->GetMean());
+ hESDResidualYPerChMean->SetBinError(iCh+1, hESDResidualYInCh->GetMeanError());
+ }
+ if (hESDResidualYPerChSigma) {
+ hESDResidualYPerChSigma->SetBinContent(iCh+1, sigmaResidualY);
+ hESDResidualYPerChSigma->SetBinError(iCh+1, hESDResidualYInCh->GetRMSError());
+ }
}
+ //
+ TH1* hESDLocalChi2XInCh = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+iCh,itc);
+ if (hESDLocalChi2XInCh) {
+ sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS();
+ if (hESDLocalChi2XPerChMean) {
+ hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean());
+ hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError());
+ }
+ }
+ //
+ TH1* hESDLocalChi2YInCh = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+iCh,itc);
+ if (hESDLocalChi2YInCh) {
+ sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS();
+ if (hESDLocalChi2YPerChMean) {
+ hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean());
+ hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError());
+ }
+ }
+ //
+ TH1* hESDLocalChi2InCh = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+iCh,itc);
+ if (hESDLocalChi2InCh) {
+ sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS();
+ if (hESDLocalChi2PerChMean) {
+ hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean());
+ hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError());
+ }
+ }
+ //
+ // loop over DE into chamber iCh
+ AliMpDEIterator it;
+ it.First(iCh);
+ while ( !it.IsDone()) {
+
+ Int_t iDE = it.CurrentDEId();
+
+ Double_t nClusters = hESDnTotClustersPerDE ? hESDnTotClustersPerDE->GetBinContent(iDE+1) : 0;
+ if (nClusters > 1) {
+
+ if (hESDClusterChargePerDE && hESDSumClusterChargePerDE) {
+ hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters);
+ hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
+ }
+
+ if (hESDResidualXPerDEMean && hESDResidualXPerDESigma && hESDSumResidualXPerDE) {
+ Double_t meanResX = hESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters;
+ hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX);
+ hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters));
+ //
+ hESDResidualXPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX));
+ hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters));
+ }
+ //
+ if (hESDResidualYPerDEMean && hESDResidualYPerDESigma && hESDSumResidualYPerDE) {
+ Double_t meanResY = hESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters;
+ hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY);
+ hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters));
+ hESDResidualYPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY));
+ hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters));
+ }
+ //
+ if (hESDLocalChi2XPerDEMean && hESDSumLocalChi2XPerDE) {
+ hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters);
+ hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters));
+ }
+ //
+ if (hESDLocalChi2YPerDEMean && hESDSumLocalChi2YPerDE) {
+ hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters);
+ hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters));
+ }
+ //
+ if (hESDLocalChi2PerDEMean && hESDSumLocalChi2PerDE) {
+ hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)/nClusters);
+ hESDLocalChi2PerDEMean->SetBinError(iDE+1, sigmaLocalChi2/TMath::Sqrt(nClusters));
+ }
+ }
+ else {
+ if (hESDClusterChargePerDE && hESDClusterChargeInCh) {
+ hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1));
+ hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax());
+ }
+ //
+ if (hESDResidualXPerDEMean && hESDResidualXPerDESigma && hESDSumResidualXPerDE && hESDResidualXInCh) {
+ hESDResidualXPerDEMean->SetBinContent(iDE+1, hESDSumResidualXPerDE->GetBinContent(iDE+1));
+ hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
+ hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.);
+ hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax());
+ }
+ //
+ if (hESDResidualYPerDEMean && hESDResidualYPerDESigma && hESDSumResidualYPerDE && hESDResidualYInCh) {
+ hESDResidualYPerDEMean->SetBinContent(iDE+1, hESDSumResidualYPerDE->GetBinContent(iDE+1));
+ hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
+ hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.);
+ hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax());
+ }
+ //
+ if (hESDLocalChi2XPerDEMean && hESDSumLocalChi2XPerDE && hESDLocalChi2XInCh) {
+ hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1));
+ hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax());
+ }
+ //
+ if (hESDLocalChi2YPerDEMean && hESDSumLocalChi2YPerDE && hESDLocalChi2YInCh) {
+ hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1));
+ hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax());
+ }
+ //
+ if (hESDLocalChi2PerDEMean && hESDSumLocalChi2PerDE && hESDLocalChi2InCh) {
+ hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1));
+ hESDLocalChi2PerDEMean->SetBinError(iDE+1, hESDLocalChi2InCh->GetXaxis()->GetXmax());
+ }
+ }
- it.Next();
- }
+ Double_t nFullClusters = hESDnTotFullClustersPerDE ? hESDnTotFullClustersPerDE->GetBinContent(iDE+1) : 0;
+ if (nFullClusters > 1) {
+ if (hESDClusterSizePerDE && hESDSumClusterSizePerDE) {
+ hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters);
+ hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters));
+ }
+ }
+ else {
+ if (hESDClusterSizePerDE && hESDSumClusterSizePerDE) {
+ hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1));
+ hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax());
+ }
+ }
+
+ it.Next();
+ } // while
+
+ } // iCh loop
- }
+ } // trigger classes loop
}
void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list)
{
/// Normalize RecPoints histograms
-
- if (!GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean)) return;
-
- AliCodeTimerAuto("",0);
-
- TH1* hTrackerClusterChargePerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean);
- TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChSigma);
- TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChMean);
- TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChSigma);
- TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDEMean);
- TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDEMean);
-
- // loop over chambers
- for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
-
- TH1* hTrackerClusterChargePerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+iCh);
- Double_t sigmaCharge = hTrackerClusterChargePerChamber->GetRMS();
- hTrackerClusterChargePerChMean->SetBinContent(iCh+1, hTrackerClusterChargePerChamber->GetMean());
- hTrackerClusterChargePerChMean->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetMeanError());
- hTrackerClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
- hTrackerClusterChargePerChSigma->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetRMSError());
+ //
+ Bool_t firstFill=kTRUE, needIns0=kTRUE, needIns1=kTRUE;
+ //
+ for (int itc=-1;itc<Master()->GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+
+ TH1* hTrackerClusterChargePerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean,itc);
+ if (!hTrackerClusterChargePerChMean) continue;
+ //
+ if (firstFill) { AliCodeTimerAuto("",0); firstFill = kFALSE;}
+
+ TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChSigma,itc);
+ TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChMean,itc);
+ TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChSigma,itc);
+ TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDEMean,itc);
+ TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDEMean,itc);
+
+ // loop over chambers
+ for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) {
- TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+iCh);
- Double_t sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS();
- hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean());
- hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError());
- hTrackerClusterMultiplicityPerChSigma->SetBinContent(iCh+1, sigmaSize);
- hTrackerClusterMultiplicityPerChSigma->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetRMSError());
-
- // loop over DE into chamber iCh
- AliMpDEIterator it;
- it.First(iCh);
- while ( !it.IsDone()) {
-
- Int_t iDE = it.CurrentDEId();
-
- TH1* hTrackerClusterChargePerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+iDE);
- hTrackerClusterChargePerDEMean->SetBinContent(iDE+1, hTrackerClusterChargePerDE->GetMean());
- Double_t nClusters = hTrackerClusterChargePerDE->GetEntries();
- if (nClusters > 1) hTrackerClusterChargePerDEMean->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
- else hTrackerClusterChargePerDEMean->SetBinError(iDE+1, hTrackerClusterChargePerChamber->GetXaxis()->GetXmax());
+ TH1* hTrackerClusterChargePerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+iCh,itc);
+ Double_t sigmaCharge = 0;
+ if (hTrackerClusterChargePerChamber) {
+ sigmaCharge = hTrackerClusterChargePerChamber->GetRMS();
+ hTrackerClusterChargePerChMean->SetBinContent(iCh+1, hTrackerClusterChargePerChamber->GetMean());
+ hTrackerClusterChargePerChMean->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetMeanError());
+ //
+ if (hTrackerClusterChargePerChSigma) {
+ hTrackerClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge);
+ hTrackerClusterChargePerChSigma->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetRMSError());
+ }
+ }
+ //
+ TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+iCh,itc);
+ Double_t sigmaSize = 0;
+ if (hTrackerClusterMultiplicityPerChamber) {
+ sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS();
+ if (hTrackerClusterMultiplicityPerChMean) {
+ hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean());
+ hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError());
+ }
+ if (hTrackerClusterMultiplicityPerChSigma) {
+ hTrackerClusterMultiplicityPerChSigma->SetBinContent(iCh+1, sigmaSize);
+ hTrackerClusterMultiplicityPerChSigma->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetRMSError());
+ }
+ }
+ //
+ // loop over DE into chamber iCh
+ AliMpDEIterator it;
+ it.First(iCh);
+ while ( !it.IsDone()) {
- TH1* hTrackerClusterMultiplicityPerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+iDE);
- hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean());
- nClusters = hTrackerClusterMultiplicityPerDE->GetEntries();
- if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters));
- else hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, hTrackerClusterMultiplicityPerChamber->GetXaxis()->GetXmax());
+ Int_t iDE = it.CurrentDEId();
- it.Next();
+ TH1* hTrackerClusterChargePerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+iDE,itc);
+ if (hTrackerClusterChargePerDEMean && hTrackerClusterChargePerDE) {
+ hTrackerClusterChargePerDEMean->SetBinContent(iDE+1, hTrackerClusterChargePerDE->GetMean());
+ Double_t nClusters = hTrackerClusterChargePerDE->GetEntries();
+ if (nClusters > 1) hTrackerClusterChargePerDEMean->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters));
+ else hTrackerClusterChargePerDEMean->SetBinError(iDE+1, hTrackerClusterChargePerChamber ?
+ hTrackerClusterChargePerChamber->GetXaxis()->GetXmax() : 0);
+ }
+ TH1* hTrackerClusterMultiplicityPerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+iDE,itc);
+ if (hTrackerClusterMultiplicityPerDEMean && hTrackerClusterMultiplicityPerDE) {
+ hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean());
+ Double_t nClusters = hTrackerClusterMultiplicityPerDE->GetEntries();
+ if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters));
+ else hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, hTrackerClusterMultiplicityPerChamber ?
+ hTrackerClusterMultiplicityPerChamber->GetXaxis()->GetXmax() : 0);
+ }
+ it.Next();
+ }
}
- }
- if ( MappingCheckRecPoints(specie) )
- {
- InsertTrackerData(specie,list,MappingCheckRecPoints(specie)->CreateData("RecPoints"),AliMUONQAIndices::kTrackerRecPoints,kTRUE);
- }
-
- if ( TrackerRecData(specie) )
- {
- /// put the trackerdata in the pipeline
- InsertTrackerData(specie,list,TrackerRecData(specie),AliMUONQAIndices::kTrackerData);
+ if (needIns0 && MappingCheckRecPoints(specie) ) { // RS: I guess this should not be in the itc loop, do this only once
+ InsertTrackerData(specie,list,MappingCheckRecPoints(specie)->CreateData("RecPoints"),AliMUONQAIndices::kTrackerRecPoints,kTRUE);
+ needIns0 = kFALSE;
+ }
- TH1* hbp = GetRecPointsData(AliMUONQAIndices::kTrackerBusPatchOccupancy);
- TH1* hnevents = GetRecPointsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed);
- TH1* hddl = GetRecPointsData(AliMUONQAIndices::kTrackerDDLOccupancy);
- TH1* hddlevents = GetRecPointsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed);
+ if ( TrackerRecData(specie) ) {
+ /// put the trackerdata in the pipeline
+ if (needIns1) { // RS: I guess this should not be in the itc loop, do this only once
+ InsertTrackerData(specie,list,TrackerRecData(specie),AliMUONQAIndices::kTrackerData);
+ needIns1 = kFALSE;
+ }
+ TH1* hbp = GetRecPointsData(AliMUONQAIndices::kTrackerBusPatchOccupancy,itc);
+ TH1* hnevents = GetRecPointsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed,itc);
+ TH1* hddl = GetRecPointsData(AliMUONQAIndices::kTrackerDDLOccupancy,itc);
+ TH1* hddlevents = GetRecPointsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed,itc);
- if ( !hbp || !hnevents || !hddl || !hddlevents)
- {
- AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents));
- return;
+ if (itc==-1 && (!hbp || !hnevents || !hddl || !hddlevents)) { //RS: produce error only for trigger-blind class
+ AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents));
+ continue; // return; // RS: the histos might be booked for some trigger class only
+ }
+ //
+ ProjectTrackerData(TrackerRecData(specie),*hbp,*hnevents,*hddl,*hddlevents);
}
-
- ProjectTrackerData(TrackerRecData(specie),
- *hbp,*hnevents,*hddl,*hddlevents);
- }
- else
- {
- AliError(Form("TrackerRecData is null for specie %s",AliRecoParam::GetEventSpecieName(specie)));
- }
-
+ else {
+ AliError(Form("TrackerRecData is null for specie %s",AliRecoParam::GetEventSpecieName(specie)));
+ }
+ } // RS: loop over eventual clones per trigger class
}
//____________________________________________________________________________
/// put the trackerdata in the pipeline
InsertTrackerData(specie,list,TrackerCalData(specie),AliMUONQAIndices::kTrackerData);
+ //
+ for (int itc=-1;itc<Master()->GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ TH1* hbp = GetDigitsData(AliMUONQAIndices::kTrackerBusPatchOccupancy, itc);
+ TH1* hnevents = GetDigitsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed, itc);
+ TH1* hddl = GetDigitsData(AliMUONQAIndices::kTrackerDDLOccupancy, itc);
+ TH1* hddlevents = GetDigitsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed, itc);
- TH1* hbp = GetDigitsData(AliMUONQAIndices::kTrackerBusPatchOccupancy);
- TH1* hnevents = GetDigitsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed);
- TH1* hddl = GetDigitsData(AliMUONQAIndices::kTrackerDDLOccupancy);
- TH1* hddlevents = GetDigitsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed);
-
- if ( !hbp || !hnevents || !hddl || !hddlevents)
- {
- AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents));
- return;
- }
-
- ProjectTrackerData(TrackerCalData(specie),
- *hbp,*hnevents,*hddl,*hddlevents);
+ if (itc==-1 && (!hbp || !hnevents || !hddl || !hddlevents) ) { // RS: produce error only for trigger-blind class
+ AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents));
+ continue; //return; // RS
+ }
+ //
+ ProjectTrackerData(TrackerCalData(specie), *hbp,*hnevents,*hddl,*hddlevents);
+ } // RS: loop over eventual clones per trigger class
}
}
/// put the trackerdata in the pipeline
InsertTrackerData(specie,list,TrackerDataMaker(specie)->Data(),AliMUONQAIndices::kTrackerData);
TrackerDataMaker(specie)->SetOwnerOfData(kFALSE); // now that it's attached to list, list will take care of the deletion
-
- TH1* hbp = GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy);
- TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed);
- TH1* hddl = GetRawsData(AliMUONQAIndices::kTrackerDDLOccupancy);
- TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed);
-
- if ( !hbp || !hnevents || !hddl || !hddlevents)
- {
- AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents));
- return;
- }
-
- ProjectTrackerData(TrackerDataMaker(specie)->Data(),
- *hbp,*hnevents,*hddl,*hddlevents);
-
- FillReadoutStatus(*fLogger,TrackerDataMaker(specie)->Data());
+ //
+ for (int itc=-1;itc<Master()->GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+
+ TH1* hbp = GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy, itc);
+ TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed, itc);
+ TH1* hddl = GetRawsData(AliMUONQAIndices::kTrackerDDLOccupancy, itc);
+ TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed, itc);
+ //
+ if (!hbp || !hnevents || !hddl || !hddlevents) {
+ if (itc==-1) AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents));
+ continue; // return; // RS
+ }
+ //
+ ProjectTrackerData(TrackerDataMaker(specie)->Data(), *hbp,*hnevents,*hddl,*hddlevents);
+ //
+ FillReadoutStatus(*fLogger,TrackerDataMaker(specie)->Data(), itc);
+ } // RS: loop over eventual clones per trigger class
+ //
}
}
//____________________________________________________________________________
-void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data)
+void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data, Int_t trigCl)
{
+ // RS: I am not sure if this part is valid for looping over trigger classes (loggers are not cloned)
+ if (trigCl!=-1) return; // For the moment only trigCl==-1 will be processed (i.e. trigger-blind histos)
+
log.ResetItr();
TString msg;
Int_t occurence;
- TH1* hparity = GetRawsData(AliMUONQAIndices::kTrackerBusPatchParityErrors);
+ TH1* hparity = GetRawsData(AliMUONQAIndices::kTrackerBusPatchParityErrors, trigCl);
- TH1* htoken = GetRawsData(AliMUONQAIndices::kTrackerBusPatchTokenLostErrors);
+ TH1* htoken = GetRawsData(AliMUONQAIndices::kTrackerBusPatchTokenLostErrors, trigCl);
- TH1* hpadding = GetRawsData(AliMUONQAIndices::kTrackerBusPatchPaddingErrors);
+ TH1* hpadding = GetRawsData(AliMUONQAIndices::kTrackerBusPatchPaddingErrors, trigCl);
- TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus);
+ TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus, trigCl);
- TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen);
+ TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen, trigCl);
+
+ //
+ if (!hparity || !htoken || !hpadding || !hrostatus || !hnevents) return;
Int_t nevents = TMath::Nint(hnevents->GetBinContent(1));
void AliMUONTrackerQADataMakerRec::FillEventSize(AliRawReader* rawReader)
{
/// Fill event size histogram(s)
+ // RS: substituted explicit histo filling by QA framework filling accounting for cloned histos
- TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen);
-
- TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsSeen);
-
- TH1* hDDLEventSize = GetRawsData(AliMUONQAIndices::kTrackerDDLEventSize);
-
- hnevents->Fill(0.0);
+ FillRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen,0.0);
Int_t offset = AliDAQ::DdlIDOffset("MUONTRK");
if (rawReader->ReadHeader() )
{
UInt_t ddlsize = rawReader->GetEquipmentSize();
- hDDLEventSize->Fill(i+offset,ddlsize);
- hddlevents->Fill(i+offset);
+ FillRawsData(AliMUONQAIndices::kTrackerDDLEventSize,i+offset,ddlsize);
+ FillRawsData(AliMUONQAIndices::kTrackerDDLNofEventsSeen,i+offset);
}
}
rawReader->Reset();
Add2RawsList(h,AliMUONQAIndices::kTrackerDDLEventSizePerEvent,kFALSE,kTRUE,kFALSE);
Add2RawsList(new TH1F("hTrackerIsThere","tracker is there",1,0,1),AliMUONQAIndices::kTrackerIsThere,kTRUE,kFALSE,kFALSE);
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//__________________________________________________________________
/// Book histograms that are common to Raws and Digits
BookHistograms(AliQAv1::kDIGITSR);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterChargePerDEMean, !expert, image);
MappingCheckRecPoints(AliRecoParam::AConvert(Master()->GetEventSpecie()),kTRUE);
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
Add2ESDsList(hESDSumLocalChi2YPerDE, AliMUONQAIndices::kESDSumLocalChi2YPerDE, expert, !image);
TH1F* hESDSumLocalChi2PerDE = new TH1F("hESDSumLocalChi2PerDE", "sum of local chi2 (~0.5*(#chi^{2}_{X}+#chi^{2}_{Y})) per DE;DetElem ID;#Sigma(local #chi^{2})", nDE+1, -0.5, nDE+0.5);
Add2ESDsList(hESDSumLocalChi2PerDE, AliMUONQAIndices::kESDSumLocalChi2PerDE, expert, !image);
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
AliMUONTrackerDataMaker* dm = static_cast<AliMUONTrackerDataMaker*>(TrackerDataMaker(AliRecoParam::AConvert(Master()->GetEventSpecie())));
- dm->SetRawReader(rawReader);
+ dm->SetRawReader(rawReader);
Int_t eventType = rawReader->GetType();
if ( dm->LastEventWasEmpty() )
{
- TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus);
-
- if (hrostatus) hrostatus->Fill(1.0*AliMUONQAIndices::kTrackerRawNofEmptyEvents);
+ FillRawsData(AliMUONQAIndices::kTrackerReadoutStatus,1.0*AliMUONQAIndices::kTrackerRawNofEmptyEvents);
}
}
+ //
}
//__________________________________________________________________
}
}
}
-
TrackerCalData(AliRecoParam::AConvert(Master()->GetEventSpecie()))->Add(oneEventData);
+ //
}
//____________________________________________________________________________
Int_t detElemId = cluster->GetDetElemId();
Int_t chamberId = AliMpDEManager::GetChamberId(detElemId);
- GetRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerDE)->Fill(detElemId);
- GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+detElemId)->Fill(cluster->GetCharge());
- GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+detElemId)->Fill(cluster->GetNDigits());
-
- GetRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerChamber)->Fill(chamberId);
- GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+chamberId)->Fill(cluster->GetCharge());
- GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+chamberId)->Fill(cluster->GetNDigits());
- GetRecPointsData(AliMUONQAIndices::kTrackerClusterHitMapPerChamber+chamberId)->Fill(cluster->GetX(),cluster->GetY());
+ FillRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerDE,detElemId);
+ FillRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+detElemId,cluster->GetCharge());
+ FillRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+detElemId,cluster->GetNDigits());
+
+ FillRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerChamber,chamberId);
+ FillRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+chamberId,cluster->GetCharge());
+ FillRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+chamberId,cluster->GetNDigits());
+ FillRecPointsData(AliMUONQAIndices::kTrackerClusterHitMapPerChamber+chamberId,cluster->GetX(),cluster->GetY());
if ( mcr ) mcr->Store(*cluster);
TrackerRecData(AliRecoParam::AConvert(Master()->GetEventSpecie()))->Add(oneEventData);
- fClusterStore->Clear();
+ fClusterStore->Clear();
+ //
}
//____________________________________________________________________________
else AliError("Unable to get recoParam: use default ones for residual calculation");
esdInterface.LoadEvent(*esd);
- GetESDsData(AliMUONQAIndices::kESDnTracks)->Fill(esdInterface.GetNTracks());
+ FillESDsData(AliMUONQAIndices::kESDnTracks,esdInterface.GetNTracks());
Int_t nTrackMatchTrig = 0;
if (esdTrack->ContainTriggerData()) nTrackMatchTrig++;
- GetESDsData(AliMUONQAIndices::kESDMomentum)->Fill(esdTrack->P());
- GetESDsData(AliMUONQAIndices::kESDPt)->Fill(esdTrack->Pt());
- GetESDsData(AliMUONQAIndices::kESDRapidity)->Fill(esdTrack->Y());
- GetESDsData(AliMUONQAIndices::kESDChi2)->Fill(track->GetNormalizedChi2());
- GetESDsData(AliMUONQAIndices::kESDProbChi2)->Fill(TMath::Prob(track->GetGlobalChi2(),track->GetNDF()));
- GetESDsData(AliMUONQAIndices::kESDThetaX)->Fill(esdTrack->GetThetaXUncorrected() / TMath::Pi() * 180.);
- GetESDsData(AliMUONQAIndices::kESDThetaY)->Fill(esdTrack->GetThetaYUncorrected() / TMath::Pi() * 180.);
- GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)->Fill(track->GetNClusters());
+ FillESDsData(AliMUONQAIndices::kESDMomentum,esdTrack->P());
+ FillESDsData(AliMUONQAIndices::kESDPt,esdTrack->Pt());
+ FillESDsData(AliMUONQAIndices::kESDRapidity,esdTrack->Y());
+ FillESDsData(AliMUONQAIndices::kESDChi2,track->GetNormalizedChi2());
+ FillESDsData(AliMUONQAIndices::kESDProbChi2,TMath::Prob(track->GetGlobalChi2(),track->GetNDF()));
+ FillESDsData(AliMUONQAIndices::kESDThetaX,esdTrack->GetThetaXUncorrected() / TMath::Pi() * 180.);
+ FillESDsData(AliMUONQAIndices::kESDThetaY,esdTrack->GetThetaYUncorrected() / TMath::Pi() * 180.);
+ FillESDsData(AliMUONQAIndices::kESDnClustersPerTrack,track->GetNClusters());
// loop over clusters
AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->First());
Double_t localChi2Y = (sigmaResidualY2 > 0.) ? residualY*residualY/sigmaResidualY2 : 0.;
Double_t localChi2 = 0.5 * trackParam->GetLocalChi2();
- GetESDsData(AliMUONQAIndices::kESDClusterHitMap+chId)->Fill(cluster->GetX(), cluster->GetY());
+ FillESDsData(AliMUONQAIndices::kESDClusterHitMap+chId,cluster->GetX(), cluster->GetY());
- GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh)->Fill(chId);
- GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE)->Fill(deID);
+ FillESDsData(AliMUONQAIndices::kESDnTotClustersPerCh,chId);
+ FillESDsData(AliMUONQAIndices::kESDnTotClustersPerDE,deID);
- GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge());
- GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE)->Fill(deID, cluster->GetCharge());
+ FillESDsData(AliMUONQAIndices::kESDClusterChargeInCh+chId,cluster->GetCharge());
+ FillESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE,deID, cluster->GetCharge());
if (cluster->GetNDigits() > 0) { // discard clusters with pad not stored in ESD
- GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE)->Fill(deID);
- GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits());
- GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE)->Fill(deID, cluster->GetNDigits());
+ FillESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE,deID);
+ FillESDsData(AliMUONQAIndices::kESDClusterSizeInCh+chId,cluster->GetNDigits());
+ FillESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE,deID, cluster->GetNDigits());
}
- GetESDsData(AliMUONQAIndices::kESDResidualXInCh+chId)->Fill(residualX);
- GetESDsData(AliMUONQAIndices::kESDResidualYInCh+chId)->Fill(residualY);
- GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE)->Fill(deID, residualX);
- GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE)->Fill(deID, residualY);
- GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE)->Fill(deID, residualX*residualX);
- GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE)->Fill(deID, residualY*residualY);
+ FillESDsData(AliMUONQAIndices::kESDResidualXInCh+chId,residualX);
+ FillESDsData(AliMUONQAIndices::kESDResidualYInCh+chId,residualY);
+ FillESDsData(AliMUONQAIndices::kESDSumResidualXPerDE,deID, residualX);
+ FillESDsData(AliMUONQAIndices::kESDSumResidualYPerDE,deID, residualY);
+ FillESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE,deID, residualX*residualX);
+ FillESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE,deID, residualY*residualY);
- GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+chId)->Fill(localChi2X);
- GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+chId)->Fill(localChi2Y);
- GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+chId)->Fill(localChi2);
- GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE)->Fill(deID, localChi2X);
- GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE)->Fill(deID, localChi2Y);
- GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE)->Fill(deID, localChi2);
+ FillESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+chId,localChi2X);
+ FillESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+chId,localChi2Y);
+ FillESDsData(AliMUONQAIndices::kESDLocalChi2InCh+chId,localChi2);
+ FillESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE,deID, localChi2X);
+ FillESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE,deID, localChi2Y);
+ FillESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE,deID, localChi2);
trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
}
- GetESDsData(AliMUONQAIndices::kESDMatchTrig)->Fill(nTrackMatchTrig);
-
+ FillESDsData(AliMUONQAIndices::kESDMatchTrig,nTrackMatchTrig);
+ //
}
//____________________________________________________________________________
{
AliDebug(1,Form("Will not reset histogram %s",hn.Data()));
}
+ continue;
}
- else
- {
- AliMUONVTrackerData* d = dynamic_cast<AliMUONVTrackerData*>(o);
- if (d)
- {
- AliDebug(1,Form("Resetting %s",d->GetName()));
- d->Clear();
+ // RS account for the case when this histos were cloned per trigger class
+ TObjArray* harr = dynamic_cast<TObjArray*>(o);
+ if (harr) {
+ TString hn(harr->GetName());
+ if ( !hn.Contains("TrackerBusPatchConfig") ) {
+
+ AliDebug(1,Form("Resetting clones of %s",hn.Data()));
+
+ TIter nextCl(harr);
+ TH1* hc = 0;
+ while ( (hc=dynamic_cast<TH1*>(nextCl())) ) hc->Reset();
}
- else
- {
- AliError(Form("Found an object of class %s. Do not know how to reset.",o->ClassName()));
+ else {
+ AliDebug(1,Form("Will not reset clones of histogram %s",hn.Data()));
}
+ continue;
+ }
+ //
+ AliMUONVTrackerData* d = dynamic_cast<AliMUONVTrackerData*>(o);
+ if (d) {
+ AliDebug(1,Form("Resetting %s",d->GetName()));
+ d->Clear();
+ }
+ else {
+ AliError(Form("Found an object of class %s. Do not know how to reset.",o->ClassName()));
}
}
-
+
fLogger->Clear();
}
void BookHistograms(AliQAv1::TASKINDEX_t task);
- void FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data);
+ void FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data, Int_t trigCl);
void FillEventSize(AliRawReader* rawReader);
void AliMUONTriggerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t /*specie*/, TObjArray** /*list*/)
{
/// Normalize RecPoints histograms
-
}
DisplayTriggerInfo();
+ int itc = -1; // RS: For the moment assume that only default histo is booked (no cloning)
// Normalize RawData histos
- Float_t nbevent = GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents)->GetBinContent(1);
+ TH1* histo1D = GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents,itc);
+ Float_t nbevent = histo1D ? histo1D->GetBinContent(1) : 0;
Int_t histoRawsIndex[] = {
AliMUONQAIndices::kTriggerErrorSummary,
AliMUONQAIndices::kTriggerCalibSummary,
const Int_t kNrawsHistos = sizeof(histoRawsIndex)/sizeof(histoRawsIndex[0]);
Float_t scaleFactor[kNrawsHistos] = {100., 100., 100., 1.};
for(Int_t ihisto=0; ihisto<kNrawsHistos; ihisto++){
- TH1* inputHisto = GetRawsData(histoRawsIndex[ihisto]);
- TH1* scaledHisto = GetRawsData(histoRawsScaledIndex[ihisto]);
+ TH1* inputHisto = GetRawsData(histoRawsIndex[ihisto],itc);
+ TH1* scaledHisto = GetRawsData(histoRawsScaledIndex[ihisto],itc);
if ( scaledHisto && inputHisto && nbevent > 0 ) {
scaledHisto->Reset();
scaledHisto->Add(inputHisto);
}
} // loop on histos
- TH1* hYCopy = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopy); //number of YCopy error per board
- TH1* hYCopyTests = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyTest); //contains the number of YCopy test per board
- TH1* hYCopyNorm = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyNorm);
+ TH1* hYCopy = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopy,itc); //number of YCopy error per board
+ TH1* hYCopyTests = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyTest,itc); //contains the number of YCopy test per board
+ TH1* hYCopyNorm = GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyNorm,itc);
hYCopyNorm->Reset();
hYCopyNorm->Divide(hYCopy, hYCopyTests, 100., 1.);
Float_t mean = hYCopyNorm->Integral();
- TH1* hSummary = GetRawsData(AliMUONQAIndices::kTriggerErrorSummary);
+ TH1* hSummary = GetRawsData(AliMUONQAIndices::kTriggerErrorSummary,itc);
hSummary->SetBinContent(AliMUONQAIndices::kAlgoLocalYCopy+1,mean/192.); //put the mean of the % of YCopy error in the kTriggerError's corresponding bin
- TH1F* hTriggerRatio = (TH1F*)GetRawsData(AliMUONQAIndices::kTriggerLocalRatio4434);
+ TH1F* hTriggerRatio = (TH1F*)GetRawsData(AliMUONQAIndices::kTriggerLocalRatio4434,itc);
if ( hTriggerRatio ){
- hTriggerRatio->Divide(((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf44Dec)),((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf34Dec)));
+ hTriggerRatio->Divide(((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf44Dec,itc)),((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf34Dec,itc)));
FillRatio4434Histos(1);
//reset bins temporary used to store informations
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents))->SetBinContent(0,0);
- Int_t nbins = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents))->GetNbinsX();
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents))->SetBinContent(nbins+1,0);
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents,itc))->SetBinContent(0,0);
+ Int_t nbins = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents,itc))->GetNbinsX();
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents,itc))->SetBinContent(nbins+1,0);
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerLocalRatio4434))->SetMaximum(1.1);
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents))->SetMaximum(1.1);
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate))->SetMaximum(1.1);
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerLocalRatio4434,itc))->SetMaximum(1.1);
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents,itc))->SetMaximum(1.1);
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate,itc))->SetMaximum(1.1);
}
- if ( GetRawsData(AliMUONQAIndices::kTriggerGlobalScalersNorm) ) {
- TH1* inputHisto = GetRawsData(AliMUONQAIndices::kTriggerGlobalScalers);
- TH1* scaledHisto = GetRawsData(AliMUONQAIndices::kTriggerGlobalScalersNorm);
+ if ( GetRawsData(AliMUONQAIndices::kTriggerGlobalScalersNorm,itc) ) {
+ TH1* inputHisto = GetRawsData(AliMUONQAIndices::kTriggerGlobalScalers,itc);
+ TH1* scaledHisto = GetRawsData(AliMUONQAIndices::kTriggerGlobalScalersNorm,itc);
scaledHisto->Reset();
scaledHisto->Add(inputHisto);
- Float_t scaleValue = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime))->GetBinContent(1);
+ Float_t scaleValue = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime,itc))->GetBinContent(1);
if ( scaleValue > 0. ) scaledHisto->Scale(1./scaleValue);
}
void AliMUONTriggerQADataMakerRec::InitRaws()
{
/// create Raws histograms in Raws subdir
-
+
+ // RS: Since there is no sense in cloning trigger scalers per trigger, I am (for the moment) forbidding their cloning
+
AliCodeTimerAuto("",0);
const Bool_t expert = kTRUE ;
histo1D->GetXaxis()->SetBinLabel(1, "One-bin histogram: bin is filled at each scaler event.");
histo1D->GetYaxis()->SetTitle("Cumulated scaler time (s)");
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerScalersTime, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
for(Int_t iCath=0; iCath<AliMpConstants::NofCathodes(); iCath++){
TString cathName = ( iCath==0 ) ? "BendPlane" : "NonBendPlane";
histo2D->GetYaxis()->SetTitle("Strip");
histo2D->SetOption("COLZ");
Add2RawsList(histo2D, AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
+ ForbidCloning(histo2D); // RS
} // loop on chambers
} // loop on cathodes
iCath, iChamber, histoTitle);
histo2D->SetOption("COLZ");
Add2RawsList(histo2D, AliMUONQAIndices::kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, expert, !image, !saveCorr);
+ ForbidCloning(histo2D); // RS
} // loop on chambers
} // loop on cathodes
histoCalibNorm->GetYaxis()->SetTitle("Percentage per event (%)");
// Adding both histos after cloning to avoid problems with the expert bit
Add2RawsList(histoCalib, AliMUONQAIndices::kTriggerCalibSummary, expert, !image, !saveCorr);
+ ForbidCloning(histoCalib); // RS
+
Add2RawsList(histoCalibNorm, AliMUONQAIndices::kTriggerCalibSummaryNorm, !expert, image, !saveCorr);
+ ForbidCloning(histoCalibNorm); // RS
+
} // Calibration reco param
const char *globalXaxisName[6] = {"US HPt", "US LPt", "LS HPt", "LS LPt", "SGL HPt", "SGL LPt"};
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalXPos, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
+
histo1D = new TH1F("hTriggerErrorLocalYPos", "ErrorLocalYPos",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalYPos, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalDev", "ErrorLocalDev",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalDev, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalTriggerDec", "ErrorLocalTriggerDec",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalTriggerDec, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalLPtLSB", "ErrorLocalLPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalLPtLSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalLPtMSB", "ErrorLocalLPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalLPtMSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalHPtLSB", "ErrorLocalHPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalHPtLSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalHPtMSB", "ErrorLocalHPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalHPtMSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocalTrigY", "ErrorLocalTrigY",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocalTrigY, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
if ( GetRecoParam()->GetEventSpecie() != AliRecoParam::kCalib ) {
histo1D = new TH1F("hTriggerRatio4434Local", "Ratio4434Local",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle("ratio 44/34");
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerLocalRatio4434, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerRatio4434AllEvents", "Ratio4434AllEvents",1,0,1);
histo1D->GetXaxis()->SetTitle("Event number");
histo1D->GetYaxis()->SetTitle("ratio 44/34");
histo1D->SetLineColor(4);
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerRatio4434AllEvents, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerRatio4434SinceLastUpdate", "Ratio4434SinceLastUpdate",1,0,1);
histo1D->GetXaxis()->SetTitle("Event number");
histo1D->GetYaxis()->SetTitle("ratio 44/34");
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
}
histo1D = new TH1F("hTriggerErrorLocal2RegionalLPtLSB", "ErrorLocal2RegionalLPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalLPtLSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocal2RegionalLPtMSB", "ErrorLocal2RegionalLPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalLPtMSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocal2RegionalHPtLSB", "ErrorLocal2RegionalHPtLSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalHPtLSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorLocal2RegionalHPtMSB", "ErrorLocal2RegionalHPtMSB",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorLocal2RegionalHPtMSB, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorOutGlobalFromInGlobal", "ErrorOutGlobalFromInGlobal",6,-0.5,6-0.5);
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
histo1D->GetXaxis()->SetBinLabel(ibin+1,globalXaxisName[ibin]);
}
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorOutGlobalFromInGlobal, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerErrorOutGlobalFromInLocal", "ErrorOutGlobalFromInLocal",6,-0.5,6-0.5);
histo1D->GetYaxis()->SetTitle(errorAxisTitle.Data());
histo1D->GetXaxis()->SetBinLabel(ibin+1,globalXaxisName[ibin]);
}
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerErrorOutGlobalFromInLocal, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
TH1F* histoAlgoErr = new TH1F("hTriggerAlgoNumOfErrors", "Trigger Algorithm total errors",AliMUONQAIndices::kNtrigAlgoErrorBins,-0.5,(Float_t)AliMUONQAIndices::kNtrigAlgoErrorBins-0.5);
histoAlgoErr->GetYaxis()->SetTitle("Number of events with errors");
histoAlgoErrNorm->GetYaxis()->SetTitle("% of events with errors");
// Adding both histos after cloning to avoid problems with the expert bit
Add2RawsList(histoAlgoErr, AliMUONQAIndices::kTriggerErrorSummary, expert, !image, !saveCorr);
+ ForbidCloning(histoAlgoErr); // RS
Add2RawsList(histoAlgoErrNorm, AliMUONQAIndices::kTriggerErrorSummaryNorm, !expert, image, !saveCorr);
+ ForbidCloning(histoAlgoErrNorm); // RS
histo1D = new TH1F("hTriggerTriggeredBoards", "Triggered boards", nbLocalBoard, 0.5, (Float_t)nbLocalBoard + 0.5);
Add2RawsList(histo1D, AliMUONQAIndices::kTriggeredBoards, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo2D = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hTriggerFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards,
0, 0, "Local board triggers / event");
histo2D->SetOption("COLZ");
Add2RawsList(histo2D, AliMUONQAIndices::kTriggerBoardsDisplay, expert, !image, !saveCorr);
+ ForbidCloning(histo2D); // RS
TH1F* histoYCopyErr = new TH1F("hTriggerErrorLocalYCopy", "Number of YCopy errors",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histoYCopyErr->GetXaxis()->SetTitle(boardName.Data());
histoYCopyErrNorm->SetTitle("% of YCopy errors");
// Adding both histos after cloning to avoid problems with the expert bit
Add2RawsList(histoYCopyErr, AliMUONQAIndices::kTriggerErrorLocalYCopy, expert, !image, !saveCorr);
+ ForbidCloning(histoYCopyErr); // RS
Add2RawsList(histoYCopyErrTest, AliMUONQAIndices::kTriggerErrorLocalYCopyTest, expert, !image, !saveCorr);
+ ForbidCloning(histoYCopyErrTest); // RS
Add2RawsList(histoYCopyErrNorm, AliMUONQAIndices::kTriggerErrorLocalYCopyNorm, expert, !image, !saveCorr);
+ ForbidCloning(histoYCopyErrNorm); // RS
TH1F* histoROerr = new TH1F("hTriggerReadoutNumOfErrors","Trigger Read-Out total errors", AliMUONQAIndices::kNtrigStructErrorBins, -0.5, (Float_t)AliMUONQAIndices::kNtrigStructErrorBins-0.5);
histoROerr->GetYaxis()->SetTitle("Fraction of errors");
histoROerrNorm->GetYaxis()->SetTitle("% of errors per event");
// Adding both histos after cloning to avoid problems with the expert bit
Add2RawsList(histoROerr, AliMUONQAIndices::kTriggerReadOutErrors, expert, !image, !saveCorr);
+ ForbidCloning(histoROerr); // RS
Add2RawsList(histoROerrNorm, AliMUONQAIndices::kTriggerReadOutErrorsNorm, !expert, image, !saveCorr);
+ ForbidCloning(histoROerrNorm); // RS
TH1F* histoGlobalMult = new TH1F("hTriggerGlobalOutMultiplicity","Trigger global outputs multiplicity", 6, -0.5, 6.-0.5);
histoGlobalMult->GetYaxis()->SetTitle("Number of triggers");
histoGlobalMultNorm->GetYaxis()->SetTitle("Triggers per event");
// Adding both histos after cloning to avoid problems with the expert bit
Add2RawsList(histoGlobalMult, AliMUONQAIndices::kTriggerGlobalOutput, expert, !image, !saveCorr);
+ ForbidCloning(histoGlobalMult); // RS
Add2RawsList(histoGlobalMultNorm, AliMUONQAIndices::kTriggerGlobalOutputNorm, expert, !image, !saveCorr);
+ ForbidCloning(histoGlobalMultNorm); // RS
histo1D = new TH1F("hTriggerRawNAnalyzedEvents", "Number of analyzed events per specie", 1, 0.5, 1.5);
Int_t esindex = AliRecoParam::AConvert(CurrentEventSpecie());
histo1D->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
histo1D->GetYaxis()->SetTitle("Number of analyzed events");
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerRawNAnalyzedEvents, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
if ( GetRecoParam()->GetEventSpecie() != AliRecoParam::kCalib ) {
histo1D = new TH1F("hTriggerNumberOf34Dec", "Number of 3/4",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle("Number of 3/4");
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerNumberOf34Dec, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
histo1D = new TH1F("hTriggerNumberOf44Dec", "Number of 4/4",nbLocalBoard,0.5,(Float_t)nbLocalBoard+0.5);
histo1D->GetXaxis()->SetTitle(boardName.Data());
histo1D->GetYaxis()->SetTitle("Number of 4/4");
Add2RawsList(histo1D, AliMUONQAIndices::kTriggerNumberOf44Dec, expert, !image, !saveCorr);
+ ForbidCloning(histo1D); // RS
}
- Add2RawsList(new TH1F("hTriggerIsThere","trigger is there",1,0,1),AliMUONQAIndices::kTriggerIsThere,kTRUE,kFALSE,kFALSE);
+ histo1D = new TH1F("hTriggerIsThere","trigger is there",1,0,1);
+ Add2RawsList(histo1D,AliMUONQAIndices::kTriggerIsThere,kTRUE,kFALSE,kFALSE);
+ ForbidCloning(histo1D); // RS
if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) {
TH1F* histoGlobalScalers = new TH1F("hTriggerGlobalScalers","Trigger global scalers", 6, -0.5, 6.-0.5);
histoGlobalScalersNorm->GetYaxis()->SetTitle("L0 scalers rate (Hz)");
// Adding both histos after cloning to avoid problems with the expert bit
Add2RawsList(histoGlobalScalers, AliMUONQAIndices::kTriggerGlobalScalers, expert, !image, !saveCorr);
+ ForbidCloning(histoGlobalScalers); // RS
Add2RawsList(histoGlobalScalersNorm, AliMUONQAIndices::kTriggerGlobalScalersNorm, expert, !image, !saveCorr);
+ ForbidCloning(histoGlobalScalersNorm); // RS
}
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // RS: this should be the last line
+ //
}
//__________________________________________________________________
TH1I* h0 = new TH1I("hTriggerDigitsDetElem", "Detection element distribution in Digits;Detection element Id;Counts", 400, 1100, 1500);
Add2DigitsList(h0, 0, !expert, image);
+ ForbidCloning(h0);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
+ //
}
//____________________________________________________________________________
histo1D->GetXaxis()->SetBinLabel(1, AliRecoParam::GetEventSpecieName(esindex));
histo1D->GetYaxis()->SetTitle("Number of analyzed events");
Add2RecPointsList(histo1D, AliMUONQAIndices::kTriggerNAnalyzedEvents, expert, !image);
+ ForbidCloning(histo1D);
histo1D = new TH1F("hTriggerTrippedChambers", "Trigger RPCs in trip", 418, 1100-0.5, 1417+0.5);
histo1D->GetXaxis()->SetTitle("DetElemId");
histo1D->SetFillColor(kRed);
histo1D->SetLineColor(kRed);
Add2RecPointsList(histo1D, AliMUONQAIndices::kTriggerRPCtrips, !expert, image);
-
- FillTriggerDCSHistos();
+ ForbidCloning(histo1D); // RS this histo is not cloned
+ //
+ FillTriggerDCSHistos();
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS);
+ //
}
AliCodeTimerAuto("",0);
// Init Local/Regional/Global decision with fake values
+ //
+
+ //
UInt_t globalInput[4];
for (Int_t bit=0; bit<4; bit++){
Bool_t containTriggerData = kFALSE;
AliMUONRawStreamTriggerHP rawStreamTrig(rawReader);
while (rawStreamTrig.NextDDL())
- {
- containTriggerData = kTRUE;
+ {
+ containTriggerData = kTRUE;
Bool_t scalerEvent = rawReader->GetDataHeader()->GetL1TriggerMessage() & 0x1;
if ( fillScalerHistos ) {
UInt_t nOfClocks = darcHeader->GetGlobalClock();
Double_t nOfSeconds = ((Double_t) nOfClocks) / 40e6; // 1 clock each 25 ns
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime))->Fill(1., nOfSeconds);
+ FillRawsData(AliMUONQAIndices::kTriggerScalersTime, 1., nOfSeconds);
const UInt_t* globScaler = darcHeader->GetGlobalScaler();
Int_t bitCorr[6] = {2,0,3,1,4,5};
for (Int_t bit=0; bit<6; bit++){
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerGlobalScalers))->Fill(bitCorr[bit],(double)(*(globScaler+bit)));
+ FillRawsData(AliMUONQAIndices::kTriggerGlobalScalers, bitCorr[bit],(double)(*(globScaler+bit)));
}
}
nDeadGlobal++;
}
else
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerGlobalOutput))->Fill(bit, resp[bit]);
+ FillRawsData(AliMUONQAIndices::kTriggerGlobalOutput, bit, resp[bit]);
} // loop on bits
//for (Int_t Bit=0; Bit<32; Bit++){
//Get local in/outputs
if (Int_t(localStruct->GetDec())!=0){
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggeredBoards))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggeredBoards,loCircuit);
}
else if ( fillScalerHistos ){
nDeadLocal++;
// if ((pattern >> ibitxy) & 0x1) nFiredStrips++;
if ( scalerVal[ich] > 0 ) {
- ((TH2F*)GetRawsData(AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + ich))
- ->Fill(loCircuit, istrip, 2*(Float_t)scalerVal[ich]);
+ FillRawsData(AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*cathode + ich,
+ loCircuit, istrip, 2*(Float_t)scalerVal[ich]);
nFiredStrips++;
}
for (Int_t ibin=0; ibin<AliMUONQAIndices::kNtrigStructErrorBins; ibin++){
if ( readoutErrors[ibin] > 0 )
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerReadOutErrors))->Fill(ibin, readoutErrors[ibin]);
+ FillRawsData(AliMUONQAIndices::kTriggerReadOutErrors, ibin, readoutErrors[ibin]);
}
} // NextDDL
if ( ! containTriggerData ) return;
- GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents)->Fill(1.);
+ FillRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents,1.);
nDeadLocal += AliMUONConstants::NTriggerCircuit() - countNotifiedBoards;
if ( nStripsTot > 0 ) { // The value is != 0 only for scaler events
for(Int_t ibin = 0; ibin < AliMUONQAIndices::kNtrigCalibSummaryBins; ibin++){
if ( fraction[ibin] > 0. )
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerCalibSummary))->Fill(ibin, fraction[ibin]);
+ FillRawsData(AliMUONQAIndices::kTriggerCalibSummary,ibin, fraction[ibin]);
}
}
// Global, reconstruction from Local inputs: compare data and reconstructed decisions and fill histos
RawTriggerMatchOutGlobal(inputGlobalTrigger, *recoGlobalTriggerFromLocal, 'L');
// Global, reconstruction from Global inputs: compare data and reconstructed decisions and fill histos
+ //
}
//__________________________________________________________________
// Do nothing in case of calibration event
if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
-
+
if (!fDigitStore)
fDigitStore = AliMUONVDigitStore::Create(*digitsTree);
-
+
fDigitStore->Clear();
fDigitStore->Connect(*digitsTree, false);
digitsTree->GetEvent(0);
while ( ( dig = static_cast<AliMUONVDigit*>(next()) ) )
{
- GetDigitsData(0)->Fill(dig->DetElemId());
+ FillDigitsData(0,dig->DetElemId());
}
}
// Do nothing in case of calibration event
if ( GetRecoParam()->GetEventSpecie() == AliRecoParam::kCalib ) return;
- GetRecPointsData(AliMUONQAIndices::kTriggerNAnalyzedEvents)->Fill(1.);
+ FillRecPointsData(AliMUONQAIndices::kTriggerNAnalyzedEvents,1.);
}
//____________________________________________________________________________
/// Display trigger information in a user-friendly way:
/// from local board and strip numbers to their position on chambers
//
+ // RS: Note: the histos involved in this routin are forbidden to be cloned, -1 in GetRawsData returns the default histos
+ int itc = -1;
AliMUONTriggerDisplay triggerDisplay;
- TH2F* histoStrips=0x0;
- TH2F* histoDisplayStrips=0x0;
- if ( GetRawsData(AliMUONQAIndices::kTriggerScalers) ) {
+ TH2* histoStrips=0x0;
+ TH2* histoDisplayStrips=0x0;
+ if ( GetRawsData(AliMUONQAIndices::kTriggerScalers, itc) ) {
AliMUONTriggerDisplay::EDisplayOption displayOption = AliMUONTriggerDisplay::kNormalizeToArea;
for (Int_t iCath = 0; iCath < AliMpConstants::NofCathodes(); iCath++)
{
for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++)
{
- histoStrips = (TH2F*)GetRawsData(AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
+ histoStrips = (TH2*)GetRawsData(AliMUONQAIndices::kTriggerScalers + AliMpConstants::NofTriggerChambers()*iCath + iChamber, itc);
if(histoStrips->GetEntries()==0) continue; // No events found => No need to display
- histoDisplayStrips = (TH2F*)GetRawsData(AliMUONQAIndices::kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber);
+ histoDisplayStrips = (TH2*)GetRawsData(AliMUONQAIndices::kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber, itc);
triggerDisplay.FillDisplayHistogram(histoStrips, histoDisplayStrips,
AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber, displayOption);
- Float_t scaleValue = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime))->GetBinContent(1);
+ Float_t scaleValue = ((TH1*)GetRawsData(AliMUONQAIndices::kTriggerScalersTime, itc))->GetBinContent(1);
if(scaleValue>0.) histoDisplayStrips->Scale(1./scaleValue);
} // iChamber
} // iCath
}
-
- if ( GetRawsData(AliMUONQAIndices::kTriggeredBoards) ){
- TH1F* histoBoards = (TH1F*)GetRawsData(AliMUONQAIndices::kTriggeredBoards);
- TH2F* histoDisplayBoards = (TH2F*)GetRawsData(AliMUONQAIndices::kTriggerBoardsDisplay);
+
+ if ( GetRawsData(AliMUONQAIndices::kTriggeredBoards, itc) ){
+ TH1* histoBoards = (TH1*)GetRawsData(AliMUONQAIndices::kTriggeredBoards, itc);
+ TH2* histoDisplayBoards = (TH2*)GetRawsData(AliMUONQAIndices::kTriggerBoardsDisplay, itc);
triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0);
- Float_t scaleValue = GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents)->GetBinContent(1);
+ Float_t scaleValue = GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents, itc)->GetBinContent(1);
if(scaleValue>0.) histoDisplayBoards->Scale(1./scaleValue);
}
}
AliMUONTriggerQADataMakerRec::FillTriggerDCSHistos()
{
/// Get HV and currents values for one trigger chamber
-
+ // RS: Note: the histos involved in this routin are forbidden to be cloned, -1 in GetRawsData returns the default histos
+ int itc = -1;
+ //
AliCodeTimerAuto("",0);
TMap* triggerDcsMap = CalibrationData()->TriggerDCS();
histoName = Form("hTriggerRPCHVChamber%i", 11+ich);
histoTitle = Form("Chamber %i: RPC HV (kV)", 11+ich);
- currHisto = (TH2F*)GetRecPointsData(histoIndex);
+ currHisto = (TH2F*)GetRecPointsData(histoIndex,itc); // RS this histo is not cloned
if(!currHisto){
currHisto = new TH2F(histoName.Data(), histoTitle.Data(),
currHisto->GetYaxis()->SetTitle("RPC");
currHisto->SetOption("TEXT45COLZ");
Add2RecPointsList(currHisto, histoIndex, expert, !image);
+ ForbidCloning(currHisto); // RS
}
Int_t slat = detElemId%100;
previousVal = currVal;
} // loop on values
currHisto->SetBinContent(previousBin, slatBin, scaleFactor*sumValuesPerBin/((Double_t)nValuesPerBin)); // Fill last value
- if ( isTrip ) ((TH1F*)GetRecPointsData(AliMUONQAIndices::kTriggerRPCtrips))->Fill(detElemId);
+ if ( isTrip ) ((TH1*)GetRecPointsData(AliMUONQAIndices::kTriggerRPCtrips,itc))->Fill(detElemId);
} // if ( values )
deIt.Next();
} // loop on detElem
{
//
/// Match data and reconstructed Local Trigger decision
- //
AliCodeTimerAuto("",0);
loCircuit = recoLocalTrigger->LoCircuit();
Int_t iboard = loCircuit - 1;
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyTest))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopyTest,loCircuit);
inputLocalTrigger = inputTriggerStore.FindLocal(loCircuit);
}
} // loop on chambers
if ( errorInCopyBoard )
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopy))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalYCopy,loCircuit);
} // loop on local boards
if (errorInYCopy)
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalYCopy);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorSummary,AliMUONQAIndices::kAlgoLocalYCopy);
Bool_t errorInXPosDev = kFALSE;
Bool_t errorInYPosTrigY = kFALSE;
if ( GetRecoParam()->GetEventSpecie() != AliRecoParam::kCalib ) {
Bool_t is34 = ( recoLocalTrigger->GetLoDecision() != 0 );
Bool_t is44 = TriggerElectronics()->ModifiedLocalResponse(loCircuit, respBendPlane, respNonBendPlane, kTRUE);
- if ( is34 ) ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf34Dec))->Fill(loCircuit);
- if ( is44 ) ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf44Dec))->Fill(loCircuit);
+ if ( is34 ) FillRawsData(AliMUONQAIndices::kTriggerNumberOf34Dec,loCircuit);
+ if ( is44 ) FillRawsData(AliMUONQAIndices::kTriggerNumberOf44Dec,loCircuit);
if ( is44 && ! is34 )
AliWarning("Event satisfies the 4/4 conditions but not the 3/4");
inputLocalTrigger = inputTriggerStore.FindLocal(loCircuit);
if ( recoLocalTrigger->LoStripX() != inputLocalTrigger->LoStripX() ) {
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalXPos))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalXPos,loCircuit);
errorInXPosDev = kTRUE;
}
-
+
if ( recoLocalTrigger->GetDeviation() != inputLocalTrigger->GetDeviation() ) {
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalDev))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalDev,loCircuit);
errorInXPosDev = kTRUE;
}
if ( (!skipBoard[iboard]) || ( (recoLocalTrigger->LoStripY() == inputLocalTrigger->LoStripY()) && (recoLocalTrigger->LoTrigY() == inputLocalTrigger->LoTrigY())) ) {
if ( recoLocalTrigger->GetLoDecision() != inputLocalTrigger->GetLoDecision() ) {
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalTriggerDec))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalTriggerDec,loCircuit);
}
// Test Hpt and LPT
for (Int_t ibit=0; ibit<2; ibit++){
Bool_t isBitDifferent = (bitDiff>>ibit)&1;
if ( isBitDifferent ){
- ((TH1F*)GetRawsData(currIndex[ilut][ibit]))->Fill(loCircuit);
- errorInLUT = kTRUE;
+ FillRawsData(currIndex[ilut][ibit],loCircuit);
+ errorInLUT = kTRUE;
}
}
}
if ( skipBoard[iboard] ) continue;
if ( recoLocalTrigger->LoStripY() != inputLocalTrigger->LoStripY() ) {
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalYPos))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalYPos,loCircuit);
errorInYPosTrigY = kTRUE;
}
if ( recoLocalTrigger->LoTrigY() != inputLocalTrigger->LoTrigY() ) {
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorLocalTrigY))->Fill(loCircuit);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorLocalTrigY,loCircuit);
errorInYPosTrigY = kTRUE;
}
} // loop on local boards
-
+
if (errorInXPosDev)
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalX);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorSummary,AliMUONQAIndices::kAlgoLocalX);
if (errorInLUT)
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalLUT);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorSummary,AliMUONQAIndices::kAlgoLocalLUT);
if (errorInYPosTrigY)
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(AliMUONQAIndices::kAlgoLocalY);
+ FillRawsData(AliMUONQAIndices::kTriggerErrorSummary,AliMUONQAIndices::kAlgoLocalY);
}
/*
}
}
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerErrorSummary))->Fill(binToFill);
-
+ FillRawsData(AliMUONQAIndices::kTriggerErrorSummary,binToFill);
+
Int_t inputResp[6] = {inputGlobalTrigger.PairUnlikeHpt(), inputGlobalTrigger.PairUnlikeLpt(),
- inputGlobalTrigger.PairLikeHpt(), inputGlobalTrigger.PairLikeLpt(),
- inputGlobalTrigger.SingleHpt(), inputGlobalTrigger.SingleLpt()};
-
+ inputGlobalTrigger.PairLikeHpt(), inputGlobalTrigger.PairLikeLpt(),
+ inputGlobalTrigger.SingleHpt(), inputGlobalTrigger.SingleLpt()};
+
Int_t recoResp[6] = {recoGlobalTrigger.PairUnlikeHpt(), recoGlobalTrigger.PairUnlikeLpt(),
- recoGlobalTrigger.PairLikeHpt(), recoGlobalTrigger.PairLikeLpt(),
- recoGlobalTrigger.SingleHpt(), recoGlobalTrigger.SingleLpt()};
-
+ recoGlobalTrigger.PairLikeHpt(), recoGlobalTrigger.PairLikeLpt(),
+ recoGlobalTrigger.SingleHpt(), recoGlobalTrigger.SingleLpt()};
+
for (int bit=0;bit<6;bit++){
if ( recoResp[bit] != inputResp[bit] )
- ((TH1F*)GetRawsData(histoToFill))->Fill(bit);
+ FillRawsData(histoToFill,bit);
}
}
void AliMUONTriggerQADataMakerRec::FillRatio4434Histos(Int_t evtInterval)
{
/// Fill ratio 44/34 histos
-
- Int_t numEvent = Int_t(((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents))->GetBinContent(1));
+ int itc = -1; // RS: For the moment assume that only default histo is booked (no cloning)
+ Int_t numEvent = Int_t(((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRawNAnalyzedEvents,itc))->GetBinContent(1));
// Fill every fgkUpdateRatio4434 events
if (numEvent % evtInterval != 0)
return;
- Float_t totalNumberOf44 = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf44Dec))->GetSumOfWeights();
- Float_t totalNumberOf34 = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf34Dec))->GetSumOfWeights();
+ Float_t totalNumberOf44 = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf44Dec,itc))->GetSumOfWeights();
+ Float_t totalNumberOf34 = ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerNumberOf34Dec,itc))->GetSumOfWeights();
if ( totalNumberOf34 == 0 )
return;
- TH1F* histoAllEvents = (TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents);
+ TH1F* histoAllEvents = (TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434AllEvents,itc);
if ( ! histoAllEvents ) return;
Int_t nbins = histoAllEvents->GetNbinsX();
Float_t maxBin = histoAllEvents->GetXaxis()->GetBinLowEdge(nbins+1);
Int_t hIndex[2] = {AliMUONQAIndices::kTriggerRatio4434AllEvents, AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate};
for (Int_t ihisto=0; ihisto<2; ihisto++){
- TH1F* currHisto = (TH1F*)GetRawsData(hIndex[ihisto]);
+ TH1F* currHisto = (TH1F*)GetRawsData(hIndex[ihisto],itc);
cloneName = Form("%sClone", currHisto->GetName());
TArrayD newAxis(newNbins+1);
for (Int_t ibin=0; ibin<newNbins; ibin++){
errorRatio4434Update = ProtectedSqrt(numOf44Update*(1-ratio4434Update))/numOf34Update;
}
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate))->SetBinContent(newNbins,ratio4434Update);
- ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate))->SetBinError(newNbins,errorRatio4434Update);
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate,itc))->SetBinContent(newNbins,ratio4434Update);
+ ((TH1F*)GetRawsData(AliMUONQAIndices::kTriggerRatio4434SinceLastUpdate,itc))->SetBinError(newNbins,errorRatio4434Update);
histoAllEvents->SetBinContent(0,totalNumberOf34);
histoAllEvents->SetBinContent(newNbins+1,totalNumberOf44);
ClassImp(AliMUONVQADataMakerRec)
/// \endcond
-#include "AliQADataMakerRec.h"
#include "AliMUONRecoParam.h"
#include "AliCDBManager.h"
#include "TH1.h"
return fMaster ? fMaster->Add2RawsList(hist,index,expert,image,saveForCorr) : -1;
}
+//_____________________________________________________________________________
+void AliMUONVQADataMakerRec::ClonePerTrigClass(AliQAv1::TASKINDEX_t task)
+{
+ // RS: alias to QADataMaker per-trigger-class histo clonning
+ if (!fMaster) return;
+ fMaster->ClonePerTrigClass(task);
+}
+
+
//_____________________________________________________________________________
AliRecoParam::EventSpecie_t
AliMUONVQADataMakerRec::CurrentEventSpecie() const
return fMaster ? dynamic_cast<const AliMUONRecoParam*>(fMaster->GetRecoParam()) : 0x0;
}
-//_____________________________________________________________________________
-TH1*
-AliMUONVQADataMakerRec::GetDigitsData(Int_t index) const
-{
- /// fwd
- return fMaster ? fMaster->GetDigitsData(index) : 0x0;
-}
-
-//_____________________________________________________________________________
-TH1*
-AliMUONVQADataMakerRec::GetESDsData(Int_t index) const
-{
- /// fwd
- return fMaster ? fMaster->GetESDsData(index) : 0x0;
-}
-
-//_____________________________________________________________________________
-TH1*
-AliMUONVQADataMakerRec::GetRecPointsData(Int_t index) const
-{
- /// fwd
- return fMaster ? fMaster->GetRecPointsData(index) : 0x0;
-}
-
-//_____________________________________________________________________________
-TH1*
-AliMUONVQADataMakerRec::GetRawsData(Int_t index) const
-{
- /// fwd
- return fMaster ? fMaster->GetRawsData(index) : 0x0;
-}
-
//_____________________________________________________________________________
void
AliMUONVQADataMakerRec::ResetDetector(const TObjArray* list)
TObject* o;
while ( (o = next()) )
{
+ // RS: Check if this is a histo or array of histos
+ TString hcn(o->GetName());
+ if ( !hcn.Contains(pattern) ) continue;
+ if ( !o->TestBit(AliQAv1::GetClonedBit()) ) { // not cloned, this is orig. histo
+ ((TH1*)o)->Reset();
+ continue;
+ }
+ // histo was cloned, so we are dealing with TObjArray
+ TIter nextCl( (TObjArray*)o );
+ TH1* hclone = 0;
+ while ( (hclone = (TH1*) next()) ) hclone->Reset();
+ /*
+ // RS: I did not understand this code: the hcn will be "TH.." and not the histo name
+ // Should not one use h->GetName() ?
TH1* h = dynamic_cast<TH1*>(o);
if ( h )
{
- TString hcn(h->ClassName());
+ TString hcn(h->ClassName());
if ( hcn.Contains(pattern) )
{
h->Reset();
}
}
+ */
}
}
# include "AliQAv1.h"
#endif
+#include "AliQADataMakerRec.h"
+
class AliESDEvent;
-class AliQADataMakerRec;
class AliMUONRecoParam;
class AliRawReader;
class TH1;
virtual void ResetDetectorESDs(TObjArray* list) { ResetDetector(list); }
/// Reset anything that must be reset for Digits
virtual void ResetDetectorDigits(TObjArray* list) { ResetDetector(list); }
-
+ ///
+ void ForbidCloning(TH1* h, Bool_t v=kTRUE) { if (fMaster) fMaster->ForbidCloning(h,v); }
+ ///
protected:
void ResetDetector(const TObjArray* list);
const AliMUONRecoParam* GetRecoParam() const;
- TH1* GetDigitsData(Int_t index) const;
- TH1* GetESDsData(Int_t index) const;
- TH1* GetRecPointsData(Int_t index) const;
- TH1* GetRawsData(Int_t index) const;
-
+ TObject* GetDigitsData(Int_t index) const {return fMaster ? fMaster->GetDigitsData(index) : 0x0;}
+ TObject* GetESDsData(Int_t index) const {return fMaster ? fMaster->GetESDsData(index) : 0x0;}
+ TObject* GetRecPointsData(Int_t index) const {return fMaster ? fMaster->GetRecPointsData(index) : 0x0;}
+ TObject* GetRawsData(Int_t index) const {return fMaster ? fMaster->GetRawsData(index) : 0x0;}
+
+ TH1* GetDigitsData(Int_t index, int trCl) const {return fMaster ? fMaster->GetDigitsData(index, trCl) : 0x0;}
+ TH1* GetESDsData(Int_t index, int trCl) const {return fMaster ? fMaster->GetESDsData(index, trCl) : 0x0;}
+ TH1* GetRecPointsData(Int_t index, int trCl) const {return fMaster ? fMaster->GetRecPointsData(index, trCl) : 0x0;}
+ TH1* GetRawsData(Int_t index, int trCl) const {return fMaster ? fMaster->GetRawsData(index,trCl) : 0x0;}
+
Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE);
Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE);
Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE);
Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE);
-
+ //
+ Int_t FillDigitsData(Int_t index, double x) {return fMaster ? fMaster->FillDigitsData(index,x) : 0;}
+ Int_t FillRawsData(Int_t index, double x) {return fMaster ? fMaster->FillRawsData(index,x) : 0;}
+ Int_t FillRecPointsData(Int_t index, double x) {return fMaster ? fMaster->FillRecPointsData(index,x) : 0;}
+ Int_t FillESDsData(Int_t index, double x) {return fMaster ? fMaster->FillESDsData(index,x) : 0;}
+ //
+ Int_t FillDigitsData(Int_t index, double x, double y) {return fMaster ? fMaster->FillDigitsData(index,x,y) : 0;}
+ Int_t FillRawsData(Int_t index, double x, double y) {return fMaster ? fMaster->FillRawsData(index,x,y) : 0;}
+ Int_t FillRecPointsData(Int_t index, double x, double y) {return fMaster ? fMaster->FillRecPointsData(index,x,y) : 0;}
+ Int_t FillESDsData(Int_t index, double x, double y) {return fMaster ? fMaster->FillESDsData(index,x,y) : 0;}
+ //
+ Int_t FillDigitsData(Int_t index, double x, double y, double w) {return fMaster ? fMaster->FillDigitsData(index,x,y,w) : 0;}
+ Int_t FillRawsData(Int_t index, double x, double y, double w) {return fMaster ? fMaster->FillRawsData(index,x,y,w) : 0;}
+ Int_t FillRecPointsData(Int_t index, double x, double y, double w) {return fMaster ? fMaster->FillRecPointsData(index,x,y,w) : 0;}
+ Int_t FillESDsData(Int_t index, double x, double y, double w) {return fMaster ? fMaster->FillESDsData(index,x,y,w) : 0;}
+ //
+ void ClonePerTrigClass(AliQAv1::TASKINDEX_t task);
+
AliQADataMakerRec* fMaster; ///< master to get access to its methods
private:
#include "AliESDEvent.h"
#include "AliLog.h"
#include "AliPHOSQADataMakerRec.h"
-#include "AliPHOSDigit.h"
+#include "AliPHOSDigit.h"
#include "AliPHOSCpvRecPoint.h"
#include "AliPHOSEmcRecPoint.h"
#include "AliPHOSRawFitterv0.h"
void AliPHOSQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
+ ResetEventTrigClasses();
+
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! IsValidEventSpecie(specie, list))
- continue ;
- SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
- if(GetRawsData(kHGqualMod0) && GetRawsData(kHGmod0))
- GetRawsData(kHGqualMod0)->Divide( GetRawsData(kHGmod0) ) ;
- 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 (! IsValidEventSpecie(specie, list)) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over all trigger clones
+ //
+ if(GetRawsData(kHGqualMod0,itc) && GetRawsData(kHGmod0,itc))
+ GetRawsData(kHGqualMod0,itc)->Divide( GetRawsData(kHGmod0,itc) );
+ if(GetRawsData(kHGqualMod1,itc) && GetRawsData(kHGmod1,itc))
+ GetRawsData(kHGqualMod1,itc)->Divide( GetRawsData(kHGmod1,itc) );
+ if(GetRawsData(kHGqualMod2,itc) && GetRawsData(kHGmod2,itc))
+ GetRawsData(kHGqualMod2,itc)->Divide( GetRawsData(kHGmod2,itc) );
+ if(GetRawsData(kHGqualMod3,itc) && GetRawsData(kHGmod3,itc))
+ GetRawsData(kHGqualMod3,itc)->Divide( GetRawsData(kHGmod3,itc) );
+ if(GetRawsData(kHGqualMod4,itc) && GetRawsData(kHGmod4,itc))
+ GetRawsData(kHGqualMod4,itc)->Divide( GetRawsData(kHGmod4,itc) );
+ } // RS: loop over all trigger clones
}
// do the QA checking
AliQAChecker::Instance()->Run(AliQAv1::kPHOS, task, list) ;
TH1F * h4 = new TH1F("hESDpid", "ESDs PID distribution in PHOS;Particle Id;Counts" , 100, 0., 1.) ;
h4->Sumw2() ;
Add2ESDsList(h4, kESDpid, !expert, image) ; //Expert histo
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS;# of Digits;Entries", 2000, 0, 10000) ;
h1->Sumw2() ;
Add2DigitsList(h1, kDigitsMul, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h8 = new TH1I("hCpvPhosRecPointsMul", "CPV RecPoints multiplicity distribution in PHOS;# of CPV clusters;Counts", 100, 0, 100) ;
h8->Sumw2() ;
Add2RecPointsList(h8, kRPNcpv, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
TH2F * h41 = new TH2F("hpedRMSLGxyMod4","Low Gain pedestal RMS in module 4", 64, 0, 64, 56, 0, 56) ;
h41->SetXTitle("x, cells"); h41->SetYTitle("z, cells");
Add2RawsList(h41,kLGpedRMSMod4, expert, !image, !saveCorr) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
void AliPHOSQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
- // make QA data from ESDs
-
+ // make QA data from ESDs
Int_t nTot = 0 ;
Double_t eTot = 0 ;
for ( Int_t index = 0; index < esd->GetNumberOfCaloClusters() ; index++ ) {
AliESDCaloCluster * clu = esd->GetCaloCluster(index) ;
if( clu->IsPHOS() ) {
- GetESDsData(kESDSpec)->Fill(clu->E()) ;
+ FillESDsData(kESDSpec,clu->E()) ;
const Double_t * pid = clu->GetPID() ;
- GetESDsData(kESDpid)->Fill(pid[AliPID::kPhoton]) ;
+ FillESDsData(kESDpid,pid[AliPID::kPhoton]) ;
eTot+=clu->E() ;
nTot++ ;
}
}
- GetESDsData(kESDNtot)->Fill(nTot) ;
- GetESDsData(kESDEtot)->Fill(eTot) ;
+ FillESDsData(kESDNtot,nTot) ;
+ FillESDsData(kESDEtot,eTot) ;
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
Double_t time = fitter->GetTime() ;
if (caloFlag == 0) { // LG
- GetRawsData(kLGpedRMS)->Fill(fitter->GetPedestalRMS()) ;
+ FillRawsData(kLGpedRMS,fitter->GetPedestalRMS()) ;
switch(module){
- case 0: GetRawsData(kLGmod0)->Fill(cellX,cellZ) ; break ;
- case 1: GetRawsData(kLGmod1)->Fill(cellX,cellZ) ; break ;
- case 2: GetRawsData(kLGmod2)->Fill(cellX,cellZ) ; break ;
- case 3: GetRawsData(kLGmod3)->Fill(cellX,cellZ) ; break ;
- case 4: GetRawsData(kLGmod4)->Fill(cellX,cellZ) ; break ;
+ case 0: FillRawsData(kLGmod0,cellX,cellZ) ; break ;
+ case 1: FillRawsData(kLGmod1,cellX,cellZ) ; break ;
+ case 2: FillRawsData(kLGmod2,cellX,cellZ) ; break ;
+ case 3: FillRawsData(kLGmod3,cellX,cellZ) ; break ;
+ case 4: FillRawsData(kLGmod4,cellX,cellZ) ; break ;
}
switch (module){
- case 0: ((TH2F*)GetRawsData(kLGpedRMSMod0))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 1: ((TH2F*)GetRawsData(kLGpedRMSMod1))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 2: ((TH2F*)GetRawsData(kLGpedRMSMod2))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 3: ((TH2F*)GetRawsData(kLGpedRMSMod3))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 4: ((TH2F*)GetRawsData(kLGpedRMSMod4))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 0: FillRawsData(kLGpedRMSMod0,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 1: FillRawsData(kLGpedRMSMod1,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 2: FillRawsData(kLGpedRMSMod2,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 3: FillRawsData(kLGpedRMSMod3,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 4: FillRawsData(kLGpedRMSMod4,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
}
//if quality was evaluated, fill histo
if(strcmp(GetRecoParam()->EMCFitterVersion(),"v1")==0){
switch (module){
- case 0: ((TH2F*)GetRawsData(kLGqualMod0))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 1: ((TH2F*)GetRawsData(kLGqualMod1))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 2: ((TH2F*)GetRawsData(kLGqualMod2))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 3: ((TH2F*)GetRawsData(kLGqualMod3))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 4: ((TH2F*)GetRawsData(kLGqualMod4))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 0: FillRawsData(kLGqualMod0,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 1: FillRawsData(kLGqualMod1,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 2: FillRawsData(kLGqualMod2,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 3: FillRawsData(kLGqualMod3,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 4: FillRawsData(kLGqualMod4,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
}
}
- GetRawsData(kNmodLG)->Fill(module) ;
- GetRawsData(kLGtime)->Fill(time) ;
- GetRawsData(kSpecLG)->Fill(energy) ;
+ FillRawsData(kNmodLG,module) ;
+ FillRawsData(kLGtime,time) ;
+ FillRawsData(kSpecLG,energy) ;
lgEtot+=energy ;
lgNtot++ ;
}
else if (caloFlag == 1) { // HG
- GetRawsData(kHGpedRMS)->Fill(fitter->GetPedestalRMS()) ;
+ FillRawsData(kHGpedRMS,fitter->GetPedestalRMS()) ;
switch (module){
- case 0: GetRawsData(kHGmod0)->Fill(cellX,cellZ) ; break ;
- case 1: GetRawsData(kHGmod1)->Fill(cellX,cellZ) ; break ;
- case 2: GetRawsData(kHGmod2)->Fill(cellX,cellZ) ; break ;
- case 3: GetRawsData(kHGmod3)->Fill(cellX,cellZ) ; break ;
- case 4: GetRawsData(kHGmod4)->Fill(cellX,cellZ) ; break ;
+ case 0: FillRawsData(kHGmod0,cellX,cellZ) ; break ;
+ case 1: FillRawsData(kHGmod1,cellX,cellZ) ; break ;
+ case 2: FillRawsData(kHGmod2,cellX,cellZ) ; break ;
+ case 3: FillRawsData(kHGmod3,cellX,cellZ) ; break ;
+ case 4: FillRawsData(kHGmod4,cellX,cellZ) ; break ;
}
switch (module){
- case 0: ((TH2F*)GetRawsData(kHGpedRMSMod0))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 1: ((TH2F*)GetRawsData(kHGpedRMSMod1))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 2: ((TH2F*)GetRawsData(kHGpedRMSMod2))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 3: ((TH2F*)GetRawsData(kHGpedRMSMod3))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
- case 4: ((TH2F*)GetRawsData(kHGpedRMSMod4))->Fill(cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 0: FillRawsData(kHGpedRMSMod0,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 1: FillRawsData(kHGpedRMSMod1,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 2: FillRawsData(kHGpedRMSMod2,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 3: FillRawsData(kHGpedRMSMod3,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
+ case 4: FillRawsData(kHGpedRMSMod4,cellX,cellZ,fitter->GetPedestalRMS()) ; break ;
}
//if quality was evaluated, fill histo
if(strcmp(GetRecoParam()->EMCFitterVersion(),"v1")==0){
switch (module){
- case 0: ((TH2F*)GetRawsData(kHGqualMod0))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 1: ((TH2F*)GetRawsData(kHGqualMod1))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 2: ((TH2F*)GetRawsData(kHGqualMod2))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 3: ((TH2F*)GetRawsData(kHGqualMod3))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
- case 4: ((TH2F*)GetRawsData(kHGqualMod4))->Fill(cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 0: FillRawsData(kHGqualMod0,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 1: FillRawsData(kHGqualMod1,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 2: FillRawsData(kHGqualMod2,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 3: FillRawsData(kHGqualMod3,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
+ case 4: FillRawsData(kHGqualMod4,cellX,cellZ,fitter->GetSignalQuality()) ; break ;
}
}
- GetRawsData(kNmodHG)->Fill(module) ;
- GetRawsData(kHGtime)->Fill(time) ;
- GetRawsData(kSpecHG)->Fill(energy) ;
+ FillRawsData(kNmodHG,module) ;
+ FillRawsData(kHGtime,time) ;
+ FillRawsData(kSpecHG,energy) ;
hgEtot+=energy ;
hgNtot++ ;
}
} // End of NextDDL
delete fitter;
- GetRawsData(kEtotLG)->Fill(lgEtot) ;
+ FillRawsData(kEtotLG,lgEtot) ;
TParameter<double> * p;
p = dynamic_cast<TParameter<double>*>(GetParameterList()->
FindObject(Form("%s_%s_%s", GetName(),
AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(),
GetRawsData(kEtotLG)->GetName()))) ;
if (p) p->SetVal(lgEtot) ;
- GetRawsData(kEtotHG)->Fill(hgEtot) ;
+ FillRawsData(kEtotHG,hgEtot) ;
p = dynamic_cast<TParameter<double>*>(GetParameterList()->
FindObject(Form("%s_%s_%s", GetName(),
AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(),
GetRawsData(kEtotHG)->GetName()))) ;
if (p) p->SetVal(hgEtot) ;
- GetRawsData(kNtotLG)->Fill(lgNtot) ;
+ FillRawsData(kNtotLG,lgNtot) ;
p = dynamic_cast<TParameter<double>*>(GetParameterList()->
FindObject(Form("%s_%s_%s", GetName(),
AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(),
GetRawsData(kNtotLG)->GetName()))) ;
if (p) p->SetVal(lgNtot) ;
- GetRawsData(kNtotHG)->Fill(hgNtot) ;
+ FillRawsData(kNtotHG,hgNtot) ;
p = dynamic_cast<TParameter<double>*>(GetParameterList()->
FindObject(Form("%s_%s_%s",
GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(),
GetRawsData(kNtotHG)->GetName()))) ;
if (p) p->SetVal(hgNtot) ;
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
void AliPHOSQADataMakerRec::MakeDigits()
{
// makes data from Digits
-
- TH1 * hist = GetDigitsData(kDigitsMul) ;
- if ( ! hist )
- InitDigits() ;
- GetDigitsData(kDigitsMul)->Fill(fDigitsArray->GetEntriesFast()) ;
+
+ if ( ! GetDigitsData(kDigitsMul) ) InitDigits() ;
+ FillDigitsData(kDigitsMul,fDigitsArray->GetEntriesFast()) ;
TIter next(fDigitsArray) ;
AliPHOSDigit * digit ;
while ( (digit = dynamic_cast<AliPHOSDigit *>(next())) ) {
- GetDigitsData(kDigits)->Fill( digit->GetEnergy()) ;
+ FillDigitsData(kDigits, digit->GetEnergy()) ;
}
+ //
}
//____________________________________________________________________________
void AliPHOSQADataMakerRec::MakeDigits(TTree * digitTree)
{
- // makes data from Digit Tree
- if (fDigitsArray)
+ // makes data from Digit Tree
+ 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(&fDigitsArray) ;
- branch->GetEntry(0) ;
- MakeDigits() ;
- }
+ TBranch * branch = digitTree->GetBranch("PHOS") ;
+ if ( ! branch ) {AliWarning("PHOS branch in Digit Tree not found"); return;}
+ branch->SetAddress(&fDigitsArray) ;
+ branch->GetEntry(0) ;
+ MakeDigits() ;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
emcbranch->SetAddress(&emcrecpoints);
emcbranch->GetEntry(0);
- GetRecPointsData(kRPNtot)->Fill(emcrecpoints->GetEntriesFast()) ;
+ FillRecPointsData(kRPNtot,emcrecpoints->GetEntriesFast()) ;
TIter next(emcrecpoints) ;
AliPHOSEmcRecPoint * rp ;
Double_t eTot = 0. ;
while ( (rp = static_cast<AliPHOSEmcRecPoint *>(next())) ) {
- GetRecPointsData(kRPSpec)->Fill( rp->GetEnergy()) ;
+ FillRecPointsData(kRPSpec, rp->GetEnergy()) ;
Int_t mod = rp->GetPHOSMod() ;
TVector3 pos ;
rp->GetLocalPosition(pos) ;
switch(mod){
- case 1: GetRecPointsData(kRPmod1)->Fill(pos.X(),pos.Z()) ; break ;
- case 2: GetRecPointsData(kRPmod2)->Fill(pos.X(),pos.Z()) ; break ;
- case 3: GetRecPointsData(kRPmod3)->Fill(pos.X(),pos.Z()) ; break ;
- case 4: GetRecPointsData(kRPmod4)->Fill(pos.X(),pos.Z()) ; break ;
- case 5: GetRecPointsData(kRPmod5)->Fill(pos.X(),pos.Z()) ; break ;
+ case 1: FillRecPointsData(kRPmod1,pos.X(),pos.Z()) ; break ;
+ case 2: FillRecPointsData(kRPmod2,pos.X(),pos.Z()) ; break ;
+ case 3: FillRecPointsData(kRPmod3,pos.X(),pos.Z()) ; break ;
+ case 4: FillRecPointsData(kRPmod4,pos.X(),pos.Z()) ; break ;
+ case 5: FillRecPointsData(kRPmod5,pos.X(),pos.Z()) ; break ;
}
eTot+= rp->GetEnergy() ;
}
- GetRecPointsData(kRPEtot)->Fill(eTot) ;
+ FillRecPointsData(kRPEtot,eTot) ;
emcrecpoints->Delete();
delete emcrecpoints;
}
cpvbranch->SetAddress(&cpvrecpoints);
cpvbranch->GetEntry(0);
- GetRecPointsData(kRPNcpv)->Fill(cpvrecpoints->GetEntriesFast()) ;
+ FillRecPointsData(kRPNcpv,cpvrecpoints->GetEntriesFast()) ;
cpvrecpoints->Delete();
delete cpvrecpoints;
}
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hPhosHitsMul", "Hits multiplicity distribution in PHOS;# of Hits;Entries", 500, 0., 10000) ;
h1->Sumw2() ;
Add2HitsList(h1, kHitsMul, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hPhosDigitsMul", "Digits multiplicity distribution in PHOS;# of Digits;Entries", 2000, 0, 10000) ;
h1->Sumw2() ;
Add2DigitsList(h1, kDigitsMul, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1I * h1 = new TH1I("hPhosSDigitsMul", "SDigits multiplicity distribution in PHOS;# of SDigits;Entries", 500, 0, 1000) ;
h1->Sumw2() ;
Add2SDigitsList(h1, kSDigitsMul, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
TIter next(fHitsArray) ;
AliPHOSHit * hit ;
while ( (hit = dynamic_cast<AliPHOSHit *>(next())) ) {
- GetHitsData(kHits)->Fill( hit->GetEnergy()) ;
+ FillHitsData(kHits, hit->GetEnergy()) ;
}
}
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(&fHitsArray) ;
- for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
- branch->GetEntry(ientry) ;
- nHits += fHitsArray->GetEntriesFast();
- MakeHits() ;
- fHitsArray->Clear();
- }
- GetHitsData(1)->Fill(nHits) ;
- }
+ if ( ! branch ) { AliWarning("PHOS branch in Hit Tree not found"); return;}
+ //
+ Int_t nHits = 0;
+ branch->SetAddress(&fHitsArray) ;
+ for (Int_t ientry = 0 ; ientry < branch->GetEntries() ; ientry++) {
+ branch->GetEntry(ientry) ;
+ nHits += fHitsArray->GetEntriesFast();
+ MakeHits() ;
+ fHitsArray->Clear();
+ }
+ FillHitsData(1,nHits) ;
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
{
// makes data from Digits
- GetDigitsData(1)->Fill(fDigitsArray->GetEntriesFast()) ;
+ FillDigitsData(1,fDigitsArray->GetEntriesFast()) ;
TIter next(fDigitsArray) ;
AliPHOSDigit * digit ;
while ( (digit = dynamic_cast<AliPHOSDigit *>(next())) ) {
- GetDigitsData(kDigits)->Fill( digit->GetEnergy()) ;
+ FillDigitsData(kDigits, digit->GetEnergy()) ;
}
}
//____________________________________________________________________________
void AliPHOSQADataMakerSim::MakeDigits(TTree * digitTree)
{
- // makes data from Digit Tree
- if (fDigitsArray)
+ // makes data from Digit Tree
+ 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(&fDigitsArray) ;
- branch->GetEntry(0) ;
- MakeDigits() ;
- }
+
+ TBranch * branch = digitTree->GetBranch("PHOS") ;
+ if ( ! branch ) {AliWarning("PHOS branch in Digit Tree not found"); return;}
+ branch->SetAddress(&fDigitsArray) ;
+ branch->GetEntry(0) ;
+ MakeDigits() ;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
{
// makes data from SDigits
- GetSDigitsData(1)->Fill(fSDigitsArray->GetEntriesFast()) ;
+ FillSDigitsData(1,fSDigitsArray->GetEntriesFast()) ;
TIter next(fSDigitsArray) ;
AliPHOSDigit * sdigit ;
while ( (sdigit = dynamic_cast<AliPHOSDigit *>(next())) ) {
- GetSDigitsData(kSDigits)->Fill( sdigit->GetEnergy()) ;
+ FillSDigitsData(kSDigits, sdigit->GetEnergy()) ;
}
}
void AliPHOSQADataMakerSim::MakeSDigits(TTree * sdigitTree)
{
// makes data from SDigit Tree
- if (fSDigitsArray)
+ 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(&fSDigitsArray) ;
- branch->GetEntry(0) ;
- MakeSDigits() ;
- }
+ TBranch * branch = sdigitTree->GetBranch("PHOS") ;
+ if ( ! branch ) {AliWarning("PHOS branch in SDigit Tree not found"); return;}
+ branch->SetAddress(&fSDigitsArray) ;
+ branch->GetEntry(0) ;
+ MakeSDigits() ;
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
TH2F *hCpvXY = new TH2F("hCpvXY","CPV plane;X [cm];Y [cm]",200,-100.,100.,200,-100.,100.);
Add2RawsList(hCpvXY, 5, !expert, !image, saveCorr);
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD);# of Digits;Entries", 500, 0, 1000);
h3->Sumw2();
Add2DigitsList(h3, 3, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH2I *h8 = new TH2I("hCpv54","Cluster - DDL5 vs DDL4;DDL4;DDL5", 100,0,200,100,0,200);
Add2RecPointsList(h8,8, !expert, image);
-
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
h2->Sumw2();
Add2ESDsList(h2, 2, !expert, image) ;
-/*
- TH1I * h3 = new TH1I("hCpvClMult","Cluster Multiplicity of CPV plane",100,0.,1000.);
- h3->Sumw2();
- Add2ESDsList(h3, 3, !expert, image) ;
-*/
-
+ /*
+ TH1I * h3 = new TH1I("hCpvClMult","Cluster Multiplicity of CPV plane",100,0.,1000.);
+ h3->Sumw2();
+ Add2ESDsList(h3, 3, !expert, image) ;
+ */
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
void AliPMDQADataMakerRec::MakeRaws(AliRawReader* rawReader)
{
- //Fill prepared histograms with Raw digit properties
+ //Fill prepared histograms with Raw digit properties
TObjArray *pmdddlcont = 0x0;
pmdddlcont = new TObjArray();
if (det == 0)
{
- GetRawsData(0)->Fill(ipp, sig);
- GetRawsData(2)->Fill(ipp);
+ FillRawsData(0,ipp, sig);
+ FillRawsData(2,ipp);
if(smn < 12)
{
cc.RectGeomCellPos(smn,xpad,ypad,xx,yy);
- GetRawsData(4)->Fill(xx,yy);
+ FillRawsData(4,xx,yy);
}
if (det == 1)
{
- GetRawsData(1)->Fill(ipp, sig);
- GetRawsData(3)->Fill(ipp);
+ FillRawsData(1,ipp, sig);
+ FillRawsData(3,ipp);
if(smn < 12)
{
}
cc.RectGeomCellPos(smn,xpad,ypad,xx,yy);
- GetRawsData(5)->Fill(xx,yy);
+ FillRawsData(5,xx,yy);
}
delete pmdddlcont;
pmdddlcont = 0x0;
-
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
void AliPMDQADataMakerRec::MakeDigits()
{
if(digit->GetDetector() == 0)
{
- GetDigitsData(0)->Fill( digit->GetADC()) ;
+ FillDigitsData(0, digit->GetADC()) ;
premul++;
}
if(digit->GetDetector() == 1)
{
- GetDigitsData(1)->Fill( digit->GetADC());
+ FillDigitsData(1, digit->GetADC());
cpvmul++;
}
}
- if (premul > 0) GetDigitsData(2)->Fill(premul);
- if (cpvmul > 0) GetDigitsData(3)->Fill(cpvmul);
+ if (premul > 0) FillDigitsData(2,premul);
+ if (cpvmul > 0) FillDigitsData(3,cpvmul);
}
fDigitsArray = new TClonesArray("AliPMDdigit", 1000) ;
TBranch * branch = digitTree->GetBranch("PMDDigit") ;
- if ( ! branch )
- {
- AliWarning("PMD branch in Digit Tree not found") ;
- }
- else
- {
- branch->SetAddress(&fDigitsArray) ;
- for (Int_t ient = 0; ient < branch->GetEntries(); ient++)
- {
- branch->GetEntry(ient) ;
- MakeDigits() ;
- }
-
- }
+ if ( ! branch ) {AliWarning("PMD branch in Digit Tree not found"); return;}
+ //
+ branch->SetAddress(&fDigitsArray) ;
+ for (Int_t ient = 0; ient < branch->GetEntries(); ient++) {
+ branch->GetEntry(ient) ;
+ MakeDigits() ;
+ }
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
{
if(recpoint->GetSMNumber() >= 0 && recpoint->GetSMNumber() < 6)
{
- GetRecPointsData(0)->Fill(recpoint->GetClusCells());
+ FillRecPointsData(0,recpoint->GetClusCells());
multDdl0++;
}
if(recpoint->GetSMNumber() >= 6 && recpoint->GetSMNumber() < 12)
{
- GetRecPointsData(1)->Fill(recpoint->GetClusCells());
+ FillRecPointsData(1,recpoint->GetClusCells());
multDdl1++;
}
if(recpoint->GetSMNumber() >= 12 && recpoint->GetSMNumber() < 18)
{
- GetRecPointsData(2)->Fill(recpoint->GetClusCells());
+ FillRecPointsData(2,recpoint->GetClusCells());
multDdl2++;
}
if(recpoint->GetSMNumber() >= 18 && recpoint->GetSMNumber() < 24)
{
- GetRecPointsData(3)->Fill(recpoint->GetClusCells());
+ FillRecPointsData(3,recpoint->GetClusCells());
multDdl3++;
}
}
if((recpoint->GetSMNumber() >= 0 && recpoint->GetSMNumber() < 6) ||
(recpoint->GetSMNumber() >= 18 && recpoint->GetSMNumber() < 24))
{
- GetRecPointsData(4)->Fill(recpoint->GetClusCells());
+ FillRecPointsData(4,recpoint->GetClusCells());
multDdl4++;
}
if(recpoint->GetSMNumber() >= 6 && recpoint->GetSMNumber() < 18 )
{
- GetRecPointsData(5)->Fill(recpoint->GetClusCells());
+ FillRecPointsData(5,recpoint->GetClusCells());
multDdl5++;
}
}
}
}
- GetRecPointsData(6)->Fill(multDdl0,multDdl1);
- GetRecPointsData(7)->Fill(multDdl2,multDdl3);
- GetRecPointsData(8)->Fill(multDdl4,multDdl5);
+ FillRecPointsData(6,multDdl0,multDdl1);
+ FillRecPointsData(7,multDdl2,multDdl3);
+ FillRecPointsData(8,multDdl4,multDdl5);
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
if (pmdtr->GetDetector() == 0)
{
- GetESDsData(0)->Fill(adc);
+ FillESDsData(0,adc);
premul++;
}
if (pmdtr->GetDetector() == 1)
{
- GetESDsData(1)->Fill(adc) ;
+ FillESDsData(1,adc) ;
cpvmul++;
}
}
- GetESDsData(2)->Fill(cpvmul,premul) ;
- //GetESDsData(3)->Fill(cpvmul) ;
+ FillESDsData(2,cpvmul,premul) ;
+ //FillESDsData(3,cpvmul) ;
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
TH1I *h3 = new TH1I("hCpvHitsMult","Hits multiplicity distribution in PRE(PMD);# of Hits;Entries", 500, 0, 3000) ;
h2->Sumw2() ;
Add2HitsList(h3, 3, !expert, image) ;
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
TH1I *h3 = new TH1I("hCpvSDigitsMult","SDigits multiplicity distribution in CPV(PMD);# of SDigits;Entries", 500, 0., 1000.);
h3->Sumw2();
Add2SDigitsList(h3, 3, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1I *h3 = new TH1I("hCpvDigitsMult","Digits multiplicity distribution in CPV(PMD);# of Digits;Entries", 500, 0, 1000);
h3->Sumw2();
Add2DigitsList(h3, 3, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
if (hit->Z() > 361.5)
{
edepkev = (hit->GetEnergy())/1000.;
- GetHitsData(0)->Fill(edepkev);
+ FillHitsData(0,edepkev);
premul++;
}
else if (hit->Z() < 361.5)
{
edepkev = (hit->GetEnergy())/1000.;
- GetHitsData(1)->Fill(edepkev);
+ FillHitsData(1,edepkev);
cpvmul++;
}
}
if(premul <= 0)
{
- GetHitsData(2)->Fill(-1.);
+ FillHitsData(2,-1.);
}
else
{
- GetHitsData(2)->Fill(premul);
+ FillHitsData(2,premul);
}
if(cpvmul <= 0)
{
- GetHitsData(3)->Fill(-1.);
+ FillHitsData(3,-1.);
}
else
{
- GetHitsData(3)->Fill(cpvmul);
+ FillHitsData(3,cpvmul);
}
}
MakeHits();
fHitsArray->Clear() ;
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
void AliPMDQADataMakerSim::MakeSDigits()
if(sdigit->GetDetector() == 0)
{
edepkev = (sdigit->GetCellEdep())/1000.;
- GetSDigitsData(0)->Fill(edepkev);
+ FillSDigitsData(0,edepkev);
premul++;
}
if(sdigit->GetDetector() == 1)
{
edepkev = (sdigit->GetCellEdep())/1000.;
- GetSDigitsData(1)->Fill(edepkev);
+ FillSDigitsData(1,edepkev);
cpvmul++;
}
}
- if (premul > 0) GetSDigitsData(2)->Fill(premul);
- if (cpvmul > 0) GetSDigitsData(3)->Fill(cpvmul);
+ if (premul > 0) FillSDigitsData(2,premul);
+ if (cpvmul > 0) FillSDigitsData(3,cpvmul);
}
branch->GetEntry(0) ;
MakeSDigits() ;
}
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
{
if(digit->GetDetector() == 0)
{
- GetDigitsData(0)->Fill( digit->GetADC()) ;
+ FillDigitsData(0, digit->GetADC()) ;
premul++;
}
if(digit->GetDetector() == 1)
{
- GetDigitsData(1)->Fill( digit->GetADC());
+ FillDigitsData(1, digit->GetADC());
cpvmul++;
}
}
- if (premul > 0) GetDigitsData(2)->Fill(premul);
- if (cpvmul > 0) GetDigitsData(3)->Fill(cpvmul);
+ if (premul > 0) FillDigitsData(2,premul);
+ if (cpvmul > 0) FillDigitsData(3,cpvmul);
}
}
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//Create histograms to controll ESD
AliInfo("TO BE IMPLEMENTED") ;
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
fCorrNt[AliRecoParam::AConvert(fEventSpecie)] = new TNtupleD(name, "Raws data correlation among detectors", varlist.Data()) ;
fVarvalue = new Double_t[fMaxRawVar] ;
}
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
// create Reconstructed Points histograms in RecPoints subdir
AliInfo("TO BE IMPLEMENTED") ;
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
// make QA data from ESDs
AliInfo("TO BE IMPLEMENTED") ;
-
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
}
static_cast<TNtupleD*>(fCorrNt[AliRecoParam::AConvert(fEventSpecie)])->Fill(fVarvalue);
}
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
void AliCorrQADataMakerRec::MakeRecPoints(TTree * /*clustersTree*/)
{
AliInfo("TO BE IMPLEMENTED") ;
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
fMachineMode(fgkInvalidString),
fLHCStateArray(0x0),
fMachineModeArray(0x0),
+ fQATrigClasses(0x0),
+ fQACloningRequest(0x0),
fMaxTimeLHCValidity(0)
{
fMachineMode(obj.fMachineMode),
fLHCStateArray(obj.fLHCStateArray),
fMachineModeArray(obj.fMachineModeArray),
+ fQATrigClasses(obj.fQATrigClasses),
+ fQACloningRequest(obj.fQACloningRequest),
fMaxTimeLHCValidity(obj.fMaxTimeLHCValidity)
{
this->fMachineModeArray = obj.fMachineModeArray;
this->fMaxTimeLHCValidity = obj.fMaxTimeLHCValidity;
+ this->fQATrigClasses = obj.fQATrigClasses;
+ this->fQACloningRequest = obj.fQACloningRequest;
+
for (Int_t ibeamType = 0; ibeamType<2; ibeamType++){
this->fSeparateBeamType[ibeamType] = obj.fSeparateBeamType[ibeamType];
}
delete fMachineModeArray;
fMachineModeArray = 0x0;
}
+ if (fQATrigClasses) {
+ delete fQATrigClasses;
+ fQATrigClasses = 0x0;
+ }
+ if (fQACloningRequest) {
+ delete fQACloningRequest;
+ fQACloningRequest = 0x0;
+ }
}
//-----------------------------------------------------------------------------
Int_t GetDimension() const {return fDimension;}\r
\r
Double_t GetMaxTimeLHCValidity() const {return fMaxTimeLHCValidity;}\r
-\r
+ //\r
+ TObjArray* GetQATrigClasses() const {return (TObjArray*)fQATrigClasses;}\r
+ TObjArray* GetQACloningRequest() const {return (TObjArray*)fQACloningRequest;}\r
+ //\r
// setters\r
void SetBeamEnergyIsSqrtSHalfGeV(Bool_t v=kTRUE) {SetBit(kConvSqrtSHalfGeV,v);}\r
void SetPolarityConventionLHC(Bool_t v=kTRUE) {return SetBit(kPolConvLHC,v);}\r
void SetPoints(Int_t points) {fPoints = points;}\r
void SetDimension(Int_t dimension) {fDimension = dimension;}\r
void SetMaxTimeLHCValidity(Double_t maxTimeLHCValidity) {fMaxTimeLHCValidity = maxTimeLHCValidity;}\r
-\r
+ //\r
+ void SetQATrigClasses(TObjArray* arr) {fQATrigClasses = arr;}\r
+ void SetQACloningRequest(TObjArray* arr) {fQACloningRequest = arr;}\r
+ //\r
// getters for "invalid" flags\r
\r
static Float_t GetInvalidFloat() {return fgkInvalidFloat;}\r
// array containg the values for the Hall Probes\r
\r
TString fMachineMode; // Machine Mode from LHC\r
-\r
TObjArray* fLHCStateArray; // Array of values for the LHC State\r
TObjArray* fMachineModeArray; // Array of values for the LHC State\r
-\r
+ TObjArray* fQATrigClasses; // RS: Array of trigger class to watch in QA\r
+ TObjArray* fQACloningRequest; // RS: Array of cloning requests for QA histos\r
Double_t fMaxTimeLHCValidity; // time until which the LHC Data Machine Mode and Beam Mode didn't change \r
TString fSeparateBeamType[2]; // separate beam Types from LHC\r
\r
- ClassDef(AliGRPObject,7)\r
+ ClassDef(AliGRPObject,8)\r
\r
};\r
\r
void AliGlobalQADataMaker::InitRaws()
{
// create Raws histograms in Raws subdir
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
// as a part of global QA
//------------------------------------------------------
static Bool_t first = kTRUE ;
- if ( ! first )
- return ;
+ if ( ! first ) return;
const Char_t *name[]={
"hGlobalSPD1ResidualsY","SPD1ResidualsZ",
"hGlobalSPD2ResidualsY","SPD2ResidualsZ",
new TH1F("hGlobalSSD2AbsoluteResidualsZPosZ",
"SSD2Absolute Residuals Z Pos Z",100,-3.,3.),47);
- first = kFALSE ;
+ first = kFALSE;
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
TH2F *h1=new TH2F(name[1],title[1],41,-0.5,40.5, 33,-0.5,32.5);
Add2ESDsList(h1,kMlt1, !expert, image);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
{
//Fill prepared histograms with Raw digit properties
rawReader->Reset() ;
-
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
Double_t xv=vtx->GetXv();
Double_t yv=vtx->GetYv();
Double_t zv=vtx->GetZv();
- GetESDsData(kEvt0)->Fill(zv);
+ FillESDsData(kEvt0,zv);
Int_t ntrk=esd->GetNumberOfTracks() ;
// Cluster related QA
if (track->IsOn(AliESDtrack::kITSrefit)) {
Int_t n=track->GetITSclusters(0);
- GetESDsData(kClr0)->Fill(Float_t(n)/6.); //6 is the number of ITS layers
+ FillESDsData(kClr0,Float_t(n)/6.); //6 is the number of ITS layers
}
for (Int_t j=0; j<6; ++j) {
if (!track->GetITSModuleIndexInfo(j,idet,sts,xloc,zloc)) continue;
if (j>=2) idet+=240;
if (j>=4) idet+=260;
- if ((sts==1)||(sts==2)||(sts==4)) GetESDsData(kClr3)->Fill(idet);
+ if ((sts==1)||(sts==2)||(sts==4)) FillESDsData(kClr3,idet);
}
if (track->IsOn(AliESDtrack::kTPCrefit)) {
Int_t nf=track->GetTPCNclsF(); // number of crossed TPC pad rows
if (nf>0) {
Double_t val = n*1.0/nf;
- GetESDsData(kClr1)->Fill(val);
+ FillESDsData(kClr1,val);
}
}
if (track->IsOn(AliESDtrack::kTRDrefit)) {
Int_t n=track->GetTRDclusters(0);
- GetESDsData(kClr2)->Fill(Float_t(n)/(6*24));//(6*24) is the number of TRD time bins
+ FillESDsData(kClr2,Float_t(n)/(6*24));//(6*24) is the number of TRD time bins
}
Double_t p=track->GetP();
track->GetDZ(xv,yv,zv,esd->GetMagneticField(),dz);
if ((TMath::Abs(dz[0])<3.) && (TMath::Abs(dz[1])<3.)) { // beam pipe
Double_t phi=track->Phi();
- GetESDsData(kTrk0)->Fill(phi);
+ FillESDsData(kTrk0,phi);
Double_t y=track->Eta();
- GetESDsData(kTrk1)->Fill(y);
+ FillESDsData(kTrk1,y);
if (TMath::Abs(y)<0.9) {
- GetESDsData(kTrk2)->Fill(p);
- if (track->IsOn(AliESDtrack::kITSrefit)) GetESDsData(kTrk3)->Fill(p);
- //if (track->IsOn(AliESDtrack::kTOFout)) GetESDsData(kTrk4)->Fill(p);
- if (track->GetTOFsignal()>0) GetESDsData(kTrk4)->Fill(p);
+ FillESDsData(kTrk2,p);
+ if (track->IsOn(AliESDtrack::kITSrefit)) FillESDsData(kTrk3,p);
+ //if (track->IsOn(AliESDtrack::kTOFout)) FillESDsData(kTrk4,p);
+ if (track->GetTOFsignal()>0) FillESDsData(kTrk4,p);
}
}
}
dz[0]*=10.; // in mm
if (innTrack->GetZ() > 0)
if (innTrack->GetTgl()> 0) { // TPC side A
- if (tpcTrack->GetSign() > 0) GetESDsData(kTrk7)->Fill(dz[0]);
- else GetESDsData(kTrk8)->Fill(dz[0]);
+ if (tpcTrack->GetSign() > 0) FillESDsData(kTrk7,dz[0]);
+ else FillESDsData(kTrk8,dz[0]);
}
if (innTrack->GetZ() < 0)
if (innTrack->GetTgl()< 0) { // TPC side C
- if (tpcTrack->GetSign() > 0) GetESDsData(kTrk9)->Fill(dz[0]);
- else GetESDsData(kTrk10)->Fill(dz[0]);
+ if (tpcTrack->GetSign() > 0) FillESDsData(kTrk9,dz[0]);
+ else FillESDsData(kTrk10,dz[0]);
}
}
if ((p>0.4) && (p<0.5)) {
if (track->IsOn(AliESDtrack::kITSpid)) {
Double_t dedx=track->GetITSsignal();
- GetESDsData(kPid0)->Fill(dedx);
+ FillESDsData(kPid0,dedx);
}
if (track->IsOn(AliESDtrack::kTPCpid)) {
Double_t dedx=track->GetTPCsignal();
- GetESDsData(kPid1)->Fill(dedx);
+ FillESDsData(kPid1,dedx);
}
}
if (p>1.0) {
Double_t times[10];
track->GetIntegratedTimes(times);
Double_t tof=track->GetTOFsignal()/*-847055 -1771207*/;
- GetESDsData(kPid2)->Fill(times[2]-tof);
+ FillESDsData(kPid2,times[2]-tof);
}
}
}
if (par) {
Double_t pp=par->GetP();
Double_t dedx=track->GetTPCsignal();
- TH2F *h = dynamic_cast<TH2F*>(GetESDsData(kPid3));
- if (h) h->Fill(pp,dedx);
+ FillESDsData(kPid3,pp,dedx);
}
}
Short_t nv0a=mltV0->GetNbPMV0A();
Short_t nv0c=mltV0->GetNbPMV0C();
Int_t nits=mltITS->GetNumberOfTracklets();
- TH2F *h0=dynamic_cast<TH2F*>(GetESDsData(kMlt0));
- if (h0) h0->Fill(nits,nv0a);
- TH2F *h1=dynamic_cast<TH2F*>(GetESDsData(kMlt1));
- if (h1) h1->Fill(nits,nv0c);
+ FillESDsData(kMlt0,nits,nv0a);
+ FillESDsData(kMlt1,nits,nv0c);
}
-
- TH1 *tpc=GetESDsData(kTrk2); tpc->Sumw2();
- TH1 *its=GetESDsData(kTrk3); its->Sumw2();
- TH1 *tof=GetESDsData(kTrk4); tof->Sumw2();
- GetESDsData(kTrk5)->Divide(its,tpc,1,1.,"b");
- GetESDsData(kTrk6)->Divide(tof,tpc,1,1.,"b");
+ // RS
+ for (int itr = -1; itr<GetNEventTrigClasses(); itr++) {
+ TH1 *tpc = GetMatchingESDsHisto(kTrk2,itr);
+ TH1 *its = GetMatchingESDsHisto(kTrk3,itr);
+ TH1 *tof = GetMatchingESDsHisto(kTrk4,itr);
+ TH1* h5 = GetMatchingESDsHisto(kTrk5,itr);
+ TH1* h6 = GetMatchingESDsHisto(kTrk6,itr);
+ if (h5 && h6 && tpc && its && tof) {
+ tpc->Sumw2();
+ its->Sumw2();
+ tof->Sumw2();
+ h5->Divide(its,tpc,1,1.,"b");
+ h6->Divide(tof,tpc,1,1.,"b");
+ }
+ }
// V0 related QA
Int_t nV0=esd->GetNumberOfV0s();
v0.ChangeMassHypothesis(kK0Short);
mass=v0.GetEffMass();
if (v0.GetOnFlyStatus())
- GetESDsData(kK0on)->Fill(mass);
+ FillESDsData(kK0on,mass);
else
- GetESDsData(kK0off)->Fill(mass);
+ FillESDsData(kK0off,mass);
v0.ChangeMassHypothesis(kLambda0);
mass=v0.GetEffMass();
if (v0.GetOnFlyStatus())
- GetESDsData(kL0on)->Fill(mass);
+ FillESDsData(kL0on,mass);
else
- GetESDsData(kL0off)->Fill(mass);
+ FillESDsData(kL0off,mass);
v0.ChangeMassHypothesis(kLambda0Bar);
mass=v0.GetEffMass();
if (v0.GetOnFlyStatus())
- GetESDsData(kL0on)->Fill(mass);
+ FillESDsData(kL0on,mass);
else
- GetESDsData(kL0off)->Fill(mass);
+ FillESDsData(kL0off,mass);
}
-
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
if ( taskName == AliQAv1::GetTaskName(AliQAv1::kESDS) )
index = AliQAv1::kESD ;
qac->Init(AliQAv1::DETECTORINDEX_t(det)) ;
- qac->Run(index, recoParam) ;
+ qac->Run(index, recoParam) ;
}
}
TString detList ;
AliError(Form("det = %i is larger than AliQAv1::kNDET ... should never happen", det));
return kFALSE ;
}
- AliQACheckerBase * qac = GetDetQAChecker(det) ;
- if (qac)
- 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())) ;
- return kFALSE;
- }
-
- AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
- if ( task == AliQAv1::kRAWS )
- index = AliQAv1::kRAW ;
- else if ( task == AliQAv1::kHITS )
- index = AliQAv1::kSIM ;
- else if ( task == AliQAv1::kSDIGITS )
- index = AliQAv1::kSIM ;
- else if ( task == AliQAv1::kDIGITS )
- index = AliQAv1::kSIM ;
- else if ( task == AliQAv1::kDIGITSR )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kRECPOINTS )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kTRACKSEGMENTS )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kRECPARTICLES )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kESDS )
- index = AliQAv1::kESD ;
-
+ AliQACheckerBase * qac = GetDetQAChecker(det) ;
+ if (qac)
+ 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())) ;
+ return kFALSE;
+ }
+
+ AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
+ if ( task == AliQAv1::kRAWS )
+ index = AliQAv1::kRAW ;
+ else if ( task == AliQAv1::kHITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kSDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kDIGITSR )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kRECPOINTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kTRACKSEGMENTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kRECPARTICLES )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kESDS )
+ index = AliQAv1::kESD ;
+
qac->Init(det) ;
qac->Run(index, list, recoParam) ;
//_____________________________________________________________________________
Bool_t AliQAChecker::Run(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, TNtupleD ** list, AliDetectorRecoParam * recoParam)
{
- // run the Quality Assurance Checker for detector det, for task task starting from data in list
+ // run the Quality Assurance Checker for detector det, for task task starting from data in list
- AliQACheckerBase * qac = GetDetQAChecker(det) ;
- if (qac)
- 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())) ;
- return kFALSE;
- }
+ AliQACheckerBase * qac = GetDetQAChecker(det) ;
+ if (qac)
+ 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())) ;
+ return kFALSE;
+ }
- AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
- if ( task == AliQAv1::kRAWS )
- index = AliQAv1::kRAW ;
- else if ( task == AliQAv1::kHITS )
- index = AliQAv1::kSIM ;
- else if ( task == AliQAv1::kSDIGITS )
- index = AliQAv1::kSIM ;
- else if ( task == AliQAv1::kDIGITS )
- index = AliQAv1::kSIM ;
- else if ( task == AliQAv1::kDIGITSR )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kRECPOINTS )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kTRACKSEGMENTS )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kRECPARTICLES )
- index = AliQAv1::kREC ;
- else if ( task == AliQAv1::kESDS )
- index = AliQAv1::kESD ;
+ AliQAv1::ALITASK_t index = AliQAv1::kNULLTASK ;
+ if ( task == AliQAv1::kRAWS )
+ index = AliQAv1::kRAW ;
+ else if ( task == AliQAv1::kHITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kSDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kDIGITS )
+ index = AliQAv1::kSIM ;
+ else if ( task == AliQAv1::kDIGITSR )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kRECPOINTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kTRACKSEGMENTS )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kRECPARTICLES )
+ index = AliQAv1::kREC ;
+ else if ( task == AliQAv1::kESDS )
+ index = AliQAv1::kESD ;
qac->Init(det) ;
qac->Run(index, list, recoParam) ;
// Performs a basic checking
// Compares all the histograms in the list
- Int_t count[AliRecoParam::kNSpecies] = { 0 };
+ Int_t count[AliRecoParam::kNSpecies] = { 0 };
GetRefSubDir(GetName(), AliQAv1::GetTaskName(task), fRefSubDir, fRefOCDBSubDir) ;
// SetRefandData(refDir, refOCDBDir) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
test[specie] = 1.0 ;
- if ( !AliQAv1::Instance()->IsEventSpecieSet(specie))
- continue ;
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie)) continue ;
if (list[specie]->GetEntries() == 0)
test[specie] = 0. ; // nothing to check
else {
if ( hdata->IsA()->InheritsFrom("TH1") ) {
if ( hdata->TestBit(AliQAv1::GetExpertBit()) ) // does not perform the test for expert data
continue ;
- TH1 * href = NULL ;
- if (fRefSubDir)
- href = static_cast<TH1*>(fRefSubDir->Get(hdata->GetName())) ;
- else if (fRefOCDBSubDir[specie])
- href = static_cast<TH1*>(fRefOCDBSubDir[specie]->FindObject(hdata->GetName())) ;
+ //
+ // First try to find the ref histo with exact name (with possible trigger clon ending)
+ TString hname = hdata->GetName();
+ TH1 * href = NULL ;
+ if (fRefSubDir) href = static_cast<TH1*>(fRefSubDir->Get(hname.Data())) ;
+ else if (fRefOCDBSubDir[specie]) href = static_cast<TH1*>(fRefOCDBSubDir[specie]->FindObject(hname.Data()));
+ //
+ if (!href && hdata->TestBit(AliQAv1::GetClonedBit())) { // try to find the histo for the base name (w/o trigger ending
+ int ind = hname.Index(AliQADataMaker::GetTriggerPrefix());
+ if (ind>0) {
+ hname.Resize(ind);
+ if (fRefSubDir) href = static_cast<TH1*>(fRefSubDir->Get(hname.Data())) ;
+ else if (fRefOCDBSubDir[specie]) href = static_cast<TH1*>(fRefOCDBSubDir[specie]->FindObject(hname.Data()));
+ }
+ }
+ //
if (!href)
test[specie] = -1 ; // no reference data ;
else {
//____________________________________________________________________________
void AliQACheckerBase::Run(AliQAv1::ALITASK_t index, AliDetectorRecoParam * recoParam)
{
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Processing %s", AliQAv1::GetAliTaskName(index))) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Processing %s", AliQAv1::GetAliTaskName(index))) ;
- Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
+ Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
Check(rv, index, recoParam) ;
- SetQA(index, rv) ;
-
+ SetQA(index, rv) ;
+
AliDebug(AliQAv1::GetQADebugLevel(), Form("Test result of %s", AliQAv1::GetAliTaskName(index))) ;
-
+
delete [] rv ;
Finish() ;
}
//____________________________________________________________________________
void AliQACheckerBase::Run(AliQAv1::ALITASK_t index, TObjArray ** list, AliDetectorRecoParam * recoParam)
{
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Processing %s", AliQAv1::GetAliTaskName(index))) ;
-
- Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
- Check(rv, index, list, recoParam) ;
- SetQA(index, rv) ;
-
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Test result of %s", AliQAv1::GetAliTaskName(index))) ;
-
+ // RS: perform check for all trigger classes in loop
+ Double_t * rv = new Double_t[AliRecoParam::kNSpecies] ;
+ //
+ TObjArray ** listTrig = new TObjArray *[AliRecoParam::kNSpecies];
+ //
+ for (int itc=-1;itc<AliQADataMaker::GetNTrigClasses();itc++) {
+ //
+ // RS: fetch the histograms for each specie and for given trigger
+ //AliInfo(Form("Processing %s for trigger: %s", AliQAv1::GetAliTaskName(index),AliQADataMaker::GetTrigClassName(itc)));
+
+ for (int specie=0;specie<AliRecoParam::kNSpecies;specie++) {
+ listTrig[specie] = 0;
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) || !list[specie]) continue;
+ listTrig[specie] = new TObjArray( list[specie]->GetSize() ); // destination for clones of this trigger
+ AliQADataMaker::GetDataOfTrigClass(list[specie],itc, listTrig[specie]);
+ }
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Processing %s for trigger: %s", AliQAv1::GetAliTaskName(index),AliQADataMaker::GetTrigClassName(itc)));
+ Check(rv, index, listTrig, recoParam) ;
+ SetQA(index, rv) ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Test result of %s for trigger: %s", AliQAv1::GetAliTaskName(index),AliQADataMaker::GetTrigClassName(itc)));
+ //
+ for (int specie=0;specie<AliRecoParam::kNSpecies;specie++) if (listTrig[specie]) delete listTrig[specie]; // clean temporary container
+ }
delete [] rv ;
Finish() ;
}
//____________________________________________________________________________
void AliQACheckerBase::Finish() const
{
- // wrap up and save QA in proper file
- AliQAv1::GetQAResultFile() ;
- AliQAv1 * qa = AliQAv1::Instance() ;
- qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;
+ // wrap up and save QA in proper file
+ AliQAv1::GetQAResultFile() ;
+ AliQAv1 * qa = AliQAv1::Instance() ;
+ qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;
}
//____________________________________________________________________________
void AliQACheckerBase::MakeImage( TObjArray ** list, AliQAv1::TASKINDEX_t task, AliQAv1::MODE_t mode)
{
// makes the QA image for sim and rec
- for (Int_t esIndex = 0 ; esIndex < AliRecoParam::kNSpecies ; esIndex++) {
- if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) || list[esIndex]->GetEntries() == 0)
- continue ;
- Int_t nImages = 0 ;
- TIter next(list[esIndex]) ;
- TH1 * hdata = NULL ;
- while ( (hdata=static_cast<TH1 *>(next())) ) {
- TString cln(hdata->ClassName()) ;
- if ( ! cln.Contains("TH") )
- continue ;
- if ( hdata->TestBit(AliQAv1::GetImageBit()) )
- nImages++;
+ TObjArray tmpArr; // array to store flat version of original array (which may contain clones)
+ //
+ for (Int_t esIndex = 0; esIndex < AliRecoParam::kNSpecies; esIndex++) {
+ if (! AliQAv1::Instance(AliQAv1::GetDetIndex(GetName()))->IsEventSpecieSet(AliRecoParam::ConvertIndex(esIndex)) || list[esIndex]->GetEntries() == 0) continue;
+ Int_t nImages = 0;
+ TIter next(list[esIndex]);
+ TObject* hdata = NULL;
+ tmpArr.Clear();
+ while ( (hdata=(next())) ) { // count histos and transfere to flat array
+ if (hdata->InheritsFrom(TH1::Class()) && hdata->TestBit(AliQAv1::GetImageBit()) ) { // histo, not cloned
+ nImages++;
+ tmpArr.AddLast(hdata);
+ continue;
}
- if ( nImages == 0 ) {
- AliDebug(AliQAv1::GetQADebugLevel(), Form("No histogram will be plotted for %s %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex))) ;
- continue;
- }
- AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data(),AliRecoParam::GetEventSpecieName(esIndex))) ;
-
- const Char_t * title = Form("QA_%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex)) ;
- if ( !fImage[esIndex] ) {
- fImage[esIndex] = new TCanvas(title, title) ;
- }
- fImage[esIndex]->Clear() ;
- fImage[esIndex]->SetTitle(title) ;
- fImage[esIndex]->cd() ;
- TPaveText someText(0.015, 0.015, 0.98, 0.98) ;
- someText.AddText(title) ;
- someText.Draw() ;
- fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps") ;
- fImage[esIndex]->Clear() ;
- Int_t nx = TMath::Nint(TMath::Sqrt(nImages));
- Int_t ny = nx ;
- if (nx < TMath::Sqrt(nImages))
- ny++ ;
-
- fImage[esIndex]->Divide(nx, ny) ;
- TIter nexthist(list[esIndex]) ;
- TH1* hist = NULL ;
- Int_t npad = 1 ;
- fImage[esIndex]->cd(npad) ;
- while ( (hist=static_cast<TH1*>(nexthist())) ) {
- TString cln(hist->ClassName()) ;
- if ( ! cln.Contains("TH") )
- continue ;
- if(hist->TestBit(AliQAv1::GetImageBit())) {
- TString opts = hist->GetDrawOption();
- if (opts.Contains("logy",TString::kIgnoreCase)) {
- gPad->SetLogy();
- opts.ReplaceAll("logy", "");
- }
- if (opts.Contains("logx", TString::kIgnoreCase)) {
- gPad->SetLogx();
- opts.ReplaceAll("logx", "");
- }
- hist->DrawCopy() ;
- fImage[esIndex]->cd(++npad) ;
- }
- }
- fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps") ;
+ if (!hdata->TestBit(AliQAv1::GetClonedBit())) continue; // not an array of clones, unknown object
+ TIter nextCl((TObjArray*)hdata); // array of histo clones
+ TObject* hcl = 0;
+ while ((hcl=nextCl())) if (hcl->InheritsFrom(TH1::Class()) && hcl->TestBit(AliQAv1::GetImageBit())) {tmpArr.AddLast(hcl); nImages++;}
+ }
+ //
+ if ( nImages == 0 ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("No histogram will be plotted for %s %s %s\n", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex)));
+ continue;
}
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%d histograms will be plotted for %s %s %s\n", nImages, GetName(), AliQAv1::GetTaskName(task).Data(),AliRecoParam::GetEventSpecieName(esIndex)));
+ //
+ const Char_t * title = Form("QA_%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(esIndex));
+ //
+ if ( !fImage[esIndex] ) fImage[esIndex] = new TCanvas(title, title);
+ //
+ fImage[esIndex]->Clear();
+ fImage[esIndex]->SetTitle(title);
+ fImage[esIndex]->cd();
+ TPaveText someText(0.015, 0.015, 0.98, 0.98);
+ someText.AddText(title);
+ someText.Draw();
+ fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps");
+ fImage[esIndex]->Clear();
+ Int_t nx = TMath::Nint(TMath::Sqrt(nImages));
+ Int_t ny = nx;
+ if (nx < TMath::Sqrt(nImages)) ny++;
+ //
+ fImage[esIndex]->Divide(nx, ny);
+ TIter nexthist(&tmpArr);
+ Int_t npad = 1;
+ fImage[esIndex]->cd(npad);
+ TH1* histo = 0;
+ while ( (histo=(TH1*)nexthist()) ) { // tmpArr is guaranteed to contain only plottable histos, no checks needed
+ TString opts = histo->GetDrawOption();
+ if (opts.Contains("logy",TString::kIgnoreCase)) gPad->SetLogy();
+ if (opts.Contains("logx",TString::kIgnoreCase)) gPad->SetLogx();
+ histo->DrawCopy();
+ fImage[esIndex]->cd(++npad);
+ }
+ fImage[esIndex]->Print(Form("%s%s%d.%s", AliQAv1::GetImageFileName(), AliQAv1::GetModeName(mode), AliQAChecker::Instance()->GetRunNumber(), AliQAv1::GetImageFileFormat()), "ps");
+ }
}
//____________________________________________________________________________
#include <TParameter.h>
#include <TH1K.h>
#include <TH2C.h>
-#include <TH2D.h>
+#include <TH2F.h>
#include <TH2F.h>
#include <TH2I.h>
#include <TH3C.h>
-#include <TH3D.h>
+#include <TH3F.h>
#include <TH3F.h>
#include <TH3I.h>
#include <TH3S.h>
-
+#include <TArrayI.h>
+#include <TPRegexp.h>
// --- Standard library ---
// --- AliRoot header files ---
ClassImp(AliQADataMaker)
-
+
+const Char_t* AliQADataMaker::fgkTriggerPrefix = "_$TR$_";
+TObjArray* AliQADataMaker::fgCloningRequest = 0;
+TObjArray* AliQADataMaker::fgTrigClasses = 0;
+TObjArray AliQADataMaker::fgEventTrigClasses;
+
//____________________________________________________________________________
AliQADataMaker::AliQADataMaker(const Char_t * name, const Char_t * title) :
TNamed(name, title),
{
// ctor
fDetectorDirName = GetName() ;
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- fParameterList[specie] = NULL ;
- }
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ fParameterList[specie] = NULL ;
+ fEvCountCycle[specie].Set(AliQAv1::kNTASKINDEX);
+ fEvCountTotal[specie].Set(AliQAv1::kNTASKINDEX);
+ }
+
}
//____________________________________________________________________________
fDetectorDirName = GetName() ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fParameterList[specie] = qadm.fParameterList[specie] ;
- // fImage[specie] = qadm.fImage[specie] ;
+ fEvCountCycle[specie] = qadm.fEvCountCycle[specie];
+ fEvCountTotal[specie] = qadm.fEvCountTotal[specie];
+ // fImage[specie] = qadm.fImage[specie] ;
}
}
delete fParameterList[esIndex] ;
}
delete[] fParameterList ;
-
if (fDigitsArray) {
fDigitsArray->Clear() ;
delete fDigitsArray ;
//____________________________________________________________________________
Int_t AliQADataMaker::Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert, const Bool_t image, const Bool_t saveForCorr)
{
- // Set histograms memory resident and add to the list
- // Maximm allowed is 10000
+ // Set histograms memory resident and add to the list
+ // Maximm allowed is 10000
Int_t rv = -1 ;
TClass * classType = hist->Class() ;
TString className(classType->GetName()) ;
if( ! className.BeginsWith("T") && ! classType->InheritsFrom("TH1") ) {
AliError(Form("QA data Object must be a generic ROOT object and derive fom TH1 and not %s", className.Data())) ;
- } else if ( index > AliQAv1::GetMaxQAObj() ) {
- AliError(Form("Max number of authorized QA objects is %d", AliQAv1::GetMaxQAObj())) ;
+ } else if ( index > AliQAv1::GetMaxQAObj() ) {
+ AliError(Form("Max number of authorized QA objects is %d", AliQAv1::GetMaxQAObj())) ;
} else {
- hist->SetDirectory(0) ;
+ hist->SetDirectory(0);
if (expert)
hist->SetBit(AliQAv1::GetExpertBit()) ;
if (image)
return rv ;
}
+//____________________________________________________________________________
+void AliQADataMaker::ClonePerTrigClassL(TObjArray ** list, AliQAv1::TASKINDEX_t task)
+{
+ // scan the histos of the list, match them to requested histo names to be
+ // cloned and create the clones per trigger class
+ int spec = AliRecoParam::AConvert(fEventSpecie);
+ if (!fgCloningRequest || !GetNTrigClasses()) return;
+ if (!list || !list[spec]) {
+ AliDebug(1,Form("Array for %s specie is not created",AliRecoParam::GetEventSpecieName(fEventSpecie)));
+ return;
+ }
+ //
+ // if the counters were not expanded, do this now
+ if (fEvCountCycle[spec].GetSize()==AliQAv1::kNTASKINDEX) {
+ fEvCountCycle[spec].Set(AliQAv1::kNTASKINDEX*(GetNTrigClasses()+1)); // +1 for trigger-independent count
+ fEvCountTotal[spec].Set(AliQAv1::kNTASKINDEX*(GetNTrigClasses()+1)); // +1 for trigger-independent count
+ }
+ //
+
+ TString prefix = Form("%s/%s/",GetName(),AliQAv1::GetTaskName(task).Data()); // take care of requests with this prefix
+ int prefLgt = prefix.Length();
+ //
+ for (int ir=fgCloningRequest->GetEntriesFast();ir--;) {
+ TNamed* rec = dynamic_cast<TNamed*>(fgCloningRequest->At(ir));
+ if (!rec) continue;
+ TString hfname = rec->GetName(); // histogram names
+ if (!hfname.BeginsWith(prefix)) continue;
+ Bool_t keepOrig = rec->TestBit(AliQAv1::GetOrigHistoKeptBit()); // is original to be kept?
+ ClonePerTrigClassA(list[spec], hfname.Data()+prefLgt, rec->GetTitle(), keepOrig);
+ }
+ //
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::ClonePerTrigClassA(TObjArray * list, const char* hnm, const char* triggers, Bool_t keepOriginal)
+{
+ // substitute the matching histogram by the TObjArray containing clones of
+ // original histogram for each trigger from the space-separated tiggers string
+ // When keepOriginal is requested, the original histo is not deleted and filled for each trigger
+ if (!list) return 0;
+ int nh = list->GetEntriesFast();
+ if (!nh) return 0;
+ //
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Cloning histogram %s for triggers %s in array %s",hnm,triggers,list->GetName()));
+ //
+ TString trigStr = triggers;
+ TObjArray* trigArr = trigStr.Tokenize(" ");
+ int nTrigs = trigArr->GetEntriesFast();
+ Bool_t cloneAll=kFALSE, cloneMany=kFALSE;
+ if (!nTrigs) {
+ AliError(Form("Triggers string supplied for histo %s is empty", hnm));
+ delete trigArr;
+ return 0;
+ }
+ // match the trigger class id to selected aliases
+ for (int i=nTrigs;i--;) {
+ TObject* alias = fgTrigClasses->FindObject( trigArr->At(i)->GetName() );
+ if (!alias) {
+ AliError(Form("Cloning for undefined trigger class %s was requested for histogram %s",trigArr->At(i)->GetName(),hnm));
+ delete trigArr->RemoveAt(i);
+ trigArr->Compress();
+ continue;
+ }
+ trigArr->At(i)->SetUniqueID( alias->GetUniqueID() );
+ }
+ //
+ TString histPatt = hnm;
+ if (histPatt == "*") {
+ cloneAll = kTRUE;
+ cloneMany = kTRUE;
+ }
+ else {
+ histPatt.Prepend(Form("%s_", AliRecoParam::GetEventSpecieName(fEventSpecie)));
+ //
+ // The histogram name may contain %d formats for histos created in loop.
+ // Then we expect more than 1 histo matching to name
+ TPRegexp rgx("%\\d*d");
+ if (histPatt.Contains(rgx)) { // need to convert to perl expression, make sure there are no perl special characters
+ const char *specials = "^$.{}[]*+?\\";
+ for (int i=strlen(specials);i--;) histPatt.ReplaceAll(specials+i,1,Form("\\%c",specials[i]),2);
+ rgx.Substitute(histPatt,"\\d+","g");
+ histPatt.Prepend('^'); histPatt += "$";
+ cloneMany = kTRUE;
+ }
+ }
+ //
+ int nCloned = 0;
+ for (int ih=0;ih<nh;ih++) {
+ TH1* hist = (TH1*)list->At(ih);
+ if (!hist) continue;
+ if (!cloneAll) {
+ TString hname = hist->GetName();
+ if (cloneMany) {
+ TPRegexp patPR(histPatt);
+ if ( !hname.Contains(patPR) ) continue;
+ }
+ else {
+ if ( !hname.Contains(histPatt) ) continue;
+ }
+ }
+ //
+ // histo name matches, clone it
+ nCloned += ClonePerTrigClassH(ih, list, trigArr, keepOriginal);
+ if (!cloneMany) break; // no wildcards, just one histo is expected
+ }
+ //
+ delete trigArr;
+ return nCloned;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::ClonePerTrigClassH(Int_t index, TObjArray* list, TObjArray* trigArr, Bool_t keepOriginal)
+{
+ // substitute the histogram at position index by the TObjArray containing clones of
+ // original histogram for each trigger from the trigArr
+ // When keepOriginal is requested, the original histo is not deleted and filled for each trigger
+ TH1* hist = (TH1*) list->At(index);
+ if (!hist) return 0; // should never happen, checked in calling method
+
+ if (IsCloningForbidden(hist)) {
+ AliError(Form("Cloning per trigger is forbidden for histo %s at slot %d",hist->GetName(),index));
+ return 0;
+ }
+ //
+ if (hist->TestBit(AliQAv1::GetClonedBit())) {
+ AliError(Form("histo %s at slot %d was already cloned!",((TObjArray*)hist)->GetName(),index));
+ return 0;
+ }
+ //
+ int nTrigs = trigArr->GetEntriesFast();
+ TObjArray* clonesArr = new TObjArray(GetNTrigClasses()+keepOriginal);
+ // transfer the user bits of the histo to be cloned to array
+ for (int ib=14;ib<=23;ib++) if (hist->TestBit(1<<ib)) clonesArr->SetBit(1<<ib);
+ //
+ if (keepOriginal) {
+ clonesArr->AddAt(hist,GetNTrigClasses());
+ clonesArr->SetBit(AliQAv1::GetOrigHistoKeptBit());
+ }
+ clonesArr->SetBit(AliQAv1::GetClonedBit());
+ clonesArr->SetName(hist->GetName());
+ for (int itr=0;itr<nTrigs;itr++) {
+ TObject* trigClass = trigArr->At(itr);
+ TH1* hclone = (TH1*)hist->Clone(Form("%s%s%s",hist->GetName(), fgkTriggerPrefix, trigClass->GetName()));
+ hclone->SetTitle(Form("%s %s",hist->GetTitle(), trigClass->GetName()));
+ hclone->SetDirectory(hist->GetDirectory());
+ //
+ // NOTE: the clone is added at position corresponding to ID of the trigger alias
+ clonesArr->AddAt(hclone, trigClass->GetUniqueID());
+ hclone->SetBit(AliQAv1::GetClonedBit());
+ AliDebug(AliQAv1::GetQADebugLevel(),Form("Cloned histogram %s for trigger class %s",hist->GetName(),trigClass->GetName()));
+ }
+ //
+ list->RemoveAt(index); // remove original histogram
+ list->AddAt(clonesArr, index);
+ if (!keepOriginal) delete hist;
+ //
+ clonesArr->SetOwner(kTRUE);
+ return clonesArr->GetEntries();
+}
+
+//____________________________________________________________________________
+Char_t* AliQADataMaker::GetHistoTrigger(const TH1* h) const
+{
+ // extract the name of the trigger from the histogram name
+ if (!h || !h->TestBit(AliQAv1::GetClonedBit())) return 0;
+ TString hnm = h->GetName();
+ int idx = hnm.Index(fgkTriggerPrefix);
+ if (idx<0) return 0; // not cloned
+ return (char*) h->GetName() + idx + sizeof(fgkTriggerPrefix) - 1;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::SetEventTrigClasses(const char* triggers)
+{
+ // sets the array of triggers fired in given event, return the number of triggers
+ //
+ ResetEventTrigClasses();
+ fgEventTrigClasses.SetUniqueID(1); // flag that this is a triggered event
+ if (!GetNTrigClasses()) return 0; // meaningless if the trigger aliases are not set
+ TString trigStr = triggers;
+ TObjArray* tarr = trigStr.Tokenize(" ");
+ int nTrigs = tarr->GetEntriesFast();
+ if (!nTrigs) {
+ AliWarningClass("The string for event triggers is empty");
+ return 0;
+ }
+ int nTrClasses = 0;
+ for (int ial=fgTrigClasses->GetEntriesFast();ial--;) {
+ TNamed *pair = (TNamed*)fgTrigClasses->At(ial);
+ TString triggSet = pair->GetTitle(); // list of trigger names
+ for (int itr=nTrigs;itr--;) {
+ if ( !triggSet.Contains(tarr->At(itr)->GetName()) ) continue;
+ fgEventTrigClasses.Add(pair);
+ nTrClasses++;
+ break;
+ }
+ }
+ //
+ fgEventTrigClasses.SetOwner(kFALSE);
+ delete tarr;
+ //
+ return nTrClasses;
+}
+
+//____________________________________________________________________________
+TH1* AliQADataMaker::GetMatchingHisto(TObjArray ** list, Int_t index, Int_t trigId)
+{
+ // get histo with given index matching to trigId-th current trigger class
+ // trigId < 0 means default hist (only if cloning was done)
+ TObject* data = GetData(list,index);
+ if (!data) return 0;
+ if (trigId<0 || trigId==GetNEventTrigClasses()) { // original histo is requested
+ if (!data->TestBit(AliQAv1::GetClonedBit())) return (TH1*)data; // was not cloned per trigger
+ // check if during the cloning the original histo was kept (always at slot GetNTrigClasses())
+ else if (data->TestBit(AliQAv1::GetOrigHistoKeptBit())) return (TH1*)((TObjArray*)data)->At(GetNTrigClasses());
+ return 0;
+ }
+ //
+ if (!data->TestBit(AliQAv1::GetClonedBit())) return 0; // no cloning was done
+ if (trigId>GetNEventTrigClasses()) {
+ AliError(Form("Current event has %d triggers only, %d-th is requested",GetNEventTrigClasses(),trigId));
+ return 0; // invalid trigger
+ }
+ int slot = fgEventTrigClasses.At(trigId)->GetUniqueID(); // the histos are at slots corresponding to trig.class ID
+ return (TH1*)((TObjArray*)data)->At(slot);
+ //
+}
+
+//____________________________________________________________________________
+TObjArray* AliQADataMaker::GetMatchingHistosSet(TObjArray ** list, const Int_t* indexList, Int_t nHist, Int_t trigId)
+{
+ // get set of nHist histos with indices from the indexList matching to trigId-th current trigger
+ // Note: a static array is returned, it will be overwritten at the next call
+ static TObjArray garr;
+ garr.Clear();
+ for (int ih=0;ih<nHist;ih++) {
+ TH1* histo = GetMatchingHisto(list, indexList[ih],trigId);
+ if (!histo) return 0; // if at least 1 histo is not found, return nothing
+ garr.Add(histo);
+ }
+ return &garr;
+}
+
+//____________________________________________________________________________
+Bool_t AliQADataMaker::CheckCloningConsistency(TObjArray ** list, const Int_t* indexList, Int_t nHist, Bool_t checkTriggers)
+{
+ // Make sure that histograms at slots mentioned in the indexList are either
+ // not cloned per trigger or
+ // cloned for the same amount of triggers and if original histo was kept, then it is done for all histos.
+ // If checkTriggers is requested, apart from clones count also the trigger names are checked
+ //
+ // This consistency check is needed to ensure validity of the operations over the group of histograms in the EndOfDetectorCycle's
+ //
+ TObjArray* refArr = 0;
+ int refSlot = -1;
+ for (int isl=0;isl<nHist;isl++) {
+ int slot = indexList[isl];
+ TObject* data = GetData(list,slot);
+ if (!data) {AliError(Form("Slot %d is not booked",slot)); return kFALSE;}
+ //
+ if (refSlot<0) { // just take the 1st mentioned slot as a reference;
+ if (data->TestBit(AliQAv1::GetClonedBit())) refArr = (TObjArray*) data; // data was cloned
+ refSlot = slot;
+ continue;
+ }
+ //
+ if (!data->TestBit(AliQAv1::GetClonedBit())) { // this slot is not cloned, compare with reference
+ if (refArr) {AliError(Form("Slot %d is not cloned, slot %d is cloned",slot, refSlot)); return kFALSE;}
+ else continue;
+ }
+ //
+ TObjArray* currArr = (TObjArray*) data; // current slot is cloned
+ if (!refArr) {AliError(Form("Slot %d is not cloned, slot %d is cloned",refSlot,slot)); return kFALSE;}
+ //
+ // both are cloned
+ if (refArr->GetEntriesFast()!=currArr->GetEntriesFast()) {
+ AliError(Form("Different number of clones: slot %d: %d vs slot %d: %d",
+ refSlot,refArr->GetEntriesFast(), slot,currArr->GetEntriesFast()));
+ return kFALSE;
+ }
+ //
+ if (refArr->TestBit(AliQAv1::GetOrigHistoKeptBit())!=currArr->TestBit(AliQAv1::GetOrigHistoKeptBit())) {
+ AliError(Form("Slot %d kept original histo, slot %d did not",
+ refArr->TestBit(AliQAv1::GetOrigHistoKeptBit()) ? refSlot:slot,refArr->TestBit(AliQAv1::GetOrigHistoKeptBit()) ? slot:refSlot));
+ return kFALSE;
+ }
+ //
+ if (checkTriggers) {
+ for (int ih=refArr->GetEntriesFast();ih--;) {
+ TH1* hRef = (TH1*)refArr->At(ih);
+ if (!hRef->TestBit(AliQAv1::GetClonedBit())) continue; // original histo was kept, no trigger name is expected
+ TString hnm = ((TH1*)currArr->At(ih))->GetName();
+ if (!hnm.EndsWith( GetHistoTrigger(hRef) )) {
+ AliError(Form("Slots %d and %d have different trigger names for clone %d: %s vs %s",
+ refSlot,slot,ih,hRef->GetName(),hnm.Data()));
+ return kFALSE;
+ }
+ }
+ }
+ }
+ //
+ return kTRUE;
+}
+
+//____________________________________________________________________________
+TObjArray* AliQADataMaker::GetMatchingHistos(TObjArray ** list, Int_t index, TObjArray* optDest)
+{
+ // return all histograms of given index matching to any trigger in the current event trigger's list
+ // If the destination optDest is provided - use it, otherwise fill/return own static array
+ // In the latter case one should be careful: the content is overwritten at each call
+ // If the original histo was cloned but kept, it is also returned
+ //
+ // Note: if there are no triggers set, all eventual clones are returned
+ // (used for EndOfDetectorCycle loop over all histos)
+ static TObjArray garr;
+ TObjArray *dest = optDest ? optDest : &garr;
+ dest->SetOwner(kFALSE);
+ dest->Clear();
+ TObject* data = GetData(list,index);
+ if (!data) return 0;
+ if (!data->TestBit(AliQAv1::GetClonedBit())) dest->AddLast(data); // not cloned per trigger
+ else {
+ TObjArray* arr = dynamic_cast<TObjArray*>(data);
+ if (IsEventTriggerSet()) {
+ int ncl = GetNEventTrigClasses();
+ for (int icl=0;icl<ncl;icl++) {
+ int indCl = GetEventTrigClass(icl)->GetUniqueID();
+ // AliInfo(Form("Ind %d at %d of %p of %p",index,indCl, arr, list[AliRecoParam::AConvert(fEventSpecie)]));
+ TH1* histo = dynamic_cast<TH1*>(arr->At(indCl));
+ dest->AddLast(histo);
+ // AliInfo(Form("EvCl%d IndTr%d add to %d IndH %d %p %s",icl,indCl,dest->LastIndex(),index,histo,histo ? histo->GetName():"XXX"));
+ }
+ // check if original histo was kept
+ if (arr->TestBit(AliQAv1::GetOrigHistoKeptBit())) {
+ TH1* histo = dynamic_cast<TH1*>(arr->At(GetNTrigClasses()));
+ dest->AddLast(histo);
+ // AliInfo(Form("Def add to %d inex: %d %p %s",dest->LastIndex(),index,histo,histo ? histo->GetName():"XXX"));
+ }
+ }
+ else { // trigger is not set, return all clones
+ for (int ih=arr->GetEntriesFast();ih--;) if (arr->At(ih)) dest->AddLast(arr->At(ih));
+ }
+ }
+ return dest;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::FillData(TObjArray ** list, Int_t index, double x)
+{
+ // fills single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH1*)arr->At(ih))->Fill(x);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::FillData(TObjArray ** list, Int_t index, double x, double y)
+{
+ // fills single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH1*)arr->At(ih))->Fill(x,y);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::FillData(TObjArray ** list, Int_t index, double x, double y, double z)
+{
+ // fills single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->Fill(x,y,z);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::SetDataBinContent(TObjArray ** list, Int_t index, int bin, double w)
+{
+ // set bin content of single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->SetBinContent(bin,w);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::SetDataBinContent(TObjArray ** list, Int_t index, int binX, int binY, double w)
+{
+ // set bin content of single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->SetBinContent(binX,binY,w);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::SetDataBinError(TObjArray ** list, Int_t index, int bin, double err)
+{
+ // set bin content of single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->SetBinError(bin,err);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::SetDataBinError(TObjArray ** list, Int_t index, int binX, int binY, double err)
+{
+ // set bin content of single histo or its trigger-dependent clones, return number of histos filled
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->SetBinError(binX,binY,err);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::ResetData(TObjArray ** list, Int_t index, Option_t* option)
+{
+ // reset content of single histo or its trigger-dependent clones, return number of histos processed
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->Reset(option);
+ return count;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::ResetStatsData(TObjArray ** list, Int_t index)
+{
+ // reset stats of single histo or its trigger-dependent clones, return number of histos processed
+ TObjArray* arr = GetMatchingHistos(list,index);
+ int count = arr->GetEntriesFast();
+ for (int ih=count;ih--;) ((TH2*)arr->At(ih))->ResetStats();
+ return count;
+}
+
//____________________________________________________________________________
TH1 * AliQADataMaker::CloneMe(TH1 * hist, Int_t specie) const
{
//____________________________________________________________________________
void AliQADataMaker::DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task)
{
- // this method must be oveloaded by detectors
- // sets the QA result to Fatal
- AliQAv1::Instance(AliQAv1::GetDetIndex(GetName())) ;
- AliQAv1 * qa = AliQAv1::Instance(task) ;
+ // this method must be oveloaded by detectors
+ // sets the QA result to Fatal
+ AliQAv1::Instance(AliQAv1::GetDetIndex(GetName())) ;
+ AliQAv1 * qa = AliQAv1::Instance(task) ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
qa->Set(AliQAv1::kFATAL, specie) ;
- AliQAv1::GetQAResultFile()->cd() ;
- qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;
- AliQAv1::GetQAResultFile()->Close() ;
+ AliQAv1::GetQAResultFile()->cd() ;
+ qa->Write(AliQAv1::GetQAName(), kWriteDelete) ;
+ AliQAv1::GetQAResultFile()->Close() ;
}
//____________________________________________________________________________
void AliQADataMaker::Finish() const
{
- // write to the output File
- if (fOutput)
- fOutput->Close() ;
+ // write to the output File
+ if (fOutput)
+ fOutput->Close() ;
}
+//____________________________________________________________________________
+TH1* AliQADataMaker::GetData(TObjArray ** list, const Int_t index, int cloneID)
+{
+ // get the cloneID-th clone of the histo, -1 for original (if kept)
+ TObject* data = GetData(list,index);
+ if (!data) return 0;
+ Bool_t orig = cloneID<0 || cloneID==GetNTrigClasses();
+ if (data->TestBit(AliQAv1::GetClonedBit())) {
+ if (orig) return data->TestBit(AliQAv1::GetOrigHistoKeptBit()) ? (TH1*)((TObjArray*)data)->At(GetNTrigClasses()) : 0;
+ else return (TH1*)((TObjArray*)data)->At(cloneID); // there was a cloning
+ }
+ //
+ // not cloned, is the original histo requested?
+ if (cloneID<0 || cloneID==GetNTrigClasses()) return (TH1*)data;
+ return 0;
+ //
+}
+
+//____________________________________________________________________________
+TObjArray* AliQADataMaker::GetDataOfTrigClass(TObjArray ** list, Int_t specieIndex, int cloneID, TObjArray *dest)
+{
+ // get all histos for cloneID-th trigger class (-1 is for original "all-triggers" histos) in
+ // a single array (if dest is not provided, use its own static array).
+ // Existing histos are attached at their original positions
+ TObjArray* arr = list[specieIndex] ;
+ return GetDataOfTrigClass(arr, cloneID, dest);
+}
+
+//____________________________________________________________________________
+TObjArray* AliQADataMaker::GetDataOfTrigClass(TObjArray *arr, int cloneID, TObjArray *dest)
+{
+ // get all histos for cloneID-th trigger class (-1 is for original "all-triggers" histos) in
+ // a single array (if dest is not provided, use its own static array).
+ // Existing histos are attached at their original positions
+ static TObjArray arrTransf;
+ TObjArray* destS = dest ? dest : &arrTransf;
+ destS->SetOwner(kFALSE);
+ destS->Clear();
+ if (arr) {
+ Bool_t orig = cloneID<0 || cloneID==GetNTrigClasses(); // is trigger-blind histo requested?
+ int nh = arr->GetEntriesFast();
+ if (nh>destS->GetSize()) destS->Expand(nh);
+ for (int ih=nh;ih--;) {
+ TObject* ob = arr->At(ih);
+ if (!ob) continue;
+ //
+ if (ob->TestBit(AliQAv1::GetClonedBit())) { // this is array of cloned histos
+ if (orig) ob = ob->TestBit(AliQAv1::GetOrigHistoKeptBit()) ? ((TObjArray*)ob)->At(GetNTrigClasses()) : 0;
+ else ob = ((TObjArray*)ob)->At(cloneID);
+ }
+ else if (!orig) ob = 0; // histogram was not cloned but the clone is requested
+ if (!ob) continue;
+ (*destS)[ih] = ob;
+ }
+ }
+ return destS;
+ //
+}
+
+//____________________________________________________________________________
+TObjArray* AliQADataMaker::GetDataOfTrigClass(TObjArray ** list, int cloneID, TObjArray *dest)
+{
+ // get all histos for cloneID-th trigger class (-1 is for original "all-triggers" histos) in
+ // a single array (if dest is not provided, use its own static array).
+ // Existing histos are attached at their original positions
+ //
+ GetData(list,0); //just to initialize, if needed
+ Int_t esindex = AliRecoParam::AConvert(fEventSpecie);
+ return GetDataOfTrigClass(list, esindex, cloneID, dest);
+ //
+}
+
//____________________________________________________________________________
TObject * AliQADataMaker::GetData(TObjArray ** list, const Int_t index)
{
- // Returns the QA object at index. Limit is AliQAv1::GetMaxQAObj()
+ // Returns the QA object at index. Limit is AliQAv1::GetMaxQAObj()
if ( ! list ) {
- AliError("Data list is NULL !!") ;
- return NULL ;
- }
-
- SetEventSpecie(fEventSpecie) ;
+ AliError("Data list is NULL !!") ;
+ return NULL ;
+ }
Int_t esindex = AliRecoParam::AConvert(fEventSpecie) ;
- TH1 * histClone = NULL ;
+ TObject* histClone = NULL ;
TObjArray * arr = list[esindex] ;
- if (arr) {
+ if (arr) {
if ( ! arr->GetEntriesFast() ) {
// Initializes the histograms
TString arrName(arr->GetName()) ;
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 {
+ if ( index > AliQAv1::GetMaxQAObj() ) {
+ AliError(Form("Max number of authorized QA objects is %d", AliQAv1::GetMaxQAObj())) ;
+ } else {
if ( arr->At(index) ) {
- histClone = static_cast<TH1*>(arr->At(index)) ;
+ histClone = arr->At(index);
}
}
}
return kTRUE ;
}
+//____________________________________________________________________________
+void AliQADataMaker::SetCloningRequest(TObjArray* aliases, TObjArray* histos)
+{
+ // set associations {trigger names} <-> {trigger class alias}
+ //
+ const UInt_t kDummyID = 0xffff;
+ //
+ if (fgTrigClasses || fgCloningRequest) {
+ AliWarningClass("Cloning request is already set");
+ return;
+ }
+ ResetEventTrigClasses();
+ if (!aliases || !histos) {
+ AliWarningClass("Cloning request is incomplete");
+ return;
+ }
+ fgTrigClasses = aliases;
+ fgCloningRequest = histos;
+ //
+ // flag those aliases which are actually used
+ fgCloningRequest->Compress();
+ fgTrigClasses->Compress();
+ int nalias = fgTrigClasses->GetEntriesFast();
+ int nhisto = fgCloningRequest->GetEntriesFast();
+ //
+ int naliasUsed = 0;
+ for (int ial=0;ial<nalias;ial++) {
+ TNamed* alias = (TNamed*)fgTrigClasses->At(ial);
+ alias->SetUniqueID(kDummyID);
+ TString aliasName = alias->GetName();
+ for (int ih=nhisto;ih--;) {
+ TNamed* histo = (TNamed*)fgCloningRequest->At(ih);
+ TString histoReq = histo->GetTitle(); // list of aliases for which the histo must be cloned
+ TObjArray* alList = histoReq.Tokenize(" ");
+ if (!alList) continue;
+ for (int iha=alList->GetEntriesFast();iha--;) {
+ if (!(aliasName == alList->At(iha)->GetName())) continue;
+ alias->SetUniqueID(naliasUsed++); // acknowledge used alias
+ break;
+ }
+ if (alias->GetUniqueID()!=kDummyID) break; // once alias is validated, check the next one
+ }
+ }
+ // eliminate unused aliases
+ for (int ial=0;ial<nalias;ial++) if (fgTrigClasses->At(ial)->GetUniqueID()==kDummyID) delete fgTrigClasses->RemoveAt(ial);
+ fgTrigClasses->Compress();
+ //
+ AliInfoClass("Aliases for trigger classes:");
+ for (int i=0;i<fgTrigClasses->GetEntriesFast();i++) {
+ TNamed* item = (TNamed*)fgTrigClasses->At(i);
+ AliInfoClass(Form("%s -> %s",item->GetName(),item->GetTitle()));
+ }
+ //
+ AliInfoClass("Histograms to clone:");
+ for (int i=0;i<fgCloningRequest->GetEntriesFast();i++) {
+ TNamed* item = (TNamed*)fgCloningRequest->At(i);
+ AliInfoClass(Form("%s -> %s %s",item->GetName(),item->GetTitle(),
+ item->TestBit(AliQAv1::GetOrigHistoKeptBit()) ? " + TriggerBlind":""));
+ }
+ //
+}
+
+//____________________________________________________________________________
+void AliQADataMaker::IncEvCountCycle(AliQAv1::TASKINDEX_t task, Int_t diff)
+{
+ // incerment by "diff" the cycle counters for the current event trigger classes (+ the global one)
+ int ncl = GetNTrigClasses();
+ int isp = AliRecoParam::AConvert(fEventSpecie);
+ //
+ if (fEvCountCycle[isp].GetSize()==AliQAv1::kNTASKINDEX && ncl>0) fEvCountCycle[isp].Set(AliQAv1::kNTASKINDEX*(GetNTrigClasses()+1)); // +1 for trigger-independent count
+ //
+ fEvCountCycle[isp][task*(1+ncl)+ncl] += diff; // trigger independent counter
+ for (int icl=GetNEventTrigClasses();icl--;) fEvCountCycle[isp][task*(1+ncl)+ GetEventTrigClass(icl)->GetUniqueID()] += diff;
+}
+
+//____________________________________________________________________________
+void AliQADataMaker::IncEvCountTotal(AliQAv1::TASKINDEX_t task, Int_t diff)
+{
+ // incerment by "diff" the cycle counters for the current event trigger classes (+ the global one)
+ int ncl = GetNTrigClasses();
+ int isp = AliRecoParam::AConvert(fEventSpecie);
+ //
+ if (fEvCountTotal[isp].GetSize()==AliQAv1::kNTASKINDEX && ncl>0) fEvCountTotal[isp].Set(AliQAv1::kNTASKINDEX*(GetNTrigClasses()+1)); // +1 for trigger-independent count
+ //
+ fEvCountTotal[isp][task*(1+ncl)+ncl] += diff; // trigger independent counter
+ for (int icl=GetNEventTrigClasses();icl--;) fEvCountTotal[isp][task*(1+ncl)+ GetEventTrigClass(icl)->GetUniqueID()] += diff;
+}
+
+//____________________________________________________________________________
+void AliQADataMaker::ResetEvCountCycle(AliRecoParam::EventSpecie_t isp, AliQAv1::TASKINDEX_t task)
+{
+ // reset counter for specific trigger class for specific specie (within the cycle)
+ int ncl = GetNTrigClasses();
+ // check if it was already expanded
+ if (fEvCountCycle[isp].GetSize()==AliQAv1::kNTASKINDEX) fEvCountCycle[isp].Set(AliQAv1::kNTASKINDEX*(ncl+1));
+ for (int icl=ncl+1;icl--;) fEvCountCycle[AliRecoParam::AConvert(isp)][task*(1+ncl) + icl] = 0;
+}
+
+//____________________________________________________________________________
+void AliQADataMaker::ResetEvCountTotal(AliRecoParam::EventSpecie_t isp, AliQAv1::TASKINDEX_t task)
+{
+ // reset counter for specific trigger class for specific specie (global count)
+ int ncl = GetNTrigClasses();
+ // check if it was already expanded
+ if (fEvCountTotal[isp].GetSize()==AliQAv1::kNTASKINDEX) fEvCountTotal[isp].Set(AliQAv1::kNTASKINDEX*(ncl+1));
+ for (int icl=ncl+1;icl--;) fEvCountTotal[AliRecoParam::AConvert(isp)][task*(1+ncl) + icl] = 0;
+}
+
+//____________________________________________________________________________
+Int_t AliQADataMaker::GetEvCountCycle(AliRecoParam::EventSpecie_t isp, AliQAv1::TASKINDEX_t task, Int_t trCl) const
+{
+ // get counter for specific trigger class for specific specie (within the cycle)
+ int ncl = GetNTrigClasses();
+ return fEvCountCycle[AliRecoParam::AConvert(isp)][task*(1+ncl) + (trCl<0||trCl>=ncl ? ncl:trCl)];
+}
+//____________________________________________________________________________
+Int_t AliQADataMaker::GetEvCountTotal(AliRecoParam::EventSpecie_t isp, AliQAv1::TASKINDEX_t task, Int_t trCl) const
+{
+ // get counter for specific trigger class for specific specie (global count)
+ int ncl = GetNTrigClasses();
+ return fEvCountTotal[AliRecoParam::AConvert(isp)][task*(1+ncl) + (trCl<0||trCl>=ncl ? ncl:trCl)];
+}
+
#include <TH1.h>
#include <TObjArray.h>
#include <TNamed.h>
+#include <TArrayI.h>
//class TCanvas ;
class TClonesArray;
class TDirectory;
class AliQADataMaker: public TNamed {
-public:
-
- AliQADataMaker(const Char_t * name="", const Char_t * title="") ; // ctor
- AliQADataMaker(const AliQADataMaker& qadm) ;
- virtual ~AliQADataMaker() ; // dtor
-
- virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
- virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
- virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
- virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
- virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE) = 0 ;
- virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
- virtual void Exec(AliQAv1::TASKINDEX_t, TObject * data) = 0 ;
- virtual void EndOfCycle() = 0 ;
- virtual void EndOfCycle(AliQAv1::TASKINDEX_t ) = 0 ;
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list ) = 0 ;
- void Finish() const ;
- virtual TH1 * GetDigitsData(const Int_t index) = 0 ;
- virtual TH1 * GetESDsData(const Int_t index) = 0 ;
+ public:
+
+ AliQADataMaker(const Char_t * name="", const Char_t * title="") ; // ctor
+ AliQADataMaker(const AliQADataMaker& qadm) ;
+ virtual ~AliQADataMaker() ; // dtor
+ //
+ void ForbidCloning(TH1* h, Bool_t v=kTRUE) {h->SetBit(AliQAv1::GetForbidCloningBit(),v);}
+ Bool_t IsCloningForbidden(TH1* h) const {return h->TestBit(AliQAv1::GetForbidCloningBit());}
+ Char_t* GetHistoTrigger(const TH1* h) const;
+ //
+ virtual Int_t Add2DigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
+ virtual Int_t Add2ESDsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
+ virtual Int_t Add2HitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
+ virtual Int_t Add2RecPointsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
+ virtual Int_t Add2RawsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE) = 0 ;
+ virtual Int_t Add2SDigitsList(TH1 * hist, const Int_t index, const Bool_t expert = kFALSE, const Bool_t image = kFALSE) = 0 ;
+ virtual void Exec(AliQAv1::TASKINDEX_t, TObject * data) = 0 ;
+ virtual void EndOfCycle() = 0 ;
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t ) = 0 ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list ) = 0 ;
+ void Finish() const ;
AliRecoParam::EventSpecie_t GetEventSpecie() const { return fEventSpecie ; }
- virtual TH1 * GetHitsData(const Int_t index) = 0 ;
- virtual TH1 * GetRecPointsData(const Int_t index) = 0 ;
- virtual TH1 * GetRawsData(const Int_t index) = 0 ;
- virtual TH1 * GetSDigitsData(const Int_t index) = 0 ;
- const Char_t * GetDetectorDirName() const { return fDetectorDirName.Data() ; }
+ //
+ virtual TObject* GetDigitsData(const Int_t index) = 0 ;
+ virtual TObject* GetESDsData(const Int_t index) = 0 ;
+ virtual TObject* GetHitsData(const Int_t index) = 0 ;
+ virtual TObject* GetRecPointsData(const Int_t index) = 0 ;
+ virtual TObject* GetRawsData(const Int_t index) = 0 ;
+ virtual TObject* GetSDigitsData(const Int_t index) = 0 ;
+ //
+ virtual TH1* GetDigitsData(const Int_t index, int cloneID) = 0 ;
+ virtual TH1* GetESDsData(const Int_t index, int cloneID) = 0 ;
+ virtual TH1* GetHitsData(const Int_t index, int cloneID) = 0 ;
+ virtual TH1* GetRecPointsData(const Int_t index, int cloneID) = 0 ;
+ virtual TH1* GetRawsData(const Int_t index, int cloneID) = 0 ;
+ virtual TH1* GetSDigitsData(const Int_t index, int cloneID) = 0 ;
+ //
+ virtual TObjArray* GetDigitsDataOfTrigClass(int cloneID, TObjArray *dest=0) = 0;
+ virtual TObjArray* GetSDigitsDataOfTrigClass(int cloneID, TObjArray *dest=0) = 0;
+ virtual TObjArray* GetESDsDataOfTrigClass(int cloneID, TObjArray *dest=0) = 0;
+ virtual TObjArray* GetHitsDataOfTrigClass(int cloneID, TObjArray *dest=0) = 0;
+ virtual TObjArray* GetRecPointsDataOfTrigClass(int cloneID, TObjArray *dest=0) = 0;
+ virtual TObjArray* GetRawsDataOfTrigClass(int cloneID, TObjArray *dest=0) = 0;
+
+ //
+ const Char_t * GetDetectorDirName() const { return fDetectorDirName.Data() ; }
TList * GetParameterList() const { return fParameterList[AliRecoParam::AConvert(fEventSpecie)] ; }
virtual const AliDetectorRecoParam * GetRecoParam() { return NULL ; }
Int_t GetRun() const { return fRun ; }
- Int_t Increment() { return ++fCycleCounter ; }
- virtual TObjArray** Init(AliQAv1::TASKINDEX_t, Int_t cycles = -1) = 0 ;
+ Int_t Increment() { return ++fCycleCounter ; }
+ 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 InitDigits() = 0 ;
- virtual void InitESDs() = 0 ;
- virtual void InitRaws() = 0 ;
+ virtual void Init(AliQAv1::TASKINDEX_t, TObjArray ** list, Int_t run, Int_t cycles = -1) = 0 ;
+ virtual void InitDigits() = 0 ;
+ virtual void InitESDs() = 0 ;
+ virtual void InitRaws() = 0 ;
virtual void InitRecPoints() = 0 ;
Bool_t IsCycleDone() const { return fCycleCounter > fCycle ? kTRUE : kFALSE ; }
Bool_t IsValidEventSpecie(Int_t eventSpecieIndex, TObjArray ** list) ;
- void Reset() { fCycleCounter = 0 ; }
- virtual void ResetDetector(AliQAv1::TASKINDEX_t task) = 0 ;
- void SetCycle(Int_t nevts) { fCycle = nevts ; }
+ void Reset() { fCycleCounter = 0 ; }
+ virtual void ResetDetector(AliQAv1::TASKINDEX_t task) = 0 ;
+ void SetCycle(Int_t nevts) { fCycle = nevts ; }
void SetWriteExpert() { fWriteExpert = kTRUE ; }
- virtual void StartOfCycle(Int_t run = -1) = 0 ;
- virtual void StartOfCycle(AliQAv1::TASKINDEX_t, Int_t run, const Bool_t sameCycle = kFALSE) = 0 ;
+ virtual void StartOfCycle(Int_t run = -1) = 0 ;
+ virtual void StartOfCycle(AliQAv1::TASKINDEX_t, Int_t run, const Bool_t sameCycle = kFALSE) = 0 ;
void UnSetWriteExpert() { fWriteExpert = kFALSE ; }
Bool_t WriteExpert() { return fWriteExpert ; }
- void SetEventSpecie(AliRecoParam::EventSpecie_t es) { fEventSpecie = es ; }
- void SetEventSpecie(Int_t es) { fEventSpecie = AliRecoParam::Convert(es) ; }
+ void SetEventSpecie(AliRecoParam::EventSpecie_t es) {fEventSpecie = es;}
+ void SetEventSpecie(Int_t es) { SetEventSpecie(AliRecoParam::Convert(es)); }
virtual void SetRecoParam(const AliDetectorRecoParam *) {;}
virtual void InitRecPointsForTracker() {;} // needed by AliGlobalQADataMaker
-protected:
-
- Int_t Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE) ;
+ Int_t IsClonedPerTrigClass(Int_t index, TObjArray ** list);
+ Bool_t IsOrigHistoKept(Int_t index, TObjArray ** list);
+ Bool_t MatchesToTriggers(UInt_t hpos) const;
+ //
+ virtual TObjArray* GetMatchingDigitsData(const Int_t index, TObjArray* optDest=0) = 0 ;
+ virtual TObjArray* GetMatchingESDsData(const Int_t index, TObjArray* optDest=0) = 0 ;
+ virtual TObjArray* GetMatchingHitsData(const Int_t index, TObjArray* optDest=0) = 0 ;
+ virtual TObjArray* GetMatchingRecPointsData(const Int_t index, TObjArray* optDest=0) = 0 ;
+ virtual TObjArray* GetMatchingRawsData(const Int_t index, TObjArray* optDest=0) = 0 ;
+ virtual TObjArray* GetMatchingSDigitsData(const Int_t index, TObjArray* optDest=0) = 0 ;
+ //
+ virtual TH1* GetMatchingRawsHisto(Int_t index, Int_t trigId) = 0;
+ virtual TH1* GetMatchingDigitsHisto(Int_t index, Int_t trigId) = 0;
+ virtual TH1* GetMatchingSDigitsHisto(Int_t index, Int_t trigId) = 0;
+ virtual TH1* GetMatchingHitsHisto(Int_t index, Int_t trigId) = 0;
+ virtual TH1* GetMatchingRecPointsHisto(Int_t index, Int_t trigId) = 0;
+ virtual TH1* GetMatchingESDsHisto(Int_t index, Int_t trigId) = 0;
+ //
+ virtual TObjArray* GetMatchingRawsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) = 0;
+ virtual TObjArray* GetMatchingDigitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) = 0;
+ virtual TObjArray* GetMatchingSDigitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) = 0;
+ virtual TObjArray* GetMatchingHitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) = 0;
+ virtual TObjArray* GetMatchingRecPointsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) = 0;
+ virtual TObjArray* GetMatchingESDsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) = 0;
+ //
+ virtual Int_t FillHitsData(Int_t index, double x) = 0;
+ virtual Int_t FillDigitsData(Int_t index, double x) = 0;
+ virtual Int_t FillSDigitsData(Int_t index, double x) = 0;
+ virtual Int_t FillRawsData(Int_t index, double x) = 0;
+ virtual Int_t FillRecPointsData(Int_t index, double x) = 0;
+ virtual Int_t FillESDsData(Int_t index, double x) = 0;
+ //
+ virtual Int_t FillHitsData(Int_t index, double x, double y) = 0;
+ virtual Int_t FillDigitsData(Int_t index, double x, double y) = 0;
+ virtual Int_t FillSDigitsData(Int_t index, double x, double y) = 0;
+ virtual Int_t FillRawsData(Int_t index, double x, double y) = 0;
+ virtual Int_t FillRecPointsData(Int_t index, double x, double y) = 0;
+ virtual Int_t FillESDsData(Int_t index, double x, double y) = 0;
+ //
+ virtual Int_t FillHitsData(Int_t index, double x, double y, double z) = 0;
+ virtual Int_t FillDigitsData(Int_t index, double x, double y, double z) = 0;
+ virtual Int_t FillSDigitsData(Int_t index, double x, double y, double z) = 0;
+ virtual Int_t FillRawsData(Int_t index, double x, double y, double z) = 0;
+ virtual Int_t FillRecPointsData(Int_t index, double x, double y, double z) = 0;
+ virtual Int_t FillESDsData(Int_t index, double x, double y, double z) = 0;
+ //
+ virtual Int_t SetHitsDataBinContent(Int_t index, int bin, double w) = 0;
+ virtual Int_t SetDigitsDataBinContent(Int_t index, int bin, double w) = 0;
+ virtual Int_t SetSDigitsDataBinContent(Int_t index, int bin, double w) = 0;
+ virtual Int_t SetRawsDataBinContent(Int_t index, int bin, double w) = 0;
+ virtual Int_t SetRecPointsDataBinContent(Int_t index, int bin, double w) = 0;
+ virtual Int_t SetESDsDataBinContent(Int_t index, int bin, double w) = 0;
+ //
+ virtual Int_t SetHitsDataBinContent(Int_t index, int binX, int binY, double w) = 0;
+ virtual Int_t SetDigitsDataBinContent(Int_t index, int binX, int binY, double w) = 0;
+ virtual Int_t SetSDigitsDataBinContent(Int_t index, int binX, int binY, double w) = 0;
+ virtual Int_t SetRawsDataBinContent(Int_t index, int binX, int binY, double w) = 0;
+ virtual Int_t SetRecPointsDataBinContent(Int_t index, int binX, int binY, double w) = 0;
+ virtual Int_t SetESDsDataBinContent(Int_t index, int binX, int binY, double w) = 0;
+ //
+ virtual Int_t SetHitsDataBinError(Int_t index, int bin, double err) = 0;
+ virtual Int_t SetDigitsDataBinError(Int_t index, int bin, double err) = 0;
+ virtual Int_t SetSDigitsDataBinError(Int_t index, int bin, double err) = 0;
+ virtual Int_t SetRawsDataBinError(Int_t index, int bin, double err) = 0;
+ virtual Int_t SetRecPointsDataBinError(Int_t index, int bin, double err) = 0;
+ virtual Int_t SetESDsDataBinError(Int_t index, int bin, double err) = 0;
+ //
+ virtual Int_t SetHitsDataBinError(Int_t index, int binX, int binY, double err) = 0;
+ virtual Int_t SetDigitsDataBinError(Int_t index, int binX, int binY, double err) = 0;
+ virtual Int_t SetSDigitsDataBinError(Int_t index, int binX, int binY, double err) = 0;
+ virtual Int_t SetRawsDataBinError(Int_t index, int binX, int binY, double err) = 0;
+ virtual Int_t SetRecPointsDataBinError(Int_t index, int binX, int binY, double err) = 0;
+ virtual Int_t SetESDsDataBinError(Int_t index, int binX, int binY, double err) = 0;
+ //
+ virtual Int_t ResetHitsData(Int_t index, Option_t *opt="") = 0;
+ virtual Int_t ResetDigitsData(Int_t index, Option_t *opt="") = 0;
+ virtual Int_t ResetSDigitsData(Int_t index, Option_t *opt="") = 0;
+ virtual Int_t ResetRawsData(Int_t index, Option_t *opt="") = 0;
+ virtual Int_t ResetRecPointsData(Int_t index, Option_t *opt="") = 0;
+ virtual Int_t ResetESDsData(Int_t index, Option_t *opt="") = 0;
+ //
+ virtual Int_t ResetStatsHitsData(Int_t index) = 0;
+ virtual Int_t ResetStatsDigitsData(Int_t index) = 0;
+ virtual Int_t ResetStatsSDigitsData(Int_t index) = 0;
+ virtual Int_t ResetStatsRawsData(Int_t index) = 0;
+ virtual Int_t ResetStatsRecPointsData(Int_t index) = 0;
+ virtual Int_t ResetStatsESDsData(Int_t index) = 0;
+ //
+ void ResetEvCountCycle(AliRecoParam::EventSpecie_t isp, AliQAv1::TASKINDEX_t task);
+ void ResetEvCountTotal(AliRecoParam::EventSpecie_t isp, AliQAv1::TASKINDEX_t task);
+ void ResetEvCountCycle(AliRecoParam::EventSpecie_t isp) {fEvCountCycle[AliRecoParam::AConvert(isp)].Reset();}
+ void ResetEvCountTotal(AliRecoParam::EventSpecie_t isp) {fEvCountTotal[AliRecoParam::AConvert(isp)].Reset();}
+ void ResetEvCountCycle() {for (int isp=AliRecoParam::kNSpecies;isp--;) ResetEvCountCycle(AliRecoParam::ConvertIndex(isp));}
+ void ResetEvCountTotal() {for (int isp=AliRecoParam::kNSpecies;isp--;) ResetEvCountTotal(AliRecoParam::ConvertIndex(isp));}
+ //
+ Int_t GetEvCountCycle(AliRecoParam::EventSpecie_t sp, AliQAv1::TASKINDEX_t task, Int_t trCl=-1) const;
+ Int_t GetEvCountTotal(AliRecoParam::EventSpecie_t sp, AliQAv1::TASKINDEX_t task, Int_t trCl=-1) const;
+ Int_t GetEvCountCycle(AliQAv1::TASKINDEX_t task,Int_t trCl=-1) const {return GetEvCountCycle(fEventSpecie,task,trCl);}
+ Int_t GetEvCountTotal(AliQAv1::TASKINDEX_t task,Int_t trCl=-1) const {return GetEvCountCycle(fEventSpecie,task,trCl);}
+ //
+ Int_t GetEvCountCycleRaws(Int_t trCl=-1) const {return GetEvCountCycle(AliQAv1::kRAWS,trCl);}
+ Int_t GetEvCountCycleHits(Int_t trCl=-1) const {return GetEvCountCycle(AliQAv1::kHITS,trCl);}
+ Int_t GetEvCountCycleSDigits(Int_t trCl=-1) const {return GetEvCountCycle(AliQAv1::kSDIGITS,trCl);}
+ Int_t GetEvCountCycleDigits(Int_t trCl=-1) const {return GetEvCountCycle(AliQAv1::kDIGITS,trCl);}
+ Int_t GetEvCountCycleRecPoints(Int_t trCl=-1) const {return GetEvCountCycle(AliQAv1::kRECPOINTS,trCl);}
+ Int_t GetEvCountCycleESDS(Int_t trCl=-1) const {return GetEvCountCycle(AliQAv1::kESDS,trCl);}
+ //
+ Int_t GetEvCountTotalRaws(Int_t trCl=-1) const {return GetEvCountTotal(AliQAv1::kRAWS,trCl);}
+ Int_t GetEvCountTotalHits(Int_t trCl=-1) const {return GetEvCountTotal(AliQAv1::kHITS,trCl);}
+ Int_t GetEvCountTotalSDigits(Int_t trCl=-1) const {return GetEvCountTotal(AliQAv1::kSDIGITS,trCl);}
+ Int_t GetEvCountTotalDigits(Int_t trCl=-1) const {return GetEvCountTotal(AliQAv1::kDIGITS,trCl);}
+ Int_t GetEvCountTotalRecPoints(Int_t trCl=-1) const {return GetEvCountTotal(AliQAv1::kRECPOINTS,trCl);}
+ Int_t GetEvCountTotalESDS(Int_t trCl=-1) const {return GetEvCountTotal(AliQAv1::kESDS,trCl);}
+ //
+ void IncEvCountCycle(AliQAv1::TASKINDEX_t task, Int_t diff=1);
+ void IncEvCountTotal(AliQAv1::TASKINDEX_t task, Int_t diff=1);
+ //
+ void IncEvCountCycleRaws(Int_t diff=1) {IncEvCountCycle(AliQAv1::kRAWS, diff);}
+ void IncEvCountCycleHits(Int_t diff=1) {IncEvCountCycle(AliQAv1::kHITS, diff);}
+ void IncEvCountCycleSDigits(Int_t diff=1) {IncEvCountCycle(AliQAv1::kSDIGITS, diff);}
+ void IncEvCountCycleDigits(Int_t diff=1) {IncEvCountCycle(AliQAv1::kDIGITS, diff);}
+ void IncEvCountCycleRecPoints(Int_t diff=1) {IncEvCountCycle(AliQAv1::kRECPOINTS, diff);}
+ void IncEvCountCycleTrackSegments(Int_t diff=1) {IncEvCountCycle(AliQAv1::kTRACKSEGMENTS, diff);}
+ void IncEvCountCycleRecParticles(Int_t diff=1) {IncEvCountCycle(AliQAv1::kRECPARTICLES, diff);}
+ void IncEvCountCycleESDs(Int_t diff=1) {IncEvCountCycle(AliQAv1::kESDS, diff);}
+ //
+ void IncEvCountTotalRaws(Int_t diff=1) {IncEvCountTotal(AliQAv1::kRAWS, diff);}
+ void IncEvCountTotalHits(Int_t diff=1) {IncEvCountTotal(AliQAv1::kHITS, diff);}
+ void IncEvCountTotalSDigits(Int_t diff=1) {IncEvCountTotal(AliQAv1::kSDIGITS, diff);}
+ void IncEvCountTotalDigits(Int_t diff=1) {IncEvCountTotal(AliQAv1::kDIGITS, diff);}
+ void IncEvCountTotalRecPoints(Int_t diff=1) {IncEvCountTotal(AliQAv1::kRECPOINTS, diff);}
+ void IncEvCountTotalTrackSegments(Int_t diff=1) {IncEvCountTotal(AliQAv1::kTRACKSEGMENTS, diff);}
+ void IncEvCountTotalRecParticles(Int_t diff=1) {IncEvCountTotal(AliQAv1::kRECPARTICLES, diff);}
+ void IncEvCountTotalESDs(Int_t diff=1) {IncEvCountTotal(AliQAv1::kESDS, diff);}
+ //
+ virtual void ClonePerTrigClass(AliQAv1::TASKINDEX_t task) = 0;
+ //
+ static Int_t SetEventTrigClasses(const char* triggers);
+ static const TObjArray& GetEventTrigClasses() {return fgEventTrigClasses;}
+ static TNamed* GetTrigClass(Int_t i) {return fgTrigClasses ? (TNamed*)fgTrigClasses->At(i) : 0;}
+ static const char* GetTrigClassName(Int_t i) {return fgTrigClasses ? (i<0||i>=GetNTrigClasses() ? "TriggerBlind":GetTrigClass(i)->GetName()) : 0;}
+ static TNamed* GetEventTrigClass(Int_t i) {return (TNamed*)fgEventTrigClasses.At(i);}
+ static Int_t GetNEventTrigClasses() {return fgEventTrigClasses.GetEntriesFast();}
+ static void ResetEventTrigClasses() {fgEventTrigClasses.Clear(); fgEventTrigClasses.SetUniqueID(0);}
+ static Int_t GetNTrigClasses() {return fgTrigClasses ? fgTrigClasses->GetEntriesFast() : 0;}
+ static Bool_t IsEventTriggerSet() {return fgEventTrigClasses.GetUniqueID()>0;}
+ static void SetCloningRequest(TObjArray* aliases, TObjArray* histos);
+ //
+ static TObjArray* GetDataOfTrigClass(TObjArray * arr, Int_t cloneID, TObjArray *dest=0);
+ static TObjArray* GetDataOfTrigClass(TObjArray ** list, Int_t specieIndex, int cloneID, TObjArray *dest);
+ //
+ static const char* GetTriggerPrefix() {return fgkTriggerPrefix;}
+ //
+ protected:
+ virtual void ClonePerTrigClassL(TObjArray ** list, AliQAv1::TASKINDEX_t task);
+ virtual Int_t ClonePerTrigClassA(TObjArray * list, const char* hnm, const char* triggers, Bool_t keepOriginal=kFALSE);
+ virtual Int_t ClonePerTrigClassH(Int_t index, TObjArray* list, TObjArray* trigArr, Bool_t keepOriginal=kFALSE);
+ //
+ Int_t Add2List(TH1 * hist, const Int_t index, TObjArray ** list, const Bool_t expert = kFALSE, const Bool_t image = kFALSE, const Bool_t saveForCorr = kFALSE) ;
TH1 * CloneMe(TH1 * hist, Int_t specie) const ;
- virtual void DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task ) ;
- TObject * GetData(TObjArray ** list, const Int_t index) ;
- virtual void InitHits() = 0 ;
+ virtual void DefaultEndOfDetectorCycle(AliQAv1::TASKINDEX_t task ) ;
+ TObject * GetData(TObjArray ** list, const Int_t index);
+ TH1* GetData(TObjArray ** list, const Int_t index, Int_t cloneID);
+ TObjArray* GetDataOfTrigClass(TObjArray ** list, Int_t cloneID, TObjArray *dest=0);
+ virtual void InitHits() = 0 ;
//virtual void InitRecParticles() = 0 ;
- virtual void InitSDigits() = 0 ;
+ virtual void InitSDigits() = 0 ;
//virtual void InitTrackSegments() = 0 ;
- virtual void MakeESDs(AliESDEvent * ) = 0 ;
- virtual void MakeHits() = 0 ;
- virtual void MakeHits(TTree * ) = 0 ;
- virtual void MakeDigits() = 0 ;
- virtual void MakeDigits(TTree * ) = 0 ;
+ virtual void MakeESDs(AliESDEvent * ) = 0 ;
+ virtual void MakeHits() = 0 ;
+ virtual void MakeHits(TTree * ) = 0 ;
+ virtual void MakeDigits() = 0 ;
+ virtual void MakeDigits(TTree * ) = 0 ;
//virtual void MakeRecParticles( ) = 0 ;
- virtual void MakeRaws(AliRawReader *) = 0 ;
- virtual void MakeRecPoints(TTree * ) = 0 ;
- virtual void MakeSDigits() = 0 ;
- virtual void MakeSDigits(TTree * ) = 0 ;
+ virtual void MakeRaws(AliRawReader *) = 0 ;
+ virtual void MakeRecPoints(TTree * ) = 0 ;
+ virtual void MakeSDigits() = 0 ;
+ virtual void MakeSDigits(TTree * ) = 0 ;
//virtual void MakeTrackSegments(TTree * ) = 0 ;
- void ResetCycle() { fCurrentCycle++ ; fCycleCounter = 0 ; }
- virtual void StartOfDetectorCycle() = 0 ;
-
- TFile * fOutput ; //! output root file
- TDirectory * fDetectorDir ; //! directory for the given detector in the file
- TString fDetectorDirName ; //! detector directory name in the quality assurance data file
- Int_t fCurrentCycle ; //! current cycle number
- Int_t fCycle ; //! length (# events) of the QA data acquisition cycle
- Int_t fCycleCounter ; //! cycle counter
+ void ResetCycle() { fCurrentCycle++ ; fCycleCounter = 0 ; }
+ virtual void StartOfDetectorCycle() = 0 ;
+ //
+ TH1* GetMatchingHisto(TObjArray ** list, Int_t index, Int_t trigId);
+ TObjArray* GetMatchingHistosSet(TObjArray ** list, const Int_t* indexList, Int_t nHist, Int_t trigId);
+ TObjArray* GetMatchingHistos(TObjArray ** list, Int_t index, TObjArray* optDest=0);
+ Bool_t CheckCloningConsistency(TObjArray ** list, const Int_t* indexList, Int_t nHist, Bool_t checkTriggers=kFALSE);
+ Int_t FillData(TObjArray ** list, Int_t index, double x);
+ Int_t FillData(TObjArray ** list, Int_t index, double x, double y);
+ Int_t FillData(TObjArray ** list, Int_t index, double x, double y, double z);
+ Int_t SetDataBinContent(TObjArray ** list, Int_t index, int bin, double w);
+ Int_t SetDataBinContent(TObjArray ** list, Int_t index, int binX, int binY, double w);
+ Int_t SetDataBinError(TObjArray ** list, Int_t index, int bin, double err);
+ Int_t SetDataBinError(TObjArray ** list, Int_t index, int binX, int binY, double err);
+ Int_t ResetData(TObjArray ** list, Int_t index, Option_t* option = "");
+ Int_t ResetStatsData(TObjArray ** list, Int_t index);
+ //
+ TFile * fOutput ; //! output root file
+ TDirectory * fDetectorDir ; //! directory for the given detector in the file
+ TString fDetectorDirName ; //! detector directory name in the quality assurance data file
+ Int_t fCurrentCycle ; //! current cycle number
+ Int_t fCycle ; //! length (# events) of the QA data acquisition cycle
+ Int_t fCycleCounter ; //! cycle counter
Bool_t fWriteExpert ; //! flag to write or not the expert QA data
TList ** fParameterList ; //! list of QA data parameters
- Int_t fRun ; //! run number
+ Int_t fRun ; //! run number
AliRecoParam::EventSpecie_t fEventSpecie ; //! event specie, see AliRecoParam
TClonesArray * fDigitsArray ; //! array to hold the sdigits
-
-private:
- AliQADataMaker& operator = (const AliQADataMaker& /*qadm*/); // Not implemented
-
-
- ClassDef(AliQADataMaker,3) // description
+ TArrayI fEvCountCycle[AliRecoParam::kNSpecies]; // cycle event counters per specie and per task and eventually per trigger class
+ TArrayI fEvCountTotal[AliRecoParam::kNSpecies]; // total event counters per specie and per task and eventually per trigger class
+ //
+ static TObjArray fgEventTrigClasses; // array of indices of fired trigger classes for current event (indices of fgTriggeClasses)
+ static TObjArray* fgCloningRequest; // set of histogram names and trigger aliases
+ static TObjArray* fgTrigClasses; // set of trigger_aliases and corresponding trigger names
+ static const Char_t* fgkTriggerPrefix; // special prefix to separate the trigger name from histo name
+ private:
+ AliQADataMaker& operator = (const AliQADataMaker& /*qadm*/); // Not implemented
+ ClassDef(AliQADataMaker,5) // description
+
};
+//____________________________________________________________________________
+inline Bool_t AliQADataMaker::IsOrigHistoKept(Int_t index, TObjArray ** list) {
+ // check if the histogram was cloned and the original is kept
+ TObject* h = GetData(list,index); if (!h) return kFALSE;
+ return (!h->TestBit(AliQAv1::GetClonedBit())) || h->TestBit(AliQAv1::GetOrigHistoKeptBit());
+}
+
+//____________________________________________________________________________
+inline Int_t AliQADataMaker::IsClonedPerTrigClass(Int_t index, TObjArray ** list)
+{
+ // if the historgam was cloned per trigger, return number of clones, otherwise, return 0
+ TObject* obj = GetData(list, index);
+ if (!obj || !obj->TestBit(AliQAv1::GetClonedBit())) return 0;
+ return ((TObjArray*)obj)->GetEntriesFast();
+}
+
+//____________________________________________________________________________
+inline Bool_t AliQADataMaker::MatchesToTriggers(UInt_t hpos) const
+{
+ // check if the position hpos of clones TObjArray matches to one of event triggers classes
+ // if the event trigger was not set, every position is matching
+ if (!IsEventTriggerSet()) return kTRUE; // if triggers are not set, then this is a call from EndOfCycle
+ for (int itc=GetNEventTrigClasses();itc--;) if (fgEventTrigClasses.UncheckedAt(itc)->GetUniqueID()==hpos) return kTRUE;
+ return kFALSE;
+}
+
#endif // AliQADataMaker_H
//____________________________________________________________________________
AliQADataMakerRec::AliQADataMakerRec(const char * name, const char * title) :
- AliQADataMaker(name, title),
+AliQADataMaker(name, title),
fDigitsQAList(NULL),
fESDsQAList(NULL),
fRawsQAList(NULL),
fRecPointsArray(NULL)
{
// ctor
- fDetectorDirName = GetName() ;
+ fDetectorDirName = GetName() ;
}
//____________________________________________________________________________
fRecPointsArray(NULL)
{
//copy ctor
- SetName(qadm.GetName()) ;
- SetTitle(qadm.GetTitle()) ;
- fDetectorDirName = GetName() ;
+ SetName(qadm.GetName()) ;
+ SetTitle(qadm.GetTitle()) ;
+ fDetectorDirName = GetName() ;
}
//____________________________________________________________________________
AliQADataMakerRec::~AliQADataMakerRec()
{
- //dtor: delete the TObjArray and thei content
- if ( fESDsQAList ) {
+ //dtor: delete the TObjArray and thei content
+ if ( fESDsQAList ) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if ( fESDsQAList[specie] ) {
- fESDsQAList[specie]->Delete() ;
+ fESDsQAList[specie]->Delete() ;
}
}
delete[] fESDsQAList ;
- }
- if ( fRawsQAList ) {
+ }
+ if ( fRawsQAList ) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if ( fRawsQAList[specie] ) {
fRawsQAList[specie]->Delete() ;
}
delete[] fRawsQAList ;
}
- if ( fDigitsQAList ) {
+ if ( fDigitsQAList ) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if ( fDigitsQAList[specie] ) {
fDigitsQAList[specie]->Delete() ;
}
}
- delete[] fDigitsQAList ;
+ delete[] fDigitsQAList ;
}
- if ( fRecPointsQAList ) {
+ if ( fRecPointsQAList ) {
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
if ( fRecPointsQAList[specie] ) {
fRecPointsQAList[specie]->Delete() ;
}
}
- delete[] fRecPointsQAList ;
+ delete[] fRecPointsQAList ;
}
if (fRecPointsArray) {
fRecPointsArray->Clear() ;
//____________________________________________________________________________
void AliQADataMakerRec::EndOfCycle(AliQAv1::TASKINDEX_t task)
{
- // Finishes a cycle of QA
+ // Finishes a cycle of QA
TObjArray ** list = NULL ;
- if ( task == AliQAv1::kRAWS )
- list = fRawsQAList ;
- else if ( task == AliQAv1::kDIGITSR )
- list = fDigitsQAList ;
- else if ( task == AliQAv1::kRECPOINTS )
- list = fRecPointsQAList ;
- else if ( task == AliQAv1::kESDS )
- list = fESDsQAList ;
+ if ( task == AliQAv1::kRAWS )
+ list = fRawsQAList ;
+ else if ( task == AliQAv1::kDIGITSR )
+ list = fDigitsQAList ;
+ else if ( task == AliQAv1::kRECPOINTS )
+ list = fRecPointsQAList ;
+ else if ( task == AliQAv1::kESDS )
+ list = fESDsQAList ;
- if ( ! list && ! fCorrNt )
+ if ( ! list && ! fCorrNt )
return ;
//DefaultEndOfDetectorCycle(task) ;
- EndOfDetectorCycle(task, list) ;
+ EndOfDetectorCycle(task, list) ;
- if (! AliQAManager::QAManager(AliQAv1::kRECMODE)->IsSaveData())
- return ;
+ if (! AliQAManager::QAManager(AliQAv1::kRECMODE)->IsSaveData()) return;
fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
- if (!fDetectorDir)
- fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
+ if (!fDetectorDir) fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
- if (!subDir)
- subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
- subDir->cd() ;
+ if (!subDir) subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
+ subDir->cd();
+ //
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 ;
+ 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)
- eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
- eventSpecieDir->cd() ;
+ if (!eventSpecieDir) eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
+ eventSpecieDir->cd();
if (list) {
if (list[specie]) {
TIter next(list[specie]) ;
TObject * obj ;
while( (obj = next()) ) {
- if (!obj->TestBit(AliQAv1::GetExpertBit()))
- obj->Write() ;
+ if (!obj->TestBit(AliQAv1::GetExpertBit())) obj->Write(); // RS: Note, this can be also TObjArray of clones
}
if (WriteExpert()) {
TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
expertDir->cd() ;
next.Reset() ;
while( (obj = next()) ) {
- if (!obj->TestBit(AliQAv1::GetExpertBit()))
- continue ;
- obj->Write() ;
+ if (!obj->TestBit(AliQAv1::GetExpertBit())) continue;
+ obj->Write(); // RS: Note, this can be also TObjArray of clones
}
}
}
{
// creates the quality assurance data for the various tasks (Hits, SDigits, Digits, ESDs)
- if ( task == AliQAv1::kRAWS ) {
- AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ;
- AliRawReader * rawReader = static_cast<AliRawReader *>(data) ;
- if (rawReader)
- MakeRaws(rawReader) ;
- else
+ if ( task == AliQAv1::kRAWS ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing Raws QA") ;
+ AliRawReader * rawReader = static_cast<AliRawReader *>(data) ;
+ if (rawReader)
+ MakeRaws(rawReader) ;
+ else
AliDebug(AliQAv1::GetQADebugLevel(), "Raw data are not processed") ;
- } else if ( task == AliQAv1::kDIGITSR ) {
- AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ;
- TTree * tree = static_cast<TTree *>(data) ;
- if (strcmp(tree->ClassName(), "TTree") == 0) {
- MakeDigits(tree) ;
- } else {
- AliWarning("data are not a TTree") ;
- }
- } else if ( task == AliQAv1::kRECPOINTS ) {
- AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ;
- TTree * tree = static_cast<TTree *>(data) ;
- if (strcmp(tree->ClassName(), "TTree") == 0) {
- MakeRecPoints(tree) ;
- } else {
- AliWarning("data are not a TTree") ;
- }
- } else if ( task == AliQAv1::kESDS ) {
- AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ;
- AliESDEvent * esd = static_cast<AliESDEvent *>(data) ;
- if (strcmp(esd->ClassName(), "AliESDEvent") == 0)
- MakeESDs(esd) ;
- else
- AliError("Wrong type of esd container") ;
- }
+ } else if ( task == AliQAv1::kDIGITSR ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing Digits QA") ;
+ TTree * tree = static_cast<TTree *>(data) ;
+ if (strcmp(tree->ClassName(), "TTree") == 0) {
+ MakeDigits(tree) ;
+ } else {
+ AliWarning("data are not a TTree") ;
+ }
+ } else if ( task == AliQAv1::kRECPOINTS ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing RecPoints QA") ;
+ TTree * tree = static_cast<TTree *>(data) ;
+ if (strcmp(tree->ClassName(), "TTree") == 0) {
+ MakeRecPoints(tree) ;
+ } else {
+ AliWarning("data are not a TTree") ;
+ }
+ } else if ( task == AliQAv1::kESDS ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), "Processing ESDs QA") ;
+ AliESDEvent * esd = static_cast<AliESDEvent *>(data) ;
+ if (strcmp(esd->ClassName(), "AliESDEvent") == 0)
+ MakeESDs(esd) ;
+ else
+ AliError("Wrong type of esd container") ;
+ }
}
//____________________________________________________________________________
{
// general intialisation
InitRecoParams() ;
- TObjArray ** rv = NULL ;
+ TObjArray ** rv = NULL ;
- if (cycles > 0)
- SetCycle(cycles) ;
+ if (cycles > 0)
+ SetCycle(cycles) ;
- if ( task == AliQAv1::kRAWS ) {
- if (! fRawsQAList ) {
+ if ( task == AliQAv1::kRAWS ) {
+ if (! fRawsQAList ) {
fRawsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fRawsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;
fRawsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
- }
- rv = fRawsQAList ;
- } else if ( task == AliQAv1::kDIGITSR ) {
- if ( ! fDigitsQAList ) {
+ }
+ rv = fRawsQAList ;
+ } else if ( task == AliQAv1::kDIGITSR ) {
+ if ( ! fDigitsQAList ) {
fDigitsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fDigitsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;
fDigitsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
- }
- rv = fDigitsQAList ;
- } else if ( task == AliQAv1::kRECPOINTS ) {
- if ( ! fRecPointsQAList ) {
+ }
+ rv = fDigitsQAList ;
+ } else if ( task == AliQAv1::kRECPOINTS ) {
+ if ( ! fRecPointsQAList ) {
fRecPointsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fRecPointsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;
fRecPointsQAList[specie]->SetName(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(task).Data(), AliRecoParam::GetEventSpecieName(specie))) ;
}
}
- rv = fRecPointsQAList ;
- } else if ( task == AliQAv1::kESDS ) {
- if ( ! fESDsQAList ) {
+ rv = fRecPointsQAList ;
+ } else if ( task == AliQAv1::kESDS ) {
+ if ( ! fESDsQAList ) {
fESDsQAList = new TObjArray *[AliRecoParam::kNSpecies] ;
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
fESDsQAList[specie] = new TObjArray(AliQAv1::GetMaxQAObj()) ;
fESDsQAList[specie]->SetName(Form("%s_%s", GetName(), AliQAv1::GetTaskName(task).Data())); //, AliRecoParam::GetEventSpecieName(specie))) ;
}
- }
- rv = fESDsQAList ;
- }
- return rv ;
+ }
+ rv = fESDsQAList ;
+ }
+ return rv ;
}
//____________________________________________________________________________
InitRecoParams() ;
fRun = run ;
- if (cycles > 0)
- SetCycle(cycles) ;
+ if (cycles > 0)
+ SetCycle(cycles) ;
- if ( task == AliQAv1::kRAWS ) {
- fRawsQAList = list ;
- } else if ( task == AliQAv1::kDIGITSR ) {
- fDigitsQAList = list ;
- } else if ( task == AliQAv1::kRECPOINTS ) {
- fRecPointsQAList = list ;
- } else if ( task == AliQAv1::kESDS ) {
- fESDsQAList = list ;
- }
+ if ( task == AliQAv1::kRAWS ) {
+ fRawsQAList = list ;
+ } else if ( task == AliQAv1::kDIGITSR ) {
+ fDigitsQAList = list ;
+ } else if ( task == AliQAv1::kRECPOINTS ) {
+ fRecPointsQAList = list ;
+ } else if ( task == AliQAv1::kESDS ) {
+ fESDsQAList = list ;
+ }
}
//____________________________________________________________________________
//____________________________________________________________________________
void AliQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
{
- // default reset that resets all the QA objects.
- // to be overloaded by detectors, if necessary
+ // default reset that resets all the QA objects.
+ // to be overloaded by detectors, if necessary
TObjArray ** list = NULL ;
if ( task == AliQAv1::kRAWS ) {
- list = fRawsQAList ;
- } else if ( task == AliQAv1::kDIGITSR ) {
- list = fDigitsQAList ;
- } else if ( task == AliQAv1::kRECPOINTS ) {
- list = fRecPointsQAList ;
- } else if ( task == AliQAv1::kESDS ) {
- list = fESDsQAList ;
- }
- //list was not initialized, skip
- if (!list)
- return ;
+ list = fRawsQAList ;
+ } else if ( task == AliQAv1::kDIGITSR ) {
+ list = fDigitsQAList ;
+ } else if ( task == AliQAv1::kRECPOINTS ) {
+ list = fRecPointsQAList ;
+ } else if ( task == AliQAv1::kESDS ) {
+ list = fESDsQAList ;
+ }
+ //list was not initialized, skip
+ if (!list) return ;
for (int spec = 0; spec < AliRecoParam::kNSpecies; spec++) {
- if (!AliQAv1::Instance()->IsEventSpecieSet(AliRecoParam::ConvertIndex(spec)))
- continue;
+ if (!AliQAv1::Instance()->IsEventSpecieSet(AliRecoParam::ConvertIndex(spec))) continue;
TIter next(list[spec]) ;
- TH1 * histo = NULL ;
- while ( (histo = dynamic_cast<TH1*> (next())) ) {
- histo->Reset("ICE") ;
- histo->ResetStats() ;
+ TObject *obj = NULL;
+ while ( (obj = next()) ) {
+ if (obj->TestBit(AliQAv1::GetClonedBit())) { // this is array of cloned histos
+ TObjArray* arr = (TObjArray*)obj;
+ for (int ih=arr->GetEntriesFast();ih--;) {
+ TH1* histo = (TH1*)arr->At(ih);
+ if (!ih) continue;
+ histo->Reset("ICE");
+ histo->ResetStats();
+ }
+ }
+ else {
+ ((TH1*)obj)->Reset("ICE");
+ ((TH1*)obj)->ResetStats();
+ }
}
+ ResetEvCountCycle(AliRecoParam::ConvertIndex(spec));
+ ResetEvCountTotal(AliRecoParam::ConvertIndex(spec));
}
}
samecycle = kTRUE ;
StartOfCycle(AliQAv1::kDIGITSR, run, samecycle) ;
StartOfCycle(AliQAv1::kRECPOINTS, run, samecycle) ;
- StartOfCycle(AliQAv1::kESDS, run, samecycle) ;
+ StartOfCycle(AliQAv1::kESDS, run, samecycle) ;
}
//____________________________________________________________________________
void AliQADataMakerRec::StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle)
{
// Finishes a cycle of QA data acquistion
- if ( run > 0 )
- fRun = run ;
- if ( !sameCycle || fCurrentCycle == -1) {
- ResetCycle() ;
- if (fOutput)
- fOutput->Close() ;
- if (AliQAManager::QAManager(AliQAv1::kRECMODE)->IsSaveData())
+ if ( run > 0 ) fRun = run ;
+ if ( !sameCycle || fCurrentCycle == -1) {
+ ResetCycle() ;
+ if (fOutput)
+ fOutput->Close() ;
+ if (AliQAManager::QAManager(AliQAv1::kRECMODE)->IsSaveData())
fOutput = AliQAv1::GetQADataFile(GetName(), fRun) ;
- }
- AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s",
- fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
+ }
+ AliDebug(AliQAv1::GetQADebugLevel(), Form(" Run %d Cycle %d task %s file %s",
+ fRun, fCurrentCycle, AliQAv1::GetTaskName(task).Data(), fOutput->GetName() )) ;
+
+ // fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
+ // if (!fDetectorDir)
+ // fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
+ //
+ // TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
+ // if (!subDir)
+ // subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
+ //
+ // for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
+ // TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
+ // if (!eventSpecieDir)
+ // eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
+ // TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
+ // if (!expertDir)
+ // expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ;
+ // }
+ StartOfDetectorCycle();
+ ResetEvCountCycle();
+}
-// fDetectorDir = fOutput->GetDirectory(GetDetectorDirName()) ;
-// if (!fDetectorDir)
-// fDetectorDir = fOutput->mkdir(GetDetectorDirName()) ;
-//
-// TDirectory * subDir = fDetectorDir->GetDirectory(AliQAv1::GetTaskName(task)) ;
-// if (!subDir)
-// subDir = fDetectorDir->mkdir(AliQAv1::GetTaskName(task)) ;
-//
-// for ( Int_t specie = AliRecoParam::kDefault ; specie < AliRecoParam::kNSpecies ; specie++ ) {
-// TDirectory * eventSpecieDir = subDir->GetDirectory(AliRecoParam::GetEventSpecieName(specie)) ;
-// if (!eventSpecieDir)
-// eventSpecieDir = subDir->mkdir(AliRecoParam::GetEventSpecieName(specie)) ;
-// TDirectory * expertDir = eventSpecieDir->GetDirectory(AliQAv1::GetExpert()) ;
-// if (!expertDir)
-// expertDir = eventSpecieDir->mkdir(AliQAv1::GetExpert()) ;
-// }
- StartOfDetectorCycle() ;
+//____________________________________________________________________________
+void AliQADataMakerRec::ClonePerTrigClass(AliQAv1::TASKINDEX_t task)
+{
+ // clone the histos of the array corresponding to task
+ switch (task)
+ {
+ case AliQAv1::kRAWS : ClonePerTrigClassL(fRawsQAList, task); break;
+ case AliQAv1::kDIGITS : ClonePerTrigClassL(fDigitsQAList, task); break;
+ case AliQAv1::kRECPOINTS : ClonePerTrigClassL(fRecPointsQAList, task); break;
+ case AliQAv1::kESDS : ClonePerTrigClassL(fESDsQAList, task); break;
+ default : AliError(Form("Task %s is invalid in this context", AliQAv1::GetTaskName(task).Data() )); break;
+ }
+ //
}
virtual Int_t Add2SDigitsList(TH1 * /*hist*/, const Int_t /*index*/, const Bool_t /*expert = kFALSE*/, const Bool_t /*image = kFALSE*/) { return -1 ; }
virtual void Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
- virtual void EndOfCycle() ;
- virtual void EndOfCycle(AliQAv1::TASKINDEX_t task) ;
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
- virtual TH1 * GetDigitsData(const Int_t index ) { return dynamic_cast<TH1 *>(GetData(fDigitsQAList, index)) ; }
- virtual TH1 * GetESDsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fESDsQAList, index)) ; }
- virtual TH1 * GetHitsData(const Int_t /*index*/) { return NULL ; }
+ virtual void EndOfCycle() ;
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t task) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
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 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 InitRecPoints() {AliInfo("To be implemented by detectors");}
- virtual void InitDigits() {AliInfo("To be implemented by detectors");}
- virtual void InitESDs() {AliInfo("To be implemented by detectors");}
- virtual void ResetDetector(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 SetRecoParam(const AliDetectorRecoParam *param) { fRecoParam = param; }
+ virtual TObject* GetDigitsData(const Int_t index ) { return GetData(fDigitsQAList, index); }
+ virtual TObject* GetESDsData(const Int_t index) { return GetData(fESDsQAList, index); }
+ virtual TObject* GetHitsData(const Int_t /*index*/) { return NULL ; }
+ virtual TObject* GetRecPointsData(const Int_t index) { return GetData(fRecPointsQAList, index); }
+ virtual TObject* GetRawsData(const Int_t index) { return GetData(fRawsQAList, index); }
+ virtual TObject* GetSDigitsData(const Int_t /*index*/) { return NULL; }
+ //
+ virtual TH1* GetDigitsData(const Int_t index, int cloneID) { return GetData(fDigitsQAList, index, cloneID); }
+ virtual TH1* GetESDsData(const Int_t index, int cloneID) { return GetData(fESDsQAList, index, cloneID); }
+ virtual TH1* GetHitsData(const Int_t /*index*/, int) { return NULL ; }
+ virtual TH1* GetRecPointsData(const Int_t index, int cloneID) { return GetData(fRecPointsQAList, index, cloneID); }
+ virtual TH1* GetRawsData(const Int_t index, int cloneID) { return GetData(fRawsQAList, index, cloneID); }
+ virtual TH1* GetSDigitsData(const Int_t /*index*/, int) { return NULL; }
+ //
+ virtual TObjArray* GetDigitsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fDigitsQAList,cloneID,dest);}
+ virtual TObjArray* GetSDigitsDataOfTrigClass(int /*cloneID*/, TObjArray */*dest*/=0) {return NULL;}
+ virtual TObjArray* GetESDsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fESDsQAList,cloneID,dest);}
+ virtual TObjArray* GetHitsDataOfTrigClass(int /*cloneID*/, TObjArray */*dest*/=0) {return NULL;}
+ virtual TObjArray* GetRecPointsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fRecPointsQAList,cloneID,dest);}
+ virtual TObjArray* GetRawsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fRawsQAList,cloneID,dest);}
+ //
+ 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 InitRecPoints() {AliInfo("To be implemented by detectors");}
+ virtual void InitDigits() {AliInfo("To be implemented by detectors");}
+ virtual void InitESDs() {AliInfo("To be implemented by detectors");}
+ virtual void ResetDetector(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 SetRecoParam(const AliDetectorRecoParam *param) { fRecoParam = param; }
+ //
+ virtual TObjArray* GetMatchingHitsData(const Int_t, TObjArray*) {return 0;}
+ virtual TObjArray* GetMatchingSDigitsData(const Int_t, TObjArray*) {return 0;}
+ virtual TObjArray* GetMatchingDigitsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fDigitsQAList,index,optDest);}
+ virtual TObjArray* GetMatchingRawsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fRawsQAList,index,optDest);}
+ virtual TObjArray* GetMatchingRecPointsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fRecPointsQAList,index,optDest);}
+ virtual TObjArray* GetMatchingESDsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fESDsQAList,index,optDest);}
+ //
+ virtual TH1* GetMatchingHitsHisto(Int_t , Int_t ) {return 0;}
+ virtual TH1* GetMatchingSDigitsHisto(Int_t , Int_t ) {return 0;}
+ virtual TH1* GetMatchingDigitsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fDigitsQAList,index,trigId);}
+ virtual TH1* GetMatchingRawsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fRawsQAList,index,trigId);}
+ virtual TH1* GetMatchingRecPointsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fRecPointsQAList,index,trigId);}
+ virtual TH1* GetMatchingESDsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fESDsQAList,index,trigId);}
+ //
+ virtual TObjArray* GetMatchingHitsHistosSet(const Int_t*, Int_t ,Int_t) {return 0;}
+ virtual TObjArray* GetMatchingSDigitsHistosSet(const Int_t* , Int_t ,Int_t) {return 0;}
+ virtual TObjArray* GetMatchingDigitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fDigitsQAList,indexList,nHist,trigId);}
+ virtual TObjArray* GetMatchingRawsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fRawsQAList,indexList,nHist,trigId);}
+ virtual TObjArray* GetMatchingRecPointsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fRecPointsQAList,indexList,nHist,trigId);}
+ virtual TObjArray* GetMatchingESDsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fESDsQAList,indexList,nHist,trigId);}
+ //
+ virtual Int_t FillHitsData(Int_t, double ) {return -1;}
+ virtual Int_t FillSDigitsData(Int_t, double) {return -1;}
+ virtual Int_t FillDigitsData(Int_t index, double x) {return FillData(fDigitsQAList, index, x);}
+ virtual Int_t FillRawsData(Int_t index, double x) {return FillData(fRawsQAList, index, x);}
+ virtual Int_t FillRecPointsData(Int_t index, double x) {return FillData(fRecPointsQAList, index, x);}
+ virtual Int_t FillESDsData(Int_t index, double x) {return FillData(fESDsQAList, index, x);}
+ //
+ virtual Int_t FillHitsData(Int_t, double, double) {return -1;}
+ virtual Int_t FillSDigitsData(Int_t, double, double) {return -1;}
+ virtual Int_t FillDigitsData(Int_t index, double x, double y) {return FillData(fDigitsQAList, index, x, y);}
+ virtual Int_t FillRawsData(Int_t index, double x, double y) {return FillData(fRawsQAList, index, x, y);}
+ virtual Int_t FillRecPointsData(Int_t index, double x, double y) {return FillData(fRecPointsQAList, index, x, y);}
+ virtual Int_t FillESDsData(Int_t index, double x, double y) {return FillData(fESDsQAList, index, x, y);}
+ //
+ virtual Int_t FillHitsData(Int_t, double, double, double) {return -1;}
+ virtual Int_t FillSDigitsData(Int_t, double, double, double) {return -1;}
+ virtual Int_t FillDigitsData(Int_t index, double x, double y, double z) {return FillData(fDigitsQAList, index, x,y,z);}
+ virtual Int_t FillRawsData(Int_t index, double x, double y, double z) {return FillData(fRawsQAList, index, x,y,z);}
+ virtual Int_t FillRecPointsData(Int_t index, double x, double y, double z) {return FillData(fRecPointsQAList, index, x,y,z);}
+ virtual Int_t FillESDsData(Int_t index, double x, double y, double z) {return FillData(fESDsQAList, index, x,y,z);}
+ //
+ virtual Int_t SetHitsDataBinContent(Int_t, int, double) {return -1;}
+ virtual Int_t SetSDigitsDataBinContent(Int_t, int, double) {return -1;}
+ virtual Int_t SetDigitsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fDigitsQAList, index,bin,w);}
+ virtual Int_t SetRawsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fRawsQAList, index,bin,w);}
+ virtual Int_t SetRecPointsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fRecPointsQAList, index,bin,w);}
+ virtual Int_t SetESDsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fESDsQAList, index,bin,w);}
+ //
+ virtual Int_t SetHitsDataBinContent(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetSDigitsDataBinContent(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetDigitsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fDigitsQAList, index,binX,binY,w);}
+ virtual Int_t SetRawsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fRawsQAList, index,binX,binY,w);}
+ virtual Int_t SetRecPointsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fRecPointsQAList, index,binX,binY,w);}
+ virtual Int_t SetESDsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fESDsQAList, index,binX,binY,w);}
+ //
+ virtual Int_t SetHitsDataBinError(Int_t, int, double) {return -1;}
+ virtual Int_t SetSDigitsDataBinError(Int_t, int, double) {return -1;}
+ virtual Int_t SetDigitsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fDigitsQAList, index,bin,err);}
+ virtual Int_t SetRawsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fRawsQAList, index,bin,err);}
+ virtual Int_t SetRecPointsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fRecPointsQAList, index,bin,err);}
+ virtual Int_t SetESDsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fESDsQAList, index,bin,err);}
+ //
+ virtual Int_t SetHitsDataBinError(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetSDigitsDataBinError(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetDigitsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fDigitsQAList, index,binX,binY,err);}
+ virtual Int_t SetRawsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fRawsQAList, index,binX,binY,err);}
+ virtual Int_t SetRecPointsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fRecPointsQAList, index,binX,binY,err);}
+ virtual Int_t SetESDsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fESDsQAList, index,binX,binY,err);}
+ //
+ virtual Int_t ResetHitsData(Int_t, Option_t*) {return -1;}
+ virtual Int_t ResetSDigitsData(Int_t, Option_t*) {return -1;}
+ virtual Int_t ResetDigitsData(Int_t index, Option_t* opt="") {return ResetData(fDigitsQAList, index, opt);}
+ virtual Int_t ResetRawsData(Int_t index, Option_t* opt="") {return ResetData(fRawsQAList, index, opt);}
+ virtual Int_t ResetRecPointsData(Int_t index, Option_t* opt="") {return ResetData(fRecPointsQAList, index, opt);}
+ virtual Int_t ResetESDsData(Int_t index, Option_t* opt="") {return ResetData(fESDsQAList, index, opt);}
+ //
+ virtual Int_t ResetStatsHitsData(Int_t) {return -1;}
+ virtual Int_t ResetStatsSDigitsData(Int_t) {return -1;}
+ virtual Int_t ResetStatsDigitsData(Int_t index) {return ResetStatsData(fDigitsQAList, index);}
+ virtual Int_t ResetStatsRawsData(Int_t index) {return ResetStatsData(fRawsQAList, index);}
+ virtual Int_t ResetStatsRecPointsData(Int_t index) {return ResetStatsData(fRecPointsQAList, index);}
+ virtual Int_t ResetStatsESDsData(Int_t index) {return ResetStatsData(fESDsQAList, index);}
+ //
+ virtual void ClonePerTrigClass(AliQAv1::TASKINDEX_t task);
+ //
protected:
virtual void InitRecoParams() ;
- virtual void InitHits() {AliWarning("Call not valid") ; }
- //virtual void InitRecParticles() {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() {AliWarning("Call not valid") ; }
- virtual void MakeHits(TTree * ) {AliWarning("Call not valid") ; }
- virtual void MakeDigits() {AliInfo("To be implemented by detectors");}
- virtual void MakeDigits(TTree * ) {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() {AliWarning("Call not valid") ; }
- virtual void MakeSDigits(TTree * ) {AliWarning("Call not valid") ; }
- virtual void StartOfDetectorCycle() {AliInfo("To be implemented by detectors");}
-
- TObjArray * * fDigitsQAList ; //! list of the digits QA data objects
- TObjArray * * fESDsQAList ; //! list of the ESDs QA data objects
- TObjArray * * fRawsQAList ; //! list of the raws QA data objects
- TObjArray * * fRecPointsQAList ; //! list of the RecPoints QA data objects
+ virtual void InitHits() {AliWarning("Call not valid") ; }
+ //virtual void InitRecParticles() {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() {AliWarning("Call not valid") ; }
+ virtual void MakeHits(TTree * ) {AliWarning("Call not valid") ; }
+ virtual void MakeDigits() {AliInfo("To be implemented by detectors");}
+ virtual void MakeDigits(TTree * ) {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() {AliWarning("Call not valid") ; }
+ virtual void MakeSDigits(TTree * ) {AliWarning("Call not valid") ; }
+ virtual void StartOfDetectorCycle() {AliInfo("To be implemented by detectors");}
+
+ TObjArray * * fDigitsQAList ; //! list of the digits QA data objects
+ TObjArray * * fESDsQAList ; //! list of the ESDs QA data objects
+ TObjArray * * fRawsQAList ; //! list of the raws QA data objects
+ TObjArray * * fRecPointsQAList ; //! list of the RecPoints QA data objects
TNtupleD ** fCorrNt ; //! This is used by Corr only to hold its Ntuple.
const AliDetectorRecoParam *fRecoParam; //! const pointer to the reco parameters to be used in the reco QA
TClonesArray * fRecPointsArray; //! Array that contains the RecPoints
// }
StartOfDetectorCycle() ;
}
+
+
+//____________________________________________________________________________
+void AliQADataMakerSim::ClonePerTrigClass(AliQAv1::TASKINDEX_t task)
+{
+ // clone the histos of the array corresponding to task
+ switch (task)
+ {
+ case AliQAv1::kHITS : ClonePerTrigClassL(fHitsQAList, task); break;
+ case AliQAv1::kSDIGITS : ClonePerTrigClassL(fSDigitsQAList, task); break;
+ case AliQAv1::kDIGITS : ClonePerTrigClassL(fDigitsQAList, task); break;
+ default : AliError(Form("Task %s is invalid in this context", AliQAv1::GetTaskName(task).Data() )); break;
+ }
+ //
+}
{ return Add2List(hist, index, fSDigitsQAList, expert, image) ; }
virtual void Exec(AliQAv1::TASKINDEX_t task, TObject * data) ;
- virtual void EndOfCycle() ;
- virtual void EndOfCycle(AliQAv1::TASKINDEX_t task) ;
- virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
- virtual TH1 * GetDigitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fDigitsQAList, index)) ; }
- virtual TH1 * GetESDsData(const Int_t /*index*/) { return NULL ; }
- virtual TH1 * GetHitsData(const Int_t index) { return dynamic_cast<TH1 *>(GetData(fHitsQAList, index)) ; }
- virtual TH1 * GetRecPointsData(const Int_t /*index*/) { return NULL ; }
- virtual TH1 * GetRawsData(const Int_t /*index*/) { return NULL ; }
- 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 EndOfCycle() ;
+ virtual void EndOfCycle(AliQAv1::TASKINDEX_t task) ;
+ virtual void EndOfDetectorCycle(AliQAv1::TASKINDEX_t, TObjArray ** ) {AliInfo("To be implemented by detectors");}
+ //
+ virtual TObject* GetDigitsData(const Int_t index) { return GetData(fDigitsQAList, index); }
+ virtual TObject* GetESDsData(const Int_t /*index*/) { return NULL; }
+ virtual TObject* GetHitsData(const Int_t index) { return GetData(fHitsQAList, index); }
+ virtual TObject* GetRecPointsData(const Int_t /*index*/) { return NULL; }
+ virtual TObject* GetRawsData(const Int_t /*index*/) { return NULL; }
+ virtual TObject* GetSDigitsData(const Int_t index) { return GetData(fSDigitsQAList, index); }
+ //
+ virtual TH1* GetDigitsData(const Int_t index, int cloneID) { return GetData(fDigitsQAList, index, cloneID); }
+ virtual TH1* GetESDsData(const Int_t /*index*/, int) { return NULL; }
+ virtual TH1* GetHitsData(const Int_t index, int cloneID) { return GetData(fHitsQAList, index, cloneID); }
+ virtual TH1* GetRecPointsData(const Int_t /*index*/, int) { return NULL; }
+ virtual TH1* GetRawsData(const Int_t /*index*/, int) { return NULL; }
+ virtual TH1* GetSDigitsData(const Int_t index, int cloneID) { return GetData(fSDigitsQAList, index, cloneID); }
+ //
+ virtual TObjArray* GetDigitsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fDigitsQAList,cloneID,dest);}
+ virtual TObjArray* GetSDigitsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fSDigitsQAList,cloneID,dest);}
+ virtual TObjArray* GetESDsDataOfTrigClass(int /*cloneID*/, TObjArray */*dest*/=0) {return NULL;}
+ virtual TObjArray* GetHitsDataOfTrigClass(int cloneID, TObjArray *dest=0) {return GetDataOfTrigClass(fHitsQAList,cloneID,dest);}
+ virtual TObjArray* GetRecPointsDataOfTrigClass(int /*cloneID*/, TObjArray */*dest*/=0) {return NULL;}
+ virtual TObjArray* GetRawsDataOfTrigClass(int /*cloneID*/, TObjArray */*dest*/=0) {return NULL;}
+ //
+ 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 InitRecPoints() {AliWarning("Call not valid") ; }
+ virtual void InitRecPoints() {AliWarning("Call not valid") ; }
virtual void ResetDetector(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) ;
-
-protected:
-
- virtual void InitDigits() {AliInfo("To be implemented by detectors");}
- virtual void InitESDs() {AliWarning("Call not valid") ; }
- virtual void InitHits() {AliInfo("To be implemented by detectors");}
- virtual void InitSDigits() {AliInfo("To be implemented by detectors");}
- virtual void MakeESDs(AliESDEvent * ) {AliWarning("Call not valid") ; }
- virtual void MakeHits() {AliInfo("To be implemented by detectors");}
- virtual void MakeHits(TTree * ) {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() {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
+ virtual void StartOfCycle(Int_t run = -1) ;
+ virtual void StartOfCycle(AliQAv1::TASKINDEX_t task, Int_t run, const Bool_t sameCycle = kFALSE) ;
+ //
+ virtual TH1* GetMatchingHitsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fHitsQAList,index,trigId);}
+ virtual TH1* GetMatchingSDigitsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fSDigitsQAList,index,trigId);}
+ virtual TH1* GetMatchingDigitsHisto(Int_t index, Int_t trigId) {return GetMatchingHisto(fDigitsQAList,index,trigId);}
+ virtual TH1* GetMatchingRawsHisto(Int_t, Int_t) {return 0;}
+ virtual TH1* GetMatchingRecPointsHisto(Int_t, Int_t) {return 0;}
+ virtual TH1* GetMatchingESDsHisto(Int_t, Int_t) {return 0;}
+ //
+ virtual TObjArray* GetMatchingHitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fHitsQAList,indexList,nHist,trigId);}
+ virtual TObjArray* GetMatchingSDigitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fSDigitsQAList,indexList,nHist,trigId);}
+ virtual TObjArray* GetMatchingDigitsHistosSet(const Int_t* indexList, Int_t nHist,Int_t trigId) {return GetMatchingHistosSet(fDigitsQAList,indexList,nHist,trigId);}
+ virtual TObjArray* GetMatchingRawsHistosSet(const Int_t*, Int_t,Int_t) {return 0;}
+ virtual TObjArray* GetMatchingRecPointsHistosSet(const Int_t*,Int_t,Int_t) {return 0;}
+ virtual TObjArray* GetMatchingESDsHistosSet(const Int_t*, Int_t,Int_t) {return 0;}
+ //
+ virtual TObjArray* GetMatchingHitsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fHitsQAList,index,optDest);}
+ virtual TObjArray* GetMatchingSDigitsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fSDigitsQAList,index,optDest);}
+ virtual TObjArray* GetMatchingDigitsData(const Int_t index, TObjArray* optDest=0) {return GetMatchingHistos(fDigitsQAList,index,optDest);}
+ virtual TObjArray* GetMatchingRawsData(const Int_t, TObjArray*) {return 0;}
+ virtual TObjArray* GetMatchingRecPointsData(const Int_t, TObjArray*) {return 0;}
+ virtual TObjArray* GetMatchingESDsData(const Int_t, TObjArray*) {return 0;}
+ //
+ virtual Int_t FillHitsData(Int_t index, double x) {return FillData(fHitsQAList, index, x);}
+ virtual Int_t FillSDigitsData(Int_t index, double x) {return FillData(fSDigitsQAList, index, x);}
+ virtual Int_t FillDigitsData(Int_t index, double x) {return FillData(fDigitsQAList, index, x);}
+ virtual Int_t FillRawsData(Int_t, double) {return -1;}
+ virtual Int_t FillRecPointsData(Int_t, double) {return -1;}
+ virtual Int_t FillESDsData(Int_t, double) {return -1;}
+ //
+ virtual Int_t FillHitsData(Int_t index, double x, double y) {return FillData(fHitsQAList, index, x, y);}
+ virtual Int_t FillSDigitsData(Int_t index, double x, double y) {return FillData(fSDigitsQAList, index, x, y);}
+ virtual Int_t FillDigitsData(Int_t index, double x, double y) {return FillData(fDigitsQAList, index, x, y);}
+ virtual Int_t FillRawsData(Int_t, double, double) {return -1;}
+ virtual Int_t FillRecPointsData(Int_t, double, double) {return -1;}
+ virtual Int_t FillESDsData(Int_t, double, double) {return -1;}
+ //
+ virtual Int_t FillHitsData(Int_t index, double x, double y, double z) {return FillData(fHitsQAList, index, x,y,z);}
+ virtual Int_t FillSDigitsData(Int_t index, double x, double y, double z) {return FillData(fSDigitsQAList, index, x,y,z);}
+ virtual Int_t FillDigitsData(Int_t index, double x, double y, double z) {return FillData(fDigitsQAList, index, x,y,z);}
+ virtual Int_t FillRawsData(Int_t, double, double, double) {return -1;}
+ virtual Int_t FillRecPointsData(Int_t, double, double, double) {return -1;}
+ virtual Int_t FillESDsData(Int_t, double, double, double) {return -1;}
+ //
+ virtual Int_t SetHitsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fHitsQAList, index,bin,w);}
+ virtual Int_t SetDigitsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fDigitsQAList, index,bin,w);}
+ virtual Int_t SetSDigitsDataBinContent(Int_t index, int bin, double w) {return SetDataBinContent(fSDigitsQAList, index,bin,w);}
+ virtual Int_t SetRawsDataBinContent(Int_t, int, double) {return -1;}
+ virtual Int_t SetRecPointsDataBinContent(Int_t, int, double) {return -1;}
+ virtual Int_t SetESDsDataBinContent(Int_t, int, double) {return -1;}
+ //
+ virtual Int_t SetHitsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fHitsQAList, index,binX,binY,w);}
+ virtual Int_t SetDigitsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fDigitsQAList, index,binX,binY,w);}
+ virtual Int_t SetSDigitsDataBinContent(Int_t index, int binX, int binY, double w) {return SetDataBinContent(fSDigitsQAList, index,binX,binY,w);}
+ virtual Int_t SetRawsDataBinContent(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetRecPointsDataBinContent(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetESDsDataBinContent(Int_t, int, int, double) {return -1;}
+ //
+ virtual Int_t SetHitsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fHitsQAList, index,bin,err);}
+ virtual Int_t SetDigitsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fDigitsQAList, index,bin,err);}
+ virtual Int_t SetSDigitsDataBinError(Int_t index, int bin, double err) {return SetDataBinError(fSDigitsQAList, index,bin,err);}
+ virtual Int_t SetRawsDataBinError(Int_t, int, double) {return -1;}
+ virtual Int_t SetRecPointsDataBinError(Int_t, int, double) {return -1;}
+ virtual Int_t SetESDsDataBinError(Int_t, int, double) {return -1;}
+ //
+ virtual Int_t SetHitsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fHitsQAList, index,binX,binY,err);}
+ virtual Int_t SetDigitsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fDigitsQAList, index,binX,binY,err);}
+ virtual Int_t SetSDigitsDataBinError(Int_t index, int binX, int binY, double err) {return SetDataBinError(fSDigitsQAList, index,binX,binY,err);}
+ virtual Int_t SetRawsDataBinError(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetRecPointsDataBinError(Int_t, int, int, double) {return -1;}
+ virtual Int_t SetESDsDataBinError(Int_t, int, int, double) {return -1;}
+ //
+ virtual Int_t ResetHitsData(Int_t index, Option_t* opt="") {return ResetData(fHitsQAList, index, opt);}
+ virtual Int_t ResetSDigitsData(Int_t index, Option_t* opt="") {return ResetData(fSDigitsQAList, index, opt);}
+ virtual Int_t ResetDigitsData(Int_t index, Option_t* opt="") {return ResetData(fDigitsQAList, index, opt);}
+ virtual Int_t ResetRawsData(Int_t, Option_t*) {return -1;}
+ virtual Int_t ResetRecPointsData(Int_t, Option_t*) {return -1;}
+ virtual Int_t ResetESDsData(Int_t, Option_t*) {return -1;}
+ //
+ virtual Int_t ResetStatsHitsData(Int_t index) {return ResetStatsData(fHitsQAList, index);}
+ virtual Int_t ResetStatsSDigitsData(Int_t index) {return ResetStatsData(fSDigitsQAList, index);}
+ virtual Int_t ResetStatsDigitsData(Int_t index) {return ResetStatsData(fDigitsQAList, index);}
+ virtual Int_t ResetStatsRawsData(Int_t) {return -1;}
+ virtual Int_t ResetStatsRecPointsData(Int_t) {return -1;}
+ virtual Int_t ResetStatsESDsData(Int_t) {return -1;}
+ //
+ virtual void ClonePerTrigClass(AliQAv1::TASKINDEX_t task);
+ //
+ protected:
+ //
+ virtual void InitDigits() {AliInfo("To be implemented by detectors");}
+ virtual void InitESDs() {AliWarning("Call not valid") ; }
+ virtual void InitHits() {AliInfo("To be implemented by detectors");}
+ virtual void InitSDigits() {AliInfo("To be implemented by detectors");}
+ virtual void MakeESDs(AliESDEvent * ) {AliWarning("Call not valid") ; }
+ virtual void MakeHits() {AliInfo("To be implemented by detectors");}
+ virtual void MakeHits(TTree * ) {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() {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
fPrintImage(kTRUE),
fSaveData(kTRUE)
{
- // default ctor
- fMaxEvents = fNumberOfEvents ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- fLoader[iDet] = NULL ;
- fQADataMaker[iDet] = NULL ;
- fQACycles[iDet] = 999999 ;
- }
- }
+ // default ctor
+ fMaxEvents = fNumberOfEvents ;
+ for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ fLoader[iDet] = NULL ;
+ fQADataMaker[iDet] = NULL ;
+ fQACycles[iDet] = 999999 ;
+ }
+ }
SetWriteExpert() ;
}
AliQAManager::AliQAManager(AliQAv1::MODE_t mode, const Char_t* gAliceFilename) :
AliCDBManager(),
fCurrentEvent(0),
- fCycleSame(kFALSE),
- fDetectors("ALL"),
- fDetectorsW("ALL"),
- fESD(NULL),
- fESDTree(NULL),
- fGAliceFileName(gAliceFilename),
- fFirstEvent(0),
- fMaxEvents(0),
+ fCycleSame(kFALSE),
+ fDetectors("ALL"),
+ fDetectorsW("ALL"),
+ fESD(NULL),
+ fESDTree(NULL),
+ fGAliceFileName(gAliceFilename),
+ fFirstEvent(0),
+ fMaxEvents(0),
fMode(AliQAv1::GetModeName(mode)),
- fNumberOfEvents(999999),
+ fNumberOfEvents(999999),
fRecoParam(),
- fRunNumber(0),
- fRawReader(NULL),
- fRawReaderDelete(kTRUE),
- fRunLoader(NULL),
+ fRunNumber(0),
+ fRawReader(NULL),
+ fRawReaderDelete(kTRUE),
+ fRunLoader(NULL),
fTasks(""),
fEventSpecie(AliRecoParam::kDefault),
fPrintImage(kTRUE),
fSaveData(kTRUE)
{
- // default ctor
- fMaxEvents = fNumberOfEvents ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- fLoader[iDet] = NULL ;
- fQADataMaker[iDet] = NULL ;
- fQACycles[iDet] = 999999 ;
+ // default ctor
+ fMaxEvents = fNumberOfEvents ;
+ for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ fLoader[iDet] = NULL ;
+ fQADataMaker[iDet] = NULL ;
+ fQACycles[iDet] = 999999 ;
}
}
SetWriteExpert() ;
//_____________________________________________________________________________
AliQAManager::AliQAManager(const AliQAManager & qas) :
AliCDBManager(),
- fCurrentEvent(qas.fCurrentEvent),
- fCycleSame(kFALSE),
- fDetectors(qas.fDetectors),
- fDetectorsW(qas.fDetectorsW),
- fESD(NULL),
- fESDTree(NULL),
- fGAliceFileName(qas.fGAliceFileName),
- fFirstEvent(qas.fFirstEvent),
- fMaxEvents(qas.fMaxEvents),
- fMode(qas.fMode),
- fNumberOfEvents(qas.fNumberOfEvents),
- fRecoParam(),
- fRunNumber(qas.fRunNumber),
- fRawReader(NULL),
- fRawReaderDelete(kTRUE),
- fRunLoader(NULL),
+ fCurrentEvent(qas.fCurrentEvent),
+ fCycleSame(kFALSE),
+ fDetectors(qas.fDetectors),
+ fDetectorsW(qas.fDetectorsW),
+ fESD(NULL),
+ fESDTree(NULL),
+ fGAliceFileName(qas.fGAliceFileName),
+ fFirstEvent(qas.fFirstEvent),
+ fMaxEvents(qas.fMaxEvents),
+ fMode(qas.fMode),
+ fNumberOfEvents(qas.fNumberOfEvents),
+ fRecoParam(),
+ fRunNumber(qas.fRunNumber),
+ fRawReader(NULL),
+ fRawReaderDelete(kTRUE),
+ fRunLoader(NULL),
fTasks(qas.fTasks),
fEventSpecie(qas.fEventSpecie),
fPrintImage(qas.fPrintImage),
fSaveData(qas.fSaveData)
{
- // cpy ctor
- for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- fLoader[iDet] = qas.fLoader[iDet] ;
- fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
- fQACycles[iDet] = qas.fQACycles[iDet] ;
+ // cpy ctor
+ for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ fLoader[iDet] = qas.fLoader[iDet] ;
+ fQADataMaker[iDet] = qas.fQADataMaker[iDet] ;
+ fQACycles[iDet] = qas.fQACycles[iDet] ;
fQAWriteExpert[iDet] = qas.fQAWriteExpert[iDet] ;
}
}
//_____________________________________________________________________________
AliQAManager & AliQAManager::operator = (const AliQAManager & qas)
{
- // assignment operator
+ // assignment operator
this->~AliQAManager() ;
new(this) AliQAManager(qas) ;
return *this ;
//_____________________________________________________________________________
AliQAManager::~AliQAManager()
{
- // dtor
- for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- fLoader[iDet] = NULL;
- if (fQADataMaker[iDet]) {
- (fQADataMaker[iDet])->Finish() ;
- delete fQADataMaker[iDet] ;
- }
- }
- }
- if (fRawReaderDelete) {
- fRunLoader = NULL ;
- delete fRawReader ;
- fRawReader = NULL ;
- }
+ // dtor
+ for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ fLoader[iDet] = NULL;
+ if (fQADataMaker[iDet]) {
+ (fQADataMaker[iDet])->Finish() ;
+ delete fQADataMaker[iDet] ;
+ }
+ }
+ }
+ if (fRawReaderDelete) {
+ fRunLoader = NULL ;
+ delete fRawReader ;
+ fRawReader = NULL ;
+ }
}
//_____________________________________________________________________________
Bool_t AliQAManager::DoIt(const AliQAv1::TASKINDEX_t taskIndex)
{
- // Runs all the QA data Maker for every detector
+ // Runs all the QA data Maker for every detector
- Bool_t rv = kFALSE ;
- // Fill QA data in event loop
- for (UInt_t iEvent = fFirstEvent ; iEvent < (UInt_t)fMaxEvents ; iEvent++) {
- fCurrentEvent++ ;
- // Get the event
- if ( iEvent%10 == 0 )
- AliDebug(AliQAv1::GetQADebugLevel(), Form("processing event %d", iEvent));
- if ( taskIndex == AliQAv1::kRAWS ) {
- if ( !fRawReader->NextEvent() )
- break ;
- } else if ( taskIndex == AliQAv1::kESDS ) {
- if ( fESDTree->GetEntry(iEvent) == 0 )
- break ;
- } else {
- if ( fRunLoader->GetEvent(iEvent) != 0 )
- break ;
- }
- // loop over active loaders
- for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet) ;
- if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
- if ( qadm->IsCycleDone() ) {
+ Bool_t rv = kFALSE ;
+ // Fill QA data in event loop
+ for (UInt_t iEvent = fFirstEvent ; iEvent < (UInt_t)fMaxEvents ; iEvent++) {
+ fCurrentEvent++ ;
+ // Get the event
+ if ( iEvent%10 == 0 )
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("processing event %d", iEvent));
+ if ( taskIndex == AliQAv1::kRAWS ) {
+ if ( !fRawReader->NextEvent() )
+ break ;
+ } else if ( taskIndex == AliQAv1::kESDS ) {
+ if ( fESDTree->GetEntry(iEvent) == 0 )
+ break ;
+ } else {
+ if ( fRunLoader->GetEvent(iEvent) != 0 )
+ break ;
+ }
+ // loop over active loaders
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (!qadm) continue; // This detector doesn't have any QA (for example, HLT)
+ if ( qadm->IsCycleDone() ) {
qadm->EndOfCycle(taskIndex) ;
- }
- TTree * data = NULL ;
- AliLoader* loader = GetLoader(qadm->GetUniqueID());
- switch (taskIndex) {
- case AliQAv1::kNULLTASKINDEX :
- break ;
- case AliQAv1::kRAWS :
- qadm->Exec(taskIndex, fRawReader) ;
- break ;
- case AliQAv1::kHITS :
- if( loader ) {
- loader->LoadHits() ;
- data = loader->TreeH() ;
- if ( ! data ) {
- AliWarning(Form(" Hit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
- break ;
- }
- qadm->Exec(taskIndex, data) ;
- }
- break ;
- case AliQAv1::kSDIGITS :
+ }
+ TTree * data = NULL ;
+ AliLoader* loader = GetLoader(qadm->GetUniqueID());
+ switch (taskIndex) {
+ case AliQAv1::kNULLTASKINDEX :
+ break ;
+ case AliQAv1::kRAWS :
+ qadm->Exec(taskIndex, fRawReader) ;
+ break ;
+ case AliQAv1::kHITS :
+ if( loader ) {
+ loader->LoadHits() ;
+ data = loader->TreeH() ;
+ if ( ! data ) {
+ AliWarning(Form(" Hit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
+ break ;
+ }
+ qadm->Exec(taskIndex, data) ;
+ }
+ break ;
+ case AliQAv1::kSDIGITS :
{
TString fileName(Form("%s.SDigits.root", AliQAv1::GetDetName(iDet))) ;
}
}
}
- break;
- case AliQAv1::kDIGITS :
- if( loader ) {
- loader->LoadDigits() ;
- data = loader->TreeD() ;
- if ( ! data ) {
- AliWarning(Form(" Digit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
- break ;
- }
- qadm->Exec(taskIndex, data) ;
- }
- break;
- case AliQAv1::kDIGITSR :
- if( loader ) {
- loader->LoadDigits() ;
- data = loader->TreeD() ;
- if ( ! data ) {
- AliWarning(Form(" Digit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
- break ;
- }
- qadm->Exec(taskIndex, data) ;
- }
- break;
- case AliQAv1::kRECPOINTS :
- if( loader ) {
- loader->LoadRecPoints() ;
- data = loader->TreeR() ;
- if (!data) {
- AliWarning(Form("RecPoints not found for %s", AliQAv1::GetDetName(iDet))) ;
- break ;
- }
- qadm->Exec(taskIndex, data) ;
- }
- break;
- case AliQAv1::kTRACKSEGMENTS :
- break;
- case AliQAv1::kRECPARTICLES :
- break;
- case AliQAv1::kESDS :
- qadm->Exec(taskIndex, fESD) ;
- break;
- case AliQAv1::kNTASKINDEX :
- break;
- } //task switch
- }
- } // detector loop
+ break;
+ case AliQAv1::kDIGITS :
+ if( loader ) {
+ loader->LoadDigits() ;
+ data = loader->TreeD() ;
+ if ( ! data ) {
+ AliWarning(Form(" Digit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
+ break ;
+ }
+ qadm->Exec(taskIndex, data) ;
+ }
+ break;
+ case AliQAv1::kDIGITSR :
+ if( loader ) {
+ loader->LoadDigits() ;
+ data = loader->TreeD() ;
+ if ( ! data ) {
+ AliWarning(Form(" Digit Tree not found for %s", AliQAv1::GetDetName(iDet))) ;
+ break ;
+ }
+ qadm->Exec(taskIndex, data) ;
+ }
+ break;
+ case AliQAv1::kRECPOINTS :
+ if( loader ) {
+ loader->LoadRecPoints() ;
+ data = loader->TreeR() ;
+ if (!data) {
+ AliWarning(Form("RecPoints not found for %s", AliQAv1::GetDetName(iDet))) ;
+ break ;
+ }
+ qadm->Exec(taskIndex, data) ;
+ }
+ break;
+ case AliQAv1::kTRACKSEGMENTS :
+ break;
+ case AliQAv1::kRECPARTICLES :
+ break;
+ case AliQAv1::kESDS :
+ qadm->Exec(taskIndex, fESD) ;
+ break;
+ case AliQAv1::kNTASKINDEX :
+ break;
+ } //task switch
+ }
+ } // detector loop
Increment(taskIndex) ;
- } // event loop
- // Save QA data for all detectors
+ } // event loop
+ // Save QA data for all detectors
EndOfCycle() ;
- if ( taskIndex == AliQAv1::kRAWS )
- fRawReader->RewindEvents() ;
+ if ( taskIndex == AliQAv1::kRAWS )
+ fRawReader->RewindEvents() ;
- return rv ;
+ return rv ;
}
//_____________________________________________________________________________
Bool_t AliQAManager::Finish(const AliQAv1::TASKINDEX_t taskIndex)
{
- // write output to file for all detectors
+ // write output to file for all detectors
AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet) ;
- if (qadm)
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (qadm)
qadm->EndOfCycle(taskIndex) ;
- }
- }
- return kTRUE ;
+ }
+ }
+ return kTRUE ;
}
//_____________________________________________________________________________
TObjArray * AliQAManager::GetFromOCDB(AliQAv1::DETECTORINDEX_t det, AliQAv1::TASKINDEX_t task, const Char_t * year) const
{
- // Retrieve the list of QA data for a given detector and a given task
- TObjArray * rv = NULL ;
- if ( !strlen(AliQAv1::GetQARefStorage()) ) {
- AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
- return NULL ;
- }
- if ( ! IsDefaultStorageSet() ) {
- TString tmp(AliQAv1::GetQARefDefaultStorage()) ;
- tmp.Append(year) ;
- tmp.Append("/") ;
- Instance()->SetDefaultStorage(tmp.Data()) ;
- Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
- }
- TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ;
- 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 = static_cast<TList *>(entry->GetObject()) ;
- if ( listDetQAD )
- rv = static_cast<TObjArray *>(listDetQAD->FindObject(AliQAv1::GetTaskName(task))) ;
- return rv ;
+ // Retrieve the list of QA data for a given detector and a given task
+ TObjArray * rv = NULL ;
+ if ( !strlen(AliQAv1::GetQARefStorage()) ) {
+ AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
+ return NULL ;
+ }
+ if ( ! IsDefaultStorageSet() ) {
+ TString tmp(AliQAv1::GetQARefDefaultStorage()) ;
+ tmp.Append(year) ;
+ tmp.Append("/") ;
+ Instance()->SetDefaultStorage(tmp.Data()) ;
+ Instance()->SetSpecificStorage(Form("%s/*", AliQAv1::GetQAName()), AliQAv1::GetQARefStorage()) ;
+ }
+ TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetQAName(), AliQAv1::GetDetName((Int_t)det), AliQAv1::GetRefOCDBDirName())) ;
+ 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 = static_cast<TList *>(entry->GetObject()) ;
+ if ( listDetQAD )
+ rv = static_cast<TObjArray *>(listDetQAD->FindObject(AliQAv1::GetTaskName(task))) ;
+ return rv ;
}
//_____________________________________________________________________________
//_____________________________________________________________________________
AliLoader * AliQAManager::GetLoader(Int_t iDet)
{
- // get the loader for a detector
+ // get the loader for a detector
- if ( !fRunLoader || iDet == AliQAv1::kCORR || iDet == AliQAv1::kGLOBAL )
- return NULL ;
+ if ( !fRunLoader || iDet == AliQAv1::kCORR || iDet == AliQAv1::kGLOBAL )
+ return NULL ;
- TString detName = AliQAv1::GetDetName(iDet) ;
- fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
- if (fLoader[iDet])
- return fLoader[iDet] ;
+ TString detName = AliQAv1::GetDetName(iDet) ;
+ fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
+ if (fLoader[iDet])
+ return fLoader[iDet] ;
- // load the QA data maker object
- TPluginManager* pluginManager = gROOT->GetPluginManager() ;
- TString loaderName = "Ali" + detName + "Loader" ;
-
- AliLoader * loader = NULL ;
- // first check if a plugin is defined for the quality assurance data maker
- TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
- // if not, add a plugin for it
- if (!pluginHandler) {
- 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 + "()") ;
- } else {
- pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
- }
- pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
- }
- if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
- }
- if (loader)
- fLoader[iDet] = loader ;
- return loader ;
+ // load the QA data maker object
+ TPluginManager* pluginManager = gROOT->GetPluginManager() ;
+ TString loaderName = "Ali" + detName + "Loader" ;
+
+ AliLoader * loader = NULL ;
+ // first check if a plugin is defined for the quality assurance data maker
+ TPluginHandler* pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
+ // if not, add a plugin for it
+ if (!pluginHandler) {
+ 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 + "()") ;
+ } else {
+ pluginManager->AddHandler("AliLoader", detName, loaderName, detName, loaderName + "()") ;
+ }
+ pluginHandler = pluginManager->FindHandler("AliLoader", detName) ;
+ }
+ if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
+ loader = (AliLoader *) pluginHandler->ExecPlugin(0) ;
+ }
+ if (loader)
+ fLoader[iDet] = loader ;
+ return loader ;
}
//_____________________________________________________________________________
AliQAv1 * AliQAManager::GetQA(UInt_t run, UInt_t evt)
{
-// retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"
+ // retrieves the QA object stored in a file named "Run{run}.Event{evt}_1.ESD.tag.root"
Char_t * fileName = Form("Run%d.Event%d_1.ESD.tag.root", run, evt) ;
TFile * tagFile = TFile::Open(fileName) ;
if ( !tagFile ) {
//_____________________________________________________________________________
AliQADataMaker * AliQAManager::GetQADataMaker(const Int_t iDet)
{
- // get the quality assurance data maker for a detector
+ // get the quality assurance data maker for a detector
AliQADataMaker * qadm = fQADataMaker[iDet] ;
- if (qadm) {
+ if (qadm) {
qadm->SetEventSpecie(fEventSpecie) ;
if ( qadm->GetRecoParam() )
} else if (iDet == AliQAv1::kGLOBAL && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0) { //Global QA
- qadm = new AliGlobalQADataMaker();
- qadm->SetName(AliQAv1::GetDetName(iDet));
- qadm->SetUniqueID(iDet);
- fQADataMaker[iDet] = qadm;
+ qadm = new AliGlobalQADataMaker();
+ qadm->SetName(AliQAv1::GetDetName(iDet));
+ qadm->SetUniqueID(iDet);
+ fQADataMaker[iDet] = qadm;
qadm->SetEventSpecie(fEventSpecie) ;
if ( qadm->GetRecoParam() )
if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
- } else if (iDet == AliQAv1::kCORR && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0 ) { //the data maker for correlations among detectors
+ } else if (iDet == AliQAv1::kCORR && strcmp(GetMode(), AliQAv1::GetModeName(AliQAv1::kRECMODE)) == 0 ) { //the data maker for correlations among detectors
qadm = new AliCorrQADataMakerRec(fQADataMaker) ;
- qadm->SetName(AliQAv1::GetDetName(iDet));
- qadm->SetUniqueID(iDet);
- fQADataMaker[iDet] = qadm;
+ qadm->SetName(AliQAv1::GetDetName(iDet));
+ qadm->SetUniqueID(iDet);
+ fQADataMaker[iDet] = qadm;
qadm->SetEventSpecie(fEventSpecie) ;
if ( qadm->GetRecoParam() )
if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
//_____________________________________________________________________________
void AliQAManager::EndOfCycle(TObjArray * detArray)
{
- // End of cycle QADataMakers
+ // End of cycle QADataMakers
AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
TCanvas fakeCanvas ;
- fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet) ;
- if (!qadm)
- continue ;
- // skip non active detectors
- if (detArray) {
- AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
- if (!det || !det->IsActive())
- continue ;
- }
- AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
+ fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (!qadm)
+ continue ;
+ // skip non active detectors
+ if (detArray) {
+ AliModule* det = static_cast<AliModule*>(detArray->FindObject(AliQAv1::GetDetName(iDet))) ;
+ if (!det || !det->IsActive())
+ continue ;
+ }
+ AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
if (qac)
qac->SetPrintImage(fPrintImage) ;
for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
if ( fTasks.Contains(Form("%d", taskIndex)) )
qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
}
- qadm->Finish();
- }
- }
+ qadm->Finish();
+ }
+ }
if (fPrintImage)
fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps");
}
//_____________________________________________________________________________
void AliQAManager::EndOfCycle(TString detectors)
{
- // End of cycle QADataMakers
-
+ // End of cycle QADataMakers
+
AliQAChecker::Instance()->SetRunNumber(fRunNumber) ;
TCanvas fakeCanvas ;
if (fPrintImage)
fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet) ;
- if (!qadm)
- continue ;
- // skip non active detectors
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (!qadm)
+ continue ;
+ // skip non active detectors
if (!detectors.Contains(AliQAv1::GetDetName(iDet)))
continue ;
- AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
+ AliQACheckerBase * qac = AliQAChecker::Instance()->GetDetQAChecker(iDet) ;
if (qac)
qac->SetPrintImage(fPrintImage) ;
for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
if ( fTasks.Contains(Form("%d", taskIndex)) )
qadm->EndOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex))) ;
}
- qadm->Finish();
- }
- }
+ qadm->Finish();
+ }
+ }
if (fPrintImage)
fakeCanvas.Print(Form("%s%s%d.%s]", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps");
}
return ;
else
currentTask = taskIndex ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet) ;
- if (qadm)
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (qadm)
qadm->Increment() ;
}
}
//_____________________________________________________________________________
Bool_t AliQAManager::InitQA(const AliQAv1::TASKINDEX_t taskIndex, const Char_t * input )
{
- // Initialize the event source and QA data makers
+ // Initialize the event source and QA data makers
- fTasks += Form("%d", taskIndex) ;
-
- if (taskIndex == AliQAv1::kRAWS) {
- if (!fRawReader) {
- fRawReader = AliRawReader::Create(input);
- }
- if ( ! fRawReader )
- return kFALSE ;
- fRawReaderDelete = kTRUE ;
- fRawReader->NextEvent() ;
- fRunNumber = fRawReader->GetRunNumber() ;
- SetRun(fRunNumber) ;
- fRawReader->RewindEvents();
- fNumberOfEvents = 999999 ;
- if ( fMaxEvents < 0 )
- fMaxEvents = fNumberOfEvents ;
- } else if (taskIndex == AliQAv1::kESDS) {
- fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ;
- if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
- TFile * esdFile = TFile::Open("AliESDs.root") ;
- fESDTree = static_cast<TTree *> (esdFile->Get("esdTree")) ;
- if ( !fESDTree ) {
- AliError("esdTree not found") ;
- return kFALSE ;
- } else {
- fESD = new AliESDEvent() ;
- fESD->ReadFromTree(fESDTree) ;
- fESDTree->GetEntry(0) ;
- fRunNumber = fESD->GetRunNumber() ;
- fNumberOfEvents = fESDTree->GetEntries() ;
- if ( fMaxEvents < 0 )
- fMaxEvents = fNumberOfEvents ;
- }
- } else {
- AliError("AliESDs.root not found") ;
- return kFALSE ;
- }
- } else {
- if ( !InitRunLoader() ) {
- AliWarning("No Run Loader not found") ;
+ fTasks += Form("%d", taskIndex) ;
+
+ if (taskIndex == AliQAv1::kRAWS) {
+ if (!fRawReader) {
+ fRawReader = AliRawReader::Create(input);
+ }
+ if ( ! fRawReader )
+ return kFALSE ;
+ fRawReaderDelete = kTRUE ;
+ fRawReader->NextEvent() ;
+ fRunNumber = fRawReader->GetRunNumber() ;
+ SetRun(fRunNumber) ;
+ fRawReader->RewindEvents();
+ fNumberOfEvents = 999999 ;
+ if ( fMaxEvents < 0 )
+ fMaxEvents = fNumberOfEvents ;
+ } else if (taskIndex == AliQAv1::kESDS) {
+ fTasks = AliQAv1::GetTaskName(AliQAv1::kESDS) ;
+ if (!gSystem->AccessPathName("AliESDs.root")) { // AliESDs.root exists
+ TFile * esdFile = TFile::Open("AliESDs.root") ;
+ fESDTree = static_cast<TTree *> (esdFile->Get("esdTree")) ;
+ if ( !fESDTree ) {
+ AliError("esdTree not found") ;
+ return kFALSE ;
} else {
- fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
- if ( fMaxEvents < 0 )
- fMaxEvents = fNumberOfEvents ;
+ fESD = new AliESDEvent() ;
+ fESD->ReadFromTree(fESDTree) ;
+ fESDTree->GetEntry(0) ;
+ fRunNumber = fESD->GetRunNumber() ;
+ fNumberOfEvents = fESDTree->GetEntries() ;
+ if ( fMaxEvents < 0 )
+ fMaxEvents = fNumberOfEvents ;
}
+ } else {
+ AliError("AliESDs.root not found") ;
+ return kFALSE ;
+ }
+ } else {
+ if ( !InitRunLoader() ) {
+ AliWarning("No Run Loader not found") ;
+ } else {
+ fNumberOfEvents = fRunLoader->GetNumberOfEvents() ;
+ if ( fMaxEvents < 0 )
+ fMaxEvents = fNumberOfEvents ;
}
+ }
// Get Detectors
TObjArray* detArray = NULL ;
- if (fRunLoader) // check if RunLoader exists
- if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
- detArray = fRunLoader->GetAliRun()->Detectors() ;
- fRunNumber = fRunLoader->GetHeader()->GetRun() ;
- }
-
- // Initialize all QA data makers for all detectors
- fRunNumber = AliCDBManager::Instance()->GetRun() ;
- if ( ! AliGeomManager::GetGeometry() )
- AliGeomManager::LoadGeometry() ;
+ if (fRunLoader) // check if RunLoader exists
+ if ( fRunLoader->GetAliRun() ) { // check if AliRun exists in gAlice.root
+ detArray = fRunLoader->GetAliRun()->Detectors() ;
+ fRunNumber = fRunLoader->GetHeader()->GetRun() ;
+ }
+
+ // Initialize all QA data makers for all detectors
+ fRunNumber = AliCDBManager::Instance()->GetRun() ;
+ if ( ! AliGeomManager::GetGeometry() )
+ AliGeomManager::LoadGeometry() ;
- InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ;
+ InitQADataMaker(fRunNumber, detArray) ; //, fCycleSame, kTRUE, detArray) ;
if (fPrintImage) {
TCanvas fakeCanvas ;
TStopwatch timer ;
}
fakeCanvas.Print(Form("%s%s%d.%s[", AliQAv1::GetImageFileName(), GetMode(), fRunNumber, AliQAv1::GetImageFileFormat()), "ps") ;
}
- return kTRUE ;
+ return kTRUE ;
}
//_____________________________________________________________________________
void AliQAManager::InitQADataMaker(UInt_t run, TObjArray * detArray)
{
- // Initializes The QADataMaker for all active detectors and for all active tasks
+ // Initializes The QADataMaker for all active detectors and for all active tasks
fRunNumber = run ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet) ;
- if (!qadm) {
- AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ;
- fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ;
- } else {
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet) ;
+ if (!qadm) {
+ AliError(Form("AliQADataMaker not found for %s", AliQAv1::GetDetName(iDet))) ;
+ fDetectorsW.ReplaceAll(AliQAv1::GetDetName(iDet), "") ;
+ } else {
if (fQAWriteExpert[iDet])
qadm->SetWriteExpert() ;
- 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))) ;
- if (!det || !det->IsActive())
- continue ;
- }
- // Set default reco params
+ 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))) ;
+ if (!det || !det->IsActive())
+ continue ;
+ }
+ // Set default reco params
Bool_t sameCycle = kFALSE ;
- for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
- if ( fTasks.Contains(Form("%d", taskIndex)) ) {
- qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
+ for (UInt_t taskIndex = 0; taskIndex < AliQAv1::kNTASKINDEX; taskIndex++) {
+ if ( fTasks.Contains(Form("%d", taskIndex)) ) {
+ qadm->Init(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), GetQACycles(qadm->GetUniqueID())) ;
qadm->StartOfCycle(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(taskIndex)), run, sameCycle) ;
sameCycle = kTRUE ;
- }
- }
- }
- }
+ }
}
+ }
+ }
+ }
}
//_____________________________________________________________________________
Bool_t AliQAManager::InitRunLoader()
{
- // get or create the run loader
- if (fRunLoader) {
- fCycleSame = kTRUE ;
- } else {
- if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
- // load all base libraries to get the loader classes
- TString libs = gSystem->GetLibraries() ;
- for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(AliQAv1::GetDetName(iDet)))
- continue ;
- TString detName = AliQAv1::GetDetName(iDet) ;
- if (detName == "HLT")
- continue;
- if (libs.Contains("lib" + detName + "base.so"))
- continue;
- gSystem->Load("lib" + detName + "base.so");
- }
- fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
- if (!fRunLoader) {
- AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
- return kFALSE;
- }
- fRunLoader->CdGAFile();
- if (fRunLoader->LoadgAlice() == 0) {
- gAlice = fRunLoader->GetAliRun();
- }
-
- if (!gAlice) {
- AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
- return kFALSE;
- }
-
- } else { // galice.root does not exist
- AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
- return kFALSE;
- }
- }
+ // get or create the run loader
+ if (fRunLoader) {
+ fCycleSame = kTRUE ;
+ } else {
+ if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+ // load all base libraries to get the loader classes
+ TString libs = gSystem->GetLibraries() ;
+ for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(AliQAv1::GetDetName(iDet)))
+ continue ;
+ TString detName = AliQAv1::GetDetName(iDet) ;
+ if (detName == "HLT")
+ continue;
+ if (libs.Contains("lib" + detName + "base.so"))
+ continue;
+ gSystem->Load("lib" + detName + "base.so");
+ }
+ fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
+ if (!fRunLoader) {
+ AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
+ return kFALSE;
+ }
+ fRunLoader->CdGAFile();
+ if (fRunLoader->LoadgAlice() == 0) {
+ gAlice = fRunLoader->GetAliRun();
+ }
- if (!fRunNumber) {
- fRunLoader->LoadHeader();
- fRunNumber = fRunLoader->GetHeader()->GetRun() ;
- }
- return kTRUE;
+ if (!gAlice) {
+ AliError(Form("no gAlice object found in file %s", fGAliceFileName.Data()));
+ return kFALSE;
+ }
+
+ } else { // galice.root does not exist
+ AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
+ return kFALSE;
+ }
+ }
+
+ if (!fRunNumber) {
+ fRunLoader->LoadHeader();
+ fRunNumber = fRunLoader->GetHeader()->GetRun() ;
+ }
+ return kTRUE;
}
//_____________________________________________________________________________
Bool_t AliQAManager::IsSelected(const Char_t * det)
{
// check whether detName is contained in detectors
- // if yes, it is removed from detectors
+ // if yes, it is removed from detectors
- Bool_t rv = kFALSE;
- const TString detName(det) ;
+ Bool_t rv = kFALSE;
+ const TString detName(det) ;
// always activates Correlation
// if ( detName.Contains(AliQAv1::GetDetName(AliQAv1::kCORR)) || detName.Contains(AliQAv1::GetDetName(AliQAv1::kGLOBAL))) {
// rv = kTRUE ;
rv = kTRUE;
}
// }
- return rv ;
+ return rv ;
}
//_____________________________________________________________________________
Bool_t AliQAManager::Merge(Int_t runNumber, const char *fileName) const
{
- // Merge data from all detectors from a given run in one single file
- // Merge the QA results from all the data chunks in one run
+ // Merge data from all detectors from a given run in one single file
+ // Merge the QA results from all the data chunks in one run
// The 'fileName' is name of the output file with merged QA data
- if ( runNumber == -1)
- runNumber = fRunNumber ;
- Bool_t rv = MergeData(runNumber,fileName) ;
- //rv *= MergeResults(runNumber) ; // not needed for the time being
- return rv ;
+ if ( runNumber == -1)
+ runNumber = fRunNumber ;
+ Bool_t rv = MergeData(runNumber,fileName) ;
+ //rv *= MergeResults(runNumber) ; // not needed for the time being
+ return rv ;
}
//______________________________________________________________________
return kFALSE ;
}
- if ( !gGrid )
- TGrid::Connect("alien://");
- if ( !gGrid )
- return kFALSE ;
+ if ( !gGrid )
+ TGrid::Connect("alien://");
+ if ( !gGrid )
+ return kFALSE ;
// Open the file collection
AliInfoClass(Form("*** Create Collection ***\n*** Wk-Dir = |%s| \n*** Coll = |%s| \n",gSystem->WorkingDirectory(), collectionFile));
//_____________________________________________________________________________
void AliQAManager::MergeCustom() const
{
- // Custom Merge of QA data from all detectors for all runs in one single file
+ // Custom Merge of QA data from all detectors for all runs in one single file
// search all the run numbers
// search all the run numbers
gROOT->ProcessLine(".! ls *QA*.root > QAtempo.txt") ;
//_____________________________________________________________________________
Bool_t AliQAManager::MergeData(const Int_t runNumber, const char *fileName) const
{
- // Merge QA data from all detectors for a given run in one single file
+ // Merge QA data from all detectors for a given run in one single file
TFileMerger merger(kFALSE) ;
TString outFileName = fileName;
delete[] file;
}
merger.Merge() ;
- return kTRUE ;
+ return kTRUE ;
}
//_____________________________________________________________________________
Bool_t AliQAManager::MergeResults(const Int_t runNumber) const
{
- // Merge the QA result from all the data chunks in a run
+ // Merge the QA result from all the data chunks in a run
// to be revised whwn it will be used (see MergeData)
- TString cmd ;
- cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ;
- gROOT->ProcessLine(cmd.Data()) ;
- ifstream in("tempo.txt") ;
- const Int_t chunkMax = 100 ;
- TString fileList[chunkMax] ;
+ TString cmd ;
+ cmd = Form(".! ls %s*.root > tempo.txt", AliQAv1::GetQADataFileName()) ;
+ gROOT->ProcessLine(cmd.Data()) ;
+ ifstream in("tempo.txt") ;
+ const Int_t chunkMax = 100 ;
+ TString fileList[chunkMax] ;
- Int_t index = 0 ;
- while ( 1 ) {
- TString file ;
- in >> fileList[index] ;
- if ( !in.good() )
- break ;
- AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ;
- index++ ;
- }
+ Int_t index = 0 ;
+ while ( 1 ) {
+ TString file ;
+ in >> fileList[index] ;
+ if ( !in.good() )
+ break ;
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("index = %d file = %s", index, (fileList[index].Data()))) ;
+ index++ ;
+ }
- if ( index == 0 ) {
- AliError("No QA Result File found") ;
- return kFALSE ;
- }
+ if ( index == 0 ) {
+ AliError("No QA Result File found") ;
+ return kFALSE ;
+ }
- TFileMerger merger ;
+ TFileMerger merger ;
TString outFileName ;
if (runNumber != -1)
outFileName = Form("Merged.%s.Result.%d.root",AliQAv1::GetQADataFileName(),runNumber);
else
outFileName = Form("Merged.%s.Result.root",AliQAv1::GetQADataFileName());
- merger.OutputFile(outFileName.Data()) ;
- for (Int_t ifile = 0 ; ifile < index ; ifile++) {
- TString file = fileList[ifile] ;
- merger.AddFile(file) ;
- }
- merger.Merge() ;
+ merger.OutputFile(outFileName.Data()) ;
+ for (Int_t ifile = 0 ; ifile < index ; ifile++) {
+ TString file = fileList[ifile] ;
+ merger.AddFile(file) ;
+ }
+ merger.Merge() ;
- return kTRUE ;
+ return kTRUE ;
}
//_____________________________________________________________________________
void AliQAManager::Reset(const Bool_t sameCycle)
{
- // Reset the default data members
+ // Reset the default data members
- for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet);
- if (qadm)
+ for (UInt_t iDet = 0; iDet < fgkNDetectors ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ if (qadm)
qadm->Reset();
- }
- }
- if (fRawReaderDelete) {
- delete fRawReader ;
- fRawReader = NULL ;
- }
+ }
+ }
+ if (fRawReaderDelete) {
+ delete fRawReader ;
+ fRawReader = NULL ;
+ }
- fCycleSame = sameCycle ;
- fESD = NULL ;
- fESDTree = NULL ;
- //fFirst = kTRUE ;
- fNumberOfEvents = 999999 ;
+ fCycleSame = sameCycle ;
+ fESD = NULL ;
+ fESDTree = NULL ;
+ //fFirst = kTRUE ;
+ fNumberOfEvents = 999999 ;
}
//_____________________________________________________________________________
void AliQAManager::ResetDetectors(AliQAv1::TASKINDEX_t task, AliQAv1::DETECTORINDEX_t det)
{
- //calls ResetDetector of specified or all detectors
+ //calls ResetDetector of specified or all detectors
UInt_t iDet = 0 ;
UInt_t iDetMax = fgkNDetectors ;
if ( det != AliQAv1::kNULLDET ) {
iDetMax = det+1 ;
}
- for (iDet = 0; iDet < iDetMax ; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet))) {
- AliQADataMaker * qadm = GetQADataMaker(iDet);
- qadm->ResetDetector(task);
- }
- }
+ for (iDet = 0; iDet < iDetMax ; iDet++) {
+ if (IsSelected(AliQAv1::GetDetName(iDet))) {
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ qadm->ResetDetector(task);
+ }
+ }
}
//_____________________________________________________________________________
{
// returns AliQAManager instance (singleton)
- if (!fgQAInstance) {
+ if (!fgQAInstance) {
if ( (mode != AliQAv1::kSIMMODE) && (mode != AliQAv1::kRECMODE) && (mode != AliQAv1::kQAMODE) ) {
AliWarningClass("You must specify kSIMMODE or kRECMODE or kQAMODE") ;
return NULL ;
}
fgQAInstance = new AliQAManager(mode) ;
if (!entryCache)
- fgQAInstance->Init();
- else
- fgQAInstance->InitFromCache(entryCache,run);
+ fgQAInstance->Init();
+ else
+ fgQAInstance->InitFromCache(entryCache,run);
}
- return fgQAInstance;
+ return fgQAInstance;
}
//_____________________________________________________________________________
//_____________________________________________________________________________
TString AliQAManager::Run(const Char_t * detectors, AliRawReader * rawReader, const Bool_t sameCycle)
{
- //Runs all the QA data Maker for Raws only
+ //Runs all the QA data Maker for Raws only
- fCycleSame = sameCycle ;
- fRawReader = rawReader ;
- fDetectors = detectors ;
- fDetectorsW = detectors ;
+ fCycleSame = sameCycle ;
+ fRawReader = rawReader ;
+ fDetectors = detectors ;
+ fDetectorsW = detectors ;
- AliCDBManager* man = AliCDBManager::Instance() ;
+ AliCDBManager* man = AliCDBManager::Instance() ;
- if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
- rawReader->NextEvent() ;
- man->SetRun(fRawReader->GetRunNumber()) ;
- rawReader->RewindEvents() ;
- }
+ if ( man->GetRun() == -1 ) {// check if run number not set previously and set it from raw data
+ rawReader->NextEvent() ;
+ man->SetRun(fRawReader->GetRunNumber()) ;
+ rawReader->RewindEvents() ;
+ }
- if (!fCycleSame)
+ if (!fCycleSame)
if ( !InitQA(AliQAv1::kRAWS) )
return "" ;
fRawReaderDelete = kFALSE ;
- DoIt(AliQAv1::kRAWS) ;
- return fDetectorsW ;
+ DoIt(AliQAv1::kRAWS) ;
+ return fDetectorsW ;
}
//_____________________________________________________________________________
TString AliQAManager::Run(const Char_t * detectors, const Char_t * fileName, const Bool_t sameCycle)
{
- //Runs all the QA data Maker for Raws only
+ //Runs all the QA data Maker for Raws only
- fCycleSame = sameCycle ;
- fDetectors = detectors ;
- fDetectorsW = detectors ;
+ fCycleSame = sameCycle ;
+ fDetectors = detectors ;
+ fDetectorsW = detectors ;
- AliCDBManager* man = AliCDBManager::Instance() ;
- if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
- AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
- if ( ! rl ) {
- AliFatal("galice.root file not found in current directory") ;
- } else {
- rl->CdGAFile() ;
- rl->LoadgAlice() ;
- if ( ! rl->GetAliRun() ) {
- AliFatal("AliRun not found in galice.root") ;
- } else {
- rl->LoadHeader() ;
- man->SetRun(rl->GetHeader()->GetRun());
- }
- }
- }
+ AliCDBManager* man = AliCDBManager::Instance() ;
+ if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
+ AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
+ if ( ! rl ) {
+ AliFatal("galice.root file not found in current directory") ;
+ } else {
+ rl->CdGAFile() ;
+ rl->LoadgAlice() ;
+ if ( ! rl->GetAliRun() ) {
+ AliFatal("AliRun not found in galice.root") ;
+ } else {
+ rl->LoadHeader() ;
+ man->SetRun(rl->GetHeader()->GetRun());
+ }
+ }
+ }
- if (!fCycleSame)
+ if (!fCycleSame)
if ( !InitQA(AliQAv1::kRAWS, fileName) )
return "" ;
- DoIt(AliQAv1::kRAWS) ;
- return fDetectorsW ;
+ DoIt(AliQAv1::kRAWS) ;
+ return fDetectorsW ;
}
//_____________________________________________________________________________
TString AliQAManager::Run(const Char_t * detectors, const AliQAv1::TASKINDEX_t taskIndex, Bool_t const sameCycle, const Char_t * fileName )
{
- // Runs all the QA data Maker for every detector
+ // Runs all the QA data Maker for every detector
- fCycleSame = sameCycle ;
- fDetectors = detectors ;
- fDetectorsW = detectors ;
+ fCycleSame = sameCycle ;
+ fDetectors = detectors ;
+ fDetectorsW = detectors ;
- AliCDBManager* man = AliCDBManager::Instance() ;
- if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
- AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
- if ( ! rl ) {
- AliFatal("galice.root file not found in current directory") ;
- } else {
- rl->CdGAFile() ;
- rl->LoadgAlice() ;
- if ( ! rl->GetAliRun() ) {
- AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
- } else {
- rl->LoadHeader() ;
- man->SetRun(rl->GetHeader()->GetRun()) ;
- }
- }
- }
+ AliCDBManager* man = AliCDBManager::Instance() ;
+ if ( man->GetRun() == -1 ) { // check if run number not set previously and set it from AliRun
+ AliRunLoader * rl = AliRunLoader::Open("galice.root") ;
+ if ( ! rl ) {
+ AliFatal("galice.root file not found in current directory") ;
+ } else {
+ rl->CdGAFile() ;
+ rl->LoadgAlice() ;
+ if ( ! rl->GetAliRun() ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), "AliRun not found in galice.root") ;
+ } else {
+ rl->LoadHeader() ;
+ man->SetRun(rl->GetHeader()->GetRun()) ;
+ }
+ }
+ }
if ( taskIndex == AliQAv1::kNULLTASKINDEX) {
- for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
- if ( fTasks.Contains(Form("%d", task)) ) {
+ for (UInt_t task = 0; task < AliQAv1::kNTASKINDEX; task++) {
+ if ( fTasks.Contains(Form("%d", task)) ) {
if (!fCycleSame)
if ( !InitQA(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task)), fileName) )
return "" ;
DoIt(AliQAv1::GetTaskIndex(AliQAv1::GetTaskName(task))) ;
- }
- }
- } else {
+ }
+ }
+ } else {
if (! fCycleSame )
if ( !InitQA(taskIndex, fileName) )
return "" ;
- DoIt(taskIndex) ;
+ DoIt(taskIndex) ;
}
- return fDetectorsW ;
+ return fDetectorsW ;
}
//_____________________________________________________________________________
void AliQAManager::RunOneEvent(AliRawReader * rawReader)
{
- //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
+ //Runs all the QA data Maker for Raws only and on one event only (event loop done by calling method)
if ( ! rawReader )
return ;
if (fTasks.Contains(Form("%d", AliQAv1::kRAWS))){
}
qadm->SetEventSpecie(fEventSpecie) ;
if ( qadm->GetRecoParam() )
- if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
+ if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
- qadm->Exec(AliQAv1::kRAWS, rawReader) ;
- }
+ qadm->Exec(AliQAv1::kRAWS, rawReader) ;
+ }
}
}
//_____________________________________________________________________________
void AliQAManager::RunOneEvent(AliESDEvent *& esd, AliESDEvent *& hltesd)
{
- //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
+ //Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
if (fTasks.Contains(Form("%d", AliQAv1::kESDS))) {
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
continue;
qadm->SetEventSpecie(fEventSpecie) ;
if ( qadm->GetRecoParam() )
- if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
+ if ( AliRecoParam::Convert(qadm->GetRecoParam()->GetEventSpecie()) != AliRecoParam::kDefault)
qadm->SetEventSpecie(qadm->GetRecoParam()->GetEventSpecie()) ;
if ( qadm->IsCycleDone() ) {
qadm->EndOfCycle() ;
} else {
qadm->Exec(AliQAv1::kESDS, esd) ;
}
- }
- }
+ }
+ }
}
//_____________________________________________________________________________
void AliQAManager::RunOneEventInOneDetector(Int_t det, TTree * tree)
{
- // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
+ // Runs all the QA data Maker for ESDs only and on one event only (event loop done by calling method)
TString test(tree->GetName()) ;
if (fTasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
//_____________________________________________________________________________
Bool_t AliQAManager::Save2OCDB(const Int_t runNumber, AliRecoParam::EventSpecie_t es, const Char_t * year, const Char_t * detectors) const
{
- // take the locasl QA data merge into a single file and save in OCDB
- Bool_t rv = kTRUE ;
- TString tmp(AliQAv1::GetQARefStorage()) ;
- if ( tmp.IsNull() ) {
- AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
- return kFALSE ;
- }
- if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
- AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ;
- return kFALSE ;
- }
- TString sdet(detectors) ;
- sdet.ToUpper() ;
- TFile * inputFile ;
- if ( sdet.Contains("ALL") ) {
- rv = Merge(runNumber) ;
- if ( ! rv )
- return kFALSE ;
- TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ;
- inputFile = TFile::Open(inputFileName.Data()) ;
- rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
- } else {
- for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
- if (sdet.Contains(AliQAv1::GetDetName(index))) {
- TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ;
- inputFile = TFile::Open(inputFileName.Data()) ;
- rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
- }
- }
- }
- return rv ;
+ // take the locasl QA data merge into a single file and save in OCDB
+ Bool_t rv = kTRUE ;
+ TString tmp(AliQAv1::GetQARefStorage()) ;
+ if ( tmp.IsNull() ) {
+ AliError("No storage defined, use AliQAv1::SetQARefStorage") ;
+ return kFALSE ;
+ }
+ if ( !(tmp.Contains(AliQAv1::GetLabLocalOCDB()) || tmp.Contains(AliQAv1::GetLabAliEnOCDB())) ) {
+ AliError(Form("%s is a wrong storage, use %s or %s", AliQAv1::GetQARefStorage(), AliQAv1::GetLabLocalOCDB().Data(), AliQAv1::GetLabAliEnOCDB().Data())) ;
+ return kFALSE ;
+ }
+ TString sdet(detectors) ;
+ sdet.ToUpper() ;
+ TFile * inputFile ;
+ if ( sdet.Contains("ALL") ) {
+ rv = Merge(runNumber) ;
+ if ( ! rv )
+ return kFALSE ;
+ TString inputFileName(Form("Merged.%s.Data.%d.root", AliQAv1::GetQADataFileName(), runNumber)) ;
+ inputFile = TFile::Open(inputFileName.Data()) ;
+ rv = SaveIt2OCDB(runNumber, inputFile, year, es) ;
+ } else {
+ for (Int_t index = 0; index < AliQAv1::kNDET; index++) {
+ if (sdet.Contains(AliQAv1::GetDetName(index))) {
+ TString inputFileName(Form("%s.%s.%d.root", AliQAv1::GetDetName(index), AliQAv1::GetQADataFileName(), runNumber)) ;
+ inputFile = TFile::Open(inputFileName.Data()) ;
+ rv *= SaveIt2OCDB(runNumber, inputFile, year, es) ;
+ }
+ }
+ }
+ return rv ;
}
//_____________________________________________________________________________
Bool_t AliQAManager::SaveIt2OCDB(const Int_t runNumber, TFile * inputFile, const Char_t * year, AliRecoParam::EventSpecie_t es) const
{
- // reads the TH1 from file and adds it to appropriate list before saving to OCDB
- Bool_t rv = kTRUE ;
- 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()) )
- Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
- else {
- TString tmp1(AliQAv1::GetQARefDefaultStorage()) ;
- tmp1.Append(year) ;
- tmp1.Append("?user=alidaq") ;
- Instance()->SetDefaultStorage(tmp1.Data()) ;
- }
- }
- Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
- if(GetRun() < 0)
- Instance()->SetRun(runNumber);
+ // reads the TH1 from file and adds it to appropriate list before saving to OCDB
+ Bool_t rv = kTRUE ;
+ 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()) )
+ Instance()->SetDefaultStorage(AliQAv1::GetQARefStorage()) ;
+ else {
+ TString tmp1(AliQAv1::GetQARefDefaultStorage()) ;
+ tmp1.Append(year) ;
+ tmp1.Append("?user=alidaq") ;
+ Instance()->SetDefaultStorage(tmp1.Data()) ;
+ }
+ }
+ Instance()->SetSpecificStorage("*", AliQAv1::GetQARefStorage()) ;
+ if(GetRun() < 0)
+ Instance()->SetRun(runNumber);
- AliCDBMetaData mdr ;
- mdr.SetResponsible("yves schutz");
+ AliCDBMetaData mdr ;
+ mdr.SetResponsible("yves schutz");
- for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
- TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
- if ( detDir ) {
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Entering %s", detDir->GetName())) ;
+ for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++) {
+ TDirectory * detDir = inputFile->GetDirectory(AliQAv1::GetDetName(detIndex)) ;
+ if ( detDir ) {
+ 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()) ;
- TList * listDetQAD = new TList() ;
- TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ;
- mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
- listDetQAD->SetName(listName) ;
- TList * taskList = detDir->GetListOfKeys() ;
- TIter nextTask(taskList) ;
- TKey * taskKey ;
- while ( (taskKey = static_cast<TKey*>(nextTask())) ) {
- TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
+ TString detOCDBDir(Form("%s/%s/%s", AliQAv1::GetDetName(detIndex), AliQAv1::GetRefOCDBDirName(), AliQAv1::GetRefDataDirName())) ;
+ AliCDBId idr(detOCDBDir.Data(), runNumber, AliCDBRunRange::Infinity()) ;
+ TList * listDetQAD = new TList() ;
+ TString listName(Form("%s QA data Reference", AliQAv1::GetDetName(detIndex))) ;
+ mdr.SetComment(Form("%s QA stuff", AliQAv1::GetDetName(detIndex)));
+ listDetQAD->SetName(listName) ;
+ TList * taskList = detDir->GetListOfKeys() ;
+ TIter nextTask(taskList) ;
+ TKey * taskKey ;
+ while ( (taskKey = static_cast<TKey*>(nextTask())) ) {
+ TDirectory * taskDir = detDir->GetDirectory(taskKey->GetName()) ;
TDirectory * esDir = taskDir->GetDirectory(AliRecoParam::GetEventSpecieName(es)) ;
- 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) ;
- TList * histList = esDir->GetListOfKeys() ;
- TIter nextHist(histList) ;
- TKey * histKey ;
- while ( (histKey = static_cast<TKey*>(nextHist())) ) {
- TObject * odata = esDir->Get(histKey->GetName()) ;
- if ( !odata ) {
- AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
- } else {
+ 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) ;
+ TList * histList = esDir->GetListOfKeys() ;
+ TIter nextHist(histList) ;
+ TKey * histKey ;
+ while ( (histKey = static_cast<TKey*>(nextHist())) ) {
+ TObject * odata = esDir->Get(histKey->GetName()) ;
+ if ( !odata ) {
+ AliError(Form("%s in %s/%s returns a NULL pointer !!", histKey->GetName(), detDir->GetName(), taskDir->GetName())) ;
+ } else {
if ( AliQAv1::GetExpert() == histKey->GetName() ) {
TDirectory * expertDir = esDir->GetDirectory(histKey->GetName()) ;
TList * expertHistList = expertDir->GetListOfKeys() ;
}
}
}
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
- if ( odata->IsA()->InheritsFrom("TH1") ) {
- AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
- TH1 * hdata = static_cast<TH1*>(odata) ;
- listTaskQAD->Add(hdata) ;
- }
- }
- }
- }
- Instance()->Put(listDetQAD, idr, &mdr) ;
- }
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
+ if ( odata->IsA()->InheritsFrom("TH1") ) {
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("Adding %s", histKey->GetName())) ;
+ TH1 * hdata = static_cast<TH1*>(odata) ;
+ listTaskQAD->Add(hdata) ;
+ }
+ }
}
- return rv ;
+ }
+ Instance()->Put(listDetQAD, idr, &mdr) ;
+ }
+ }
+ return rv ;
}
//_____________________________________________________________________________
{
// enable the writing of QA expert data
for (UInt_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (IsSelected(AliQAv1::GetDetName(iDet)))
+ if (IsSelected(AliQAv1::GetDetName(iDet)))
fQAWriteExpert[iDet] = kTRUE ;
}
}
void AliQAManager::ShowQA() {
// Show the result of the QA checking
// for all detectors
- for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++)
- if ( IsSelected(AliQAv1::GetDetName(detIndex)) )
- AliQAv1::Instance(AliQAv1::GetDetIndex(AliQAv1::GetDetName(detIndex)))->Show() ;
+ for ( Int_t detIndex = 0 ; detIndex < AliQAv1::kNDET ; detIndex++)
+ if ( IsSelected(AliQAv1::GetDetName(detIndex)) )
+ AliQAv1::Instance(AliQAv1::GetDetIndex(AliQAv1::GetDetName(detIndex)))->Show() ;
}
TString AliQAv1::fgRefDataDirName = "" ;
const TString AliQAv1::fgkQARefOCDBDefault = "alien://folder=/alice/QA/20" ;
const TString AliQAv1::fgkExpert = "Expert" ;
+//
+const UInt_t AliQAv1::fgkQAClonedBit = BIT(14); // RS: bits set to the histos or arrays of cloned histos
+const UInt_t AliQAv1::fgkForbidCloningBit = BIT(15); // to flag the state (cloned or not) of the
+const UInt_t AliQAv1::fgkOrigHistoKeptBit = BIT(16); // object at the given slot of fXXXQAList[]
+//
const UInt_t AliQAv1::fgkExpertBit = BIT(19);
const UInt_t AliQAv1::fgkQABit = BIT(20) ;
const UInt_t AliQAv1::fgkImageBit = BIT(21) ;
QABIT_t GetQAStatusBit(AliRecoParam::EventSpecie_t es = AliRecoParam::kDefault, DETECTORINDEX_t det=kNULLDET, ALITASK_t tsk=kNULLTASK) const ;
static const char * GetRefOCDBDirName() { return fgkRefOCDBDirName.Data() ; }
static const char * GetRefDataDirName() { return fgRefDataDirName.Data() ; }
-
+ //
+ static UInt_t GetClonedBit() { return fgkQAClonedBit; }
+ static UInt_t GetForbidCloningBit() { return fgkForbidCloningBit; }
+ static UInt_t GetOrigHistoKeptBit() { return fgkOrigHistoKeptBit; }
+ //
static TASKINDEX_t GetTaskIndex(const char * name) ;
static TString GetTaskName(UInt_t tsk) { return fgTaskNames[tsk] ; }
static const char * GetModeName(MODE_t mode) { return (mode == kSIMMODE || mode == kRECMODE || mode == kQAMODE) ? (fgModeNames[mode]).Data() : "" ; }
static const TString fgkImageFileName ; //! name of the file that contains all the QA images
static const TString fImageFileFormat ; //! format of the file that contains all the QA images
static const UShort_t fgkMaxQAObjects ;//! maximum number of QA objects allowed dor each task (Raws, digits,....)
-
+ //
+ static const UInt_t fgkQAClonedBit ;//! flag that the histrogram was cloned per trigger class
+ static const UInt_t fgkForbidCloningBit ;//! flag that the histogram is forbiden to clone per trigger class
+ static const UInt_t fgkOrigHistoKeptBit ;//! flag that the histogram was clonned but original is kept
ClassDef(AliQAv1,3) //ALICE Quality Assurance Object
};
#endif
if (fInitQACalled) return;
fInitQACalled = kTRUE;
+ if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
+
+
AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
if (fWriteQAExpertData)
qam->SetWriteExpert() ;
}
}
}
+ //
+ if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
+ //
if (fRunQA) {
const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
}
loader->UnloadDigits();
}
- if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
+ if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
- AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
+ AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
}
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
void AliReconstruction::CleanUp()
{
// delete trackers and the run loader and close and delete the file
-
+/*
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
delete fReconstructor[iDet];
fReconstructor[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
}
+*/
+
delete fRunInfo;
fRunInfo = NULL;
if (AliQAManager::QAManager())
AliQAManager::QAManager()->ShowQA() ;
- AliQAManager::Destroy() ;
+ // AliQAManager::Destroy() ;
}
char name[21];
for (j=0; j< 2; j++) {
- printf("\n A Z dens radL absL");
+ printf("\n A Z ZPos DZ dens radL absL");
printf("\n==================================================================================");
f0=f1=f2=0;
for (i=0; i< nl[j]; i++) {
f0 += dz/radl;
f1 += dz/(2.*radl)*(2.*zmin[j][i]+dz);
f2 += dz/(3.*radl)*(3.*zmin[j][i]*zmin[j][i]+3.*dz*zmin[j][i]+dz*dz);
- printf("\n %3d %14s %12.3f %12.3f %12.3f %12.3f %12.3f",
- i+1, name, a, z, dens, radl, absl);
+ printf("\n %3d %14s %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f %12.3f",
+ i+1, name, a, z, (zmax[j][i]+zmin[j][i])/2., dz, dens, radl, absl);
}
//
Float_t deltaThetaB = 0.0136 * TMath::Sqrt(f0-f1*f1/f2);
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
// TString dataType = AliQAv1::GetAliTaskName(index);
- if (list[specie]->GetEntries() == 0){
+ if (!(AliQAv1::Instance()->IsEventSpecieSet(specie) && list[specie]) || list[specie]->GetEntries() == 0) {
test[specie] = 1. ; // nothing to check
+ continue;
}
- else {
- if (index == AliQAv1::kRAW && AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCalib)
- // if (index == AliQAv1::kRAW )
- {
- test[specie] = CheckRaw(list[specie]);
- }
-
- if (index == AliQAv1::kESD && AliRecoParam::Convert(specie) != AliRecoParam::kCalib)
- test[specie] = CheckESD(list[specie]);
- }
-
+ if (index == AliQAv1::kRAW && AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCalib)
+ // if (index == AliQAv1::kRAW )
+ {
+ test[specie] = CheckRaw(list[specie]);
+ }
+ if (index == AliQAv1::kESD && AliRecoParam::Convert(specie) != AliRecoParam::kCalib)
+ test[specie] = CheckESD(list[specie]);
+ //
}
}
TH2F *fhHitsEffC = new TH2F("hHitsEffC", "Hits Efficiency C side", 25,-0.5,24.5, 100,2,3 );
Add2HitsList(fhHitsEffC,1);
*/
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
Add2DigitsList( fhDigEff,72);
TH1F* fhDigMean = new TH1F("hDigMean","online mean signal", 100,500,600);
Add2DigitsList( fhDigMean,73);
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1F* fhRawMean = new TH1F("hRawMean","online mean signal", 100,500,600);
Add2RawsList( fhRawMean,72);
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
Add2RecPointsList ( fhRecEff,72);
TH1F * fhRecMean = new TH1F("hRecMean"," reconstructed mean signal",100,500,600);
Add2RecPointsList( fhRecMean,73);
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
void AliT0QADataMaker::InitESDs()
Add2ESDsList(fhESDMean, 0) ;
TH1F * fhESDVertex = new TH1F("hESDvertex","EAD vertex",100,-50,50);
Add2ESDsList(fhESDVertex, 1) ;
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
break;
}
Int_t pmt=startHit->Pmt();
- GetHitsData(pmt-1)->Fill(startHit->Time()) ;
+ FillHitsData(pmt-1,startHit->Time()) ;
}
}
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
brDigits->SetAddress(&fDigits);
}else{
AliError(Form("EXEC Branch T0 digits not found"));
- return;
+ delete digCFD;
+ delete digLED;
+ delete digQT0;
+ delete digQT1;
+ return;
}
digitsTree->GetEvent(0);
{
if (digCFD->At(i)>0) {
Int_t cfd=digCFD->At(i)- refpoint;
- GetDigitsData(i) ->Fill(cfd);
- GetDigitsData(i+24) -> Fill(digLED->At(i) - digCFD->At(i));
- GetDigitsData(i+48) -> Fill(digQT1->At(i) - digQT0->At(i));
+ FillDigitsData(i,cfd);
+ FillDigitsData(i+24, digLED->At(i) - digCFD->At(i));
+ FillDigitsData(i+48, digQT1->At(i) - digQT0->At(i));
}
}
delete digLED;
delete digQT0;
delete digQT1;
-
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
for (Int_t iHt=0; iHt<5; iHt++){
Int_t cc = ik/2;
if(allData[cc+1][iHt]!=0){
- GetRawsData(cc) -> Fill(allData[cc+1][iHt]-allData[0][0]);
+ FillRawsData(cc,allData[cc+1][iHt]-allData[0][0]);
if(allData[ik+25][iHt]!=0 && allData[ik+26][iHt]!=0)
- GetRawsData(cc+48)->Fill(allData[ik+26][iHt]-allData[ik+25][iHt]);
+ FillRawsData(cc+48,allData[ik+26][iHt]-allData[ik+25][iHt]);
if(allData[cc+13][iHt]!=0 )
- GetRawsData(cc+24)->Fill(allData[cc+13][iHt]-allData[cc+1][iHt]);
+ FillRawsData(cc+24,allData[cc+13][iHt]-allData[cc+1][iHt]);
}
}
}
for (Int_t iHt=0; iHt<5; iHt++) {
Int_t cc = ik/2;
if(allData[cc+45][iHt]!=0) {
- GetRawsData(cc)->Fill(allData[cc+1][iHt]-allData[0][0]);
+ FillRawsData(cc,allData[cc+1][iHt]-allData[0][0]);
if(allData[ik+57][iHt]!=0 && allData[ik+58][iHt]!=0)
- GetRawsData(cc+48)->Fill(allData[ik+57][iHt]-allData[ik+58][iHt]);
+ FillRawsData(cc+48,allData[ik+57][iHt]-allData[ik+58][iHt]);
if(allData[cc+57][iHt]!=0 )
- GetRawsData(cc+48)->Fill(allData[cc+57][iHt]-allData[cc+45][iHt]);
+ FillRawsData(cc+48,allData[cc+57][iHt]-allData[cc+45][iHt]);
}
}
}
delete start;
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
brRec->GetEntry(0);
for ( Int_t i=0; i<24; i++) {
- GetRecPointsData(i) -> Fill(frecpoints -> GetTime(i));
- GetRecPointsData(i+24) -> Fill(frecpoints -> GetAmp(i));
- GetRecPointsData(i+48) -> Fill(frecpoints->AmpLED(i));
+ FillRecPointsData(i,frecpoints -> GetTime(i));
+ FillRecPointsData(i+24,frecpoints -> GetAmp(i));
+ FillRecPointsData(i+48,frecpoints->AmpLED(i));
// if(frecpoints -> GetTime(i) > 0) fhRecEff->Fill(i);
}
- GetRecPointsData(72) ->Fill(frecpoints->GetMeanTime());
-
+ FillRecPointsData(72,frecpoints->GetMeanTime());
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
{
//fills QA histos for ESD
- GetESDsData(0) -> Fill(esd->GetT0());
- GetESDsData(1)-> Fill(esd->GetT0zVertex());
-
+ FillESDsData(0,esd->GetT0());
+ FillESDsData(1,esd->GetT0zVertex());
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
}
//____________________________________________________________________________
AliT0QADataMakerRec::AliT0QADataMakerRec() :
AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kT0),
- "T0 Quality Assurance Data Maker"),
- fnEventCal(0),
- fnEventPhys(0)
+ "T0 Quality Assurance Data Maker")
+// fnEventCal(0),
+// fnEventPhys(0)
{
// ctor
+ // RS: There is some inconsistency here: the separation of physics and calib. events/histos is done by
+ // fEventSpecie. Why do we book separate histos on different slots for calib and physics ?
+ // I am changing this in such way that we don't need local counters like fNumTriggers (the corresponding
+ // histos now incremented in the MakeRaws, and for the normalization I will use the framework's counters
+ // AliQADataMaker::GetEvCountCycle(...), AliQADataMaker::GetEvCountTotal(...)
+ // All these fTrEff.. feff.. will by directly filled in corresponding histos
+ /*
for (Int_t i=0; i<6; i++) {
fNumTriggers[i]=0;
fNumTriggersCal[i]=0;
feffPhysC[i]=0;
feffPhysA[i]=0;
feffqtcPhys[i]=0;
- fMeans[i]=2500;
+ fMeans[i]=0;
}
-
+ */
// for(Int_t ic=0; ic<24; ic++)
// fMeans[ic] = new TH1F(Form("CFD1minCFD%d",ic+1),"CFD-CFD",100,-250,250);
}
//____________________________________________________________________________
AliT0QADataMakerRec::AliT0QADataMakerRec(const AliT0QADataMakerRec& qadm) :
- AliQADataMakerRec(),
- fnEventCal(0),
- fnEventPhys(0)
+ AliQADataMakerRec()
+ // fnEventCal(0),
+ // fnEventPhys(0)
{
//copy ctor
SetName((const char*)qadm.GetName()) ;
}
//____________________________________________________________________________
void AliT0QADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
+{
+ //Detector specific actions at end of cycle
+ // do the QA checking
+ AliInfo(Form("Task: %d",task));
+ ResetEventTrigClasses();
+ AliQAChecker::Instance()->Run(AliQAv1::kT0, task, list) ;
+ // const Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
+ //
+ TH1* htmp = 0;
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ //
+ // RS: There is some inconsistency here: the separation of physics and calib. events/histos is done by
+ // fEventSpecie. Why do we book separate histos on different slots for calib and physics ?
+ // I am changing this in such way that we don't need local counters like fNumTriggers (the corresponding
+ // histos now incremented in the MakeRaws, and for the normalization I will use the framework's counters
+ // AliQADataMaker::GetEvCountCycle(...), AliQADataMaker::GetEvCountTotal(...)
+ //
+ // I think the histos xx+250 should be suppressed (the xx calib histos of specie==calibration will be
+ // used automatically)
+ //
+ if (! IsValidEventSpecie(specie, list)) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ if ( task == AliQAv1::kRAWS ) {
+ //
+ float nEvent = GetEvCountCycleRaws(itc); // counted events for given trigger class
+ if (nEvent>0) {
+ if ( (htmp=GetRawsData(169,itc)) ) htmp->Scale(1./nEvent); // RS
+ if ( (htmp=GetRawsData(169+250,itc)) ) htmp->Scale(1./nEvent); // RS I think this should be removed!!!
+ //
+ if ( (htmp=GetRawsData(207+250,itc)) ) htmp->Scale(1./nEvent); // RS // former feffC count. Remove?
+ if ( (htmp=GetRawsData(207,itc)) ) htmp->Scale(1./nEvent); // RS // former feffPhysC count.
+
+ if ( (htmp=GetRawsData(208+250,itc)) ) htmp->Scale(1./nEvent); // RS // former feffA count. Remove?
+ if ( (htmp=GetRawsData(209+250,itc)) ) htmp->Scale(1./nEvent); // RS // former feffqtc count.
+ //
+ }
+ } // kRAWS
+ } // RS: loop over eventual clones per trigger class
+ } // loop over species
+ //
+}
+
+/*
+// RS Old version using custom cunters
+void AliT0QADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
// do the QA checking
if ( fnEventPhys>0) effic = Float_t(feffPhysC[ik])/Float_t(fnEventPhys);
GetRawsData(207)->SetBinContent(ik+1, effic);
- }
-
-
- }
-
+ }
+ }
}
-
}
+
+*/
+
//____________________________________________________________________________
void AliT0QADataMakerRec::StartOfDetectorCycle()
{
const Bool_t image = kTRUE ;
Float_t low[500];
Float_t high[500];
-
+ //triggers
+ const Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
+
for (Int_t i=0; i<500; i++){
low[i] = 0;
TString nhits;
TH1F* fhRefPoint = new TH1F("hRefPoint","Ref Point", 10000, 0 ,50000);
+ fhRefPoint->SetLabelSize(0.02);
Add2RawsList( fhRefPoint,0, expert, !image, !saveCorr);
TH1F* fhRefPointcal = new TH1F("hRefPointcal","Ref Point laser", 5000, 0 ,20000);
ledname += i+1;
nhits += i+1;
fhRawCFD[i] = new TH1F(timename.Data(), Form("%s;CFD [#channels];Counts", timename.Data()),Int_t((high[i+1]-low[i+1])/4),low[i+1],high[i+1]);
+ ForbidCloning(fhRawCFD[i]); //RS I don't know how histos 1-24 should be processed in MakeRaws, for the moment forbidding the cloning
Add2RawsList( fhRawCFD[i],i+1, expert, !image, !saveCorr);
fhRawLED[i] = new TH1F(ledname.Data(), Form("%s;LED[#channels];Counts", ledname.Data()),Int_t((high[i+25]-low[i+25])/4),low[i+25],high[i+25]);
Add2RawsList( fhRawLED[i],i+25, expert, !image, !saveCorr);
TH1F* fhRawTrigger = new TH1F("hRawTrigger"," phys triggers;Trigger ;Counts",6,0,6);
+ for (Int_t itr=0; itr<6; itr++) fhRawTrigger->Fill(triggers[itr], 0); // RS Modified to allow cloning (no fNumTriggers member anymore)
+
Add2RawsList(fhRawTrigger ,169, expert, image, !saveCorr);
TH1F* fhRawMean = new TH1F("hRawMean","online mean signal, physics event;",Int_t((high[170]-low[170])/4),low[170],high[170]);
Add2RawsList( fhMultSeCentr,175, expert, !image, !saveCorr);
- TH1F* fhRawTriggerCal = new TH1F("hRawTriggerCal"," laser triggers",6,0,6);
+ TH1F* fhRawTriggerCal = new TH1F("hRawTriggerCal"," laser triggers",6,0,6); // RS Modified to allow cloning (no fNumTriggersCall member anymore)
+ for (Int_t itr=0; itr<6; itr++) fhRawTriggerCal->Fill(triggers[itr], 0);
Add2RawsList(fhRawTriggerCal ,169+250 , !expert, image, !saveCorr);
TH1F* fhRawMeanCal = new TH1F("hRawMeanCal","online mean signal, calibration event",Int_t((high[170+250]-low[170+250])/4),low[170+250],high[170+250]);
Add2RawsList( fhEffQTC,209+250, !expert, image, !saveCorr);
- TH2F* fhCFD = new TH2F("hCFD","CFD phys; #PMT; CFD {#channnels}",25, 0 ,25,Int_t((high[210]-low[210])/4),low[210],high[210]);
+ TH2F* fhCFD = new TH2F("hCFD","CFD phys; #PMT; CFD {#channnels}",25, 0 ,25,Int_t((high[210]-low[210])/4),low[210],high[210]);
fhCFD->SetOption("COLZ");
Add2RawsList( fhCFD,210, expert, image, !saveCorr);
Add2RawsList( fhOrCminOrATvdcOffcal,218+250, expert, !image, !saveCorr);
//satellite & beam background
- TH2F* fhBeam = new TH2F("fhBeam", " Mean vs Vertex ", 120, -30, 30, 120, -30, 30);
- fhBeam->SetOption("COLZ");
- fhBeam->GetXaxis()->SetTitle("(T0C-T0A/2, ns");
- fhBeam->GetYaxis()->SetTitle("(T0C+T0A/2, ns");
- Add2RawsList( fhBeam,220, !expert, image, !saveCorr);
- TH2F* fhBeamTVDCon = new TH2F("fhBeamTVDCon", " Mean vs Vertex TVDC on ",50, -5, 5, 50, -5, 5) ;
- fhBeamTVDCon->SetOption("COLZ");
- fhBeamTVDCon->GetXaxis()->SetTitle("(T0C-T0A/2, ns");
- fhBeamTVDCon->GetYaxis()->SetTitle("(T0C+T0A/2, ns");
+ TH2F* fhBeam = new TH2F("fhBeam", " Mean vs Vertex; (T0A-T0C)/2 [ns]; (T0A+T0C)/2 [ns] ", 120, -30, 30, 120, -30, 30);
+ Add2RawsList( fhBeam,220, !expert, image, !saveCorr);
+ TH2F* fhBeamTVDCon = new TH2F("fhBeamTVDCon", " Mean vs Vertex TVDC on; (T0A-T0C)/2 [ns]; (T0A+T0C)/2 [ns]",50, -5, 5, 50, -5, 5) ;
Add2RawsList( fhBeamTVDCon,221, expert, image, !saveCorr);
- TH2F* fhBeamTVDCoff = new TH2F("fhBeamTVDCoff", " Mean vs Vertex TVDC off", 120, -30, 30, 120, -30, 30);
- fhBeamTVDCoff->GetXaxis()->SetTitle("(T0C-T0A/2, ns");
- fhBeamTVDCoff->GetYaxis()->SetTitle("(T0C+T0A/2, ns");
- fhBeamTVDCoff->SetOption("COLZ");
+ TH2F* fhBeamTVDCoff = new TH2F("fhBeamTVDCoff", " Mean vs Vertex TVDC off; (T0A-T0C)/2 [ns]; (T0A+T0C)/2 [ns]", 120, -30, 30, 120, -30, 30);
Add2RawsList( fhBeamTVDCoff,222, expert, image, !saveCorr);
- TH1F* fhMean = new TH1F("fhMean", " (T0A+T0C)/2, ns ", 200, -2000, 2000);
+ TH1F* fhMean = new TH1F("fhMean", " (T0A+T0C)/2; (T0A+T0C)/2 [ps] ", 200, -2000, 2000);
Add2RawsList( fhMean,223, !expert, image, !saveCorr);
-
- TH2F* fhBCID = new TH2F("fhBCID", "header BCID vs TRM BC ID ", 500, 0, 5000, 500, 0, 5000);
- fhBCID->SetOption("COLZ");
- fhBCID->GetXaxis()->SetTitle("TRM BC ID");
- fhBCID->GetYaxis()->SetTitle("event header BC ID");
- Add2RawsList(fhBCID ,224, !expert, image, !saveCorr);
-
- //triggers
- const Char_t *triggers[6] = {"mean", "vertex","ORA","ORC","central","semi-central"};
- for (Int_t itr=0; itr<6; itr++) {
- GetRawsData(169)->Fill(triggers[itr], fNumTriggersCal[itr]);
- GetRawsData(169)->SetBinContent(itr+1, fNumTriggersCal[itr]);
- GetRawsData(169+250)->Fill(triggers[itr], fNumTriggers[itr]);
- GetRawsData(169+250)->SetBinContent(itr+1, fNumTriggers[itr]);
- }
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits; #PMT; QTC amplitude",25,-0.5,24.5,100,100,10000);
fhDigQTC->SetOption("COLZ");
Add2DigitsList( fhDigQTC,2, !expert, !image);
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
TH1F *fhMean = new TH1F("hMean","online - rec mean;online - rec mean[#channels];",2000, -1000, 1000);
Add2RecPointsList ( fhMean,2, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
TH1F * fhESDResolution = new TH1F("hESDResolution","(T0A-T0C)/2 corrected by SPD vertex; ns",800,-2,2);
Add2ESDsList(fhESDResolution, 2, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
// Int_t refPointParam = GetRecoParam()->GetRefPoint();
Int_t refpoint = 0;
Int_t refPointParam = 0;
-
+ Int_t means[24] = {0};
AliT0RawReader *start = new AliT0RawReader(rawReader);
if (! start->Next())
AliDebug(AliQAv1::GetQADebugLevel(),Form(" no raw data found!!"));
- else
- {
-
- UInt_t type =rawReader->GetType();
- if (type == 8){ shift=250; fnEventCal++;}
- if (type == 7){ shift=0; fnEventPhys++;}
- //BC ID
- if (type == 7){
- UInt_t bcid = rawReader->GetBCID();
- UInt_t trmbcid = start->GetTRMBunchID();
- GetRawsData(224)->Fill(trmbcid, bcid);
- }
- // if (type == 7){ shift=1; fnEventPhys++;}
- Int_t allData[110][5];
- for (Int_t i0=0; i0<110; i0++)
- {
- for (Int_t j0=0; j0<5; j0++) allData[i0][j0]=0;
- }
- for (Int_t i=0; i<107; i++)
- for (Int_t iHit=0; iHit<5; iHit++)
- allData[i][iHit]= start->GetData(i,iHit);
-
- if ( allData[0][0] > 0 && (type == 7))
- GetRawsData(0) -> Fill( allData[0][0]);
- if ( allData[0][0] > 0 && (type == 8))
- GetRawsData(250) -> Fill( allData[0][0]);
+ else {
+ UInt_t type =rawReader->GetType();
+
+ // RS: Don't use custom counters, they create problems with trigger cloning
+ // Use instead framework counters, incremented in the end of this routine
+ // RS: There is some inconsistency here: the separation of physics and calib. events/histos is done by
+ // fEventSpecie. Why do we book separate histos on different slots for calib and physics ?
+ // I am changing this in such way that we don't need local counters like fNumTriggers (the corresponding
+ // histos now incremented in the MakeRaws, and for the normalization I will use the framework's counters
+ // AliQADataMaker::GetEvCountCycle(...), AliQADataMaker::GetEvCountTotal(...)
+ //
+ // I think the histos xx+250 should be suppressed (the xx calib histos of specie==calibration will be
+ // used automatically)
- refpoint = allData[refPointParam][0];
- if (refPointParam < 0 ) refpoint=0;
- if (refPointParam == 0 ) refpoint = allData[0][0] - 5000;
+ if (type == 8){ shift=250; /*fnEventCal++;*/}
+ if (type == 7){ shift=0; /*fnEventPhys++;*/}
+
+ // if (type == 7){ shift=1; fnEventPhys++;}
+ Int_t allData[110][5];
+ for (Int_t i0=0; i0<110; i0++)
+ {
+ for (Int_t j0=0; j0<5; j0++) allData[i0][j0]=0;
+ }
+ for (Int_t i=0; i<107; i++)
+ for (Int_t iHit=0; iHit<5; iHit++)
+ allData[i][iHit]= start->GetData(i,iHit);
+
+ if ( allData[0][0] > 0 && (type == 7))
+ FillRawsData(0, allData[0][0]);
+ if ( allData[0][0] > 0 && (type == 8))
+ FillRawsData(250, allData[0][0]);
+
+ refpoint = allData[refPointParam][0];
+ if (refPointParam < 0 ) refpoint=0;
+ if (refPointParam == 0 ) refpoint = allData[0][0] - 5000;
+
+ Int_t sideshift, sideshiftqtc;
+ Int_t numPmtC=0;
+ Int_t numPmtA=0;
+ for (Int_t ik = 0; ik<24; ik++) {
+ if(ik<12) {
+ sideshift=1;
+ sideshiftqtc=1;
+ if(allData[ik+sideshift][0]>0 && type == 7 ) numPmtC++;
+ }
+ else {
+ if(allData[ik+45][0]>0 && type == 7 ) numPmtA++;
+ sideshift=45;
+ sideshiftqtc=33;
+ }
+ Int_t nhitsPMT=0;
- Int_t sideshift, sideshiftqtc;
- Int_t numPmtC=0;
- Int_t numPmtA=0;
- for (Int_t ik = 0; ik<24; ik++)
- {
- if(ik<12) {
- sideshift=1;
- sideshiftqtc=1;
- if(allData[ik+sideshift][0]>0 && type == 7 ) numPmtC++;
+ for (Int_t iHt=0; iHt<5; iHt++) {
+ //cfd
+ if(allData[ik+sideshift][iHt]>0) {
+ FillRawsData(shift+ik+1, allData[ik+sideshift][iHt]);
+ FillRawsData(210+shift, ik+1, allData[ik+sideshift][iHt]);
+ if(type == 8 ) { // RS I think the type check should be removed
+ //feffC[ik]++;
+ FillRawsData(207+shift,ik,1.); // instead of incrementing former feff's, increment histo directly
}
- else {
- if(allData[ik+45][0]>0 && type == 7 ) numPmtA++;
- sideshift=45;
- sideshiftqtc=33;
-
+ AliDebug(50,Form("%i CFD %i data %s",ik, ik+sideshift, GetRawsData(shift+ik+1)->GetName()));
+ if(type == 7 ) { // RS I think the type check should be removed
+ nhitsPMT++;
+ // feffPhysC[ik]++;
+ FillRawsData(207 ,ik,1.); // instead of incrementing former feff's, increment histo directly
}
- Int_t nhitsPMT=0;
- for (Int_t iHt=0; iHt<5; iHt++){
- //cfd
- if(allData[ik+sideshift][iHt]>0) {
- GetRawsData(shift+ik+1) -> Fill(allData[ik+sideshift][iHt]);
- GetRawsData(210+shift)->Fill(ik+1, allData[ik+sideshift][iHt]);
- if(type == 8 ) feffC[ik]++;
- AliDebug(50,Form("%i CFD %i data %s",ik, ik+sideshift, GetRawsData(shift+ik+1)->GetName()));
- if(type == 7 ) {
- nhitsPMT++;
- feffPhysC[ik]++;
- }
-
- }
- //led
- if(allData[ik+12+sideshift][iHt] > 0) {
- GetRawsData(shift+ik+24+1)-> Fill(allData[ik+12+sideshift][iHt]);
- GetRawsData(211+shift)->Fill(ik+1, allData[ik+12+sideshift][iHt]);
- AliDebug(50,Form("%i LED %i data %s",ik, ik+12+sideshift, GetRawsData(shift+ik+1+24)->GetName()));
- if(type == 8 ) {
- feffA[ik]++;
- }
- }
- //led -cfd
-
- if(allData[ik+12+sideshift][iHt] > 0 && allData[ik+sideshift][iHt] >0 )
- GetRawsData(shift+ik+48+1)->
- Fill(allData[ik+12+sideshift][iHt]-allData[ik+sideshift][iHt]);
-
- //qtc
- if(allData[2*ik+sideshiftqtc+24][iHt] > 0 &&
- allData[2*ik+sideshiftqtc+25][iHt] > 0) {
- GetRawsData(shift+ik+72+1)->
- Fill(allData[2*ik+sideshiftqtc+24][iHt]-allData[2*ik+sideshiftqtc+25][iHt]);
- GetRawsData(212+shift)->Fill(ik+1, allData[2*ik+sideshiftqtc+24][iHt]-allData[2*ik+sideshiftqtc+25][iHt]);
- if(type == 8) feffqtc[ik]++;
- AliDebug(50,Form("%i QTC %i data %s",ik, 2*ik+sideshiftqtc+24, GetRawsData(shift+ik+1+72)->GetName()));
-
- }
- if(allData[2*ik+sideshiftqtc+24][iHt] > 0) {
- AliDebug(50,Form("%i QT0 %i data %s",ik, 2*ik+sideshiftqtc+24, GetRawsData(shift+ik+1+96)->GetName()));
- GetRawsData(shift+ik+96+1)->Fill(allData[2*ik+sideshiftqtc+24][iHt]);
- }
- if(allData[2*ik+sideshiftqtc+25][iHt] > 0) {
- AliDebug(50,Form("%i QT0 %i data %s",ik, 2*ik+sideshiftqtc+25, GetRawsData(shift+ik+1+120)->GetName()));
- GetRawsData(shift+ik+120+1)->Fill(allData[2*ik+sideshiftqtc+25][iHt]);
- }
+ }
+ //led
+ if(allData[ik+12+sideshift][iHt] > 0) {
+ FillRawsData(shift+ik+24+1,allData[ik+12+sideshift][iHt]);
+ FillRawsData(211+shift,ik+1, allData[ik+12+sideshift][iHt]);
+ AliDebug(50,Form("%i LED %i data %s",ik, ik+12+sideshift, GetRawsData(shift+ik+1+24)->GetName()));
+ if(type == 8 ) {
+ FillRawsData(208+shift,ik,1.); // instead of incrementing former feff's, increment histo directly
+ // feffA[ik]++;
}
+ }
+ //led -cfd
- if(type == 7 ) {
- GetRawsData(ik+176)->Fill(nhitsPMT);
- GetRawsData(213)->Fill(numPmtC);
- GetRawsData(214)->Fill(numPmtA);
- }
- }
-
- Int_t trChannel[6] = {49,50,51,52,55,56};
- Float_t ch2cm = 24.4*0.029979;
- Int_t nhitsOrA=0;
- Int_t nhitsOrC=0;
- for (Int_t iHt=0; iHt<5; iHt++) {
+ if(allData[ik+12+sideshift][iHt] > 0 && allData[ik+sideshift][iHt] >0 )
+ FillRawsData(shift+ik+48+1, allData[ik+12+sideshift][iHt]-allData[ik+sideshift][iHt]);
- //orA-orC phys tvdc 1
- if((allData[51][iHt]>0 && allData[52][iHt]>0) && allData[50][iHt]>0)
- {
- AliDebug(10,Form("orA-orC phys tvdc 1 %i data %s", 217+shift, GetRawsData(shift+217)->GetName()));
-
- GetRawsData(217+shift)->Fill((allData[52][iHt]-allData[51][iHt])*ch2cm);
- // GetRawsData(345) ->Fill((allData[51][iHt]+allData[52][iHt])/2.);
- }
- //orA-orC phys tvdc 0
- if((allData[51][iHt]>0 && allData[52][iHt]>0) && allData[50][iHt]<=0)
- {
- AliDebug(10,Form("orA-orC phys tvdc 0 %i data %s", 218+shift, GetRawsData(shift+218)->GetName()));
-
- GetRawsData(218+shift)->Fill((allData[52][iHt]-allData[51][iHt])*ch2cm);
+ //qtc
+ if(allData[2*ik+sideshiftqtc+24][iHt] > 0 &&
+ allData[2*ik+sideshiftqtc+25][iHt] > 0) {
+ FillRawsData(shift+ik+72+1, allData[2*ik+sideshiftqtc+24][iHt]-allData[2*ik+sideshiftqtc+25][iHt]);
+ FillRawsData(212+shift,ik+1, allData[2*ik+sideshiftqtc+24][iHt]-allData[2*ik+sideshiftqtc+25][iHt]);
+ if(type == 8) {
+ FillRawsData(209+shift,ik,1.); // instead of incrementing former feff's, increment histo directly
+ // feffqtc[ik]++;
}
- if(allData[51][iHt]>0 && allData[52][iHt]>0) {
- AliDebug(50,Form("orA-orC phys tvdc all %i data %s", 219+shift, GetRawsData(shift+219)->GetName()));
- GetRawsData(219+shift)->Fill((allData[52][iHt]-allData[51][iHt])*ch2cm);
+ AliDebug(50,Form("%i QTC %i data %s",ik, 2*ik+sideshiftqtc+24, GetRawsData(shift+ik+1+72)->GetName()));
+
}
- for (Int_t itr=0; itr<6; itr++) {
- if (allData[trChannel[itr]][iHt] >0) {
- if(type == 7 )fNumTriggers[itr]++;
- if(type == 8 )fNumTriggersCal[itr]++;
- AliDebug(50,Form(" hit %i channel %i triggers %i data %s",iHt, trChannel[itr], 170+itr+shift, GetRawsData(170+itr+shift)->GetName()));
-
- GetRawsData(170+itr+shift)->Fill(allData[trChannel[itr]][iHt]);
- }
+ if(allData[2*ik+sideshiftqtc+24][iHt] > 0) {
+ AliDebug(50,Form("%i QT0 %i data %s",ik, 2*ik+sideshiftqtc+24, GetRawsData(shift+ik+1+96)->GetName()));
+ FillRawsData(shift+ik+96+1,allData[2*ik+sideshiftqtc+24][iHt]);
}
-
- if(type == 7) if(allData[51][iHt] >0) nhitsOrA++;
- if(type == 7) if(allData[52][iHt] >0) nhitsOrC++;
-
- //mult trigger signals phys
- //C side
- if(allData[53][iHt]>0 && allData[54][iHt]>0) {
- AliDebug(50,Form(" mpdA %i data %s", 201+shift, GetRawsData(201+shift)->GetName()));
-
- GetRawsData(201+shift)->Fill(allData[53][iHt]-allData[54][iHt]);
- if(allData[56][iHt]>0) GetRawsData(202+shift)->Fill(allData[53][iHt]-allData[54][iHt]);
- if(allData[55][iHt]>0) GetRawsData(203+shift)->Fill(allData[53][iHt]-allData[54][iHt]);
+ if(allData[2*ik+sideshiftqtc+25][iHt] > 0) {
+ AliDebug(50,Form("%i QT0 %i data %s",ik, 2*ik+sideshiftqtc+25, GetRawsData(shift+ik+1+120)->GetName()));
+ FillRawsData(shift+ik+120+1,allData[2*ik+sideshiftqtc+25][iHt]);
}
+ }
+
+ if(type == 7 ) {
+ FillRawsData(ik+176,nhitsPMT);
+ FillRawsData(213,numPmtC);
+ FillRawsData(214,numPmtA);
+ }
+ }
+
+ Int_t trChannel[6] = {49,50,51,52,55,56};
+ Float_t ch2cm = 24.4*0.029979;
+ Int_t nhitsOrA=0;
+ Int_t nhitsOrC=0;
+ for (Int_t iHt=0; iHt<5; iHt++) {
+
+ //orA-orC phys tvdc 1
+ if((allData[51][iHt]>0 && allData[52][iHt]>0) && allData[50][iHt]>0) {
+ AliDebug(10,Form("orA-orC phys tvdc 1 %i data %s", 217+shift, GetRawsData(shift+217)->GetName()));
- //A side
- if(allData[105][iHt]>0 && allData[106][iHt]>0) {
- AliDebug(50,Form(" mpdC %i data %s", 204+shift, GetRawsData(204+shift)->GetName()));
-
- GetRawsData(204+shift)->Fill(allData[105][iHt]-allData[106][iHt]);
- if(allData[56][iHt]>0) GetRawsData(205+shift)->Fill(allData[105][iHt]-allData[106][iHt]);
- if(allData[55][iHt]>0) GetRawsData(206+shift)->Fill(allData[105][iHt]-allData[106][iHt]);
+ FillRawsData(217+shift,(allData[52][iHt]-allData[51][iHt])*ch2cm);
+ // FillRawsData(345,(allData[51][iHt]+allData[52][iHt])/2.);
+ }
+ //orA-orC phys tvdc 0
+ if((allData[51][iHt]>0 && allData[52][iHt]>0) && allData[50][iHt]<=0) {
+ AliDebug(10,Form("orA-orC phys tvdc 0 %i data %s", 218+shift, GetRawsData(shift+218)->GetName()));
+
+ FillRawsData(218+shift,(allData[52][iHt]-allData[51][iHt])*ch2cm);
+ }
+ if(allData[51][iHt]>0 && allData[52][iHt]>0) {
+ AliDebug(50,Form("orA-orC phys tvdc all %i data %s", 219+shift, GetRawsData(shift+219)->GetName()));
+ FillRawsData(219+shift,(allData[52][iHt]-allData[51][iHt])*ch2cm);
+ }
+ for (Int_t itr=0; itr<6; itr++) {
+ if (allData[trChannel[itr]][iHt] >0) {
+ //
+ // RS instead of incremented custom counters, fill directly the specie-specific histos
+ FillRawsData(169+shift, 0.5+itr, 1.); // RS: increment counters
+ // if(type == 7 )fNumTriggers[itr]++;
+ // if(type == 8 )fNumTriggersCal[itr]++;
+ AliDebug(50,Form(" triggers %i data %s", 170+itr+shift, GetRawsData(170+itr+shift)->GetName()));
+
+ FillRawsData(170+itr+shift,allData[trChannel[itr]][iHt]);
}
}
- GetRawsData(215)->Fill(nhitsOrA);
- GetRawsData(216)->Fill(nhitsOrC);
-
- //draw satellite
- if(type == 7){
- if(fnEventPhys == 1000) {
- for (Int_t ik=0; ik<24; ik++)
- {
- GetRawsData(ik+1)->GetXaxis()->SetRangeUser(2000, 3000);
- int maxBin = GetRawsData(ik+1) ->GetMaximumBin();
- double meanEstimate = GetRawsData(ik+1)->GetBinCenter( maxBin);
- TF1* fit= new TF1("fit","gaus", meanEstimate - 40, meanEstimate + 40);
- fit->SetParameters (GetRawsData(ik+1)->GetBinContent(maxBin), meanEstimate, 80);
- GetRawsData(ik+1) -> Fit("fit","RQ","Q", meanEstimate-40, meanEstimate+40);
- if(fit->GetParameter(1)>2000 && fit->GetParameter(1)<3000)
- fMeans[ik]= (Int_t) fit->GetParameter(1);
- GetRawsData(ik+1)->GetXaxis()->SetRangeUser(0, 30000);
-
- }
+ if(type == 7) if(allData[51][iHt] >0) nhitsOrA++;
+ if(type == 7) if(allData[52][iHt] >0) nhitsOrC++;
+
+ //mult trigger signals phys
+ //C side
+ if(allData[53][iHt]>0 && allData[54][iHt]>0) {
+ AliDebug(50,Form(" mpdA %i data %s", 201+shift, GetRawsData(201+shift)->GetName()));
+
+ FillRawsData(201+shift,allData[53][iHt]-allData[54][iHt]);
+ if(allData[56][iHt]>0) FillRawsData(202+shift,allData[53][iHt]-allData[54][iHt]);
+ if(allData[55][iHt]>0) FillRawsData(203+shift,allData[53][iHt]-allData[54][iHt]);
+ }
+
+ //A side
+ if(allData[105][iHt]>0 && allData[106][iHt]>0) {
+ AliDebug(50,Form(" mpdC %i data %s", 204+shift, GetRawsData(204+shift)->GetName()));
+
+ FillRawsData(204+shift,allData[105][iHt]-allData[106][iHt]);
+ if(allData[56][iHt]>0) FillRawsData(205+shift,allData[105][iHt]-allData[106][iHt]);
+ if(allData[55][iHt]>0) FillRawsData(206+shift,allData[105][iHt]-allData[106][iHt]);
+ }
+ }
+
+ FillRawsData(215,nhitsOrA);
+ FillRawsData(216,nhitsOrC);
+
+ //draw satellite
+ for (int itr=-1;itr<GetNEventTrigClasses();itr++) { //RS loop over all active trigger classes, including the global one
+ int itrID = itr==-1 ? -1 : GetEventTrigClass(itr)->GetUniqueID();
+ int nEvent = GetEvCountCycleRaws(itrID);
+ //
+ if(type == 7) { // RS Do we need here event type check, specie should do the job
+ if(nEvent == 1000) {
+ for (Int_t ik=0; ik<24; ik++) {
+ //
+ TH1* hik = (TH1*) GetRawsData(ik+1,itrID); if (!hik) continue;
+ hik->GetXaxis()->SetRangeUser(2000, 3000);
+ int maxBin = hik->GetMaximumBin();
+ double meanEstimate = hik->GetBinCenter( maxBin);
+ TF1* fit= new TF1("fit","gaus", meanEstimate - 40, meanEstimate + 40);
+ fit->SetParameters (hik->GetBinContent(maxBin), meanEstimate, 80);
+ hik->Fit("fit","RQ","Q", meanEstimate-40, meanEstimate+40);
+ means[ik]= (Int_t) fit->GetParameter(1);
+ hik->GetXaxis()->SetRangeUser(0, 30000);
}
-
- if( fnEventPhys > 1000) {
- Int_t besttimeA=9999999;
- Int_t besttimeC=9999999;
- for (Int_t ipmt=0; ipmt<12; ipmt++){
- if(allData[ipmt+1][0] > 1 ) {
- // time[ipmt] = allData[ipmt+1][0] - Int_t(GetRawsData(1)->GetMean());
- time[ipmt] = allData[ipmt+1][0] - fMeans[ipmt];
- if(TMath::Abs(time[ipmt]) < TMath::Abs(besttimeC))
- besttimeC=time[ipmt]; //timeC
- }
+ }
+ //
+ TH2 *h220 = (TH2*)GetRawsData(220,itrID);
+ TH2 *h221 = (TH2*)GetRawsData(221,itrID);
+ TH2 *h222 = (TH2*)GetRawsData(222,itrID);
+ TH1 *h223 = (TH1*)GetRawsData(223,itrID);
+ if( nEvent>1000 && (h220 || h221 || h222 || h223) ) {
+ Int_t besttimeA=9999999;
+ Int_t besttimeC=9999999;
+ for (Int_t ipmt=0; ipmt<12; ipmt++){
+ if(allData[ipmt+1][0] > 1 ) {
+ // time[ipmt] = allData[ipmt+1][0] - Int_t(GetRawsData(1)->GetMean());
+ time[ipmt] = allData[ipmt+1][0] - means[ipmt];
+ if(TMath::Abs(time[ipmt]) < TMath::Abs(besttimeC))
+ besttimeC=time[ipmt]; //timeC
}
- for ( Int_t ipmt=12; ipmt<24; ipmt++){
- if(allData[ipmt+45][0] > 1) {
- time[ipmt] = allData[ipmt+45][0] - fMeans[ipmt] ;
- if(TMath::Abs(time[ipmt]) < TMath::Abs(besttimeA) )
- besttimeA=time[ipmt]; //timeA
- }
+ }
+ for ( Int_t ipmt=12; ipmt<24; ipmt++){
+ if(allData[ipmt+45][0] > 0) {
+ time[ipmt] = allData[ipmt+45][0] - means[ipmt] ;
+ if(TMath::Abs(time[ipmt]) < TMath::Abs(besttimeA) )
+ besttimeA=time[ipmt]; //timeA
}
- if(besttimeA<99999 &&besttimeC< 99999) {
- Float_t t0 = 24.4 * (Float_t( besttimeA+besttimeC)/2. );
- Float_t ver = 24.4 * Float_t( besttimeC-besttimeA)/2.;
- GetRawsData(220)->Fill(0.001*ver, 0.001*(t0));
- if(allData[50][0] > 0) GetRawsData(221)->Fill(0.001*ver, 0.001*(t0));
- if(allData[50][0] <= 0) GetRawsData(222)->Fill(0.001*ver, 0.001*(t0));
- GetRawsData(223) ->Fill(t0);
- }
- } //event >100
+ }
+ if(besttimeA<99999 &&besttimeC< 99999) {
+ Float_t t0 = 24.4 * (Float_t( besttimeA+besttimeC)/2. );
+ Float_t ver = 24.4 * Float_t( besttimeA-besttimeC)/2.;
+ if (h220) h220->Fill(0.001*ver, 0.001*(t0));
+ if(allData[50][0] > 0) if (h221) h221->Fill(0.001*ver, 0.001*(t0));
+ if(allData[50][0] <= 0) if (h222) h222->Fill(0.001*ver, 0.001*(t0));
+ if (h223) h223->Fill(t0);
+ }
+ } //event >100
} //type 7
- } //next
-
-
-
+ } // RS loop over all active trigger classes, including the global one
+ } //next
delete start;
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
-
-
-
//____________________________________________________________________________
void AliT0QADataMakerRec::MakeDigits( TTree *digitsTree)
{
brDigits->SetAddress(&fDigits);
}else{
AliError(Form("EXEC Branch T0 digits not found"));
+ delete digCFD;
+ delete digLED;
+ delete digQT0;
+ delete digQT1;
return;
}
digitsTree->GetEvent(0);
fDigits->GetQT0(*digQT0);
fDigits->GetQT1(*digQT1);
refpoint = fDigits->RefPoint();
- for (Int_t i=0; i<24; i++)
- {
+ for (Int_t i=0; i<24; i++) {
if (digCFD->At(i)>0) {
Int_t cfd=digCFD->At(i)- refpoint;
- GetDigitsData(0) ->Fill(i,cfd);
- GetDigitsData(1) -> Fill(i, (digLED->At(i) - digCFD->At(i)));
- GetDigitsData(2) -> Fill(i, (digQT1->At(i) - digQT0->At(i)));
+ FillDigitsData(0,i,cfd);
+ FillDigitsData(1,i, (digLED->At(i) - digCFD->At(i)));
+ FillDigitsData(2,i, (digQT1->At(i) - digQT0->At(i)));
}
- }
+ }
delete digCFD;
delete digLED;
delete digQT0;
delete digQT1;
-
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
for ( Int_t i=0; i<24; i++) {
if(i<12)
- GetRecPointsData(0) -> Fill(i, frecpoints -> GetTime(i) - frecpoints -> GetTime(0));
+ FillRecPointsData(0, i, frecpoints -> GetTime(i) - frecpoints -> GetTime(0));
if(i>11)
- GetRecPointsData(0) -> Fill(i, frecpoints -> GetTime(i) - frecpoints -> GetTime(12));
- GetRecPointsData(1) -> Fill( i, frecpoints -> GetAmp(i) - frecpoints->AmpLED(i));
+ FillRecPointsData(0, i, frecpoints -> GetTime(i) - frecpoints -> GetTime(12));
+ FillRecPointsData(1, i, frecpoints -> GetAmp(i) - frecpoints->AmpLED(i));
}
Double_t mmm=frecpoints->GetOnlineMean()- frecpoints->GetMeanTime();
- GetRecPointsData(2) ->Fill(mmm);
-
+ FillRecPointsData(2,mmm);
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
Double32_t orA= 0.001*mean[1];
Double32_t orC=0.001* mean[2];
- if (t0time<99) GetESDsData(0) -> Fill(t0time);
- if( esd->GetT0zVertex() <99) GetESDsData(1)-> Fill(esd->GetT0zVertex());
- if( orA<99 && orC<99) GetESDsData(2)-> Fill((orA-orC)/2.);
-
+ if (t0time<99) FillESDsData(0,t0time);
+ if( esd->GetT0zVertex() <99) FillESDsData(1, esd->GetT0zVertex());
+ if( orA<99 && orC<99) FillESDsData(2,(orA-orC)/2.);
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
virtual void StartOfDetectorCycle() ;
const AliT0RecoParam* GetRecoParam() { return dynamic_cast<const AliT0RecoParam*>(fRecoParam);}
+
+ // RS Commented by Ruben, read below:
+ /*
+ // RS: Don't use custom counters, they create problems with trigger cloning
+ // Use instead framework counters, incremented in the end of this routine
+ // RS: There is some inconsistency here: the separation of physics and calib. events/histos is done by
+ // fEventSpecie. Why do we book separate histos on different slots for calib and physics ?
+ // I am changing this in such way that we don't need local counters like fNumTriggers (the corresponding
+ // histos now incremented in the MakeRaws, and for the normalization I will use the framework's counters
+ // AliQADataMaker::GetEvCountCycle(...), AliQADataMaker::GetEvCountTotal(...)
+ //
+ // I think the histos xx+250 should be suppressed (the xx calib histos of specie==calibration will be
+ // used automatically)
+
+
Int_t fNumTriggers[6]; //number of trigger signals;
Int_t fNumTriggersCal[6]; //number of calibration trigger signals;
Float_t fTrEffPhys[6];
TH1F* fhTimeDiff[24];
Int_t fMeans[24];
-
+ */
- ClassDef(AliT0QADataMakerRec,6) // description
+ ClassDef(AliT0QADataMakerRec,7) // description
};
TH2F *fhHitsTimeA = new TH2F("hHitsTimeA", "Hits Efficiency;#PMT; Time [ns];", 13, 12, 25, 100,12,15 );
fhHitsTimeA->SetOption("COLZ");
- Add2HitsList(fhHitsTimeA,0, !expert, image);
+ Add2HitsList(fhHitsTimeA,0, !expert, image);
TH2F *fhHitsTimeC = new TH2F("hHitsTimeC", "Hits Efficiency;#PMT; Time [ns];", 13, 0, 13, 100,2,5 );
fhHitsTimeC->SetOption("COLZ");
Add2HitsList(fhHitsTimeC,1, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
TH2F * fhDigQTC = new TH2F("fhDigQTC", " QTC digits; #PMT; amplitude QTC [#channel]",25,-0.5,24.5,200,500,10000);
fhDigQTC->SetOption("COLZ");
Add2DigitsList( fhDigQTC,2, !expert, image);
-
-
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
}
Int_t pmt=startHit->Pmt();
Float_t time = 0.001 * startHit->Time();
- if(pmt<13)GetHitsData(1)->Fill(pmt,time) ;
- if(pmt>12)GetHitsData(0)->Fill(pmt,time) ;
+ if(pmt<13) FillHitsData(1,pmt,time) ;
+ if(pmt>12) FillHitsData(0,pmt,time) ;
}
}
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
{
if (digCFD->At(i)>0) {
Int_t cfd=digCFD->At(i)- refpoint;
- GetDigitsData(0) ->Fill(i,cfd);
- GetDigitsData(1) -> Fill(i,(digLED->At(i) - digCFD->At(i)));
- GetDigitsData(2) -> Fill(i, (digQT1->At(i) - digQT0->At(i)));
+ FillDigitsData(0, i,cfd);
+ FillDigitsData(1, i,(digLED->At(i) - digCFD->At(i)));
+ FillDigitsData(2, i, (digQT1->At(i) - digQT0->At(i)));
}
}
delete digLED;
delete digQT0;
delete digQT1;
-
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2HitsList(h3, 3, expert) ;
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2DigitsList(h3, 3, expert) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
h2->GetYaxis()->SetTitle("48*sector+padx (phi)");
h2->GetYaxis()->SetTitleOffset(1.15);
Add2SDigitsList(h2, 2, expert) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
h3->GetYaxis()->SetTitle("48*sector+padx (phi)");
h3->GetYaxis()->SetTitleOffset(1.15);
Add2RawsList(h3, 3, expert) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
h4->GetYaxis()->SetTitle("48*sector+padx (phi)");
h4->GetYaxis()->SetTitleOffset(1.15);
Add2RecPointsList(h4, 4, expert) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
h4->Sumw2() ;
h4->GetXaxis()->SetTitle("Fraction of TOF matched ESD tracks with good flag [%]");
Add2ESDsList(h4, 4, expert) ;
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
Int_t nentries=hits->GetEntriesFast();
if(nentries<=0) {
- GetHitsData(0)->Fill(-1.) ;
+ FillHitsData(0,-1.) ;
} else{
- GetHitsData(0)->Fill(TMath::Log10(nentries)) ;
+ FillHitsData(0,TMath::Log10(nentries)) ;
}
TIter next(hits) ;
AliTOFhitT0 * hit ;
while ( (hit = dynamic_cast<AliTOFhitT0 *>(next())) ) {
- GetHitsData(1)->Fill( hit->GetTof()*1.E9) ;//in ns
- GetHitsData(2)->Fill( hit->GetLen()) ;//in cm
+ FillHitsData(1, hit->GetTof()*1.E9) ;//in ns
+ FillHitsData(2, hit->GetLen()) ;//in cm
in[0] = hit->GetSector();
in[1] = hit->GetPlate();
in[3]= hit->GetPadx();
in[4]= hit->GetPadz();
GetMapIndeces(in,out);
- GetHitsData(3)->Fill( out[0],out[1]) ;//hit map
+ FillHitsData(3, out[0],out[1]) ;//hit map
}
}
dummy->Delete();
delete dummy;
MakeHits(hits) ;
-
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
Int_t nentries=digits->GetEntriesFast();
if(nentries<=0){
- GetDigitsData(0)->Fill(-1.) ;
+ FillDigitsData(0,-1.) ;
}else{
- GetDigitsData(0)->Fill(TMath::Log10(nentries)) ;
+ FillDigitsData(0, TMath::Log10(nentries)) ;
}
TIter next(digits) ;
AliTOFdigit * digit ;
while ( (digit = dynamic_cast<AliTOFdigit *>(next())) ) {
- GetDigitsData(1)->Fill( digit->GetTdc()*tdc2ns) ;//in ns
- GetDigitsData(2)->Fill( digit->GetToT()*tot2ns) ;//in ns
+ FillDigitsData(1, digit->GetTdc()*tdc2ns) ;//in ns
+ FillDigitsData(2, digit->GetToT()*tot2ns) ;//in ns
in[0] = digit->GetSector();
in[1] = digit->GetPlate();
in[3] = digit->GetPadx();
in[4]= digit->GetPadz();
GetMapIndeces(in,out);
- GetDigitsData(3)->Fill( out[0],out[1]) ;//digit map
+ FillDigitsData(3, out[0],out[1]) ;//digit map
}
}
branch->SetAddress(&digits) ;
branch->GetEntry(0) ;
MakeDigits(digits) ;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
Int_t nentries=sdigits->GetEntriesFast();
if(nentries<=0){
- GetSDigitsData(0)->Fill(-1.) ;
+ FillSDigitsData(0,-1.) ;
}else{
- GetSDigitsData(0)->Fill(TMath::Log10(nentries)) ;
+ FillSDigitsData(0,TMath::Log10(nentries)) ;
}
TIter next(sdigits) ;
while ( (sdigit = dynamic_cast<AliTOFSDigit *>(next())) ) {
for(Int_t i=0;i<sdigit->GetNDigits();i++){
- GetSDigitsData(1)->Fill( sdigit->GetTdc(i)*tdc2ns) ;//in ns
+ FillSDigitsData(1, sdigit->GetTdc(i)*tdc2ns) ;//in ns
}
in[0] = sdigit->GetSector();
in[3] = sdigit->GetPadx();
in[4]= sdigit->GetPadz();
GetMapIndeces(in,out);
- GetSDigitsData(2)->Fill( out[0],out[1]) ;//sdigit map
+ FillSDigitsData(2, out[0],out[1]) ;//sdigit map
}
}
branch->SetAddress(&sdigits) ;
branch->GetEntry(0) ;
MakeSDigits(sdigits) ;
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
//if (!tofRawDatum->GetTOT() || !tofRawDatum->GetTOF()) continue;
if (!tofRawDatum->GetTOF()) continue;
ntof++;
- GetRawsData(1)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;//in ns
- GetRawsData(2)->Fill( tofRawDatum->GetTOT()*tot2ns) ;//in ns
+ FillRawsData(1, tofRawDatum->GetTOF()*tdc2ns) ;//in ns
+ FillRawsData(2, tofRawDatum->GetTOT()*tot2ns) ;//in ns
fTOFRawStream.EquipmentId2VolumeId(iDDL,
tofRawDatum->GetTRM(),
in);
GetMapIndeces(in,out);
- GetRawsData(3)->Fill( out[0],out[1]) ;//raw map
+ FillRawsData(3, out[0],out[1]) ;//raw map
} // while loop
Int_t nentries=ntof;
if(nentries<=0){
- GetRawsData(0)->Fill(-1.) ;
+ FillRawsData(0,-1.) ;
}else{
- GetRawsData(0)->Fill(TMath::Log10(nentries)) ;
+ FillRawsData(0,TMath::Log10(nentries)) ;
}
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
Int_t nentries=clusters->GetEntriesFast();
if(nentries<=0){
- GetRecPointsData(0)->Fill(-1.) ;
+ FillRecPointsData(0,-1.) ;
}else{
- GetRecPointsData(0)->Fill(TMath::Log10(nentries)) ;
+ FillRecPointsData(0,TMath::Log10(nentries)) ;
}
TIter next(clusters) ;
AliTOFcluster * c ;
while ( (c = dynamic_cast<AliTOFcluster *>(next())) ) {
- GetRecPointsData(1)->Fill(c->GetTDC()*tdc2ns);
- GetRecPointsData(2)->Fill(c->GetTDCRAW()*tdc2ns);
- GetRecPointsData(3)->Fill(c->GetToT()*tot2ns);
+ FillRecPointsData(1,c->GetTDC()*tdc2ns);
+ FillRecPointsData(2,c->GetTDCRAW()*tdc2ns);
+ FillRecPointsData(3,c->GetToT()*tot2ns);
in[0] = c->GetDetInd(0);
in[1] = c->GetDetInd(1);
in[4] = c->GetDetInd(3); //X and Z indeces inverted in RecPoints
GetMapIndeces(in,out);
- GetRecPointsData(4)->Fill(out[0],out[1]);
-
+ FillRecPointsData(4,out[0],out[1]);
}
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
Double_t tofToT=track->GetTOFsignalToT(); //in ns
if(!(tofTime>0))continue;
ntof++;
- GetESDsData(1)->Fill(tofTime);
- GetESDsData(2)->Fill(tofTimeRaw);
- GetESDsData(3)->Fill(tofToT);
+ FillESDsData(1,tofTime);
+ FillESDsData(2,tofTimeRaw);
+ FillESDsData(3,tofToT);
//check how many tracks where ESD PID is ok
UInt_t status=track->GetStatus();
if (((status&AliESDtrack::kESDpid)==0) ||
Int_t nentries=ntof;
if(nentries<=0){
- GetESDsData(0)->Fill(-1.) ;
+ FillESDsData(0,-1.) ;
}else{
- GetESDsData(0)->Fill(TMath::Log10(nentries)) ;
+ FillESDsData(0,TMath::Log10(nentries)) ;
}
Float_t ratio = 0.;
if(ntof>0) ratio=(Float_t)ntofpid/(Float_t)ntof*100.;
- GetESDsData(4)->Fill(ratio) ;
-
+ FillESDsData(4,ratio) ;
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
fCalibData(0x0),
fEnableNoiseFiltering(kFALSE),
fEnableDqmShifterOpt(kFALSE),
- fProcessedRawEventN(0),
+// fProcessedRawEventN(0),
fIsSOC(kFALSE),
fLineExpTimeMin(new TLine(200., 0., 200., 0.)),
fLineExpTimeMax(new TLine(250., 0., 250., 0.)),
fCalibData(qadm.fCalibData),
fEnableNoiseFiltering(qadm.fEnableNoiseFiltering),
fEnableDqmShifterOpt(qadm.fEnableDqmShifterOpt),
- fProcessedRawEventN(qadm.fProcessedRawEventN),
+ // fProcessedRawEventN(qadm.fProcessedRawEventN),
fIsSOC(qadm.fIsSOC),
fLineExpTimeMin(qadm.fLineExpTimeMin),
fLineExpTimeMax(qadm.fLineExpTimeMax),
Add2RawsList(h20, 20, expert, !image, !saveCorr) ;
Add2RawsList(h21, 21, expert, !image, !saveCorr) ;
Add2RawsList(h22, 22, expert, !image, !saveCorr) ;
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
Add2RecPointsList(h14, 14, expert, image) ;
Add2RecPointsList(h15, 15, expert, !image) ;
Add2RecPointsList(h16, 16, expert, !image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
Add2ESDsList(h7, 7, expert, image) ;
Add2ESDsList(h8, 8, expert, !image) ;
Add2ESDsList(h9, 9, !expert, !image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
fDecoderSummary = ( (AliTOFDecoderV2*) fTOFRawStream.GetDecoderV2() )->GetDecoderSummaryData();
if ( (fDecoderSummary) && (fDecoderSummary ->GetErrorDetected()) ) {
Int_t errorSlotID=(Int_t) fDecoderSummary->GetErrorSlotID();
- GetRawsData(18)->Fill(iDDL,errorSlotID);
+ FillRawsData(18,iDDL,errorSlotID);
if (fDecoderSummary -> GetRecoverError() )
- GetRawsData(18)->Fill(iDDL,13);
+ FillRawsData(18,iDDL,13);
}
clonesRawData = (TClonesArray*)fTOFRawStream.GetRawData();
//LTM data
if (FilterLTMData(equipmentID)) { //counts LTM hits
if (equipmentID[2]==1) { //crate left, A-side or C-side
- GetRawsData(15)->Fill(equipmentID[0]);
+ FillRawsData(15,equipmentID[0]);
} else {
- if (equipmentID[0]<36) { GetRawsData(15)->Fill(equipmentID[0]-1); }
- else { GetRawsData(15)->Fill(equipmentID[0]+1); }
+ if (equipmentID[0]<36) { FillRawsData(15,equipmentID[0]-1); }
+ else { FillRawsData(15,equipmentID[0]+1); }
}
continue;
}
ntof[0]++; //counter for tof hits
//fill global spectra for DQM plots
- GetRawsData(5)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;//in ns
- GetRawsData(10)->Fill( tofRawDatum->GetTOT()*tot2ns) ;//in ns
+ FillRawsData(5, tofRawDatum->GetTOF()*tdc2ns) ;//in ns
+ FillRawsData(10, tofRawDatum->GetTOT()*tot2ns) ;//in ns
//fill side-related spectra for experts plots
Int_t ddlACside=iDDL/36; // 0 or 1
if (volumeID2[0]>4 && volumeID2[0]<14){ //O side
if (ddlPerSm<2){ //A side
ntof[1]++;
- GetRawsData(6)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;
- GetRawsData(11)->Fill( tofRawDatum->GetTOT()*tot2ns) ;
+ FillRawsData(6, tofRawDatum->GetTOF()*tdc2ns) ;
+ FillRawsData(11, tofRawDatum->GetTOT()*tot2ns) ;
} else { //C side
ntof[3]++;
- GetRawsData(8)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;
- GetRawsData(13)->Fill( tofRawDatum->GetTOT()*tot2ns) ;
+ FillRawsData(8, tofRawDatum->GetTOF()*tdc2ns) ;
+ FillRawsData(13, tofRawDatum->GetTOT()*tot2ns) ;
}
} else {
if (volumeID2[0]<5 || volumeID2[0]>13){ //I side
if (ddlPerSm<2){ //A side
ntof[2]++;
- GetRawsData(7)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;
- GetRawsData(12)->Fill( tofRawDatum->GetTOT()*tot2ns) ;
+ FillRawsData(7, tofRawDatum->GetTOF()*tdc2ns) ;
+ FillRawsData(12, tofRawDatum->GetTOT()*tot2ns) ;
} else {//C side
ntof[4]++;
- GetRawsData(9)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;
- GetRawsData(14)->Fill( tofRawDatum->GetTOT()*tot2ns) ;
+ FillRawsData(9, tofRawDatum->GetTOF()*tdc2ns) ;
+ FillRawsData(14, tofRawDatum->GetTOT()*tot2ns) ;
}
}
}
//compute TRM offset
Int_t trm= iDDL*10+(equipmentID[1]-3);
- GetRawsData(20+ddlACside)->Fill(trm,tofRawDatum->GetTOF()*tdc2ns);
- GetRawsData(22)->Fill(GetStripIndex(volumeID),tofRawDatum->GetTOF()*tdc2ns) ;
+ FillRawsData(20+ddlACside,trm,tofRawDatum->GetTOF()*tdc2ns);
+ FillRawsData(22,GetStripIndex(volumeID),tofRawDatum->GetTOF()*tdc2ns) ;
Short_t fea = volumeID2[4]/12;
Float_t hitmapx = volumeID2[0] + ((Double_t)(3 - fea) + 0.5) *0.25;
- GetRawsData(17)->Fill(hitmapx,GetStripIndex(volumeID2));
+ FillRawsData(17,hitmapx,GetStripIndex(volumeID2));
}//noise filter
}//end hit selection
else { //orphans
if (!(fCalibData->GetNoiseStatus(chIndex) == AliTOFChannelOnlineStatusArray::kTOFNoiseBad)
&& (fCalibData->GetHWStatus(chIndex) == AliTOFChannelOnlineStatusArray::kTOFHWOk))
- GetRawsData(19)->Fill( tofRawDatum->GetTOF()*tdc2ns) ;//in ns
+ FillRawsData(19, tofRawDatum->GetTOF()*tdc2ns) ;//in ns
}//end orphans
}//end volumeID check
}//end equipID check
clonesRawData->Clear();
} // DDL Loop
- for (Int_t j=0;j<5;j++) { GetRawsData(j)->Fill(ntof[j]); }
- fProcessedRawEventN++;
+ for (Int_t j=0;j<5;j++) FillRawsData(j,ntof[j]);
+ // fProcessedRawEventN++; // RS Now the framework conters are use
fTOFRawStream.Clear();
} else {
AliDebug(1,Form("Event of type %d found. Skipping non-physics event for QA.\n", rawReader->GetType()));
//fill reference map with info from OCDB
Short_t fea = geoId[4]/12;
Float_t hitmapx = geoId[0] + ((Double_t)(3 - fea) + 0.5)*0.25;
- GetRawsData(16)->Fill(hitmapx, GetStripIndex(geoId));
+ FillRawsData(16,hitmapx, GetStripIndex(geoId));
}
}
//printf("Counters for noisy, enabled and good channels in TOF TRMs read from OCDB.\n");
//enable options for DQM shifter
EnableDqmShifterOpt(kTRUE);
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
// Import the tree
clustersTree->GetEvent(0);
- GetRecPointsData(0)->Fill((Int_t)clusters->GetEntriesFast()) ;
+ FillRecPointsData(0,(Int_t)clusters->GetEntriesFast()) ;
TIter next(clusters) ;
AliTOFcluster * c ;
if ((c->GetTDCRAW()) && (c->GetTDC()) && (c->GetToT())){
if (volumeID2[0]>4 && volumeID2[0]<14){ //I side
if (ddlPerSm<2){ //A side
- GetRecPointsData(1)->Fill( c->GetTDC()*tdc2ns) ;//in ns
- GetRecPointsData(5)->Fill( c->GetTDCRAW()*tdc2ns) ;//in ns
- GetRecPointsData(9)->Fill( c->GetToT()*tot2ns) ;//in ns
+ FillRecPointsData(1, c->GetTDC()*tdc2ns) ;//in ns
+ FillRecPointsData(5, c->GetTDCRAW()*tdc2ns) ;//in ns
+ FillRecPointsData(9, c->GetToT()*tot2ns) ;//in ns
} else {//C side
- GetRecPointsData(3)->Fill( c->GetTDC()*tdc2ns) ;//in ns
- GetRecPointsData(7)->Fill( c->GetTDCRAW()*tdc2ns) ;//in ns
- GetRecPointsData(11)->Fill( c->GetToT()*tot2ns) ;//in ns
+ FillRecPointsData(3, c->GetTDC()*tdc2ns) ;//in ns
+ FillRecPointsData(7, c->GetTDCRAW()*tdc2ns) ;//in ns
+ FillRecPointsData(11, c->GetToT()*tot2ns) ;//in ns
}
} else {
if (volumeID2[0]<5 || volumeID2[0]>13){ //O side
if (ddlPerSm<2){ //A side
- GetRecPointsData(2)->Fill( c->GetTDC()*tdc2ns) ;//in ns
- GetRecPointsData(6)->Fill( c->GetTDCRAW()*tdc2ns) ;//in ns
- GetRecPointsData(10)->Fill( c->GetToT()*tot2ns) ;//in ns
+ FillRecPointsData(2, c->GetTDC()*tdc2ns) ;//in ns
+ FillRecPointsData(6, c->GetTDCRAW()*tdc2ns) ;//in ns
+ FillRecPointsData(10, c->GetToT()*tot2ns) ;//in ns
} else { //C side
- GetRecPointsData(4)->Fill( c->GetTDC()*tdc2ns) ;//in ns
- GetRecPointsData(8)->Fill( c->GetTDCRAW()*tdc2ns) ;//in ns
- GetRecPointsData(12)->Fill( c->GetToT()*tot2ns) ;//in ns
+ FillRecPointsData(4, c->GetTDC()*tdc2ns) ;//in ns
+ FillRecPointsData(8, c->GetTDCRAW()*tdc2ns) ;//in ns
+ FillRecPointsData(12, c->GetToT()*tot2ns) ;//in ns
}
}
}
- GetRecPointsData(13)->Fill(hitmapx,GetStripIndex(volumeID2));
- GetRecPointsData(14)->Fill(GetStripIndex(volumeID2), c->GetTDC()*tdc2ns) ;
+ FillRecPointsData(13,hitmapx,GetStripIndex(volumeID2));
+ FillRecPointsData(14,GetStripIndex(volumeID2), c->GetTDC()*tdc2ns) ;
Int_t trm= iDDL*10+(iTRM-3);
if (ddlACside==0) { //A side
- GetRecPointsData(15)->Fill(trm,c->GetTDC()*tdc2ns);
+ FillRecPointsData(15,trm,c->GetTDC()*tdc2ns);
} else {//C side
- GetRecPointsData(16)->Fill(trm,c->GetTDC()*tdc2ns);
+ FillRecPointsData(16,trm,c->GetTDC()*tdc2ns);
}
}//hit selection
}//end while
EnableDqmShifterOpt(kFALSE);
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
if (TMath::Abs(y)<0.9) { //select TOF acceptance
if ((status&AliESDtrack::kTOFout)!=0) { //define matching
ntofout++;
- GetESDsData(1)->Fill(tofTime*1E-3);
- GetESDsData(2)->Fill(tofTimeRaw*1E-3);
- GetESDsData(3)->Fill(tofToT*1E-3);
- GetESDsData(4)->Fill(track->Pt());
+ FillESDsData(1,tofTime*1E-3);
+ FillESDsData(2,tofTimeRaw*1E-3);
+ FillESDsData(3,tofToT*1E-3);
+ FillESDsData(4,track->Pt());
Double_t length =track->GetIntegratedLength();
Double_t mom2=(track->Pt()*track->Pt())+(track->Pz()*track->Pz());
Double_t piTexp = TMath::Sqrt(1+(pionMass*pionMass/mom2))*length/speedOfLight; //in ps
- GetESDsData(8)->Fill(tofTime-piTexp);
- GetESDsData(9)->Fill(length);
+ FillESDsData(8,tofTime-piTexp);
+ FillESDsData(9,length);
if ((status&AliESDtrack::kTIME)!=0)
- GetESDsData(5)->Fill(track->Pt());
+ FillESDsData(5,track->Pt());
if (tofTime>0)
- GetESDsData(6)->Fill(track->Pt());
+ FillESDsData(6,track->Pt());
} //end check on matched tracks
}
}//end check on TPCrefit
}
- GetESDsData(0)->Fill(ntofout) ;
+ FillESDsData(0,ntofout) ;
if(ntpc>0){
Float_t ratio = (Float_t)ntofout/(Float_t)ntpc*100.; //matching probability
- GetESDsData(7)->Fill(ratio) ;
+ FillESDsData(7,ratio) ;
}
if(ntofout>0) {
Float_t ratio = (Float_t)ntofout/(Float_t)ntpc*100; //matched over propagated to TOF outer radius
- GetESDsData(8)->Fill(ratio) ;
+ FillESDsData(8,ratio) ;
}
EnableDqmShifterOpt(kFALSE);
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
{
//Detector specific actions at end of cycle
// do the QA checking
-
+ ResetEventTrigClasses();
+ //
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
- continue ;
-
- if (fEnableDqmShifterOpt){
- // Help make the raw qa histogram easier to interpret for the DQM shifter
- if (!GetRawsData(0) || !GetRawsData(5) || !GetRawsData(10)
- || !GetRawsData(15) || !GetRawsData(16) || !GetRawsData(17)) {
- printf("No histogram for DQM found - Possible memory corruption ???. Please check\n") ;
- continue;
- }
- printf("=========>Processed %i physics raw events. \n",fProcessedRawEventN);
-
- //Double_t monitorPeriodLength=fProcessedRawEventN*600*1E-9;//in s
-
- if (fCalibData){
- //set minima and maxima to allow log scale
- Double_t yTimeMax = GetRawsData(5)->GetMaximum()*1.05;
- Double_t yTotMax = GetRawsData(10)->GetMaximum()*1.05;
- fLineExpTimeMin->SetY2(yTimeMax);
- fLineExpTimeMax->SetY2(yTimeMax);
- fLineExpTotMin->SetY2(yTotMax);
- fLineExpTotMax->SetY2(yTotMax);
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) continue ;
+ //
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie)); // RS: the specie is not set, why?
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ if (fEnableDqmShifterOpt) {
+ //
+ // RS: fetch the histograms for given trigger class
+ TObjArray& arrRW = *GetRawsDataOfTrigClass(itc);
+
+ // Help make the raw qa histogram easier to interpret for the DQM shifter
+ if (!arrRW[ 0] || !arrRW[ 5] || !arrRW[10] || !arrRW[15] || !arrRW[16] || !arrRW[17]) continue;
+ //printf("No histogram for DQM found - Possible memory corruption ???. Please check\n") ;
+ printf("=========>Processed %i physics raw of specie %s with TrigGlass %d\n",
+ GetEvCountCycleRaws(itc),AliRecoParam::GetEventSpecieName(specie), itc);
- for (Int_t j=0;j<18;j++){
- if ((j==0)||(j==5)||(j==10)||(j==15)||(j==16)||(j==17)) {
- GetRawsData(j)->GetXaxis()->SetLabelOffset(0.005);
- GetRawsData(j)->GetXaxis()->SetLabelSize(0.05);
- GetRawsData(j)->GetXaxis()->SetTitleOffset(0.8);
- GetRawsData(j)->GetXaxis()->SetTitleSize(0.05);
- GetRawsData(j)->GetYaxis()->SetLabelOffset(0.005);
- GetRawsData(j)->GetYaxis()->SetLabelSize(0.06);
- GetRawsData(j)->GetYaxis()->SetTitleOffset(0.8);
- GetRawsData(j)->GetYaxis()->SetTitleSize(0.06);
+ //Double_t monitorPeriodLength=fProcessedRawEventN*600*1E-9;//in s
+
+ if (fCalibData){
+ //set minima and maxima to allow log scale
+ Double_t yTimeMax = ((TH1*)arrRW[5])->GetMaximum()*1.05;
+ Double_t yTotMax = ((TH1*)arrRW[10])->GetMaximum()*1.05;
+ fLineExpTimeMin->SetY2(yTimeMax);
+ fLineExpTimeMax->SetY2(yTimeMax);
+ fLineExpTotMin->SetY2(yTotMax);
+ fLineExpTotMax->SetY2(yTotMax);
+ //
+ for (Int_t j=0;j<18;j++){
+ if ((j==0)||(j==5)||(j==10)||(j==15)||(j==16)||(j==17)) {
+ TH1* htmp = (TH1*)arrRW[j];
+ htmp->GetXaxis()->SetLabelOffset(0.005);
+ htmp->GetXaxis()->SetLabelSize(0.05);
+ htmp->GetXaxis()->SetTitleOffset(0.8);
+ htmp->GetXaxis()->SetTitleSize(0.05);
+ htmp->GetYaxis()->SetLabelOffset(0.005);
+ htmp->GetYaxis()->SetLabelSize(0.06);
+ htmp->GetYaxis()->SetTitleOffset(0.8);
+ htmp->GetYaxis()->SetTitleSize(0.06);
+ }
}
+ //make up for all histos
+ for(Int_t j=0;j<5;j++) {
+ TH1* htmp = (TH1*)arrRW[j];
+ if (!htmp) continue;
+ htmp->SetMarkerColor(kBlue);
+ htmp->SetMarkerStyle(8);
+ htmp->SetMarkerSize(0.7);
+ }
+ for(Int_t j=5;j<15;j++) {
+ TH1* htmp = (TH1*)arrRW[j];
+ if (!htmp) continue;
+ htmp->SetLineColor(kBlue);
+ htmp->SetLineWidth(1);
+ htmp->SetMarkerColor(kBlue);
+ //htmp->SetFillColor(kWhite);
+ //htmp->SetDrawOption("bar");
+ }
+ //
+ TH1* htmp = (TH1*)arrRW[15];
+ htmp->SetLineColor(kBlue);
+ htmp->SetLineWidth(1);
+ htmp->SetMarkerStyle(8);
+ htmp->SetMarkerSize(0.7);
+ htmp->SetMarkerColor(kBlue);//Option("bar");
+ //
+ if ( (htmp=(TH1*)arrRW[16]) ) htmp->SetOption("colz");
+ if ( (htmp=(TH1*)arrRW[17]) ) htmp->SetOption("colz");
+ if ( (htmp=(TH1*)arrRW[18]) ) htmp->SetOption("colz");
}
- //make up for all histos
- for(Int_t j=0;j<5;j++){
- GetRawsData(j)->SetMarkerColor(kBlue);
- GetRawsData(j)->SetMarkerStyle(8);
- GetRawsData(j)->SetMarkerSize(0.7);
- }
- for(Int_t j=5;j<15;j++){
- GetRawsData(j)->SetLineColor(kBlue);
- GetRawsData(j)->SetLineWidth(1);
- GetRawsData(j)->SetMarkerColor(kBlue);
- //GetRawsData(j)->SetFillColor(kWhite);
- //GetRawsData(j)->SetDrawOption("bar");
- }
-
- GetRawsData(15)->SetLineColor(kBlue);
- GetRawsData(15)->SetLineWidth(1);
- GetRawsData(15)->SetMarkerStyle(8);
- GetRawsData(15)->SetMarkerSize(0.7);
- GetRawsData(15)->SetMarkerColor(kBlue);//Option("bar");
-
- GetRawsData(16)->SetOption("colz");
- GetRawsData(17)->SetOption("colz");
- GetRawsData(18)->SetOption("colz");
- }
- }//END ENABLE DQM SHIFTER OPT
+ }//END ENABLE DQM SHIFTER OPT
+ } // RS: loop over trigger classes
} //end for
+ //
AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;
+ //
}
//____________________________________________________________________________
void AliTOFQADataMakerRec::GetMapIndeces(const Int_t* const in , Int_t* out)
// interpretation of the TOF
// raw QA histograms
- Int_t fProcessedRawEventN; // number of processed rawData events
+ // Int_t fProcessedRawEventN; // number of processed rawData events
Bool_t fIsSOC; //flag for StartOfCycle operations
//lines for the DQM GUI
TLine* fLineExpTimeMin;
AliTOFDecoderSummaryData * fDecoderSummary;
- ClassDef(AliTOFQADataMakerRec,5) // description
+ ClassDef(AliTOFQADataMakerRec,6) // description
};
h3->Sumw2() ;
h3->GetYaxis()->SetTitleOffset(1.15);
Add2HitsList(h3, 3, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
h3->Sumw2() ;
h3->GetYaxis()->SetTitleOffset(1.15);
Add2DigitsList(h3, 3, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
h2->Sumw2() ;
h2->GetYaxis()->SetTitleOffset(1.15);
Add2SDigitsList(h2, 2, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
Int_t nentries= fHitsArray->GetEntriesFast();
if(nentries<=0) {
- GetHitsData(0)->Fill(-1.) ;
+ FillHitsData(0,-1.) ;
} else{
- GetHitsData(0)->Fill(nentries) ;
+ FillHitsData(0,nentries) ;
}
TIter next(fHitsArray) ;
AliTOFhitT0 * hit ;
while ( (hit = dynamic_cast<AliTOFhitT0 *>(next())) ) {
- GetHitsData(1)->Fill( hit->GetTof()*1.E9) ;//in ns
- GetHitsData(2)->Fill( hit->GetLen()) ;//in cm
+ FillHitsData(1, hit->GetTof()*1.E9) ;//in ns
+ FillHitsData(2, hit->GetLen()) ;//in cm
in[0] = hit->GetSector();
in[1] = hit->GetPlate();
in[3]= hit->GetPadx();
in[4]= hit->GetPadz();
GetMapIndeces(in,out);
- GetHitsData(3)->Fill( out[0],out[1]) ;//hit map
+ FillHitsData(3, out[0],out[1]) ;//hit map
}
}
MakeHits() ;
fHitsArray->Clear() ;
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
Int_t nentries=fDigitsArray->GetEntriesFast();
if(nentries<=0){
- GetDigitsData(0)->Fill(-1.) ;
+ FillDigitsData(0,-1.) ;
}else{
- GetDigitsData(0)->Fill(nentries) ;
+ FillDigitsData(0,nentries) ;
}
TIter next(fDigitsArray) ;
AliTOFdigit * digit ;
while ( (digit = dynamic_cast<AliTOFdigit *>(next())) ) {
- GetDigitsData(1)->Fill( digit->GetTdc()*tdc2ns) ;//in ns
- GetDigitsData(2)->Fill( digit->GetToT()*tot2ns) ;//in ns
+ FillDigitsData(1, digit->GetTdc()*tdc2ns) ;//in ns
+ FillDigitsData(2, digit->GetToT()*tot2ns) ;//in ns
in[0] = digit->GetSector();
in[1] = digit->GetPlate();
in[3] = digit->GetPadx();
in[4]= digit->GetPadz();
GetMapIndeces(in,out);
- GetDigitsData(3)->Fill( out[0],out[1]) ;//digit map
+ FillDigitsData(3, out[0],out[1]) ;//digit map
}
}
AliError("TOF branch in Digit Tree not found") ;
return;
}
- branch->SetAddress(&fDigitsArray) ;
- branch->GetEntry(0) ;
- MakeDigits() ;
+ branch->SetAddress(&fDigitsArray);
+ branch->GetEntry(0);
+ MakeDigits();
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
Int_t nentries=fSDigitsArray->GetEntriesFast();
if(nentries<=0){
- GetSDigitsData(0)->Fill(-1.) ;
+ FillSDigitsData(0,-1.) ;
}else{
- GetSDigitsData(0)->Fill(nentries) ;
+ FillSDigitsData(0,nentries) ;
}
TIter next(fSDigitsArray) ;
while ( (sdigit = dynamic_cast<AliTOFSDigit *>(next())) ) {
for(Int_t i=0;i<sdigit->GetNDigits();i++){
- GetSDigitsData(1)->Fill( sdigit->GetTdc(i)*tdc2ns) ;//in ns
+ FillSDigitsData(1, sdigit->GetTdc(i)*tdc2ns) ;//in ns
}
in[0] = sdigit->GetSector();
in[3] = sdigit->GetPadx();
in[4]= sdigit->GetPadz();
GetMapIndeces(in,out);
- GetSDigitsData(2)->Fill( out[0],out[1]) ;//sdigit map
+ FillSDigitsData(2, out[0],out[1]) ;//sdigit map
}
}
AliError("TOF branch in SDigit Tree not found") ;
return;
}
- branch->SetAddress(&fSDigitsArray) ;
- branch->GetEntry(0) ;
- MakeSDigits() ;
+ branch->SetAddress(&fSDigitsArray);
+ branch->GetEntry(0);
+ MakeSDigits();
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
{
//Detector specific actions at end of cycle
// do the QA checking
-
+ ResetEventTrigClasses();
AliQAChecker::Instance()->Run(AliQAv1::kTOF, task, list) ;
}
//____________________________________________________________________________
void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
-
+ ResetEventTrigClasses();
+ //
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) )
- continue ;
- if(fTPCdataQA[specie] != NULL) { // do the final step of the QA for Raw data
-
- fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
- // RAW data files with no TPC data
-
- SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
- TH1F * histRawsOccupancy = (TH1F*)GetRawsData(kRawsOccupancy) ;
- TH1F * histRawsOccupancyVsSector = (TH1F*)GetRawsData(kRawsOccupancyVsSector) ;
- TH1F * histRawsNClustersPerEventVsSector = (TH1F*)GetRawsData(kRawsNClustersPerEventVsSector) ;
- TH1F * histRawsQVsSector = (TH1F*)GetRawsData(kRawsQVsSector) ;
- TH1F * histRawsQmaxVsSector = (TH1F*)GetRawsData(kRawsQmaxVsSector) ;
- TH1F * histRawsOccupancyVsEvent = (TH1F*)GetRawsData(kRawsOccupancyVsEvent) ;
- TH1F * histRawsNclustersVsEvent = (TH1F*)GetRawsData(kRawsNclustersVsEvent) ;
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) continue ;
+ if (fTPCdataQA[specie] == NULL) continue; // do the final step of the QA for Raw data
+
+ fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
+ // RAW data files with no TPC data
+
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over all trigger class clones
+
+ TH1F * histRawsOccupancy = (TH1F*)GetRawsData(kRawsOccupancy, itc);
+ TH1F * histRawsOccupancyVsSector = (TH1F*)GetRawsData(kRawsOccupancyVsSector, itc);
+ TH1F * histRawsNClustersPerEventVsSector = (TH1F*)GetRawsData(kRawsNClustersPerEventVsSector, itc);
+ TH1F * histRawsQVsSector = (TH1F*)GetRawsData(kRawsQVsSector, itc);
+ TH1F * histRawsQmaxVsSector = (TH1F*)GetRawsData(kRawsQmaxVsSector, itc) ;
+ TH1F * histRawsOccupancyVsEvent = (TH1F*)GetRawsData(kRawsOccupancyVsEvent, itc);
+ TH1F * histRawsNclustersVsEvent = (TH1F*)GetRawsData(kRawsNclustersVsEvent, itc);
if ( !histRawsOccupancy ||
!histRawsOccupancyVsSector ||
!histRawsNClustersPerEventVsSector ||
!histRawsQmaxVsSector ||
!histRawsOccupancyVsEvent ||
!histRawsNclustersVsEvent ) {
- AliError("Something very wrong here, corrupted memory ?????. Please check\n") ;
- continue ;
+ AliError("Something very wrong here, corrupted memory ?????. Please check\n") ;
+ continue ;
}
-
+
//Add2RawsList(fTPCdataQA, 0);
// get the histograms and add them to the output
// 31/8-08 Histogram is only added if the Calibration class
// receives TPC data
- const Int_t eventCounter = fTPCdataQA[specie]->GetEventCounter();
+ const Int_t eventCounter = fTPCdataQA[specie]->GetEventCounter(); // RS : to change
if(eventCounter>0) { // some TPC data has been processed
-
- // Reset histograms and refill them
- histRawsOccupancy->Reset();
- histRawsOccupancyVsSector->Reset();
- histRawsNClustersPerEventVsSector->Reset();
- histRawsQVsSector->Reset();
- histRawsQmaxVsSector->Reset();
-
- TH1F* hNormOcc = new TH1F("hNormOcc", 0, 72, 0, 72);
- hNormOcc->Sumw2();
- TH1F* hNormNclusters = new TH1F("hNormNclusters", 0, 72, 0, 72);
- hNormNclusters->Sumw2();
-
- for (Int_t iSec = 0; iSec < 72; iSec++) {
- AliTPCCalROC* occupancyROC =
- fTPCdataQA[specie]->GetNoThreshold()->GetCalROC(iSec);
- AliTPCCalROC* nclusterROC =
- fTPCdataQA[specie]->GetNLocalMaxima()->GetCalROC(iSec);
- AliTPCCalROC* qROC =
- fTPCdataQA[specie]->GetMeanCharge()->GetCalROC(iSec);
- AliTPCCalROC* qmaxROC =
- fTPCdataQA[specie]->GetMaxCharge()->GetCalROC(iSec);
-
- const Int_t nRows = occupancyROC->GetNrows();
- for (Int_t iRow = 0; iRow < nRows; iRow++) {
-
- const Int_t nPads = occupancyROC->GetNPads(iRow);
- for (Int_t iPad = 0; iPad < nPads; iPad++) {
+ // Reset histograms and refill them
+ histRawsOccupancy->Reset();
+ histRawsOccupancyVsSector->Reset();
+ histRawsNClustersPerEventVsSector->Reset();
+ histRawsQVsSector->Reset();
+ histRawsQmaxVsSector->Reset();
+
+ TH1F* hNormOcc = new TH1F("hNormOcc", 0, 72, 0, 72);
+ hNormOcc->Sumw2();
+ TH1F* hNormNclusters = new TH1F("hNormNclusters", 0, 72, 0, 72);
+ hNormNclusters->Sumw2();
+
+ for (Int_t iSec = 0; iSec < 72; iSec++) {
+
+ AliTPCCalROC* occupancyROC =
+ fTPCdataQA[specie]->GetNoThreshold()->GetCalROC(iSec);
+ AliTPCCalROC* nclusterROC =
+ fTPCdataQA[specie]->GetNLocalMaxima()->GetCalROC(iSec);
+ AliTPCCalROC* qROC =
+ fTPCdataQA[specie]->GetMeanCharge()->GetCalROC(iSec);
+ AliTPCCalROC* qmaxROC =
+ fTPCdataQA[specie]->GetMaxCharge()->GetCalROC(iSec);
+
+ const Int_t nRows = occupancyROC->GetNrows();
+ for (Int_t iRow = 0; iRow < nRows; iRow++) {
+
+ const Int_t nPads = occupancyROC->GetNPads(iRow);
+ for (Int_t iPad = 0; iPad < nPads; iPad++) {
- histRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad));
- hNormOcc->Fill(iSec);
- histRawsOccupancyVsSector
- ->Fill(iSec, occupancyROC->GetValue(iRow, iPad));
+ histRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad));
+ hNormOcc->Fill(iSec);
+ histRawsOccupancyVsSector->Fill(iSec, occupancyROC->GetValue(iRow, iPad));
- const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad));
+ const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad));
- if(nClusters>0) {
+ if(nClusters>0) {
hNormNclusters->Fill(iSec,nClusters);
- histRawsNClustersPerEventVsSector->Fill(iSec, nClusters);
- histRawsQVsSector->Fill(iSec,
+ histRawsNClustersPerEventVsSector->Fill(iSec, nClusters);
+ histRawsQVsSector->Fill(iSec,
nClusters*qROC->GetValue(iRow, iPad));
- histRawsQmaxVsSector->Fill(iSec,
+ histRawsQmaxVsSector->Fill(iSec,
nClusters*qmaxROC->GetValue(iRow, iPad));
- }
- }
- }
- } // end loop over sectors
-
- // update event histograms - copy info from TPDdataQA histos
+ }
+ }
+ }
+ } // end loop over sectors
+
+ // update event histograms - copy info from TPDdataQA histos
const TH1F* hQAOccVsEvent = fTPCdataQA[specie]->GetHistOccupancyVsEvent();
const TH1F* hQANclVsEvent = fTPCdataQA[specie]->GetHistNclustersVsEvent();
// In case the histogram limits have changed we have to update
// them here
- if(histRawsOccupancy->GetXaxis()->GetXmax()!=
- hQAOccVsEvent->GetXaxis()->GetXmax()) {
+ if(histRawsOccupancy->GetXaxis()->GetXmax()!=
+ hQAOccVsEvent->GetXaxis()->GetXmax()) {
histRawsOccupancyVsEvent->GetXaxis()->Set(histRawsOccupancyVsEvent->GetXaxis()->GetNbins(), hQAOccVsEvent->GetXaxis()->GetXmin(), hQAOccVsEvent->GetXaxis()->GetXmax());
histRawsNclustersVsEvent->GetXaxis()->Set(histRawsOccupancyVsEvent->GetXaxis()->GetNbins(), hQANclVsEvent->GetXaxis()->GetXmin(), hQANclVsEvent->GetXaxis()->GetXmax());
- }
+ }
// reset the number of entries
histRawsOccupancyVsEvent->SetEntries(0);
histRawsNclustersVsEvent->SetEntries(0);
-
+
// the two event histograms should have the same number of bins
const Int_t nBins = hQAOccVsEvent->GetXaxis()->GetNbins();
for(Int_t bin = 1; bin <= nBins; bin++) {
histRawsNclustersVsEvent->SetBinContent(bin, hQANclVsEvent->GetBinContent(bin));
}
- // Normalize histograms
- histRawsOccupancyVsSector->Divide(hNormOcc);
- histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter));
- histRawsQVsSector->Divide(hNormNclusters);
- histRawsQmaxVsSector->Divide(hNormNclusters);
- delete hNormOcc;
- delete hNormNclusters;
+ // Normalize histograms
+ histRawsOccupancyVsSector->Divide(hNormOcc);
+ histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter));
+ histRawsQVsSector->Divide(hNormNclusters);
+ histRawsQmaxVsSector->Divide(hNormNclusters);
+ delete hNormOcc;
+ delete hNormNclusters;
- }
- }
- }
+ } //
+ } // RS: loop over all trigger class clones
+ } // loop over species
+ //
AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
}
50, 0, 5);
histESDpt->Sumw2();
Add2ESDsList(histESDpt, kPt, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
TH1F * histRawsNclustersVsEvent =
CreateEventsHistCopy(hNclHelp, "hRawsNclustersVsEvent");
Add2RawsList(histRawsNclustersVsEvent, kRawsNclustersVsEvent, expert, !image, !saveCorr);
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
1000, 0, 1000);
histDigitsADC->Sumw2();
Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
159, 0, 159);
histRecPointsRow->Sumw2();
Add2RecPointsList(histRecPointsRow, kRow, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
Int_t nTPCclusters = track->GetTPCNcls();
Int_t nTPCclustersFindable = track->GetTPCNclsF();
if ( nTPCclustersFindable<=0) continue;
- GetESDsData(KClusters)->Fill(nTPCclusters);
- GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
- GetESDsData(kPt)->Fill(track->Pt());
+ FillESDsData(KClusters,nTPCclusters);
+ FillESDsData(kRatio,Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
+ FillESDsData(kPt,track->Pt());
}
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
rawReader->Reset() ;
if (! fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)] ) {
AliError("Something unexpected here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") ;
- } else {
- fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
+ return;
}
+
+ fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
do {
Float_t dig = digArray->CurrentDigit();
- GetDigitsData(kDigitsADC)->Fill(dig);
+ FillDigitsData(kDigitsADC,dig);
} while (digArray->Next());
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
if(cluster->GetDetector()<36) { // IROC (short pads)
- GetRecPointsData(kQmaxShort)->Fill(Qmax);
- GetRecPointsData(kQShort)->Fill(Q);
+ FillRecPointsData(kQmaxShort,Qmax);
+ FillRecPointsData(kQShort,Q);
} else { // OROC (medium and long pads)
row += 63;
if(cluster->GetRow()<64) { // medium pads
- GetRecPointsData(kQmaxMedium)->Fill(Qmax);
- GetRecPointsData(kQMedium)->Fill(Q);
+ FillRecPointsData(kQmaxMedium,Qmax);
+ FillRecPointsData(kQMedium,Q);
} else { // long pads
- GetRecPointsData(kQmaxLong)->Fill(Qmax);
- GetRecPointsData(kQLong)->Fill(Q);
+ FillRecPointsData(kQmaxLong,Qmax);
+ FillRecPointsData(kQLong,Q);
}
}
- GetRecPointsData(kRow)->Fill(row);
+ FillRecPointsData(kRow,row);
} // end loop over clusters
} // end loop over tree
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
list. This have been implemented but not tested.
*/
-#include <TTree.h>
#include "AliTPCQADataMakerSim.h"
// --- ROOT system ---
#include "AliTPC.h"
#include "AliTPCv2.h"
#include "AliSimDigits.h"
+#include <TTree.h>
ClassImp(AliTPCQADataMakerSim)
1000, 0, 1000);
histDigitsADC->Sumw2();
Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
300, 0., 300.);
histHitsElectronsPerCm->Sumw2();
Add2HitsList(histHitsElectronsPerCm, kElectronsPerCm, !expert, image);
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
do {
Float_t dig = digArray->CurrentDigit();
- GetDigitsData(kDigitsADC)->Fill(dig);
+ FillDigitsData(kDigitsADC,dig);
} while (digArray->Next());
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
Int_t trackNo = tpcHit->GetTrack();
- GetHitsData(kElectrons)->Fill(tpcHit->fQ);
- GetHitsData(kRadius)->Fill(radius);
+ FillHitsData(kElectrons,tpcHit->fQ);
+ FillHitsData(kRadius,radius);
if(trackNo==trackOld) { // if the same track
// if(nprim==1)
// cout << radius << ", " << radiusOld << ", " << dist << endl;
- GetHitsData(kPrimPerCm)->Fill((Float_t)nprim);
- GetHitsData(kElectronsPerCm)->Fill(q);
+ FillHitsData(kPrimPerCm,(Float_t)nprim);
+ FillHitsData(kElectronsPerCm,q);
dist = 0;
q = 0;
}
}
- GetHitsData(kNhits)->Fill(nHits);
+ FillHitsData(kNhits,nHits);
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
// --- ROOT system ---
#include <TClonesArray.h>
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TH3D.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TH3F.h>
#include <TProfile.h>
#include <TF1.h>
//
//TStopwatch watch;
//watch.Start();
-
+ ResetEventTrigClasses();
+ //
//AliDebug(AliQAv1::GetQADebugLevel(), Form("EndOfCycle", "Fitting RecPoints %d", task))
- TH1D *hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
-
- if (task == AliQAv1::kRECPOINTS) {
-
- //list->Print();
-
- // Rec points full chambers
- for (Int_t i=0; i<540; i++) {
-
- //TH1D *h = ((TH2D*)list->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 xvalue = hist->GetBinCenter(b);
- Int_t bin = ((TH2D*)list->At(1))->FindBin(i,xvalue);
- Double_t value = ((TH2D*)list->At(1))->GetBinContent(bin);
- hist->SetBinContent(b, value);
- }
-
- //printf("Sum = %d %f\n", i, hist->GetSum());
- if (hist->GetSum() < 100) continue; // chamber not present
-
- hist->Fit("landau", "q0", "goff", 10, 180);
- TF1 *fit = hist->GetFunction("landau");
- ((TH1D*)list->At(12))->Fill(fit->GetParameter(1));
- ((TH1D*)list->At(13))->Fill(fit->GetParameter(2));
- }
-
- // time-bin by time-bin
- for (Int_t i=0; i<540; i++) {
-
- //TH1D *test = ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, 0, 35);
- //if (test->GetSum() < 100) continue;
-
- //AliDebug(AliQAv1::GetQADebugLevel(), Form("fitting det = %d", i));
-
- for(Int_t j=0; j<35; j++) {
-
- //TH1D *h = ((TH3D*)list->At(10))->ProjectionZ(Form("ampTime_%d",i), i+1, i+1, j+1, j+1);
- hist->Reset();
- for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
- Double_t xvalue = hist->GetBinCenter(b);
- Int_t bin = ((TH3D*)list->At(10))->FindBin(i,j,xvalue);
- Double_t value = ((TH3D*)list->At(10))->GetBinContent(bin);
- //printf("v = %f\n", value);
- hist->SetBinContent(b, value);
+ TH1F *hist = new TH1F("fitHist", "", 200, -0.5, 199.5);
+ //
+ // RS Add a loop over species
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+ if ( !AliQAv1::Instance()->IsEventSpecieSet(specie) ) continue ;
+ SetEventSpecie(specie);
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ if (task == AliQAv1::kRECPOINTS) {
+
+ //list->Print();
+ TObjArray& arrRP = *GetRecPointsDataOfTrigClass(itc); // RS Histos matching to trigger class
+ // Rec points full chambers
+ TH2* h2tmp = (TH2*) arrRP[1];
+ if (h2tmp) {
+ for (Int_t i=0; i<540; i++) {
+ hist->Reset();
+ for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
+ Double_t xvalue = hist->GetBinCenter(b);
+ Int_t bin = h2tmp->FindBin(i,xvalue);
+ Double_t value = h2tmp->GetBinContent(bin);
+ hist->SetBinContent(b, value);
+ }
+ //printf("Sum = %d %f\n", i, hist->GetSum());
+ if (hist->GetSum() < 100) continue; // chamber not present
+ //
+ hist->Fit("landau", "q0", "goff", 10, 180);
+ TF1 *fit = hist->GetFunction("landau");
+ if (arrRP[12]) ((TH1*)arrRP[12])->Fill(fit->GetParameter(1));
+ if (arrRP[13]) ((TH1*)arrRP[13])->Fill(fit->GetParameter(2));
+ }
}
-
- if (hist->GetSum() < 100) continue;
- //printf("fitting %d %d %f\n", i, j, hist->GetSum());
-
- hist->Fit("landau", "q0", "goff", 10, 180);
- TF1 *fit = hist->GetFunction("landau");
-
- Int_t sm = i/18;
- Int_t det = i%18;
- TH2D *h2 = (TH2D*)list->At(14+sm);
- Int_t bin = h2->FindBin(det,j);
- // printf("%d %d %d\n", det, j, bin);
- h2->SetBinContent(bin, fit->GetParameter(1));
- }
- }
- }
+ //
+ // time-bin by time-bin
+ TH3* h3tmp = (TH3*) arrRP[10];
+ if (h3tmp) {
+ for (Int_t i=0; i<540; i++) {
+ for(Int_t j=0; j<35; j++) {
+ hist->Reset();
+ for(Int_t b=1; b<hist->GetXaxis()->GetNbins()-1; b++) {
+ Double_t xvalue = hist->GetBinCenter(b);
+ Int_t bin = h3tmp->FindBin(i,j,xvalue);
+ Double_t value = h2tmp->GetBinContent(bin);
+ //printf("v = %f\n", value);
+ hist->SetBinContent(b, value);
+ }
+ if (hist->GetSum() < 100) continue;
+ //printf("fitting %d %d %f\n", i, j, hist->GetSum());
+ hist->Fit("landau", "q0", "goff", 10, 180);
+ TF1 *fit = hist->GetFunction("landau");
+ //
+ Int_t sm = i/18;
+ Int_t det = i%18;
+ TH2* h2 = (TH2*)arrRP[14+sm];
+ if (!h2) continie;
+ Int_t bin = h2->FindBin(det,j);
+ // printf("%d %d %d\n", det, j, bin);
+ h2->SetBinContent(bin, fit->GetParameter(1));
+ }
+ }
+ } // h3tmp
+ } // RESPOINTS
+ } // RS: loop over eventual clones per trigger class
+ } // loop over species
+
delete hist;
TH1 *hist[kNhist];
Int_t histoCounter = -1 ;
- hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", ":Number of tracks", 300, -0.5, 299.5);
- hist[++histoCounter] = new TH1D("qaTRD_esd_sector", ":Sector", 18, -0.5, 17.7);
- hist[++histoCounter] = new TH1D("qaTRD_esd_bits", ";Bits", 64, -0.5, 63.5);
+ hist[++histoCounter] = new TH1F("qaTRD_esd_ntracks", ":Number of tracks", 300, -0.5, 299.5);
+ hist[++histoCounter] = new TH1F("qaTRD_esd_sector", ":Sector", 18, -0.5, 17.7);
+ hist[++histoCounter] = new TH1F("qaTRD_esd_bits", ";Bits", 64, -0.5, 63.5);
const Int_t knbits = 6;
const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
for(Int_t i=0; i<knbits; i++) {
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), ";p_{T} (GeV/c);", 50, 0, 10);
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400);
+ hist[++histoCounter] = new TH1F(Form("qaTRD_esd_pt%s",suf[i]), ";p_{T} (GeV/c);", 50, 0, 10);
+ hist[++histoCounter] = new TH1F(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400);
}
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters", 130, -0.5, 129.5);;
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters", 130, -0.5, 129.5);;
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters", 130, -0.5, 129.5);;
- //hist[++histoCounter] = new TH1D("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
+ hist[++histoCounter] = new TH1F("qaTRD_esd_clsTRDo", "TRDo;number of clusters", 130, -0.5, 129.5);;
+ hist[++histoCounter] = new TH1F("qaTRD_esd_clsTRDr", "TRDr;number of clusters", 130, -0.5, 129.5);;
+ hist[++histoCounter] = new TH1F("qaTRD_esd_clsTRDz", "TRDz;number of clusters", 130, -0.5, 129.5);;
+ //hist[++histoCounter] = new TH1F("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
- hist[++histoCounter] = new TH2D("qaTRD_esd_sigMom", ";momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
+ hist[++histoCounter] = new TH2F("qaTRD_esd_sigMom", ";momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
for(Int_t i=0; i<=histoCounter; i++) {
//hist[i]->Sumw2();
Add2ESDsList(hist[i], i);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
//
const Int_t kNhist = 4;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
- hist[0] = new TH1D("qaTRD_hits_det", ";Detector Id of the hit", 540, -0.5, 539.5) ;
+ hist[0] = new TH1F("qaTRD_hits_det", ";Detector Id of the hit", 540, -0.5, 539.5) ;
- hist[1] = new TH1D("qaTRD_hist_Qdrift", ";Charge from tracks", 100, 0, 100);
- hist[2] = new TH1D("qaTRD_hist_Qamp", ";Charge from TRD photon", 100, 0, 100);
- hist[3] = new TH1D("qaTRD_hist_Qphoton", ";Charge from TRD photon", 100, 0, 100);
+ hist[1] = new TH1F("qaTRD_hist_Qdrift", ";Charge from tracks", 100, 0, 100);
+ hist[2] = new TH1F("qaTRD_hist_Qamp", ";Charge from TRD photon", 100, 0, 100);
+ hist[3] = new TH1F("qaTRD_hist_Qphoton", ";Charge from TRD photon", 100, 0, 100);
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
Add2HitsList(hist[i], i);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
//
const Int_t kNhist = 3;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
- hist[0] = new TH1D("qaTRD_digits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_digits_time", ";Time bin", 40, -0.5, 39.5);
- hist[2] = new TH1D("qaTRD_digits_amp", ";Amplitude", 100, 0, 100.);
+ hist[0] = new TH1F("qaTRD_digits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
+ hist[1] = new TH1F("qaTRD_digits_time", ";Time bin", 40, -0.5, 39.5);
+ hist[2] = new TH1F("qaTRD_digits_amp", ";Amplitude", 100, 0, 100.);
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
Add2DigitsList(hist[i], i);
}
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
const Int_t kNhist = 14 + 18;
TH1 *hist[kNhist];
- hist[0] = new TH1D("qaTRD_recPoints_det", ";Detector ID of the cluster", 540, -0.5, 539.5);
- hist[1] = new TH2D("qaTRD_recPoints_amp", ";Amplitude", 540, -0.5, 539, 200, -0.5, 199.5);
- hist[2] = new TH1D("qaTRD_recPoints_npad", ";Number of Pads", 12, -0.5, 11.5);
+ hist[0] = new TH1F("qaTRD_recPoints_det", ";Detector ID of the cluster", 540, -0.5, 539.5);
+ hist[1] = new TH2F("qaTRD_recPoints_amp", ";Amplitude", 540, -0.5, 539, 200, -0.5, 199.5);
+ hist[2] = new TH1F("qaTRD_recPoints_npad", ";Number of Pads", 12, -0.5, 11.5);
- hist[3] = new TH1D("qaTRD_recPoints_dist2", ";residuals [2pad]", 100, -1, 1);
- hist[4] = new TH1D("qaTRD_recPoints_dist3", ";residuals [3pad]", 100, -1, 1);
- hist[5] = new TH1D("qaTRD_recPoints_dist4", ";residuals [4pad]", 100, -1, 1);
- hist[6] = new TH1D("qaTRD_recPoints_dist5", ";residuals [5pad]", 100, -1, 1);
+ hist[3] = new TH1F("qaTRD_recPoints_dist2", ";residuals [2pad]", 100, -1, 1);
+ hist[4] = new TH1F("qaTRD_recPoints_dist3", ";residuals [3pad]", 100, -1, 1);
+ hist[5] = new TH1F("qaTRD_recPoints_dist4", ";residuals [4pad]", 100, -1, 1);
+ hist[6] = new TH1F("qaTRD_recPoints_dist5", ";residuals [5pad]", 100, -1, 1);
- hist[7] = new TH2D("qaTRD_recPoints_rowCol", ";row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
- hist[8] = new TH1D("qaTRD_recPoints_time", ";time bin", 35, -0.5, 34.5);
- hist[9] = new TH1D("qaTRD_recPoints_nCls", ";number of clusters", 500, -0.5, 499.5);
+ hist[7] = new TH2F("qaTRD_recPoints_rowCol", ";row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
+ hist[8] = new TH1F("qaTRD_recPoints_time", ";time bin", 35, -0.5, 34.5);
+ hist[9] = new TH1F("qaTRD_recPoints_nCls", ";number of clusters", 500, -0.5, 499.5);
- hist[10] = new TH3D("qaTRD_recPoints_sigTime", ";chamber;time bin;signal",
+ hist[10] = new TH3F("qaTRD_recPoints_sigTime", ";chamber;time bin;signal",
540, -0.5, 539.5, 35, -0.5, 34.5, 200, 0.5, 199.5);
hist[11] = new TProfile("qaTRD_recPoints_prf", ";distance;center of gravity"
, 120, -0.6, 0.6, -1.2, 1.2, "");
- hist[12] = new TH1D("qaTRD_recPoints_ampMPV", ";amplitude MPV", 100, 0, 100);
- hist[13] = new TH1D("qaTRD_recPoints_ampSigma", ";amplitude Sigma", 100, 0, 100);
+ hist[12] = new TH1F("qaTRD_recPoints_ampMPV", ";amplitude MPV", 100, 0, 100);
+ hist[13] = new TH1F("qaTRD_recPoints_ampSigma", ";amplitude Sigma", 100, 0, 100);
for(Int_t i=0; i<18; i++) {
- hist[14+i] = new TH2D(Form("qaTRD_recPoints_sigTime_sm%d",i), Form("sm%d;det;time bin"),
+ hist[14+i] = new TH2F(Form("qaTRD_recPoints_sigTime_sm%d",i), Form("sm%d;det;time bin"),
30, -0.5, 29.5, 35, -0.5, 34.5);
hist[14+i]->SetMinimum(20);
hist[14+i]->SetMaximum(40);
//hist[i]->Sumw2();
Add2RecPointsList(hist[i], i);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
const Int_t kSM = 18;
//const Int_t kNCh = 540;
const Int_t kNhist = 4+kSM;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
// four histograms to be published
- hist[0] = new TH1D("qaTRD_raws_det", ";detector", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_raws_sig", ";signal", 100, -0.5, 99.5);
- hist[2] = new TH1D("qaTRD_raws_timeBin", ";time bin", 40, -0.5, 39.5);
- hist[3] = new TH1D("qaTRD_raws_smId", ";supermodule", 18, -0.5, 17.5);
+ hist[0] = new TH1F("qaTRD_raws_det", ";detector", 540, -0.5, 539.5);
+ hist[1] = new TH1F("qaTRD_raws_sig", ";signal", 100, -0.5, 99.5);
+ hist[2] = new TH1F("qaTRD_raws_timeBin", ";time bin", 40, -0.5, 39.5);
+ hist[3] = new TH1F("qaTRD_raws_smId", ";supermodule", 18, -0.5, 17.5);
//
// one double per MCM (not published)
const Int_t kNMCM = 30 * 8 * 16;
for(Int_t i=0; i<kSM; i++)
- hist[4+i] = new TH1D(Form("qaTRD_raws_sm%d",i),"",kNMCM, -0.5, kNMCM-0.5);
+ hist[4+i] = new TH1F(Form("qaTRD_raws_sm%d",i),"",kNMCM, -0.5, kNMCM-0.5);
// register
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
Add2RawsList(hist[i], i);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
//
const Int_t kNhist = 3;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
- hist[0] = new TH1D("qaTRD_sdigits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_sdigits_time", ";Time bin", 40, -0.5, 39.5);
- hist[2] = new TH1D("qaTRD_sdigits_amp", ";Amplitude", 100, 0, 1e7);
+ hist[0] = new TH1F("qaTRD_sdigits_det", ";Detector Id of the digit", 540, -0.5, 539.5);
+ hist[1] = new TH1F("qaTRD_sdigits_time", ";Time bin", 40, -0.5, 39.5);
+ hist[2] = new TH1F("qaTRD_sdigits_amp", ";Amplitude", 100, 0, 1e7);
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
Add2SDigitsList(hist[i], i);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
//
Int_t nTracks = esd->GetNumberOfTracks();
- GetESDsData(0)->Fill(nTracks);
+ FillESDsData(0,nTracks);
// track loop
for (Int_t i=0; i<nTracks; i++) {
UInt_t u = 1;
UInt_t status = track->GetStatus();
for(Int_t bit=0; bit<32; bit++)
- if (u<<bit & status) GetESDsData(2)->Fill(bit);
+ if (u<<bit & status) FillESDsData(2,bit);
const Int_t knbits = 6;
Int_t bit[6] = {0,0,0,0,0,0};
for(Int_t b=0; b<knbits; b++) {
if (bit[b]) {
- GetESDsData(2*b+3)->Fill(pt);
- GetESDsData(2*b+4)->Fill(extZ);
+ FillESDsData(2*b+3,pt);
+ FillESDsData(2*b+4,extZ);
}
}
// clusters
for(Int_t b=0; b<3; b++)
- if (bit[3+b]) GetESDsData(b+15)->Fill(track->GetTRDncls());
+ if (bit[3+b]) FillESDsData(b+15,track->GetTRDncls());
// refitted only
if (!bit[4]) continue;
//fBudget->Fill(track->GetTRDBudget());
//fSignal->Fill(track->GetTRDsignal());
- GetESDsData(18)->Fill(track->GetP(), track->GetTRDsignal());
- GetESDsData(1)->Fill(sector);
+ FillESDsData(18,track->GetP(), track->GetTRDsignal());
+ FillESDsData(1,sector);
/*
// PID only
*/
}
-
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//______________________________________________________________________________
AliTRDhit * hit;
while ( (hit = dynamic_cast<AliTRDhit *>(next())) ) {
- GetHitsData(0)->Fill(hit->GetDetector());
+ FillHitsData(0,hit->GetDetector());
Double_t q = TMath::Abs(hit->GetCharge());
- if (hit->FromDrift()) GetHitsData(1)->Fill(q);
- if (hit->FromAmplification()) GetHitsData(2)->Fill(q);
- if (hit->FromTRphoton()) GetHitsData(3)->Fill(q);
+ if (hit->FromDrift()) FillHitsData(1,q);
+ if (hit->FromAmplification()) FillHitsData(2,q);
+ if (hit->FromTRphoton()) FillHitsData(3,q);
}
}
tmp->Delete();
delete tmp;
MakeHits(hits);
-
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
TIter next(digits) ;
AliTRDdigit * digit ;
while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
- GetDigitsData(0)->Fill(digit->GetDetector());
- GetDigitsData(1)->Fill(digit->GetTime());
- GetDigitsData(2)->Fill(digit->GetAmp());
+ FillDigitsData(0,digit->GetDetector());
+ FillDigitsData(1,digit->GetTime());
+ FillDigitsData(2,digit->GetAmp());
}
}
for(Int_t time = 0; time < nTbins; time++)
{
Float_t signal = digitsIn->GetData(row,col,time);
- GetDigitsData(0)->Fill(i);
- GetDigitsData(1)->Fill(time);
- GetDigitsData(2)->Fill(signal);
+ FillDigitsData(0,i);
+ FillDigitsData(1,time);
+ FillDigitsData(2,signal);
}
//delete digitsIn;
}
delete digitsManager;
-
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
TIter next(sdigits) ;
AliTRDdigit * digit ;
while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
- GetDigitsData(0)->Fill(digit->GetDetector());
- GetDigitsData(1)->Fill(digit->GetTime());
- GetDigitsData(2)->Fill(digit->GetAmp());
+ FillDigitsData(0,digit->GetDetector());
+ FillDigitsData(1,digit->GetTime());
+ FillDigitsData(2,digit->GetAmp());
}
}
{
Float_t signal = digitsIn->GetData(row,col,time);
if (signal <= 0) continue;
- GetSDigitsData(0)->Fill(i);
- GetSDigitsData(1)->Fill(time);
- GetSDigitsData(2)->Fill(signal);
+ FillSDigitsData(0,i);
+ FillSDigitsData(1,time);
+ FillSDigitsData(2,signal);
}
// delete digitsIn;
}
delete digitsManager;
-
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
while (raw.Next()) {
- GetRawsData(0)->Fill(raw.GetDet());
+ FillRawsData(0,raw.GetDet());
// possibly needs changes with the new reader !!
Int_t *sig = raw.GetSignals();
- for(Int_t i=0; i<3; i++) GetRawsData(1)->Fill(sig[i]);
+ for(Int_t i=0; i<3; i++) FillRawsData(1,sig[i]);
// ---
- GetRawsData(2)->Fill(raw.GetTimeBin());
+ FillRawsData(2,raw.GetTimeBin());
// calculate the index;
Int_t sm = raw.GetSM();
//Int_t index = roc * (kROB*kMCM*kADC) + rob * (kMCM*kADC) + mcm * kADC + adc;
Int_t index = roc * (kROB*kMCM) + rob * kMCM + mcm;
- GetRawsData(3)->Fill(sm);
- GetRawsData(4+sm)->Fill(index);
+ FillRawsData(3,sm);
+ FillRawsData(4+sm,index);
}
-
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
Int_t iDet = c->GetDetector();
nDet[iDet]++;
- GetRecPointsData(0)->Fill(iDet);
- GetRecPointsData(1)->Fill(iDet, c->GetQ());
- GetRecPointsData(2)->Fill(c->GetNPads());
+ FillRecPointsData(0,iDet);
+ FillRecPointsData(1,iDet, c->GetQ());
+ FillRecPointsData(2,c->GetNPads());
if (c->GetNPads() < 6)
- GetRecPointsData(1+c->GetNPads())->Fill(c->GetCenter());
+ FillRecPointsData(1+c->GetNPads(),c->GetCenter());
//if (c->GetPadTime() < 5)
- ((TH2D*)GetRecPointsData(7))->Fill(c->GetPadRow(), c->GetPadCol());
- GetRecPointsData(8)->Fill(c->GetPadTime());
+ FillRecPointsData(7,c->GetPadRow(), c->GetPadCol());
+ FillRecPointsData(8,c->GetPadTime());
- ((TH3D*)GetRecPointsData(10))->Fill(iDet, c->GetPadTime(), c->GetQ());
+ TObjArray *hists = GetMatchingRecPointsData(10); //RS no alias for 3d histo filling, to directly
+ for (int ih=hists->GetEntriesFast();ih--;) ((TH3F*)hists->UncheckedAt(ih))->Fill(iDet, c->GetPadTime(), c->GetQ());
// PRF for 2pad
//if (c->GetNPads() == 2) {
if (sig[0] == 0 && sig[1] == 0 && sig[4] == 0 && sig[5] == 0 && sig[6] == 0)
frac = -1. * sig[2] / (sig[2] + sig[3]);
- if (frac > -10) ((TProfile*)GetRecPointsData(11))->Fill(c->GetCenter(), frac);
+ if (frac > -10) FillRecPointsData(11,c->GetCenter(), frac);
//}
}
}
for(Int_t i=0; i<540; i++)
- if (nDet[i] > 0) GetRecPointsData(9)->Fill(nDet[i]);
+ if (nDet[i] > 0) FillRecPointsData(9,nDet[i]);
delete clusterArray;
// --- ROOT system ---
#include <TClonesArray.h>
#include <TFile.h>
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TH3D.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TH3F.h>
#include <TProfile.h>
#include <TF1.h>
#include <TCanvas.h>
//
//TStopwatch watch;
//watch.Start();
- /**/
+ ResetEventTrigClasses();
AliDebug(AliQAv1::GetQADebugLevel(), "End of TRD cycle");
-
-
- if (task == AliQAv1::kRAWS) {
-
- // loop over event types
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
-
- if (! IsValidEventSpecie(specie, list)) continue;
-
-
- TH2D *mnCls = (TH2D*)list[specie]->At(1);
- TH2D *mClsDet = (TH2D*)list[specie]->At(2);
-
- mClsDet->Divide(mnCls);
- }
- }
-
-
- if (task == AliQAv1::kRECPOINTS) {
-
- TH1D * hist = new TH1D("fitHist", "", 200, -0.5, 199.5);
-
- // loop over event types
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! IsValidEventSpecie(specie, list))
- continue ;
- //list[specie]->Print();
-
- // fill detector map;
- for(Int_t i = 0 ; i < 540 ; i++) {
- Double_t v = ((TH1D*)list[specie]->At(0))->GetBinContent(i+1);
- Int_t sm = i/30;
- Int_t det = i%30;
- TH2D *detMap = (TH2D*)list[specie]->At(87);
- Int_t bin = detMap->FindBin(sm, det);
- detMap->SetBinContent(bin, v);
- }
-
- // Rec points full chambers
- for (Int_t i = 0 ; i < 540 ; 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();
-
- // project TH2D into TH1D
- for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
- Double_t xvalue = hist->GetBinCenter(b);
- Int_t bin = ((TH2D*)list[specie]->At(1))->FindBin(i,xvalue);
- Double_t value = ((TH2D*)list[specie]->At(1))->GetBinContent(bin);
- hist->SetBinContent(b, value);
- }
- //AliDebug(AliQAv1::GetQADebugLevel(), Form("Sum = %d %f\n", i, hist->GetSum()));
- if (hist->GetSum() < 100)
- continue; // not enougth data in a chamber
-
- hist->Fit("landau", "q0", "goff", 10, 180);
- TF1 *fit = hist->GetFunction("landau");
- ((TH1D*)list[specie]->At(12))->Fill(fit->GetParameter(1));
- ((TH1D*)list[specie]->At(13))->Fill(fit->GetParameter(2));
+ //
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) { // loop over event types
+ //
+ if (!IsValidEventSpecie(specie, list)) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ if (task == AliQAv1::kRAWS) {
+ TH2 *mnCls = (TH2*)GetRawsData(1, itc);
+ TH2 *mClsDet = (TH2*)GetRawsData(2, itc);
+ if (mnCls && mClsDet) mClsDet->Divide(mnCls);
}
-
-
- // time-bin by time-bin sm by sm
- for(Int_t i=0; i<18; i++) { // loop over super-modules
- for(Int_t j=0; j<kTimeBin; j++) { // loop over time bins
-
- hist->Reset();
- for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
- Double_t xvalue = hist->GetBinCenter(b);
- Double_t svalue = 0.0;
- for(Int_t det = i*30 ; det < (i+1)*30 ; det++) { // loop over detectors
- Int_t bin = ((TH3D*)list[specie]->At(10))->FindBin(det,j,xvalue);
- Double_t value = ((TH3D*)list[specie]->At(10))->GetBinContent(bin);
- svalue += value;
- }
- //AliDebug(AliQAv1::GetQADebugLevel(), Form("v = %f\n", value));
- hist->SetBinContent(b, svalue);
- }
-
- if (hist->GetSum() < 100)
- continue;
-
- hist->Fit("landau", "q0", "goff", 10, 180);
- TF1 *fit = hist->GetFunction("landau");
-
- TH1D *h1 = (TH1D*)list[specie]->At(14+18+i);
- h1->SetMarkerStyle(20);
- Int_t bin = h1->FindBin(j);
- // printf("%d %d %d\n", det, j, bin);
-
- Double_t value = TMath::Abs(fit->GetParameter(1));
- Double_t error = TMath::Abs(fit->GetParError(1));
-
- if (value/error < 3) continue; // insuficient statistics
-
- h1->SetBinContent(bin, value);
- h1->SetBinError(bin, error);
+ //
+ if (task == AliQAv1::kRECPOINTS) {
+ //
+ TH1F * hist = new TH1F("fitHist", "", 200, -0.5, 199.5);
+ TObjArray& arrRP = *GetRecPointsDataOfTrigClass(itc); // RS Histos matching to trigger class
+ // fill detector map;
+ TH1* h0 = (TH1*) arrRP[0];
+ TH1* detMap = (TH1*) arrRP[87];
+ if (h0 && detMap) {
+ for(Int_t i = 0 ; i < 540 ; i++) {
+ Double_t v = h0->GetBinContent(i+1);
+ Int_t sm = i/30;
+ Int_t det = i%30;
+ Int_t bin = detMap->FindBin(sm, det);
+ detMap->SetBinContent(bin, v);
+ }
}
- }
-
- // for numerical convergence
- TF1 *form = new TF1("formLandau", "landau", 0, 200);
-
- // time-bin by time-bin chamber by chamber
- for (Int_t i=0; i<540; i++) {
- for(Int_t j=0; j<kTimeBin; j++) {
-
- hist->Reset();
- for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
- 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);
- //AliDebug(AliQAv1::GetQADebugLevel(), Form("v = %f\n", value));
- hist->SetBinContent(b, value);
+ //
+ // Rec points full chambers
+ TH2* h2tmp = (TH2*) arrRP[1];
+ TH1* h12 = (TH1*) arrRP[12];
+ TH1* h13 = (TH1*) arrRP[13];
+ if (h2tmp && h12 && h13) {
+ for (Int_t i = 0 ; i < 540 ; i++) {
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("I = %d", i));
+ hist->Reset();
+ // project TH2F into TH1F
+ for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
+ Double_t xvalue = hist->GetBinCenter(b);
+ Int_t bin = h2tmp->FindBin(i,xvalue);
+ Double_t value = h2tmp->GetBinContent(bin);
+ hist->SetBinContent(b, value);
+ }
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("Sum = %d %f\n", i, hist->GetSum()));
+ if (hist->GetSum() < 100) continue; // not enougth data in a chamber
+ //
+ hist->Fit("landau", "q0", "goff", 10, 180);
+ TF1 *fit = hist->GetFunction("landau");
+ h12->Fill(fit->GetParameter(1));
+ h13->Fill(fit->GetParameter(2));
}
-
- if (hist->GetSum() < 100)
- continue;
-
- form->SetParameters(1000, 60, 20);
- hist->Fit(form, "q0", "goff", 20, 180);
-
- Int_t sm = i/30;
- Int_t det = i%30;
- TH2D *h2 = (TH2D*)list[specie]->At(14+sm);
- Int_t bin = h2->FindBin(det,j);
- // printf("%d %d %d\n", det, j, bin);
-
- Double_t value = TMath::Abs(form->GetParameter(1));
- Double_t error = TMath::Abs(form->GetParError(1));
-
- if (value/error < 3) continue;
-
- h2->SetBinContent(bin, value);
- h2->SetBinError(bin, error);
}
- }
- }
- if (hist)
- delete hist;
- }
- //////////////////////////
- // const Int_t knbits = 6;
- // const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
- //const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
-
- if (task == AliQAv1::kESDS) {
-
- const Int_t knRatio = 4;
- const Int_t kN[knRatio] = {4,3,4,5};
- const Int_t kD[knRatio] = {3,1,1,3};
-
- // create ratios
- for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! IsValidEventSpecie(specie, list))
- continue ;
- 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);
- TH1D *histD = (TH1D*)list[specie]->At(3 + 2*kD[i] + type);
- BuildRatio(ratio, histN, histD);
- //ratio->Reset();
- //ratio->Add(histN);
- //ratio->Divide(histD);
- }
- }
- // ratio for the fraction of electrons per stack
- TH1D *histN = (TH1D*)list[specie]->At(33);
- TH1D *histD = (TH1D*)list[specie]->At(32);
- TH1D *ratio = (TH1D*)list[specie]->At(34);
- BuildRatio(ratio, histN, histD);
- }
- }
+ //
+ // time-bin by time-bin sm by sm
+ TH3* h3tmp = (TH3*) arrRP[10];
+ if (h3tmp) {
+ for(Int_t i=0; i<18; i++) { // loop over super-modules
+ for(Int_t j=0; j<kTimeBin; j++) { // loop over time bins
+ hist->Reset();
+ for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
+ Double_t xvalue = hist->GetBinCenter(b);
+ Double_t svalue = 0.0;
+ for(Int_t det = i*30 ; det < (i+1)*30 ; det++) { // loop over detectors
+ Int_t bin = h3tmp->FindBin(det,j,xvalue);
+ Double_t value = h3tmp->GetBinContent(bin);
+ svalue += value;
+ }
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("v = %f\n", value));
+ hist->SetBinContent(b, svalue);
+ }
+ //
+ if (hist->GetSum() < 100) continue;
+ //
+ hist->Fit("landau", "q0", "goff", 10, 180);
+ TF1 *fit = hist->GetFunction("landau");
+ //
+ TH1 *hi = (TH1*)arrRP[14+18+i];
+ if (!hi) continue;
+ hi->SetMarkerStyle(20);
+ Int_t bin = hi->FindBin(j);
+ // printf("%d %d %d\n", det, j, bin);
+ //
+ Double_t value = TMath::Abs(fit->GetParameter(1));
+ Double_t error = TMath::Abs(fit->GetParError(1));
+ //
+ if (value/error < 3) continue; // insuficient statistics
+ //
+ hi->SetBinContent(bin, value);
+ hi->SetBinError(bin, error);
+ } // j
+ } // i
+ //
+ // for numerical convergence
+ TF1 *form = new TF1("formLandau", "landau", 0, 200);
+ //
+ // time-bin by time-bin chamber by chamber
+ for (Int_t i=0; i<540; i++) {
+ for(Int_t j=0; j<kTimeBin; j++) {
+ //
+ hist->Reset();
+ for(Int_t b = 1 ; b < hist->GetXaxis()->GetNbins()-1 ; b++) {
+ Double_t xvalue = hist->GetBinCenter(b);
+ Int_t bin = h3tmp->FindBin(i,j,xvalue);
+ Double_t value = h3tmp->GetBinContent(bin);
+ //AliDebug(AliQAv1::GetQADebugLevel(), Form("v = %f\n", value));
+ hist->SetBinContent(b, value);
+ }
+ //
+ if (hist->GetSum() < 100) continue;
+
+ form->SetParameters(1000, 60, 20);
+ hist->Fit(form, "q0", "goff", 20, 180);
+
+ Int_t sm = i/30;
+ Int_t det = i%30;
+ TH1 *hi = (TH1*)arrRP[14+sm];
+ if (!hi) continue;
+ Int_t bin = hi->FindBin(det,j);
+ // printf("%d %d %d\n", det, j, bin);
+ //
+ Double_t value = TMath::Abs(form->GetParameter(1));
+ Double_t error = TMath::Abs(form->GetParError(1));
+ //
+ if (value/error < 3) continue;
+ //
+ hi->SetBinContent(bin, value);
+ hi->SetBinError(bin, error);
+ } // j
+ } // i
+ } // h3tmp
+ if (hist) delete hist;
+ } // RECPOINTS
+ //
+ //////////////////////////
+ // const Int_t knbits = 6;
+ // const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
+ //const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
+
+ if (task == AliQAv1::kESDS) {
+ //
+ const Int_t knRatio = 4;
+ const Int_t kN[knRatio] = {4,3,4,5};
+ const Int_t kD[knRatio] = {3,1,1,3};
+ //
+ TObjArray& arrES = *GetESDsDataOfTrigClass(itc); // RS Histos matching to trigger class
+ // create ratios
+ for(Int_t type = 0 ; type < 2 ; type++) {
+ for(Int_t i = 0 ; i < knRatio ; i++) {
+ TH1 *ratio = (TH1*)arrES[19 + 2*i + type];
+ TH1 *histN = (TH1*)arrES[3 + 2*kN[i] + type];
+ TH1 *histD = (TH1*)arrES[3 + 2*kD[i] + type];
+ if ( ! (ratio && histN && histD) ) continue;
+ BuildRatio(ratio, histN, histD);
+ //ratio->Reset();
+ //ratio->Add(histN);
+ //ratio->Divide(histD);
+ }
+ }
+ // ratio for the fraction of electrons per stack
+ TH1 *histN = (TH1*)arrES[33];
+ TH1 *histD = (TH1*)arrES[32];
+ TH1 *ratio = (TH1*)arrES[34];
+ BuildRatio(ratio, histN, histD);
+ } // ESDs
+ } // RS: loop over eventual clones per trigger class
+ } // loop over species
// call the checker
AliQAChecker::Instance()->Run(AliQAv1::kTRD, task, list) ;
-
+ //
}
//____________________________________________________________________________
TH1 *hist[kNhist];
Int_t histoCounter = -1 ;
- hist[++histoCounter] = new TH1D("qaTRD_esd_ntracks", "TRD esd ntracks;Number of tracks;Counts", 300, -0.5, 299.5);
- hist[++histoCounter] = new TH1D("qaTRD_esd_sector", "TRD esd sector;Sector;Counts", 18, -0.5, 17.7);
- hist[++histoCounter] = new TH1D("qaTRD_esd_bits", "TRD esd bits;Bits;Counts", 64, -0.5, 63.5);
+ hist[++histoCounter] = new TH1F("qaTRD_esd_ntracks", "TRD esd ntracks;Number of tracks;Counts", 300, -0.5, 299.5);
+ hist[++histoCounter] = new TH1F("qaTRD_esd_sector", "TRD esd sector;Sector;Counts", 18, -0.5, 17.7);
+ hist[++histoCounter] = new TH1F("qaTRD_esd_bits", "TRD esd bits;Bits;Counts", 64, -0.5, 63.5);
const Int_t knbits = 6;
const char *suf[knbits] = {"TPCi", "TPCo", "TPCz", "TRDo", "TRDr", "TRDz"};
// histo = 3
for(Int_t i=0; i<knbits; i++) {
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",suf[i]), Form("qaTRD_esd_pt%s;p_{T} (GeV/c);Counts",suf[i]), 100, 0, 10);
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400);
+ hist[++histoCounter] = new TH1F(Form("qaTRD_esd_pt%s",suf[i]), Form("qaTRD_esd_pt%s;p_{T} (GeV/c);Counts",suf[i]), 100, 0, 10);
+ hist[++histoCounter] = new TH1F(Form("qaTRD_esd_trdz%s", suf[i]), ";z (cm)", 200, -400, 400);
}
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDo", "TRDo;number of clusters;Counts", 180, -0.5, 179.5);;
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDr", "TRDr;number of clusters;Counts", 180, -0.5, 179.5);;
- hist[++histoCounter] = new TH1D("qaTRD_esd_clsTRDz", "TRDz;number of clusters;Counts", 180, -0.5, 179.5);;
- //hist[++histoCounter] = new TH1D("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
+ hist[++histoCounter] = new TH1F("qaTRD_esd_clsTRDo", "TRDo;number of clusters;Counts", 180, -0.5, 179.5);;
+ hist[++histoCounter] = new TH1F("qaTRD_esd_clsTRDr", "TRDr;number of clusters;Counts", 180, -0.5, 179.5);;
+ hist[++histoCounter] = new TH1F("qaTRD_esd_clsTRDz", "TRDz;number of clusters;Counts", 180, -0.5, 179.5);;
+ //hist[++histoCounter] = new TH1F("qaTRD_esd_clsRatio", ";cluster ratio", 100, 0., 1.3);;
- hist[++histoCounter] = new TH2D("qaTRD_esd_sigMom", "TRD esd sig Mom;momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
+ hist[++histoCounter] = new TH2F("qaTRD_esd_sigMom", "TRD esd sig Mom;momentum (GeV/c);signal", 100, 0, 5, 200, 0, 1e3);
// end of cycle plots (hist 19)
const char *sufRatio[4] = {"TRDrTRDo", "TRDoTPCo", "TRDrTPCo", "TRDzTPCo"};
for(int i=0; i<4; i++) {
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_pt%s",sufRatio[i]),
+ hist[++histoCounter] = new TH1F(Form("qaTRD_esd_pt%s",sufRatio[i]),
Form("Efficiency in Pt %s;p_{T};eff", sufRatio[i]),
100, 0, 10);
- hist[++histoCounter] = new TH1D(Form("qaTRD_esd_trdz%s",sufRatio[i]),
+ hist[++histoCounter] = new TH1F(Form("qaTRD_esd_trdz%s",sufRatio[i]),
Form("Efficiency in Z %s;z (cm);eff", sufRatio[i]),
200, -400, 400);
}
// 27 - 31
- hist[27] = new TH1D("qaTRD_esd_quality", "TRD esd quality;quality;Counts", 120, 0, 12);
- hist[28] = new TH1D("qaTRD_esd_budget", "TRD esd budget;NN;Counts", 110, -1000, 100);
- hist[29] = new TH1D("qaTRD_esd_chi2", "TRD esd chi2;chi2;Counts", 200, 0, 100);
- hist[30] = new TH1D("qaTRD_esd_timeBin", "TRD esd timeBin;time bin;Counts", 7, -0.5, 6.5);
- hist[31] = new TH1D("qaTRD_esd_pidQuality", "pid Quality;quality;;Counts", 7, -0.5, 6.5);
+ hist[27] = new TH1F("qaTRD_esd_quality", "TRD esd quality;quality;Counts", 120, 0, 12);
+ hist[28] = new TH1F("qaTRD_esd_budget", "TRD esd budget;NN;Counts", 110, -1000, 100);
+ hist[29] = new TH1F("qaTRD_esd_chi2", "TRD esd chi2;chi2;Counts", 200, 0, 100);
+ hist[30] = new TH1F("qaTRD_esd_timeBin", "TRD esd timeBin;time bin;Counts", 7, -0.5, 6.5);
+ hist[31] = new TH1F("qaTRD_esd_pidQuality", "pid Quality;quality;;Counts", 7, -0.5, 6.5);
// stack by stack electron identyfication
- hist[32] = new TH1D("qaTRD_esd_tracksStack", "number of all tracks;stack;Counts", 90, -0.5, 89.5);
- hist[33] = new TH1D("qaTRD_esd_electronStack", "number of electron tracks;stack;Counts", 90, -0.5, 89.5);
- hist[34] = new TH1D("qaTRD_esd_elRatioStack", "fraction of electron tracks;stack;Counts", 90, -0.5, 89.5);
- hist[35] = new TH1D("qaTRD_esd_thetaOut", ";tan(theta);", 100, -1, 1);
+ hist[32] = new TH1F("qaTRD_esd_tracksStack", "number of all tracks;stack;Counts", 90, -0.5, 89.5);
+ hist[33] = new TH1F("qaTRD_esd_electronStack", "number of electron tracks;stack;Counts", 90, -0.5, 89.5);
+ hist[34] = new TH1F("qaTRD_esd_elRatioStack", "fraction of electron tracks;stack;Counts", 90, -0.5, 89.5);
+ hist[35] = new TH1F("qaTRD_esd_thetaOut", ";tan(theta);", 100, -1, 1);
const char *partType[5] = {"Electron", "Muon", "Pion", "Kaon", "Proton"};
for(Int_t i=0; i<AliPID::kSPECIES; i++)
- hist[36+i] = new TH1D(Form("qaTRD_esd_pid%d",i),
+ hist[36+i] = new TH1F(Form("qaTRD_esd_pid%d",i),
Form("%s;probability;Counts",partType[i]), 100, 0, 1);
// dE/dX vs momentum in three regions
for(Int_t i=0; i<4; i++) {
- hist[41+i] = new TH2D(Form("qaTRD_esd_signalPzone_%d",i),
+ hist[41+i] = new TH2F(Form("qaTRD_esd_signalPzone_%d",i),
Form("%s;momentum (GeV/c);signal (a.u.)", zoneName[i]),
nscalex, scalex, nscaley, scaley);
}
//hist[i]->Sumw2();
Add2ESDsList(hist[i], i, !expert, image);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
const Int_t kNhist = 14 + 4 * 18 + 2 + 9;// + 540;
TH1 *hist[kNhist];
- hist[0] = new TH1D("qaTRD_recPoints_det", "RRD recPoints det;Detector ID of the cluster;Counts", 540, -0.5, 539.5);
- hist[1] = new TH2D("qaTRD_recPoints_amp", "TRD recPoints amp;Amplitude;??", 540, -0.5, 539, 200, -0.5, 199.5);
- hist[2] = new TH1D("qaTRD_recPoints_npad", "TRD recPoints npad;Number of Pads;Counts", 12, -0.5, 11.5);
+ hist[0] = new TH1F("qaTRD_recPoints_det", "RRD recPoints det;Detector ID of the cluster;Counts", 540, -0.5, 539.5);
+ hist[1] = new TH2F("qaTRD_recPoints_amp", "TRD recPoints amp;Amplitude;??", 540, -0.5, 539, 200, -0.5, 199.5);
+ hist[2] = new TH1F("qaTRD_recPoints_npad", "TRD recPoints npad;Number of Pads;Counts", 12, -0.5, 11.5);
- hist[3] = new TH1D("qaTRD_recPoints_dist2", "TRD recPoints dist2;residuals [2pad];Counts", 100, -1, 1);
- hist[4] = new TH1D("qaTRD_recPoints_dist3", "TRD recPoints dist3;residuals [3pad];Counts", 100, -1, 1);
- hist[5] = new TH1D("qaTRD_recPoints_dist4", "TRD recPoints dist4;residuals [4pad];Counts", 100, -1, 1);
- hist[6] = new TH1D("qaTRD_recPoints_dist5", "TRD recPoints dist5;residuals [5pad];Counts", 100, -1, 1);
+ hist[3] = new TH1F("qaTRD_recPoints_dist2", "TRD recPoints dist2;residuals [2pad];Counts", 100, -1, 1);
+ hist[4] = new TH1F("qaTRD_recPoints_dist3", "TRD recPoints dist3;residuals [3pad];Counts", 100, -1, 1);
+ hist[5] = new TH1F("qaTRD_recPoints_dist4", "TRD recPoints dist4;residuals [4pad];Counts", 100, -1, 1);
+ hist[6] = new TH1F("qaTRD_recPoints_dist5", "TRD recPoints dist5;residuals [5pad];Counts", 100, -1, 1);
- hist[7] = new TH2D("qaTRD_recPoints_rowCol", "TRDrecPointsrowCol;row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
- hist[8] = new TH1D("qaTRD_recPoints_time", "TRDrecPoints time;time bin;Counts", kTimeBin, -0.5, kTimeBin-0.5);
- hist[9] = new TH1D("qaTRD_recPoints_nCls", "TRD recPoints nCls;number of clusters;Counts", 500, -0.5, 499.5);
+ hist[7] = new TH2F("qaTRD_recPoints_rowCol", "TRDrecPointsrowCol;row;col", 16, -0.5, 15.5, 145, -0.5, 144.5);
+ hist[8] = new TH1F("qaTRD_recPoints_time", "TRDrecPoints time;time bin;Counts", kTimeBin, -0.5, kTimeBin-0.5);
+ hist[9] = new TH1F("qaTRD_recPoints_nCls", "TRD recPoints nCls;number of clusters;Counts", 500, -0.5, 499.5);
- hist[10] = new TH3D("qaTRD_recPoints_sigTime", "TRD recPoints sigTime;chamber;time bin;signal",
+ hist[10] = new TH3F("qaTRD_recPoints_sigTime", "TRD recPoints sigTime;chamber;time bin;signal",
540, -0.5, 539.5, kTimeBin, -0.5, kTimeBin-0.5, 200, -0.5, 199.5);
hist[11] = new TProfile("qaTRD_recPoints_prf", "TRD recPoints prf;distance;center of gravity;Counts"
, 120, -0.6, 0.6, -1.2, 1.2, "");
- hist[12] = new TH1D("qaTRD_recPoints_ampMPV", "TRD recPoints ampMPV;amplitude MPV;Counts", 150, 0, 150);
- hist[13] = new TH1D("qaTRD_recPoints_ampSigma", "TRD recPoints ampSigma;amplitude Sigma;Counts", 200, 0, 200);
+ hist[12] = new TH1F("qaTRD_recPoints_ampMPV", "TRD recPoints ampMPV;amplitude MPV;Counts", 150, 0, 150);
+ hist[13] = new TH1F("qaTRD_recPoints_ampSigma", "TRD recPoints ampSigma;amplitude Sigma;Counts", 200, 0, 200);
// chamber by chamber
for(Int_t i=0; i<18; i++) {
- hist[14+i] = new TH2D(Form("qaTRD_recPoints_sigTime_sm%d",i), Form("sm%d;det;time bin",i),
+ hist[14+i] = new TH2F(Form("qaTRD_recPoints_sigTime_sm%d",i), Form("sm%d;det;time bin",i),
30, -0.5, 29.5, kTimeBin, -0.5, kTimeBin-0.5);
hist[14+i]->SetMinimum(0);
hist[14+i]->SetMaximum(150);
// time bin by time bin sm-by-sm
for(Int_t i=0; i<18; i++) {
- hist[14+18+i] = new TH1D(Form("qaTRD_recPoints_sigTimeShape_sm%d", i),
+ hist[14+18+i] = new TH1F(Form("qaTRD_recPoints_sigTimeShape_sm%d", i),
Form("sm%d;time bin;signal",i),
kTimeBin, -0.5, kTimeBin-0.5);
// str = 50
for(Int_t i=0; i<18; i++) {
- hist[50+i] = new TH1D(Form("qaTRD_recPoints_nCls_sm%d",i),
+ hist[50+i] = new TH1F(Form("qaTRD_recPoints_nCls_sm%d",i),
Form("sm%d;time bin;number of clusters",i),
kTimeBin, -0.5, kTimeBin-0.5);
}
// str = 68
for(Int_t i=0; i<18; i++) {
- hist[68+i] = new TH1D(Form("qaTRD_recPoints_totalCharge_sm%d", i),
+ hist[68+i] = new TH1F(Form("qaTRD_recPoints_totalCharge_sm%d", i),
Form("sm%d;time bin;total charge", i),
kTimeBin, -0.5, kTimeBin-0.5);
}
- hist[86] = new TH1D("qaTRD_recPoints_signal", "TRD recPoints signal;amplitude;Counts", 400, -0.5, 399.5);
- hist[87] = new TH2D("qaTRD_recPoints_detMap", "TRD recPoints detMap;sm;chamber;Counts", 18, -0.5, 17.5, 30, -0.5, 29.5);
+ hist[86] = new TH1F("qaTRD_recPoints_signal", "TRD recPoints signal;amplitude;Counts", 400, -0.5, 399.5);
+ hist[87] = new TH2F("qaTRD_recPoints_detMap", "TRD recPoints detMap;sm;chamber;Counts", 18, -0.5, 17.5, 30, -0.5, 29.5);
// amplitude as a function of the pad size
for(Int_t i=0; i<9; i++) {
- hist[88+i] = new TH1D(Form("qaTRD_recPoints_signalNpad_%d", i+2), Form("qaTRD_recPoints_signalNpad_%d;amplitude, ADC", i+2), 400, -0.5, 399.5);
+ hist[88+i] = new TH1F(Form("qaTRD_recPoints_signalNpad_%d", i+2), Form("qaTRD_recPoints_signalNpad_%d;amplitude, ADC", i+2), 400, -0.5, 399.5);
}
// one 2D histogram per chamber
// for(Int_t i=0; i<540; i++) {
- // hist[88+i] = new TH2D(Form("qaTRD_recPoints_map%d", i), ";col;row", 16, -0.5, 15.5, 144, -0.5, 143.5);
+ // hist[88+i] = new TH2F(Form("qaTRD_recPoints_map%d", i), ";col;row", 16, -0.5, 15.5, 144, -0.5, 143.5);
//}
//hist[i]->Sumw2();
Add2RecPointsList(hist[i], i, !expert, image);
}
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
const Int_t kNhist = 7;
TH1 *hist[kNhist];
- hist[0] = new TH2D("qaTRD_raws_nADC","number of ADC channels;sector;detector", 18, -0.5, 17.5, 30, -0.5, 29.5);
- hist[1] = new TH2D("qaTRD_raws_nCls", "number of clusters;sector;detector", 18, -0.5, 17.5, 30, -0.5, 29.5);
- hist[2] = new TH2D("qaTRD_raws_meanSig", "mean signal;sector;detector", 18, -0.5, 17.5, 30, -0.5, 29.5);
+ hist[0] = new TH2F("qaTRD_raws_nADC","number of ADC channels;sector;detector", 18, -0.5, 17.5, 30, -0.5, 29.5);
+ hist[1] = new TH2F("qaTRD_raws_nCls", "number of clusters;sector;detector", 18, -0.5, 17.5, 30, -0.5, 29.5);
+ hist[2] = new TH2F("qaTRD_raws_meanSig", "mean signal;sector;detector", 18, -0.5, 17.5, 30, -0.5, 29.5);
- hist[3] = new TH1D("qaTRD_raws_ADC", "ADC amplitude;ADC counts", 100, -0.5, 99.5);
- hist[4] = new TH1D("qaTRD_raws_Cls", "Cluster amplitude; ADC counts", 100, -0.5, 199.5);
- hist[5] = new TH2D("qaTRD_raws_ClsTb", "Clusters vs Time Bin;time bin;amoplitude", 30, -0.5, 29.5, 200, -0.5, 199.5);
+ hist[3] = new TH1F("qaTRD_raws_ADC", "ADC amplitude;ADC counts", 100, -0.5, 99.5);
+ hist[4] = new TH1F("qaTRD_raws_Cls", "Cluster amplitude; ADC counts", 100, -0.5, 199.5);
+ hist[5] = new TH2F("qaTRD_raws_ClsTb", "Clusters vs Time Bin;time bin;amoplitude", 30, -0.5, 29.5, 200, -0.5, 199.5);
- hist[6] = new TH2D("qaTRD_raws_ClsAmpDet", ";detector;amplitude", 540, -0.5, 539.5, 100, 0, 200);
+ hist[6] = new TH2F("qaTRD_raws_ClsAmpDet", ";detector;amplitude", 540, -0.5, 539.5, 100, 0, 200);
/*
- hist[0] = new TH2D("qaTRD_raws_DataVolume", ";Sector;Data Volume, kB", 18, -0.5, 17.5, 100, 0, 30);
- hist[1] = new TH2D("qaTRD_raws_HC", "Data Headers;Sector;HC", 18, -0.5, 17.5, 60, -0.5, 59.5);
- hist[2] = new TH2D("qaTRD_raws_LME", "Link Monitor Error;Sector;HC", 18, -0.5, 17.5, 60, -0.5, 59.5);
+ hist[0] = new TH2F("qaTRD_raws_DataVolume", ";Sector;Data Volume, kB", 18, -0.5, 17.5, 100, 0, 30);
+ hist[1] = new TH2F("qaTRD_raws_HC", "Data Headers;Sector;HC", 18, -0.5, 17.5, 60, -0.5, 59.5);
+ hist[2] = new TH2F("qaTRD_raws_LME", "Link Monitor Error;Sector;HC", 18, -0.5, 17.5, 60, -0.5, 59.5);
- hist[3] = new TH1D("qaTRD_rawd_cls", "Clusters amplitude;ADC counts", 100, 0, 200);
- hist[4] = new TH2D("qaTRD_raws_clsTB", "amplitude - time bins;time bin;amplitude"
+ hist[3] = new TH1F("qaTRD_rawd_cls", "Clusters amplitude;ADC counts", 100, 0, 200);
+ hist[4] = new TH2F("qaTRD_raws_clsTB", "amplitude - time bins;time bin;amplitude"
30, -0.5, 29.5, 100, 0, 200);
- hist[5] = new TH2D("qaTRD_raws_clsSec", "amplitude in sectors;Sector;amplitude, ADCs"
+ hist[5] = new TH2F("qaTRD_raws_clsSec", "amplitude in sectors;Sector;amplitude, ADCs"
18, -0.5, 17.5);
*/
//hist[i]->Sumw2();
Add2RawsList(hist[i], i, !expert, image, !saveCorr);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
//
Int_t nTracks = esd->GetNumberOfTracks();
- GetESDsData(0)->Fill(nTracks);
+ FillESDsData(0,nTracks);
// track loop
for (Int_t iTrack = 0; iTrack<nTracks; iTrack++) {
UInt_t u = 1;
UInt_t status = track->GetStatus();
for(Int_t bit=0; bit<32; bit++)
- if (u<<bit & status) GetESDsData(2)->Fill(bit);
+ if (u<<bit & status) FillESDsData(2,bit);
const Int_t knbits = 6;
Int_t bit[6] = {0,0,0,0,0,0};
for(Int_t b=0; b<knbits; b++) {
if (bit[b]) {
- GetESDsData(2*b+3)->Fill(pt);
- GetESDsData(2*b+4)->Fill(extZ);
+ FillESDsData(2*b+3,pt);
+ FillESDsData(2*b+4,extZ);
}
}
// clusters
for(Int_t b=0; b<3; b++)
- if (bit[3+b]) GetESDsData(b+15)->Fill(track->GetTRDncls0());
+ if (bit[3+b]) FillESDsData(b+15,track->GetTRDncls0());
// refitted only
if (!bit[4]) continue;
//fBudget->Fill(track->GetTRDBudget());
//fSignal->Fill(track->GetTRDsignal());
- GetESDsData(1)->Fill(sector);
- GetESDsData(18)->Fill(track->GetP(), track->GetTRDsignal());
+ FillESDsData(1,sector);
+ FillESDsData(18,track->GetP(), track->GetTRDsignal());
- GetESDsData(27)->Fill(track->GetTRDQuality());
- GetESDsData(28)->Fill(track->GetTRDBudget());
- GetESDsData(29)->Fill(track->GetTRDchi2());
- GetESDsData(30)->Fill(track->GetTRDTimBin(0));
- GetESDsData(31)->Fill(track->GetTRDntrackletsPID());
+ FillESDsData(27,track->GetTRDQuality());
+ FillESDsData(28,track->GetTRDBudget());
+ FillESDsData(29,track->GetTRDchi2());
+ FillESDsData(30,track->GetTRDTimBin(0));
+ FillESDsData(31,track->GetTRDntrackletsPID());
// dedx
for(Int_t j=0; j<6; j++) {
dedx += track->GetTRDslice(j, k-1);
}
- GetESDsData(41+k)->Fill(paramOut->GetP(), dedx/6.);
+ FillESDsData(41+k,paramOut->GetP(), dedx/6.);
}
// probabilities
if (status & AliESDtrack::kTRDpid) {
for(Int_t k=0; k<AliPID::kSPECIES; ++k)
- GetESDsData(36+k)->Fill(track->GetTRDpid(k));
+ FillESDsData(36+k,track->GetTRDpid(k));
}
// probabilities uniformity
if (track->GetTRDntrackletsPID() < 6) continue;
- GetESDsData(35)->Fill(paramOut->GetZ()/paramOut->GetX());
+ FillESDsData(35,paramOut->GetZ()/paramOut->GetX());
Int_t idx = 5 * sector + stack;
- GetESDsData(32)->Fill(idx); // all tracks
+ FillESDsData(32,idx); // all tracks
if (track->GetTRDpid(AliPID::kElectron) > 0.9)
- GetESDsData(33)->Fill(idx); // electrons only
+ FillESDsData(33,idx); // electrons only
/*
- hist[27] = new TH1D("qaTRD_esd_quality", ";quality", 120, 0, 12);
- hist[28] = new TH1D("qaTRD_esd_budget", ";NN", 110, -1000, 100);
- hist[29] = new TH1D("qaTRD_esd_chi2", ";chi2", 300, 0, 100);
- hist[30] = new TH1D("qaTRD_esd_timeBin", 7, -0.5, 6.5);
- hist[31] = new TH1D("qaTRD_esd_pidQuality", 7, -0.5, 6.5);
+ hist[27] = new TH1F("qaTRD_esd_quality", ";quality", 120, 0, 12);
+ hist[28] = new TH1F("qaTRD_esd_budget", ";NN", 110, -1000, 100);
+ hist[29] = new TH1F("qaTRD_esd_chi2", ";chi2", 300, 0, 100);
+ hist[30] = new TH1F("qaTRD_esd_timeBin", 7, -0.5, 6.5);
+ hist[31] = new TH1F("qaTRD_esd_pidQuality", 7, -0.5, 6.5);
*/
/*
*/
}
-
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//______________________________________________________________________________
AliInfo("Making QA for Raws");
- // take histograms
-
- TH2D *mnADC = (TH2D*)GetRawsData(0);
- TH2D *mnCls = (TH2D*)GetRawsData(1);
- TH2D *mClsDet = (TH2D*)GetRawsData(2);
-
- TH1D *mADC = (TH1D*)GetRawsData(3);
- TH1D *mCls = (TH1D*)GetRawsData(4);
- TH2D *mClsTb = (TH2D*)GetRawsData(5);
-
- TH2D *mClsDetAmp = (TH2D*)GetRawsData(6);
+ // take histograms (RS: arrays of histos)
+ static TObjArray mnADC,mnCls,mClsDet,mADC,mCls,mClsTb,mClsDetAmp;
+ GetMatchingRawsData(0,&mnADC);
+ GetMatchingRawsData(1,&mnCls);
+ GetMatchingRawsData(2,&mClsDet);
+ GetMatchingRawsData(3,&mADC);
+ GetMatchingRawsData(4,&mCls);
+ GetMatchingRawsData(5,&mClsTb);
+ GetMatchingRawsData(6,&mClsDetAmp);
const Int_t baseline = 10;
while(indexes->NextRCIndex(row, col)) {
- mnADC->Fill(det/30, det%30);
+ for (int ih=mnADC.GetEntriesFast();ih--;) ((TH2*)mnADC.UncheckedAt(ih))->Fill(det/30, det%30);
for(Int_t tb = 0; tb < digits->GetNtime(); tb++) {
Int_t value = digits->GetData(row, col, tb);
- mADC->Fill(value);
+ for (int ih=mADC.GetEntriesFast();ih--;) ((TH1*)mADC.UncheckedAt(ih))->Fill(value);
// simple clusterizer
if (col < 1 || col > digits->GetNcol()-2) continue;
Int_t valueTot = value + valueL + valueR;
if (valueTot < 0) continue;
- mCls->Fill(valueTot);
- mClsTb->Fill(tb, valueTot);
- mClsDetAmp->Fill(det, valueTot);
+ for (int ih=mCls.GetEntriesFast();ih--;) ((TH1*)mCls.UncheckedAt(ih))->Fill(valueTot);
+ for (int ih=mClsTb.GetEntriesFast();ih--;) ((TH2*)mClsTb.UncheckedAt(ih))->Fill(tb, valueTot);
+ for (int ih=mClsDetAmp.GetEntriesFast();ih--;) ((TH2*)mClsDetAmp.UncheckedAt(ih))->Fill(det, valueTot);
if (valueTot < 200) {
- mnCls->Fill(det/30, det%30);
- mClsDet->Fill(det/30, det%30, valueTot);
+ for (int ih=mnCls.GetEntriesFast();ih--;) ((TH2*)mnCls.UncheckedAt(ih))->Fill(det/30, det%30);
+ for (int ih=mClsDet.GetEntriesFast();ih--;) ((TH2*)mClsDet.UncheckedAt(ih))->Fill(det/30, det%30, valueTot);
}
}
delete digitsManager;
delete data;
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
*/
/////
-
+ TObjArray *hists3D = GetMatchingRecPointsData(10); //RS no alias for 3d histo filling, to directly
+ //
for (Int_t iEntry = 0; iEntry < nEntries; iEntry++) {
// Import the tree
Int_t nPads = c->GetNPads();
nDet[iDet]++;
- GetRecPointsData(0)->Fill(iDet);
- GetRecPointsData(86)->Fill(c->GetQ());
- GetRecPointsData(1)->Fill(iDet, c->GetQ());
- GetRecPointsData(2)->Fill(nPads);
+ FillRecPointsData(0,iDet);
+ FillRecPointsData(86,c->GetQ());
+ FillRecPointsData(1,iDet, c->GetQ());
+ FillRecPointsData(2,nPads);
if (nPads < 6)
- GetRecPointsData(1+c->GetNPads())->Fill(c->GetCenter());
+ FillRecPointsData(1+c->GetNPads(),c->GetCenter());
if (nPads < 10)
- GetRecPointsData(88+nPads-2)->Fill(c->GetQ());
- else GetRecPointsData(96)->Fill(c->GetQ());
+ FillRecPointsData(88+nPads-2,c->GetQ());
+ else FillRecPointsData(96,c->GetQ());
//if (c->GetPadTime() < 5)
- ((TH2D*)GetRecPointsData(7))->Fill(c->GetPadRow(), c->GetPadCol());
- GetRecPointsData(8)->Fill(c->GetPadTime());
-
- ((TH3D*)GetRecPointsData(10))->Fill(iDet, c->GetPadTime(), c->GetQ());
+ FillRecPointsData(7,c->GetPadRow(), c->GetPadCol());
+ FillRecPointsData(8,c->GetPadTime());
+ //
+ for (int ih=hists3D->GetEntriesFast();ih--;) ((TH3F*)hists3D->UncheckedAt(ih))->Fill(iDet, c->GetPadTime(), c->GetQ());
Int_t iSM = iDet / 30;
- GetRecPointsData(50+iSM)->Fill(c->GetPadTime());
- GetRecPointsData(68+iSM)->Fill(c->GetPadTime(), c->GetQ());
+ FillRecPointsData(50+iSM,c->GetPadTime());
+ FillRecPointsData(68+iSM,c->GetPadTime(), c->GetQ());
// total charge sm / det / timeBin
- //((TH2D*)GetRecPointsData(14+iSM))->Fill(iDet-iSM*30, c->GetPadTime(), c->GetQ());
+ // FillRecPointsData(14+iSM,iDet-iSM*30, c->GetPadTime(), c->GetQ());
// PRF for 2pad
if (sig[0] == 0 && sig[1] == 0 && sig[4] == 0 && sig[5] == 0 && sig[6] == 0)
frac = -1. * sig[2] / (sig[2] + sig[3]);
- if (frac > -10) ((TProfile*)GetRecPointsData(11))->Fill(c->GetCenter(), frac);
+ if (frac > -10) FillRecPointsData(11,c->GetCenter(), frac);
//}
}
/*
for(Int_t i=0; i<540; i++)
- if (nDet[i] > 0) GetRecPointsData(9)->Fill(nDet[i]);
+ if (nDet[i] > 0) FillRecPointsData(9,nDet[i]);
*/
- GetRecPointsData(9)->Fill(nCls);
+ FillRecPointsData(9,nCls);
delete clusterArray;
-
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
return !!obj;
}
//__________________________________________________________________________
-void AliTRDQADataMakerRec::BuildRatio(TH1D *ratio, TH1D *histN, TH1D*histD) {
+void AliTRDQADataMakerRec::BuildRatio(TH1 *ratio, TH1 *histN, TH1* histD) {
//
// Calculate the ratio of two histograms
// error are calculated assuming the histos have the same counts
}
//__________________________________________________________________________
-Int_t AliTRDQADataMakerRec::FillBits(TH1D *hist, Int_t code, Int_t offset) {
+Int_t AliTRDQADataMakerRec::FillBits(TH1F *hist, Int_t code, Int_t offset) {
Int_t nb = 0;
UInt_t test = 1;
Int_t GetSector(Double_t alpha) const;
Int_t GetStack(const AliExternalTrackParam *paramOut) const;
Double_t GetExtZ(const AliExternalTrackParam *paramIn) const;
- Int_t FillBits(TH1D *hist, Int_t code, Int_t offset);
+ Int_t FillBits(TH1F *hist, Int_t code, Int_t offset);
- void BuildRatio(TH1D *ratio, TH1D * const histN, TH1D * const histD);
+ void BuildRatio(TH1 *ratio, TH1 * const histN, TH1 * const histD);
ClassDef(AliTRDQADataMakerRec,1) // Creates the TRD QA data
// --- ROOT system ---
#include <TClonesArray.h>
#include <TFile.h>
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TH3D.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TH3F.h>
#include <TProfile.h>
#include <TF1.h>
#include <TCanvas.h>
//
// Detector specific actions at end of cycle
//
-
+ ResetEventTrigClasses();
//AliDebug(AliQAv1::GetQADebugLevel(), Form("EndOfCycle", "Fitting RecPoints %d", task));
// call the checker
const Bool_t image = kTRUE ;
const Int_t kNhist = 4;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
- hist[0] = new TH1D("qaTRD_hits_det", "TRD hits det;Detector Id of the hit;Counts", 540, -0.5, 539.5) ;
+ hist[0] = new TH1F("qaTRD_hits_det", "TRD hits det;Detector Id of the hit;Counts", 540, -0.5, 539.5) ;
- hist[1] = new TH1D("qaTRD_hist_Qdrift", "TRD hits Qdrift;Charge from tracks;Counts", 100, 0, 100);
- hist[2] = new TH1D("qaTRD_hist_Qamp", "TRD hits Qamp;Charge from TRD photon;Counts", 100, 0, 100);
- hist[3] = new TH1D("qaTRD_hist_Qphoton", "TRD hits Qphoton;Charge from TRD photon;Counts", 100, 0, 100);
+ hist[1] = new TH1F("qaTRD_hist_Qdrift", "TRD hits Qdrift;Charge from tracks;Counts", 100, 0, 100);
+ hist[2] = new TH1F("qaTRD_hist_Qamp", "TRD hits Qamp;Charge from TRD photon;Counts", 100, 0, 100);
+ hist[3] = new TH1F("qaTRD_hist_Qphoton", "TRD hits Qphoton;Charge from TRD photon;Counts", 100, 0, 100);
for(Int_t i=0; i<kNhist; i++) {
//hist[i]->Sumw2();
Add2HitsList(hist[i], i, !expert, image);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
const Bool_t image = kTRUE ;
const Int_t kNhist = 3;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
- hist[0] = new TH1D("qaTRD_digits_det", "TRD digits det;Detector Id of the digit;Counts", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_digits_time", "TRDdigits time;Time bin;Counts", 40, -0.5, 39.5);
- hist[2] = new TH1D("qaTRD_digits_amp", "TRD digits amp;Amplitude;Counts", 100, -5.5, 94.5);
+ hist[0] = new TH1F("qaTRD_digits_det", "TRD digits det;Detector Id of the digit;Counts", 540, -0.5, 539.5);
+ hist[1] = new TH1F("qaTRD_digits_time", "TRDdigits time;Time bin;Counts", 40, -0.5, 39.5);
+ hist[2] = new TH1F("qaTRD_digits_amp", "TRD digits amp;Amplitude;Counts", 100, -5.5, 94.5);
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
Add2DigitsList(hist[i], i, !expert, image);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
const Bool_t image = kTRUE ;
const Int_t kNhist = 3;
- TH1D *hist[kNhist];
+ TH1F *hist[kNhist];
- hist[0] = new TH1D("qaTRD_sdigits_det", "TRD sdigits det;Detector Id of the digit;Counts", 540, -0.5, 539.5);
- hist[1] = new TH1D("qaTRD_sdigits_time", "TRD sdigits time;Time bin;Counts", 40, -0.5, 39.5);
- hist[2] = new TH1D("qaTRD_sdigits_amp", "TRD sdigits amp;Amplitude;Counts", 100, 0, 1e7);
+ hist[0] = new TH1F("qaTRD_sdigits_det", "TRD sdigits det;Detector Id of the digit;Counts", 540, -0.5, 539.5);
+ hist[1] = new TH1F("qaTRD_sdigits_time", "TRD sdigits time;Time bin;Counts", 40, -0.5, 39.5);
+ hist[2] = new TH1F("qaTRD_sdigits_amp", "TRD sdigits amp;Amplitude;Counts", 100, 0, 1e7);
for(Int_t i=0; i<kNhist; i++) {
hist[i]->Sumw2();
Add2SDigitsList(hist[i], i, !expert, image);
}
-
+ //
+ ClonePerTrigClass(AliQAv1::kSDIGITS); // this should be the last line
}
//____________________________________________________________________________
AliTRDhit * hit;
while ( (hit = dynamic_cast<AliTRDhit *>(next())) ) {
- GetHitsData(0)->Fill(hit->GetDetector());
+ FillHitsData(0,hit->GetDetector());
Double_t q = TMath::Abs(hit->GetCharge());
- if (hit->FromDrift()) GetHitsData(1)->Fill(q);
- if (hit->FromAmplification()) GetHitsData(2)->Fill(q);
- if (hit->FromTRphoton()) GetHitsData(3)->Fill(q);
+ if (hit->FromDrift()) FillHitsData(1,q);
+ if (hit->FromAmplification()) FillHitsData(2,q);
+ if (hit->FromTRphoton()) FillHitsData(3,q);
}
-
}
//____________________________________________________________________________
MakeHits();
fHitsArray->Clear() ;
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
//____________________________________________________________________________
while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
if (digit->GetAmp() < 1) continue;
- GetDigitsData(0)->Fill(digit->GetDetector());
- GetDigitsData(1)->Fill(digit->GetTime());
- GetDigitsData(2)->Fill(digit->GetAmp());
+ FillDigitsData(0,digit->GetDetector());
+ FillDigitsData(1,digit->GetTime());
+ FillDigitsData(2,digit->GetAmp());
}
}
AliTRDdigitsManager *digitsManager = new AliTRDdigitsManager();
digitsManager->CreateArrays();
digitsManager->ReadDigits(digits);
-
- TH1D *histDet = (TH1D*)GetDigitsData(0);
- TH1D *histTime = (TH1D*)GetDigitsData(1);
- TH1D *histSignal = (TH1D*)GetDigitsData(2);
+ static TObjArray histDet,histTime,histSignal;
+ //
+ GetMatchingDigitsData(0,&histDet);
+ GetMatchingDigitsData(1,&histTime);
+ GetMatchingDigitsData(2,&histSignal);
for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++)
{
{
Float_t signal = digitsIn->GetData(row,col,time);
if (signal < 1) continue;
- histDet->Fill(i);
- histTime->Fill(time);
- histSignal->Fill(signal);
+ for (int ih=histDet.GetEntriesFast();ih--;) ((TH1*)histDet.UncheckedAt(ih))->Fill(i);
+ for (int ih=histTime.GetEntriesFast();ih--;) ((TH1*)histTime.UncheckedAt(ih))->Fill(time);
+ for (int ih=histSignal.GetEntriesFast();ih--;) ((TH1*)histSignal.UncheckedAt(ih))->Fill(signal);
}
//delete digitsIn;
}
delete digitsManager;
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
//____________________________________________________________________________
TIter next(fSDigitsArray) ;
AliTRDdigit * digit ;
while ( (digit = dynamic_cast<AliTRDdigit *>(next())) ) {
- GetDigitsData(0)->Fill(digit->GetDetector());
- GetDigitsData(1)->Fill(digit->GetTime());
- GetDigitsData(2)->Fill(digit->GetAmp());
+ FillDigitsData(0,digit->GetDetector());
+ FillDigitsData(1,digit->GetTime());
+ FillDigitsData(2,digit->GetAmp());
}
}
digitsManager->CreateArrays();
digitsManager->ReadDigits(digits);
- TH1D *histDet = (TH1D*)GetSDigitsData(0);
- TH1D *histTime = (TH1D*)GetSDigitsData(1);
- TH1D *histSignal = (TH1D*)GetSDigitsData(2);
+ static TObjArray histDet,histTime,histSignal;
+ //
+ GetMatchingSDigitsData(0,&histDet);
+ GetMatchingSDigitsData(1,&histTime);
+ GetMatchingSDigitsData(2,&histSignal);
for (Int_t i = 0; i < AliTRDgeometry::kNdet; i++)
{
{
Float_t signal = digitsIn->GetData(row,col,time);
if (signal < 1) continue;
- histDet->Fill(i);
- histTime->Fill(time);
- histSignal->Fill(signal);
+ for (int ih=histDet.GetEntriesFast();ih--;) ((TH1*)histDet.UncheckedAt(ih))->Fill(i);
+ for (int ih=histTime.GetEntriesFast();ih--;) ((TH1*)histTime.UncheckedAt(ih))->Fill(time);
+ for (int ih=histSignal.GetEntriesFast();ih--;) ((TH1*)histSignal.UncheckedAt(ih))->Fill(signal);
}
}
}
// delete digitsIn;
}
delete digitsManager;
+ //
+ IncEvCountCycleSDigits();
+ IncEvCountTotalSDigits();
+ //
}
//____________________________________________________________________________
#include <TH1F.h>
#include <TH1I.h>
#include <TH2I.h>
-#include <TH2D.h>
+#include <TH2F.h>
#include <TGraph.h>
#include <TParameter.h>
#include <TTimeStamp.h>
#include "AliCTPTimeParams.h"
#include "event.h"
- const Float_t kMinBBA = 68. ;
- const Float_t kMaxBBA = 100. ;
- const Float_t kMinBBC = 75.5 ;
- const Float_t kMaxBBC = 100. ;
- const Float_t kMinBGA = 54. ;
- const Float_t kMaxBGA = 58. ;
- const Float_t kMinBGC = 69.5 ;
- const Float_t kMaxBGC = 74. ;
+const Float_t kMinBBA = 68. ;
+const Float_t kMaxBBA = 100. ;
+const Float_t kMinBBC = 75.5 ;
+const Float_t kMaxBBC = 100. ;
+const Float_t kMinBGA = 54. ;
+const Float_t kMaxBGA = 58. ;
+const Float_t kMinBGC = 69.5 ;
+const Float_t kMaxBGC = 74. ;
ClassImp(AliVZEROQADataMakerRec)
//____________________________________________________________________________
- AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() :
- AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"),
- fCalibData(0x0),
- fEvent(0),
- fNTotEvents(0),
- fNSubEvents(0),
- fTrendingUpdateEvent(0),
- fNTrendingUpdates(0),
- fTrendingUpdateTime(0),
- fCycleStartTime(0),
- fCycleStopTime(0),
- fTimeSlewing(0)
+AliVZEROQADataMakerRec::AliVZEROQADataMakerRec() :
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kVZERO), "VZERO Quality Assurance Data Maker"),
+ fCalibData(0x0),
+// fEvent(0),
+// fNTotEvents(0),
+// fNSubEvents(0),
+// fTrendingUpdateEvent(0),
+// fNTrendingUpdates(0),
+ fTrendingUpdateTime(0),
+ fCycleStartTime(0),
+ fCycleStopTime(0),
+ fTimeSlewing(0)
{
- // Constructor
+ // Constructor
- AliDebug(AliQAv1::GetQADebugLevel(), "Construct VZERO QA Object");
+ AliDebug(AliQAv1::GetQADebugLevel(), "Construct VZERO QA Object");
- for(Int_t i=0; i<64; i++){
- fEven[i] = 0;
- fOdd[i] = 0;
+ for(Int_t i=0; i<64; i++){
+ fEven[i] = 0;
+ fOdd[i] = 0;
}
- for(Int_t i=0; i<128; i++){
- fADCmean[i] = 0.0; }
+ for(Int_t i=0; i<128; i++){
+ fADCmean[i] = 0.0; }
}
//____________________________________________________________________________
- AliVZEROQADataMakerRec::AliVZEROQADataMakerRec(const AliVZEROQADataMakerRec& qadm) :
+AliVZEROQADataMakerRec::AliVZEROQADataMakerRec(const AliVZEROQADataMakerRec& qadm) :
AliQADataMakerRec(),
- fCalibData(0x0),
- fEvent(0),
- fNTotEvents(0),
- fNSubEvents(0),
- fTrendingUpdateEvent(0),
- fNTrendingUpdates(0),
- fTrendingUpdateTime(0),
- fCycleStartTime(0),
- fCycleStopTime(0),
- fTimeSlewing(0)
+ fCalibData(0x0),
+ // fEvent(0),
+ // fNTotEvents(0),
+ // fNSubEvents(0),
+ // fTrendingUpdateEvent(0),
+ // fNTrendingUpdates(0),
+ fTrendingUpdateTime(0),
+ fCycleStartTime(0),
+ fCycleStopTime(0),
+ fTimeSlewing(0)
{
// Copy constructor
- SetName((const char*)qadm.GetName()) ;
- SetTitle((const char*)qadm.GetTitle());
+ SetName((const char*)qadm.GetName()) ;
+ SetTitle((const char*)qadm.GetTitle());
}
//__________________________________________________________________
AliVZEROCalibData* AliVZEROQADataMakerRec::GetCalibData() const
{
- AliCDBManager *man = AliCDBManager::Instance();
+ AliCDBManager *man = AliCDBManager::Instance();
- AliCDBEntry *entry=0;
+ AliCDBEntry *entry=0;
- entry = man->Get("VZERO/Calib/Data",fRun);
- if(!entry){
- AliWarning("Load of calibration data from default storage failed!");
- AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
+ entry = man->Get("VZERO/Calib/Data",fRun);
+ if(!entry){
+ AliWarning("Load of calibration data from default storage failed!");
+ AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
- man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
- entry = man->Get("VZERO/Calib/Data",fRun);
- }
- // Retrieval of data in directory VZERO/Calib/Data:
+ man->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
+ entry = man->Get("VZERO/Calib/Data",fRun);
+ }
+ // Retrieval of data in directory VZERO/Calib/Data:
- AliVZEROCalibData *calibdata = 0;
+ AliVZEROCalibData *calibdata = 0;
- if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
- if (!calibdata) AliFatal("No calibration data from calibration database !");
+ if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
+ if (!calibdata) AliFatal("No calibration data from calibration database !");
- return calibdata;
+ return calibdata;
}
-
-
//____________________________________________________________________________
void AliVZEROQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
// Detector specific actions at end of cycle
// Does the QA checking
-
+ ResetEventTrigClasses();
+ //
AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
if(task == AliQAv1::kRAWS){
- TTimeStamp currentTime;
- fCycleStopTime = currentTime.GetSec();
+ TTimeStamp currentTime;
+ fCycleStopTime = currentTime.GetSec();
}
for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
- if (! IsValidEventSpecie(specie, list))
- continue ;
- SetEventSpecie(AliRecoParam::ConvertIndex(specie)) ;
- if(task == AliQAv1::kRAWS){
+ if (! IsValidEventSpecie(specie, list)) continue ;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ if(task == AliQAv1::kRAWS) {
} else if (task == AliQAv1::kESDS) {
}
}
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH2D * h2d;
+ TH2F * h2d;
TH1I * h1i;
- TH1D * h1d;
+ TH1F * h1d;
h1i = new TH1I("H1I_Cell_Multiplicity_V0A", "Cell Multiplicity in V0A;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;
Add2ESDsList(h1i, kCellMultiV0A, !expert, image) ;
h1i = new TH1I("H1I_Cell_Multiplicity_V0C", "Cell Multiplicity in V0;Multiplicity (Nb of Cell);Counts", 35, 0, 35) ;
Add2ESDsList(h1i, kCellMultiV0C, !expert, image) ;
- h1d = new TH1D("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
+ h1d = new TH1F("H1D_MIP_Multiplicity_V0A", "MIP Multiplicity in V0A;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
Add2ESDsList(h1d, kMIPMultiV0A, !expert, image) ;
- h1d = new TH1D("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
+ h1d = new TH1F("H1D_MIP_Multiplicity_V0C", "MIP Multiplicity in V0C;Multiplicity (Nb of MIP);Counts", 1000, 0, 1000) ;
Add2ESDsList(h1d, kMIPMultiV0C, !expert, image) ;
- h2d = new TH2D("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel;Channel;Multiplicity (Nb of MIP)",64, 0, 64, 100, 0, 100) ;
+ h2d = new TH2F("H2D_MIP_Multiplicity_Channel", "MIP Multiplicity per Channel;Channel;Multiplicity (Nb of MIP)",64, 0, 64, 100, 0, 100) ;
Add2ESDsList(h2d, kMIPMultiChannel, !expert, image) ;
- h1d = new TH1D("H1D_BBFlag_Counters", "BB Flag Counters;Channel;Counts",64, 0, 64) ;
+ h1d = new TH1F("H1D_BBFlag_Counters", "BB Flag Counters;Channel;Counts",64, 0, 64) ;
Add2ESDsList(h1d, kBBFlag, !expert, image) ;
- h1d = new TH1D("H1D_BGFlag_Counters", "BG Flag Counters;Channel;Counts",64, 0, 64) ;
+ h1d = new TH1F("H1D_BGFlag_Counters", "BG Flag Counters;Channel;Counts",64, 0, 64) ;
Add2ESDsList(h1d, kBGFlag, !expert, image) ;
- h2d = new TH2D("H2D_Charge_Channel", "ADC Charge per channel;Channel;Charge (ADC counts)",64, 0, 64, 1024, 0, 1024) ;
+ h2d = new TH2F("H2D_Charge_Channel", "ADC Charge per channel;Channel;Charge (ADC counts)",64, 0, 64, 1024, 0, 1024) ;
Add2ESDsList(h2d, kChargeChannel, !expert, image) ;
- h2d = new TH2D("H2D_Time_Channel", "Time per channel;Channel;Time (ns)",64, 0, 64, 400, -100, 100) ;
+ h2d = new TH2F("H2D_Time_Channel", "Time per channel;Channel;Time (ns)",64, 0, 64, 400, -100, 100) ;
Add2ESDsList(h2d, kTimeChannel, !expert, image) ;
- h1d = new TH1D("H1D_V0A_Time", "Mean V0A Time;Time (ns);Counts",1000, -100., 100.);
+ h1d = new TH1F("H1D_V0A_Time", "Mean V0A Time;Time (ns);Counts",1000, -100., 100.);
Add2ESDsList(h1d,kESDV0ATime, !expert, image);
- h1d = new TH1D("H1D_V0C_Time", "Mean V0C Time;Time (ns);Counts",1000, -100., 100.);
+ h1d = new TH1F("H1D_V0C_Time", "Mean V0C Time;Time (ns);Counts",1000, -100., 100.);
Add2ESDsList(h1d,kESDV0CTime, !expert, image);
- h1d = new TH1D("H1D_Diff_Time", "Diff Time V0A - V0C;Diff Time V0A - V0C (ns);Counts",1000, -200., 200.);
+ h1d = new TH1F("H1D_Diff_Time", "Diff Time V0A - V0C;Diff Time V0A - V0C (ns);Counts",1000, -200., 200.);
Add2ESDsList(h1d,kESDDiffTime, !expert, image);
-
+ //
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//____________________________________________________________________________
- void AliVZEROQADataMakerRec::InitRaws()
- {
- // Creates RAW histograms in Raws subdir
-
- const Bool_t expert = kTRUE ;
- const Bool_t saveCorr = kTRUE ;
- const Bool_t image = kTRUE ;
+void AliVZEROQADataMakerRec::InitRaws()
+{
+ // Creates RAW histograms in Raws subdir
+ const Bool_t expert = kTRUE ;
+ const Bool_t saveCorr = kTRUE ;
+ const Bool_t image = kTRUE ;
const Int_t kNintegrator = 2;
const Float_t kMIPMax = 16;
TH2I * h2i;
- TH2D * h2d;
+ TH2F * h2d;
TH1I * h1i;
- TH1D * h1d;
+ TH1F * h1d;
int iHisto =0;
- // Creation of Trigger Histogram
- h1d = new TH1D("H1D_Trigger_Type", "V0 Trigger Type;;Counts", 4,0 ,4) ;
+ // Creation of Trigger Histogram
+ h1d = new TH1F("H1D_Trigger_Type", "V0 Trigger Type;;Counts", 4,0 ,4) ;
Add2RawsList(h1d,kTriggers, !expert, image, saveCorr); iHisto++;
h1d->SetFillColor(29);
h1d->SetLineWidth(2);
h1d->GetXaxis()->SetLabelSize(0.06);
- h1d->GetXaxis()->SetNdivisions(808,kFALSE);
+ h1d->GetXaxis()->SetNdivisions(808,kFALSE);
h1d->GetXaxis()->SetBinLabel(1, "V0-AND");
h1d->GetXaxis()->SetBinLabel(2, "V0-OR");
h1d->GetXaxis()->SetBinLabel(3, "V0-BGA");
h1d->GetXaxis()->SetBinLabel(4, "V0-BGC");
- h2d = new TH2D("H2D_Trigger_Type", "V0 Trigger Type;V0A;V0C", 4,0 ,4,4,0,4) ;
- Add2RawsList(h2d,kTriggers2, !expert, image, saveCorr); iHisto++;
+ h2d = new TH2F("H2D_Trigger_Type", "V0 Trigger Type;V0A;V0C", 4,0 ,4,4,0,4) ;
+ Add2RawsList(h2d,kTriggers2, !expert, image, saveCorr); iHisto++;
h2d->SetDrawOption("coltext");
h2d->GetXaxis()->SetLabelSize(0.06);
- h2d->GetXaxis()->SetNdivisions(808,kFALSE);
- h2d->GetYaxis()->SetNdivisions(808,kFALSE);
+ h2d->GetXaxis()->SetNdivisions(808,kFALSE);
+ h2d->GetYaxis()->SetNdivisions(808,kFALSE);
h2d->GetXaxis()->SetBinLabel(1, "Empty");
h2d->GetXaxis()->SetBinLabel(2, "Fake");
h2d->GetXaxis()->SetBinLabel(3, "BB");
h2d->GetYaxis()->SetBinLabel(3, "BB");
h2d->GetYaxis()->SetBinLabel(4, "BG");
- // Creation of Cell Multiplicity Histograms
+ // Creation of Cell Multiplicity Histograms
h1i = new TH1I("H1I_Multiplicity_V0A", "Cell Multiplicity in V0A;# of Cells;Entries", 35, 0, 35) ;
Add2RawsList(h1i,kMultiV0A, expert, image, saveCorr); iHisto++;
h1i = new TH1I("H1I_Multiplicity_V0C", "Cell Multiplicity in V0C;# of Cells;Entries", 35, 0, 35) ;
Add2RawsList(h1i,kMultiV0C, expert, image, saveCorr); iHisto++;
// Creation of Total Charge Histograms
- h1d = new TH1D("H1D_Charge_V0A", "Total Charge in V0A;Charge [ADC counts];Counts", 2000, 0, 10000) ;
+ h1d = new TH1F("H1D_Charge_V0A", "Total Charge in V0A;Charge [ADC counts];Counts", 2000, 0, 10000) ;
Add2RawsList(h1d,kChargeV0A, expert, !image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_Charge_V0C", "Total Charge in V0C;Charge [ADC counts];Counts", 2000, 0, 10000) ;
+ h1d = new TH1F("H1D_Charge_V0C", "Total Charge in V0C;Charge [ADC counts];Counts", 2000, 0, 10000) ;
Add2RawsList(h1d,kChargeV0C, expert, !image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_Charge_V0", "Total Charge in V0;Charge [ADC counts];Counts", 2000, 0, 20000) ;
+ h1d = new TH1F("H1D_Charge_V0", "Total Charge in V0;Charge [ADC counts];Counts", 2000, 0, 20000) ;
Add2RawsList(h1d,kChargeV0, expert, !image, saveCorr); iHisto++;
// Creation of MIP Histograms
- h1d = new TH1D("H1D_MIP_V0A", "Total MIP in V0A;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ;
+ h1d = new TH1F("H1D_MIP_V0A", "Total MIP in V0A;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ;
Add2RawsList(h1d,kRawMIPV0A, expert, !image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_MIP_V0C", "Total MIP in V0C;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ;
+ h1d = new TH1F("H1D_MIP_V0C", "Total MIP in V0C;Multiplicity [MIP];Counts", kNMIPBins,kMIPMin ,32*kMIPMax) ;
Add2RawsList(h1d,kRawMIPV0C, expert, !image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_MIP_V0", "Total MIP in V0;Multiplicity [MIP];Counts", 2*kNMIPBins,kMIPMin ,64*kMIPMax) ;
+ h1d = new TH1F("H1D_MIP_V0", "Total MIP in V0;Multiplicity [MIP];Counts", 2*kNMIPBins,kMIPMin ,64*kMIPMax) ;
Add2RawsList(h1d,kRawMIPV0, expert, !image, saveCorr); iHisto++;
- h2d = new TH2D("H2D_MIP_Channel", "Nb of MIP per channel;Channel;# of Mips", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ;
+ h2d = new TH2F("H2D_MIP_Channel", "Nb of MIP per channel;Channel;# of Mips", kNChannelBins, kChannelMin, kChannelMax,kNMIPBins,kMIPMin ,kMIPMax) ;
Add2RawsList(h2d,kRawMIPChannel, expert, !image, !saveCorr); iHisto++;
// Creation of Charge EoI histogram
- h2d = new TH2D("H2D_ChargeEoI", "Charge Event of Interest;Channel Number;Charge [ADC counts]"
- ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
- Add2RawsList(h2d,kChargeEoI, !expert, image, !saveCorr); iHisto++;
+ h2d = new TH2F("H2D_ChargeEoI", "Charge Event of Interest;Channel Number;Charge [ADC counts]"
+ ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
+ Add2RawsList(h2d,kChargeEoI, !expert, image, !saveCorr); iHisto++;
- for(Int_t iInt=0;iInt<kNintegrator;iInt++){
+ for(Int_t iInt=0;iInt<kNintegrator;iInt++){
// Creation of Pedestal histograms
h2i = new TH2I(Form("H2I_Pedestal_Int%d",iInt), Form("Pedestal (Int%d);Channel;Pedestal [ADC counts]",iInt)
- ,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
+ ,kNChannelBins, kChannelMin, kChannelMax,kNPedestalBins,kPedestalMin ,kPedestalMax );
Add2RawsList(h2i,(iInt == 0 ? kPedestalInt0 : kPedestalInt1), expert, !image, !saveCorr); iHisto++;
- // Creation of Charge EoI histograms
+ // Creation of Charge EoI histograms
h2i = new TH2I(Form("H2I_ChargeEoI_Int%d",iInt), Form("Charge EoI (Int%d);Channel;Charge [ADC counts]",iInt)
- ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
+ ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
Add2RawsList(h2i,(iInt == 0 ? kChargeEoIInt0 : kChargeEoIInt1), expert, image, !saveCorr); iHisto++;
h2i = new TH2I(Form("H2I_ChargeEoI_BB_Int%d",iInt), Form("Charge EoI w/ BB Flag (Int%d);Channel;Charge [ADC counts]",iInt)
- ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
+ ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
Add2RawsList(h2i,(iInt == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1), expert, !image, !saveCorr); iHisto++;
h2i = new TH2I(Form("H2I_ChargeEoI_BG_Int%d",iInt), Form("Charge EoI w/ BG Flag (Int%d);Channel;Charge [ADC counts]",iInt)
- ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
+ ,kNChannelBins, kChannelMin, kChannelMax, kNChargeBins, kChargeMin, kChargeMax);
Add2RawsList(h2i,(iInt == 0 ? kChargeEoIBGInt0: kChargeEoIBGInt1), expert, !image, !saveCorr); iHisto++;
// Creation of Charge versus LHC Clock histograms
- h2d = new TH2D(Form("H2D_ChargeVsClock_Int%d",iInt), Form("Charge Versus LHC-Clock (Int%d);Channel;LHCClock;Charge [ADC counts]",iInt)
- ,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
+ h2d = new TH2F(Form("H2D_ChargeVsClock_Int%d",iInt), Form("Charge Versus LHC-Clock (Int%d);Channel;LHCClock;Charge [ADC counts]",iInt)
+ ,kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
Add2RawsList(h2d,(iInt == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), expert, !image, !saveCorr); iHisto++;
// Creation of Minimum Bias Charge histograms
for(Int_t iBB=0;iBB<2;iBB++){
- for(Int_t iBG=0;iBG<2;iBG++){
- h2i = new TH2I(Form("H2I_ChargeMB_BB%d_BG%d_Int%d",iBB,iBG,iInt), Form("MB Charge (BB=%d, BG=%d, Int=%d);Channel;Charge [ADC counts]",iBB,iBG,iInt)
- ,kNChannelBins, kChannelMin, kChannelMax,kNChargeBins, kChargeMin, kChargeMax);
- int idx;
- if(iInt==0){
- if(iBB==0){
- if(iBG==0) idx = kChargeMBBB0BG0Int0;
- else idx = kChargeMBBB0BG1Int0;
- } else {
- if(iBG==0) idx = kChargeMBBB1BG0Int0;
- else idx = kChargeMBBB1BG1Int0;
- }
- } else {
- if(iBB==0){
- if(iBG==0) idx = kChargeMBBB0BG0Int1;
- else idx = kChargeMBBB0BG1Int1;
- } else {
- if(iBG==0) idx = kChargeMBBB1BG0Int1;
- else idx = kChargeMBBB1BG1Int1;
- }
- }
- Add2RawsList(h2i,idx, expert, !image, !saveCorr); iHisto++;
- }
+ for(Int_t iBG=0;iBG<2;iBG++){
+ h2i = new TH2I(Form("H2I_ChargeMB_BB%d_BG%d_Int%d",iBB,iBG,iInt), Form("MB Charge (BB=%d, BG=%d, Int=%d);Channel;Charge [ADC counts]",iBB,iBG,iInt)
+ ,kNChannelBins, kChannelMin, kChannelMax,kNChargeBins, kChargeMin, kChargeMax);
+ int idx;
+ if(iInt==0){
+ if(iBB==0){
+ if(iBG==0) idx = kChargeMBBB0BG0Int0;
+ else idx = kChargeMBBB0BG1Int0;
+ } else {
+ if(iBG==0) idx = kChargeMBBB1BG0Int0;
+ else idx = kChargeMBBB1BG1Int0;
+ }
+ } else {
+ if(iBB==0){
+ if(iBG==0) idx = kChargeMBBB0BG0Int1;
+ else idx = kChargeMBBB0BG1Int1;
+ } else {
+ if(iBG==0) idx = kChargeMBBB1BG0Int1;
+ else idx = kChargeMBBB1BG1Int1;
+ }
+ }
+ Add2RawsList(h2i,idx, expert, !image, !saveCorr); iHisto++;
+ }
}
- }
+ }
- // Creation of Time histograms
- h2i = new TH2I("H2I_Width", "HPTDC Width;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
- Add2RawsList(h2i,kWidth, expert, !image, !saveCorr); iHisto++;
+ // Creation of Time histograms
+ h2i = new TH2I("H2I_Width", "HPTDC Width;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
+ Add2RawsList(h2i,kWidth, expert, !image, !saveCorr); iHisto++;
- h2i = new TH2I("H2I_Width_BB", "HPTDC Width w/ BB Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
- Add2RawsList(h2i,kWidthBB, expert, !image, !saveCorr); iHisto++;
+ h2i = new TH2I("H2I_Width_BB", "HPTDC Width w/ BB Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
+ Add2RawsList(h2i,kWidthBB, expert, !image, !saveCorr); iHisto++;
- h2i = new TH2I("H2I_Width_BG", "HPTDC Width w/ BG Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
- Add2RawsList(h2i,kWidthBG, expert, !image, !saveCorr); iHisto++;
+ h2i = new TH2I("H2I_Width_BG", "HPTDC Width w/ BG Flag condition;Channel;Width [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcWidthBins, kTdcWidthMin, kTdcWidthMax);
+ Add2RawsList(h2i,kWidthBG, expert, !image, !saveCorr); iHisto++;
- h2i = new TH2I("H2I_HPTDCTime", "HPTDC Time;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
- Add2RawsList(h2i,kHPTDCTime, expert, image, !saveCorr); iHisto++;
+ h2i = new TH2I("H2I_HPTDCTime", "HPTDC Time;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
+ Add2RawsList(h2i,kHPTDCTime, expert, image, !saveCorr); iHisto++;
- h2i = new TH2I("H2I_HPTDCTime_BB", "HPTDC Time w/ BB Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
- Add2RawsList(h2i,kHPTDCTimeBB, !expert, image, !saveCorr); iHisto++;
+ h2i = new TH2I("H2I_HPTDCTime_BB", "HPTDC Time w/ BB Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
+ Add2RawsList(h2i,kHPTDCTimeBB, !expert, image, !saveCorr); iHisto++;
- h2i = new TH2I("H2I_HPTDCTime_BG", "HPTDC Time w/ BG Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
- Add2RawsList(h2i,kHPTDCTimeBG, !expert, image, !saveCorr); iHisto++;
+ h2i = new TH2I("H2I_HPTDCTime_BG", "HPTDC Time w/ BG Flag condition;Channel;Leading Time [ns]",kNChannelBins, kChannelMin, kChannelMax, kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
+ Add2RawsList(h2i,kHPTDCTimeBG, !expert, image, !saveCorr); iHisto++;
- h1d = new TH1D("H1D_V0A_Time", "V0A Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
- Add2RawsList(h1d,kV0ATime, expert, !image, saveCorr); iHisto++;
+ h1d = new TH1F("H1D_V0A_Time", "V0A Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
+ Add2RawsList(h1d,kV0ATime, expert, !image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_V0C_Time", "V0C Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
- Add2RawsList(h1d,kV0CTime, expert, !image, saveCorr); iHisto++;
+ h1d = new TH1F("H1D_V0C_Time", "V0C Time;Time [ns];Counts",kNTdcTimeBins, kTdcTimeMin, kTdcTimeMax);
+ Add2RawsList(h1d,kV0CTime, expert, !image, saveCorr); iHisto++;
- h1d = new TH1D("H1D_Diff_Time","Diff V0A-V0C Time;Time [ns];Counts",kNTdcTimeBins, -50., 50.);
- Add2RawsList(h1d,kDiffTime, expert, image, saveCorr); iHisto++;
+ h1d = new TH1F("H1D_Diff_Time","Diff V0A-V0C Time;Time [ns];Counts",kNTdcTimeBins, -50., 50.);
+ Add2RawsList(h1d,kDiffTime, expert, image, saveCorr); iHisto++;
- h2d = new TH2D("H2D_TimeV0A_V0C", "Mean Time in V0C versus V0A;Time V0A [ns];Time V0C [ns]",
+ h2d = new TH2F("H2D_TimeV0A_V0C", "Mean Time in V0C versus V0A;Time V0A [ns];Time V0C [ns]",
kNTdcTimeBins/8, kTdcTimeMin,kTdcTimeMax,kNTdcTimeBins/8, kTdcTimeMin,kTdcTimeMax) ;
Add2RawsList(h2d,kTimeV0AV0C, !expert, image, !saveCorr); iHisto++;
- // Creation of Flag versus LHC Clock histograms
+ // Creation of Flag versus LHC Clock histograms
- h1d = new TH1D("H1D_BBFlagPerChannel", "BB-Flags Versus Channel;Channel;BB Flags Count",kNChannelBins, kChannelMin, kChannelMax );
- h1d->SetMinimum(0);
- Add2RawsList(h1d,kBBFlagsPerChannel, !expert, image, !saveCorr); iHisto++;
+ h1d = new TH1F("H1D_BBFlagPerChannel", "BB-Flags Versus Channel;Channel;BB Flags Count",kNChannelBins, kChannelMin, kChannelMax );
+ h1d->SetMinimum(0);
+ Add2RawsList(h1d,kBBFlagsPerChannel, !expert, image, !saveCorr); iHisto++;
- h2d = new TH2D("H2D_BBFlagVsClock", "BB-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
- Add2RawsList(h2d,kBBFlagVsClock, expert, !image, !saveCorr); iHisto++;
+ h2d = new TH2F("H2D_BBFlagVsClock", "BB-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
+ Add2RawsList(h2d,kBBFlagVsClock, expert, !image, !saveCorr); iHisto++;
- h2d = new TH2D("H2D_BGFlagVsClock", "BG-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
- Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++;
-
-
- AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto));
- }
+ h2d = new TH2F("H2D_BGFlagVsClock", "BG-Flags Versus LHC-Clock;Channel;LHC Clocks",kNChannelBins, kChannelMin, kChannelMax,21, -10.5, 10.5 );
+ Add2RawsList(h2d,kBGFlagVsClock, expert, !image, !saveCorr); iHisto++;
+ //
+ AliDebug(AliQAv1::GetQADebugLevel(), Form("%d Histograms has been added to the Raws List",iHisto));
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
+}
//____________________________________________________________________________
void AliVZEROQADataMakerRec::InitDigits()
for (Int_t i=0; i<64; i++)
{
- fhDigTDC[i] = new TH1I(Form("hDigitTDC%d", i),Form("Digit TDC in cell %d; TDC value;Entries",i),300,0.,149.);
+ fhDigTDC[i] = new TH1I(Form("hDigitTDC%d", i),Form("Digit TDC in cell %d; TDC value;Entries",i),300,0.,149.);
- fhDigADC[i]= new TH1I(Form("hDigitADC%d",i),Form("Digit ADC in cell %d;ADC value;Entries",i),1024,0.,1023.);
+ fhDigADC[i]= new TH1I(Form("hDigitADC%d",i),Form("Digit ADC in cell %d;ADC value;Entries",i),1024,0.,1023.);
- Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
- Add2DigitsList(fhDigADC[i],i+1+64, !expert, image);
+ Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
+ Add2DigitsList(fhDigADC[i],i+1+64, !expert, image);
}
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
{
// makes data from Digits
- GetDigitsData(0)->Fill(fDigitsArray->GetEntriesFast()) ;
+ FillDigitsData(0,fDigitsArray->GetEntriesFast()) ;
TIter next(fDigitsArray) ;
AliVZEROdigit *aVZERODigit ;
while ( (aVZERODigit = dynamic_cast<AliVZEROdigit *>(next())) ) {
Int_t aPMNumber = aVZERODigit->PMNumber();
- GetDigitsData(aPMNumber +1)->Fill( aVZERODigit->Time()) ; // in 100 of picoseconds
- GetDigitsData(aPMNumber +1+64)->Fill( aVZERODigit->ADC()) ;
+ FillDigitsData(aPMNumber +1, aVZERODigit->Time()) ; // in 100 of picoseconds
+ FillDigitsData(aPMNumber +1+64, aVZERODigit->ADC()) ;
}
}
branch->GetEntry(0) ;
MakeDigits() ;
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
UInt_t eventType = esd->GetEventType();
switch (eventType){
- case PHYSICS_EVENT:
- AliESDVZERO *esdVZERO=esd->GetVZEROData();
+ case PHYSICS_EVENT:
+ AliESDVZERO *esdVZERO=esd->GetVZEROData();
- if (!esdVZERO) break;
+ if (!esdVZERO) break;
- GetESDsData(kCellMultiV0A)->Fill(esdVZERO->GetNbPMV0A());
- GetESDsData(kCellMultiV0C)->Fill(esdVZERO->GetNbPMV0C());
- GetESDsData(kMIPMultiV0A)->Fill(esdVZERO->GetMTotV0A());
- GetESDsData(kMIPMultiV0C)->Fill(esdVZERO->GetMTotV0C());
+ FillESDsData(kCellMultiV0A,esdVZERO->GetNbPMV0A());
+ FillESDsData(kCellMultiV0C,esdVZERO->GetNbPMV0C());
+ FillESDsData(kMIPMultiV0A,esdVZERO->GetMTotV0A());
+ FillESDsData(kMIPMultiV0C,esdVZERO->GetMTotV0C());
- for(Int_t i=0;i<64;i++) {
- GetESDsData(kMIPMultiChannel)->Fill((Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i));
- GetESDsData(kChargeChannel)->Fill((Float_t) i,(Float_t) esdVZERO->GetAdc(i));
- if (i < 32) {
- if(esdVZERO->BBTriggerV0C(i)) GetESDsData(kBBFlag)->Fill((Float_t) i);
- if(esdVZERO->BGTriggerV0C(i)) GetESDsData(kBGFlag)->Fill((Float_t) i);
- }
- else {
- if(esdVZERO->BBTriggerV0A(i-32)) GetESDsData(kBBFlag)->Fill((Float_t) i);
- if(esdVZERO->BGTriggerV0A(i-32)) GetESDsData(kBGFlag)->Fill((Float_t) i);
- }
- Float_t time = (Float_t) esdVZERO->GetTime(i); //Convert in ns: 1 TDC channel = 100ps
- GetESDsData(kTimeChannel)->Fill((Float_t) i,time);
- }
+ for(Int_t i=0;i<64;i++) {
+ FillESDsData(kMIPMultiChannel,(Float_t) i,(Float_t) esdVZERO->GetMultiplicity(i));
+ FillESDsData(kChargeChannel,(Float_t) i,(Float_t) esdVZERO->GetAdc(i));
+ if (i < 32) {
+ if(esdVZERO->BBTriggerV0C(i)) FillESDsData(kBBFlag,(Float_t) i);
+ if(esdVZERO->BGTriggerV0C(i)) FillESDsData(kBGFlag,(Float_t) i);
+ }
+ else {
+ if(esdVZERO->BBTriggerV0A(i-32)) FillESDsData(kBBFlag,(Float_t) i);
+ if(esdVZERO->BGTriggerV0A(i-32)) FillESDsData(kBGFlag,(Float_t) i);
+ }
+ Float_t time = (Float_t) esdVZERO->GetTime(i); //Convert in ns: 1 TDC channel = 100ps
+ FillESDsData(kTimeChannel,(Float_t) i,time);
+ }
- Float_t timeV0A = esdVZERO->GetV0ATime();
- Float_t timeV0C = esdVZERO->GetV0CTime();
- Float_t diffTime;
+ Float_t timeV0A = esdVZERO->GetV0ATime();
+ Float_t timeV0C = esdVZERO->GetV0CTime();
+ Float_t diffTime;
- if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.;
- else diffTime = timeV0A - timeV0C;
+ if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.;
+ else diffTime = timeV0A - timeV0C;
- GetESDsData(kESDV0ATime)->Fill(timeV0A);
- GetESDsData(kESDV0CTime)->Fill(timeV0C);
- GetESDsData(kESDDiffTime)->Fill(diffTime);
+ FillESDsData(kESDV0ATime,timeV0A);
+ FillESDsData(kESDV0CTime,timeV0C);
+ FillESDsData(kESDDiffTime,diffTime);
- break;
- }
-
+ break;
+ }
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
+ //
}
//____________________________________________________________________________
- void AliVZEROQADataMakerRec::MakeRaws(AliRawReader* rawReader)
- {
+void AliVZEROQADataMakerRec::MakeRaws(AliRawReader* rawReader)
+{
// Fills histograms with Raws, computes average ADC values dynamically (pedestal subtracted)
- // Check id histograms already created for this Event Specie
- if ( ! GetRawsData(kPedestalInt0) )
- InitRaws() ;
+ // Check id histograms already created for this Event Specie
+ if ( ! GetRawsData(kPedestalInt0) )
+ InitRaws() ;
- rawReader->Reset() ;
+ rawReader->Reset() ;
AliVZERORawStream* rawStream = new AliVZERORawStream(rawReader);
- if(!(rawStream->Next())) return;
+ if(!(rawStream->Next())) return;
eventTypeType eventType = rawReader->GetType();
switch (eventType){
- case PHYSICS_EVENT:
+ case PHYSICS_EVENT:
- fNTotEvents++;
-
- Int_t iFlag=0;
- Int_t pedestal;
- Int_t integrator;
- Bool_t flagBB[64];
- Bool_t flagBG[64];
- Int_t mbCharge;
- Float_t charge;
- Int_t offlineCh;
- Float_t adc[64], time[64], width[64], timeCorr[64];
-
- for(Int_t iChannel=0; iChannel<64; iChannel++) { // BEGIN : Loop over channels
+ // fNTotEvents++; // Use framework counters instead
+
+ Int_t iFlag=0;
+ Int_t pedestal;
+ Int_t integrator;
+ Bool_t flagBB[64];
+ Bool_t flagBG[64];
+ Int_t mbCharge;
+ Float_t charge;
+ Int_t offlineCh;
+ Float_t adc[64], time[64], width[64], timeCorr[64];
+
+ for(Int_t iChannel=0; iChannel<64; iChannel++) { // BEGIN : Loop over channels
- offlineCh = rawStream->GetOfflineChannel(iChannel);
+ offlineCh = rawStream->GetOfflineChannel(iChannel);
- // Fill Pedestal histograms
+ // Fill Pedestal histograms
- for(Int_t j=15; j<21; j++) {
- if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++;
- }
+ for(Int_t j=15; j<21; j++) {
+ if((rawStream->GetBGFlag(iChannel,j) || rawStream->GetBBFlag(iChannel,j))) iFlag++;
+ }
- if(iFlag == 0){ //No Flag found
- for(Int_t j=15; j<21; j++){
- pedestal= (Int_t) rawStream->GetPedestal(iChannel, j);
- integrator = rawStream->GetIntegratorFlag(iChannel, j);
+ if(iFlag == 0){ //No Flag found
+ for(Int_t j=15; j<21; j++){
+ pedestal= (Int_t) rawStream->GetPedestal(iChannel, j);
+ integrator = rawStream->GetIntegratorFlag(iChannel, j);
- GetRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1))->Fill(offlineCh,pedestal);
- }
- }
+ FillRawsData((integrator == 0 ? kPedestalInt0 : kPedestalInt1),offlineCh,pedestal);
+ }
+ }
- // Fill Charge EoI histograms
+ // Fill Charge EoI histograms
- adc[offlineCh] = 0.0;
-
- // Search for the maximum charge in the train of 21 LHC clocks
- // regardless of the integrator which has been operated:
- Float_t maxadc = 0;
- Int_t imax = -1;
- Float_t adcPedSub[21];
- for(Int_t iClock=0; iClock<21; iClock++){
- Bool_t iIntegrator = rawStream->GetIntegratorFlag(iChannel,iClock);
- Int_t k = offlineCh+64*iIntegrator;
-
- //printf(Form("clock = %d adc = %f ped %f\n",iClock,rawStream->GetPedestal(iChannel,iClock),fPedestal[k]));
-
- adcPedSub[iClock] = rawStream->GetPedestal(iChannel,iClock) - fCalibData->GetPedestal(k);
-// if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) {
- if(adcPedSub[iClock] <= 2.*fCalibData->GetSigma(k)) {
- adcPedSub[iClock] = 0;
- continue;
- }
-// if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue;
- if(iClock < 8 || iClock > 12) continue;
- if(adcPedSub[iClock] > maxadc) {
- maxadc = adcPedSub[iClock];
- imax = iClock;
- }
- }
- //printf(Form("Channel %d (online), %d (offline)\n",iChannel,j));
- if (imax != -1) {
-// Int_t start = imax - GetRecoParam()->GetNPreClocks();
- Int_t start = imax - 2;
- if (start < 0) start = 0;
-// Int_t end = imax + GetRecoParam()->GetNPostClocks();
- Int_t end = imax + 1;
- if (end > 20) end = 20;
- for(Int_t iClock = start; iClock <= end; iClock++) {
- adc[offlineCh] += adcPedSub[iClock];
- }
- }
+ adc[offlineCh] = 0.0;
+
+ // Search for the maximum charge in the train of 21 LHC clocks
+ // regardless of the integrator which has been operated:
+ Float_t maxadc = 0;
+ Int_t imax = -1;
+ Float_t adcPedSub[21];
+ for(Int_t iClock=0; iClock<21; iClock++){
+ Bool_t iIntegrator = rawStream->GetIntegratorFlag(iChannel,iClock);
+ Int_t k = offlineCh+64*iIntegrator;
+
+ //printf(Form("clock = %d adc = %f ped %f\n",iClock,rawStream->GetPedestal(iChannel,iClock),fPedestal[k]));
+
+ adcPedSub[iClock] = rawStream->GetPedestal(iChannel,iClock) - fCalibData->GetPedestal(k);
+ // if(adcPedSub[iClock] <= GetRecoParam()->GetNSigmaPed()*fCalibData->GetSigma(k)) {
+ if(adcPedSub[iClock] <= 2.*fCalibData->GetSigma(k)) {
+ adcPedSub[iClock] = 0;
+ continue;
+ }
+ // if(iClock < GetRecoParam()->GetStartClock() || iClock > GetRecoParam()->GetEndClock()) continue;
+ if(iClock < 8 || iClock > 12) continue;
+ if(adcPedSub[iClock] > maxadc) {
+ maxadc = adcPedSub[iClock];
+ imax = iClock;
+ }
+ }
+ //printf(Form("Channel %d (online), %d (offline)\n",iChannel,j));
+ if (imax != -1) {
+ // Int_t start = imax - GetRecoParam()->GetNPreClocks();
+ Int_t start = imax - 2;
+ if (start < 0) start = 0;
+ // Int_t end = imax + GetRecoParam()->GetNPostClocks();
+ Int_t end = imax + 1;
+ if (end > 20) end = 20;
+ for(Int_t iClock = start; iClock <= end; iClock++) {
+ adc[offlineCh] += adcPedSub[iClock];
+ }
+ }
- Int_t iClock = imax;
- charge = rawStream->GetPedestal(iChannel,iClock); // Charge at the maximum
+ Int_t iClock = imax;
+ charge = rawStream->GetPedestal(iChannel,iClock); // Charge at the maximum
- integrator = rawStream->GetIntegratorFlag(iChannel,iClock);
- flagBB[offlineCh] = rawStream->GetBBFlag(iChannel, iClock);
- flagBG[offlineCh] = rawStream->GetBGFlag(iChannel,iClock );
- Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh);
- time[offlineCh] = rawStream->GetTime(iChannel)*fCalibData->GetTimeResolution(board);
- width[offlineCh] = rawStream->GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
+ integrator = rawStream->GetIntegratorFlag(iChannel,iClock);
+ flagBB[offlineCh] = rawStream->GetBBFlag(iChannel, iClock);
+ flagBG[offlineCh] = rawStream->GetBGFlag(iChannel,iClock );
+ Int_t board = AliVZEROCalibData::GetBoardNumber(offlineCh);
+ time[offlineCh] = rawStream->GetTime(iChannel)*fCalibData->GetTimeResolution(board);
+ width[offlineCh] = rawStream->GetWidth(iChannel)*fCalibData->GetWidthResolution(board);
- if (time[offlineCh] >= 1e-6) GetRawsData(kChargeEoI)->Fill(offlineCh,adc[offlineCh]);
+ if (time[offlineCh] >= 1e-6) FillRawsData(kChargeEoI,offlineCh,adc[offlineCh]);
- GetRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1))->Fill(offlineCh,charge);
- if(flagBB[offlineCh]) GetRawsData((integrator == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1))->Fill(offlineCh,charge);
- if(flagBG[offlineCh]) GetRawsData((integrator == 0 ? kChargeEoIBGInt0 : kChargeEoIBGInt1))->Fill(offlineCh,charge);
+ FillRawsData((integrator == 0 ? kChargeEoIInt0 : kChargeEoIInt1),offlineCh,charge);
+ if(flagBB[offlineCh]) FillRawsData((integrator == 0 ? kChargeEoIBBInt0 : kChargeEoIBBInt1),offlineCh,charge);
+ if(flagBG[offlineCh]) FillRawsData((integrator == 0 ? kChargeEoIBGInt0 : kChargeEoIBGInt1),offlineCh,charge);
- Float_t sigma = fCalibData->GetSigma(offlineCh+64*integrator);
+ Float_t sigma = fCalibData->GetSigma(offlineCh+64*integrator);
- // Calculation of the number of MIP
- Double_t mipEoI = adc[offlineCh] * fCalibData->GetMIPperADC(offlineCh);
-
- if((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)){
- ((TH2D*)GetRawsData(kRawMIPChannel))->Fill(offlineCh,mipEoI);
- if(offlineCh<32) {
- mulV0C++;
- chargeV0C += adc[offlineCh];
- mipV0C += mipEoI;
- } else {
- mulV0A++;
- chargeV0A += adc[offlineCh];
- mipV0A += mipEoI;
- }
- }
-
- // Fill Charge Minimum Bias Histograms
+ // Calculation of the number of MIP
+ Double_t mipEoI = adc[offlineCh] * fCalibData->GetMIPperADC(offlineCh);
+
+ if((adc[offlineCh] > 2.*sigma) && !(time[offlineCh] <1.e-6)){
+ FillRawsData(kRawMIPChannel,offlineCh,mipEoI);
+ if(offlineCh<32) {
+ mulV0C++;
+ chargeV0C += adc[offlineCh];
+ mipV0C += mipEoI;
+ } else {
+ mulV0A++;
+ chargeV0A += adc[offlineCh];
+ mipV0A += mipEoI;
+ }
+ }
+
+ // Fill Charge Minimum Bias Histograms
- int idx;
- for(Int_t iBunch=0; iBunch<10; iBunch++){
- integrator = rawStream->GetIntMBFlag(iChannel, iBunch);
- bool bbFlag = rawStream->GetBBMBFlag(iChannel, iBunch);
- bool bgFlag = rawStream->GetBGMBFlag(iChannel, iBunch);
- mbCharge = rawStream->GetChargeMB(iChannel, iBunch);
-
- if(integrator==0){
- if(bbFlag==0){
- if(bgFlag==0) idx = kChargeMBBB0BG0Int0;
- else idx = kChargeMBBB0BG1Int0;
- } else {
- if(bgFlag==0) idx = kChargeMBBB1BG0Int0;
- else idx = kChargeMBBB1BG1Int0;
- }
- } else {
- if(bbFlag==0){
- if(bgFlag==0) idx = kChargeMBBB0BG0Int1;
- else idx = kChargeMBBB0BG1Int1;
- } else {
- if(bgFlag==0) idx = kChargeMBBB1BG0Int1;
- else idx = kChargeMBBB1BG1Int1;
- }
- }
- GetRawsData(idx)->Fill(offlineCh,mbCharge);
- }
-
- // Fill HPTDC Time Histograms
- timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]);
-
- const Float_t p1 = 2.50; // photostatistics term in the time resolution
- const Float_t p2 = 3.00; // slewing related term in the time resolution
- if(timeCorr[offlineCh]>-1024 + 1.e-6){
- Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
- Float_t timeErr = 0;
- if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
- p1*p1/nphe+
- p2*p2*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*
- TMath::Power(adc[offlineCh]/fCalibData->GetCalibDiscriThr(offlineCh,kTRUE),2.*(fTimeSlewing->GetParameter(1)-1.))/
- (fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)*fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)));
-
- if (timeErr>1.e-6) {
- if (offlineCh<32) {
- itimeV0C++;
- timeV0C += timeCorr[offlineCh]/(timeErr*timeErr);
- weightV0C += 1./(timeErr*timeErr);
- }else{
- itimeV0A++;
- timeV0A += timeCorr[offlineCh]/(timeErr*timeErr);
- weightV0A += 1./(timeErr*timeErr);
- }
- }
- }
- GetRawsData(kHPTDCTime)->Fill(offlineCh,timeCorr[offlineCh]);
- GetRawsData(kWidth)->Fill(offlineCh,width[offlineCh]);
- if(flagBB[offlineCh]) {
- GetRawsData(kHPTDCTimeBB)->Fill(offlineCh,timeCorr[offlineCh]);
- GetRawsData(kWidthBB)->Fill(offlineCh,width[offlineCh]);
- }
- if(flagBG[offlineCh]) {
- GetRawsData(kHPTDCTimeBG)->Fill(offlineCh,timeCorr[offlineCh]);
- GetRawsData(kWidthBG)->Fill(offlineCh,width[offlineCh]);
- }
-
- // Fill Flag and Charge Versus LHC-Clock histograms
+ int idx;
+ for(Int_t iBunch=0; iBunch<10; iBunch++){
+ integrator = rawStream->GetIntMBFlag(iChannel, iBunch);
+ bool bbFlag = rawStream->GetBBMBFlag(iChannel, iBunch);
+ bool bgFlag = rawStream->GetBGMBFlag(iChannel, iBunch);
+ mbCharge = rawStream->GetChargeMB(iChannel, iBunch);
+
+ if(integrator==0){
+ if(bbFlag==0){
+ if(bgFlag==0) idx = kChargeMBBB0BG0Int0;
+ else idx = kChargeMBBB0BG1Int0;
+ } else {
+ if(bgFlag==0) idx = kChargeMBBB1BG0Int0;
+ else idx = kChargeMBBB1BG1Int0;
+ }
+ } else {
+ if(bbFlag==0){
+ if(bgFlag==0) idx = kChargeMBBB0BG0Int1;
+ else idx = kChargeMBBB0BG1Int1;
+ } else {
+ if(bgFlag==0) idx = kChargeMBBB1BG0Int1;
+ else idx = kChargeMBBB1BG1Int1;
+ }
+ }
+ FillRawsData(idx,offlineCh,mbCharge);
+ }
+
+ // Fill HPTDC Time Histograms
+ timeCorr[offlineCh] = CorrectLeadingTime(offlineCh,time[offlineCh],adc[offlineCh]);
+
+ const Float_t p1 = 2.50; // photostatistics term in the time resolution
+ const Float_t p2 = 3.00; // slewing related term in the time resolution
+ if(timeCorr[offlineCh]>-1024 + 1.e-6){
+ Float_t nphe = adc[offlineCh]*kChargePerADC/(fCalibData->GetGain(offlineCh)*TMath::Qe());
+ Float_t timeErr = 0;
+ if (nphe>1.e-6) timeErr = TMath::Sqrt(kIntTimeRes*kIntTimeRes+
+ p1*p1/nphe+
+ p2*p2*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*(fTimeSlewing->GetParameter(0)*fTimeSlewing->GetParameter(1))*
+ TMath::Power(adc[offlineCh]/fCalibData->GetCalibDiscriThr(offlineCh,kTRUE),2.*(fTimeSlewing->GetParameter(1)-1.))/
+ (fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)*fCalibData->GetCalibDiscriThr(offlineCh,kTRUE)));
+
+ if (timeErr>1.e-6) {
+ if (offlineCh<32) {
+ itimeV0C++;
+ timeV0C += timeCorr[offlineCh]/(timeErr*timeErr);
+ weightV0C += 1./(timeErr*timeErr);
+ }else{
+ itimeV0A++;
+ timeV0A += timeCorr[offlineCh]/(timeErr*timeErr);
+ weightV0A += 1./(timeErr*timeErr);
+ }
+ }
+ }
+ FillRawsData(kHPTDCTime,offlineCh,timeCorr[offlineCh]);
+ FillRawsData(kWidth,offlineCh,width[offlineCh]);
+ if(flagBB[offlineCh]) {
+ FillRawsData(kHPTDCTimeBB,offlineCh,timeCorr[offlineCh]);
+ FillRawsData(kWidthBB,offlineCh,width[offlineCh]);
+ }
+ if(flagBG[offlineCh]) {
+ FillRawsData(kHPTDCTimeBG,offlineCh,timeCorr[offlineCh]);
+ FillRawsData(kWidthBG,offlineCh,width[offlineCh]);
+ }
+
+ // Fill Flag and Charge Versus LHC-Clock histograms
- for(Int_t iEvent=0; iEvent<21; iEvent++){
- charge = rawStream->GetPedestal(iChannel,iEvent);
- integrator = rawStream->GetIntegratorFlag(iChannel,iEvent);
- bool bbFlag = rawStream->GetBBFlag(iChannel, iEvent);
- bool bgFlag = rawStream->GetBGFlag(iChannel,iEvent );
-
- ((TH2*) GetRawsData((integrator == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 )))->Fill(offlineCh,(float)iEvent-10,(float)charge);
- ((TH2*) GetRawsData(kBBFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)bbFlag);
- ((TH2*) GetRawsData(kBGFlagVsClock))->Fill(offlineCh,(float)iEvent-10,(float)bgFlag);
- if(iEvent==10) ((TH1*) GetRawsData(kBBFlagsPerChannel))->Fill(offlineCh,(float)bbFlag);
- }
-
- }// END of Loop over channels
-
- if(weightV0A>1.e-6) timeV0A /= weightV0A;
- else timeV0A = -1024.;
- if(weightV0C>1.e-6) timeV0C /= weightV0C;
- else timeV0C = -1024.;
- if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.;
- else diffTime = timeV0A - timeV0C;
-
- Bool_t v0ABB = kFALSE;
- Bool_t v0CBB = kFALSE;
- Bool_t v0ABG = kFALSE;
- Bool_t v0CBG = kFALSE;
- Bool_t v0AFake = kFALSE;
- Bool_t v0CFake = kFALSE;
- Bool_t v0AEmpty = kFALSE;
- Bool_t v0CEmpty = kFALSE;
- Int_t v0ATrigger=0;
- Int_t v0CTrigger=0;
-
- // Change default BB and BG windows according to the Trigger Count Offset setting with respect to the default one which is 3247.
- Float_t winOffset = (fCalibData->GetTriggerCountOffset(0) - 3247)*25.;
-
- if((timeV0A>kMinBBA-winOffset) && (timeV0A<kMaxBBA-winOffset)) {
- v0ABB = kTRUE;
- v0ATrigger=2;
- } else if((timeV0A>kMinBGA-winOffset) && (timeV0A<kMaxBGA-winOffset)) {
- v0ABG = kTRUE;
- v0ATrigger=3;
- } else if(timeV0A>-1024.+1.e-6) {
- v0AFake = kTRUE;
- v0ATrigger=1;
- } else {
- v0AEmpty = kTRUE;
- v0ATrigger=0;
- }
-
- if((timeV0C>kMinBBC-winOffset) && (timeV0C<kMaxBBC-winOffset)) {
- v0CBB = kTRUE;
- v0CTrigger=2;
- } else if((timeV0C>kMinBGC-winOffset) && (timeV0C<kMaxBGC-winOffset)) {
- v0CBG = kTRUE;
- v0CTrigger=3;
- } else if(timeV0C>-1024.+1.e-6) {
- v0CFake = kTRUE;
- v0CTrigger=1;
- } else {
- v0CEmpty = kTRUE;
- v0CTrigger=0;
- }
-
-// Fill Trigger output histograms
- if(v0ABB && v0CBB) GetRawsData(kTriggers)->Fill(0);
- if((v0ABB || v0CBB) && !(v0ABG || v0CBG)) GetRawsData(kTriggers)->Fill(1);
- if(v0ABG && v0CBB) GetRawsData(kTriggers)->Fill(2);
- if(v0ABB && v0CBG) GetRawsData(kTriggers)->Fill(3);
-
- GetRawsData(kTriggers2)->Fill(v0ATrigger,v0CTrigger);
+ for(Int_t iEvent=0; iEvent<21; iEvent++){
+ charge = rawStream->GetPedestal(iChannel,iEvent);
+ integrator = rawStream->GetIntegratorFlag(iChannel,iEvent);
+ bool bbFlag = rawStream->GetBBFlag(iChannel, iEvent);
+ bool bgFlag = rawStream->GetBGFlag(iChannel,iEvent );
+
+ FillRawsData((integrator == 0 ? kChargeVsClockInt0 : kChargeVsClockInt1 ), offlineCh,(float)iEvent-10,(float)charge);
+ FillRawsData(kBBFlagVsClock, offlineCh,(float)iEvent-10,(float)bbFlag);
+ FillRawsData(kBGFlagVsClock, offlineCh,(float)iEvent-10,(float)bgFlag);
+ if(iEvent==10) FillRawsData(kBBFlagsPerChannel, offlineCh,(float)bbFlag);
+ }
+
+ }// END of Loop over channels
+
+ if(weightV0A>1.e-6) timeV0A /= weightV0A;
+ else timeV0A = -1024.;
+ if(weightV0C>1.e-6) timeV0C /= weightV0C;
+ else timeV0C = -1024.;
+ if(timeV0A<-1024.+1.e-6 || timeV0C<-1024.+1.e-6) diffTime = -1024.;
+ else diffTime = timeV0A - timeV0C;
+
+ Bool_t v0ABB = kFALSE;
+ Bool_t v0CBB = kFALSE;
+ Bool_t v0ABG = kFALSE;
+ Bool_t v0CBG = kFALSE;
+ Bool_t v0AFake = kFALSE;
+ Bool_t v0CFake = kFALSE;
+ Bool_t v0AEmpty = kFALSE;
+ Bool_t v0CEmpty = kFALSE;
+ Int_t v0ATrigger=0;
+ Int_t v0CTrigger=0;
+
+ // Change default BB and BG windows according to the Trigger Count Offset setting with respect to the default one which is 3247.
+ Float_t winOffset = (fCalibData->GetTriggerCountOffset(0) - 3247)*25.;
+
+ if((timeV0A>kMinBBA-winOffset) && (timeV0A<kMaxBBA-winOffset)) {
+ v0ABB = kTRUE;
+ v0ATrigger=2;
+ } else if((timeV0A>kMinBGA-winOffset) && (timeV0A<kMaxBGA-winOffset)) {
+ v0ABG = kTRUE;
+ v0ATrigger=3;
+ } else if(timeV0A>-1024.+1.e-6) {
+ v0AFake = kTRUE;
+ v0ATrigger=1;
+ } else {
+ v0AEmpty = kTRUE;
+ v0ATrigger=0;
+ }
+
+ if((timeV0C>kMinBBC-winOffset) && (timeV0C<kMaxBBC-winOffset)) {
+ v0CBB = kTRUE;
+ v0CTrigger=2;
+ } else if((timeV0C>kMinBGC-winOffset) && (timeV0C<kMaxBGC-winOffset)) {
+ v0CBG = kTRUE;
+ v0CTrigger=3;
+ } else if(timeV0C>-1024.+1.e-6) {
+ v0CFake = kTRUE;
+ v0CTrigger=1;
+ } else {
+ v0CEmpty = kTRUE;
+ v0CTrigger=0;
+ }
+
+ // Fill Trigger output histogram
+ if(v0ABB && v0CBB) FillRawsData(kTriggers,0);
+ if((v0ABB || v0CBB) && !(v0ABG || v0CBG)) FillRawsData(kTriggers,1);
+ if(v0ABG && v0CBB) FillRawsData(kTriggers,2);
+ if(v0ABB && v0CBG) FillRawsData(kTriggers,3);
- GetRawsData(kV0ATime)->Fill(timeV0A);
- GetRawsData(kV0CTime)->Fill(timeV0C);
- GetRawsData(kDiffTime)->Fill(diffTime);
- GetRawsData(kTimeV0AV0C)->Fill(timeV0A,timeV0C);
-
- GetRawsData(kMultiV0A)->Fill(mulV0A);
- GetRawsData(kMultiV0C)->Fill(mulV0C);
-
- GetRawsData(kChargeV0A)->Fill(chargeV0A);
- GetRawsData(kChargeV0C)->Fill(chargeV0C);
- GetRawsData(kChargeV0)->Fill(chargeV0A + chargeV0C);
-
- GetRawsData(kRawMIPV0A)->Fill(mipV0A);
- GetRawsData(kRawMIPV0C)->Fill(mipV0C);
- GetRawsData(kRawMIPV0)->Fill(mipV0A + mipV0C);
- break;
+ FillRawsData(kTriggers2,v0ATrigger,v0CTrigger);
+
+ FillRawsData(kV0ATime,timeV0A);
+ FillRawsData(kV0CTime,timeV0C);
+ FillRawsData(kDiffTime,diffTime);
+ FillRawsData(kTimeV0AV0C,timeV0A,timeV0C);
+
+ FillRawsData(kMultiV0A,mulV0A);
+ FillRawsData(kMultiV0C,mulV0C);
+
+ FillRawsData(kChargeV0A,chargeV0A);
+ FillRawsData(kChargeV0C,chargeV0C);
+ FillRawsData(kChargeV0,chargeV0A + chargeV0C);
+
+ FillRawsData(kRawMIPV0A,mipV0A);
+ FillRawsData(kRawMIPV0C,mipV0C);
+ FillRawsData(kRawMIPV0,mipV0A + mipV0C);
+ break;
- } // END of SWITCH : EVENT TYPE
+ } // END of SWITCH : EVENT TYPE
- fEvent++;
- TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ;
- if (p) p->SetVal((double)mulV0A) ;
+ // fEvent++; // RS: Use framework counters instead
+ TParameter<double> * p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0A)->GetName()))) ;
+ if (p) p->SetVal((double)mulV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ;
- if (p) p->SetVal((double)mulV0C) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kMultiV0C)->GetName()))) ;
+ if (p) p->SetVal((double)mulV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ;
- if (p) p->SetVal((double)chargeV0A) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0A)->GetName()))) ;
+ if (p) p->SetVal((double)chargeV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ;
- if (p) p->SetVal((double)chargeV0C) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0C)->GetName()))) ;
+ if (p) p->SetVal((double)chargeV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ;
- if (p) p->SetVal((double)(chargeV0A + chargeV0C)) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kChargeV0)->GetName()))) ;
+ if (p) p->SetVal((double)(chargeV0A + chargeV0C)) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ;
- if (p) p->SetVal((double)mipV0A) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0A)->GetName()))) ;
+ if (p) p->SetVal((double)mipV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ;
- if (p) p->SetVal((double)mipV0C) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0C)->GetName()))) ;
+ if (p) p->SetVal((double)mipV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ;
- if (p) p->SetVal((double)(mipV0A + mipV0C)) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kRawMIPV0)->GetName()))) ;
+ if (p) p->SetVal((double)(mipV0A + mipV0C)) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ;
- if (p) p->SetVal((double)timeV0A) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0ATime)->GetName()))) ;
+ if (p) p->SetVal((double)timeV0A) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ;
- if (p) p->SetVal((double)timeV0C) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kV0CTime)->GetName()))) ;
+ if (p) p->SetVal((double)timeV0C) ;
- p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ;
- if (p) p->SetVal((double)diffTime) ;
+ p = dynamic_cast<TParameter<double>*>(GetParameterList()->FindObject(Form("%s_%s_%s", GetName(), AliQAv1::GetTaskName(AliQAv1::kRAWS).Data(), GetRawsData(kDiffTime)->GetName()))) ;
+ if (p) p->SetVal((double)diffTime) ;
- delete rawStream; rawStream = 0x0;
-
-
- }
+ delete rawStream; rawStream = 0x0;
+ //
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
+}
//____________________________________________________________________________
void AliVZEROQADataMakerRec::StartOfDetectorCycle()
for(Int_t i = 0 ; i < 64; ++i) {
//Int_t board = AliVZEROCalibData::GetBoardNumber(i);
fTimeOffset[i] = (
- // ((Float_t)fCalibData->GetTriggerCountOffset(board) -
- // (Float_t)fCalibData->GetRollOver(board))*25.0 +
- // fCalibData->GetTimeOffset(i) -
- // l1Delay+
- delays->GetBinContent(i+1)//+
- // kV0Offset
- );
-// AliInfo(Form(" fTimeOffset[%d] = %f kV0offset %f",i,fTimeOffset[i],kV0Offset));
+ // ((Float_t)fCalibData->GetTriggerCountOffset(board) -
+ // (Float_t)fCalibData->GetRollOver(board))*25.0 +
+ // fCalibData->GetTimeOffset(i) -
+ // l1Delay+
+ delays->GetBinContent(i+1)//+
+ // kV0Offset
+ );
+ // AliInfo(Form(" fTimeOffset[%d] = %f kV0offset %f",i,fTimeOffset[i],kV0Offset));
}
TTimeStamp currentTime;
fCycleStartTime = currentTime.GetSec();
- fNTotEvents = 0;
+ // fNTotEvents = 0;
}
if (time < 1e-6) return -1024;
// Channel alignment and general offset subtraction
-// if (i < 32) time -= kV0CDelayCables;
-// time -= fTimeOffset[i];
+ // if (i < 32) time -= kV0CDelayCables;
+ // time -= fTimeOffset[i];
//AliInfo(Form("time-offset %f", time));
// In case of pathological signals
,kMultiV0A,kMultiV0C,kChargeV0A,kChargeV0C,kChargeV0
,kV0ATime,kV0CTime,kDiffTime
,kRawMIPV0A,kRawMIPV0C,kRawMIPV0,kRawMIPChannel
- ,kBBFlagsPerChannel, kTriggers,kTriggers2,kTimeV0AV0C} ;
+ ,kBBFlagsPerChannel, kTriggers,kTriggers2,kTimeV0AV0C} ;
enum HESDType_t {kCellMultiV0A,kCellMultiV0C,kMIPMultiV0A,kMIPMultiV0C,kMIPMultiChannel
,kBBFlag,kBGFlag,kChargeChannel,kTimeChannel
Float_t CorrectLeadingTime(Int_t i, Float_t time, Float_t adc) const;
- Int_t fEvent; // event index
+ // Int_t fEvent; // event index
Int_t fEven[64]; // even charge integrators
Int_t fOdd[64]; // odd charge intergators
Float_t fADCmean[128]; // mean adc per integrator
- size_t fNTotEvents; // total number of events
- size_t fNSubEvents; // number of events used in trending histos
- size_t fTrendingUpdateEvent; // event index of last update of the trending histos
- size_t fNTrendingUpdates; // number of updates in trending histos
+ // size_t fNTotEvents; // total number of events
+ // size_t fNSubEvents; // number of events used in trending histos
+ // size_t fTrendingUpdateEvent; // event index of last update of the trending histos
+ // size_t fNTrendingUpdates; // number of updates in trending histos
size_t fTrendingUpdateTime; // trending histos update time
UInt_t fCycleStartTime; // timestamp of QA start-of-cycle
UInt_t fCycleStopTime; // timestamp of QA end-of-cycle
Float_t fTimeOffset[64]; //! HPTDC time offsets channel by channel
TF1* fTimeSlewing; //! Function for time slewing correction
- ClassDef(AliVZEROQADataMakerRec,2) // description
+ ClassDef(AliVZEROQADataMakerRec,3) // description
};
{
//Detector specific actions at end of cycle
// do the QA checking
+ ResetEventTrigClasses();
AliQAChecker::Instance()->Run(AliQAv1::kVZERO, task, list) ;
}
TH1I * h1 = new TH1I("hHitCellNumber", "Hit cell distribution in VZERO;# of Hits;Entries", 80, 0, 79) ;
h1->Sumw2() ;
Add2HitsList(h1, 1, !expert, image) ;
-
+ //
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line
}
//____________________________________________________________________________
Add2DigitsList(fhDigTDC[i],i+1, !expert, image);
Add2DigitsList(fhDigADC[i],i+1+64, !expert, image);
}
+ //
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//make QA data from Hits
Int_t nhits = fHitsArray->GetEntriesFast();
- GetHitsData(0)->Fill(nhits) ; // fills Hit multiplicity
- for (Int_t ihit=0;ihit<nhits;ihit++)
- {
+ FillHitsData(0,nhits) ; // fills Hit multiplicity
+ for (Int_t ihit=0;ihit<nhits;ihit++)
+ {
AliVZEROhit * VZEROHit = (AliVZEROhit*) fHitsArray->UncheckedAt(ihit);
if (!VZEROHit) {
AliError("The unchecked hit doesn't exist");
break;
}
- GetHitsData(1)->Fill(VZEROHit->Cell());
+ FillHitsData(1,VZEROHit->Cell());
}
}
for (Int_t track=0; track<ntracks;track++) {
branch->GetEntry(track);
Int_t nhits = fHitsArray->GetEntriesFast();
- GetHitsData(0)->Fill(nhits) ; // fills Hit multiplicity
+ FillHitsData(0,nhits) ; // fills Hit multiplicity
for (Int_t ihit=0;ihit<nhits;ihit++)
{
AliVZEROhit * VZEROHit = (AliVZEROhit*) fHitsArray->UncheckedAt(ihit);
AliError("The unchecked hit doesn't exist");
break;
}
- GetHitsData(1)->Fill(VZEROHit->Cell());
+ FillHitsData(1,VZEROHit->Cell());
}
}
}
+ //
+ IncEvCountCycleHits();
+ IncEvCountTotalHits();
+ //
}
{
// makes data from Digits
- GetDigitsData(0)->Fill(fDigitsArray->GetEntriesFast()) ;
- TIter next(fDigitsArray) ;
+ FillDigitsData(0,fDigitsArray->GetEntriesFast()) ;
+ TIter next(fDigitsArray) ;
AliVZEROdigit *VZERODigit ;
while ( (VZERODigit = dynamic_cast<AliVZEROdigit *>(next())) ) {
Int_t PMNumber = VZERODigit->PMNumber();
- GetDigitsData(PMNumber +1)->Fill( VZERODigit->Time()) ; // in 100 of picoseconds
- GetDigitsData(PMNumber +1+64)->Fill( VZERODigit->ADC()) ;
+ FillDigitsData(PMNumber +1, VZERODigit->Time()) ; // in 100 of picoseconds
+ FillDigitsData(PMNumber +1+64, VZERODigit->ADC()) ;
}
}
branch->GetEntry(0) ;
MakeDigits() ;
}
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
Bool_t iDetPM = kTRUE;
// --- Checks
- if(irawHisto==22){
+ if(irawHisto==18){
Float_t resADC=0.;
for(int ibin=1; ibin<=hdata->GetNbinsX(); ibin++){
if((hdata->GetBinContent(ibin))>10.){
else if(iDetPM==kTRUE) messages.Add(new TObjString("Minor problem with ADCs"));
SetupHisto(messages, *hdata, rv);
}
- else if(irawHisto==23){
+ else if(irawHisto==19){
// Reference values from RUN 145456
Double_t refTDCs[6] = {-322.5,-319.1,-320.9,-319.2,-319.7,-319.2};
Float_t resTDC=0.;
//
// Check ESD HIGH GAIN CHAIN histos
if(hdata->GetEntries()>0){
- if(esdInd==2) sumADCZNC = hdata->GetMean();
- else if(esdInd==3) sumADCZNA = hdata->GetMean();
- else if(esdInd==4) sumADCZPC = hdata->GetMean();
- else if(esdInd==5) sumADCZPA = hdata->GetMean();
- else if(esdInd==8) pmQZNC = hdata->GetMean();
- else if(esdInd==9) pmQZNA = hdata->GetMean();
- else if(esdInd==10) pmQZPC = hdata->GetMean();
- else if(esdInd==11) pmQZPA = hdata->GetMean();
- else if(esdInd==12) pmCZNC = hdata->GetMean();
- else if(esdInd==13) pmCZNA = hdata->GetMean();
- else if(esdInd==14) pmCZPC = hdata->GetMean();
- else if(esdInd==15) pmCZPA = hdata->GetMean();
+ if(esdInd==0) sumADCZNC = hdata->GetMean();
+ else if(esdInd==1) sumADCZNA = hdata->GetMean();
+ else if(esdInd==2) sumADCZPC = hdata->GetMean();
+ else if(esdInd==3) sumADCZPA = hdata->GetMean();
+ else if(esdInd==6) pmQZNC = hdata->GetMean();
+ else if(esdInd==7) pmQZNA = hdata->GetMean();
+ else if(esdInd==8) pmQZPC = hdata->GetMean();
+ else if(esdInd==9) pmQZPA = hdata->GetMean();
+ else if(esdInd==10) pmCZNC = hdata->GetMean();
+ else if(esdInd==11) pmCZNA = hdata->GetMean();
+ else if(esdInd==12) pmCZPC = hdata->GetMean();
+ else if(esdInd==13) pmCZPA = hdata->GetMean();
}
//
// --- Check whether (sum PMQi - PMC)/PMC < percentageDiff
Bool_t iDetPM = kTRUE;
// --- Checks
- if(irawHisto==22){
+ if(irawHisto==18){
Float_t resADC=0.;
for(int ibin=1; ibin<=hdata->GetNbinsX(); ibin++){
if((hdata->GetBinContent(ibin))>10.){
else if(iDetPM==kTRUE) messages.Add(new TObjString("Minor problem with ADCs"));
SetupHisto(messages, *hdata, rv);
}
- else if(irawHisto==23){
+ else if(irawHisto==19){
Double_t refTDCs[6] = {-322.5,-319.1,-320.9,-319.2,-319.7,-319.2};
Float_t resTDC=0.;
for(int ibin=1; ibin<=hdata->GetNbinsX(); ibin++){
}
SetupHisto(messages, *hdata, rv);
}
- else if(irawHisto==26){
- Double_t yZNC=hdata->GetBinContent(2);
- Double_t yZNA=hdata->GetBinContent(4);
- if(TMath::Abs(yZNC)<0.4 && TMath::Abs(yZNA)<0.4) res=1.;
- else res=0.5;
- test[specie] += res;
- count++;
- //
- printf(" yZNC = %1.2f yZNA = %1.2f -> res %1.2f\n",yZNC, yZNA,res);
- if(res == 1.) messages.Add(new TObjString("ZN positions are OK!"));
- else{
- messages.Add(new TObjString("Problem in ZN positions!"));
- messages.Add(new TObjString("IF THIS IS NOT A TECHNICAL RUN"));
- }
- SetupHisto(messages, *hdata, res);
- }
irawHisto++;
}
//
// Check ESD HIGH GAIN CHAIN histos
if(hdata->GetEntries()>0){
- if(esdInd==2) sumADCZNC = hdata->GetMean();
- else if(esdInd==3) sumADCZNA = hdata->GetMean();
- else if(esdInd==4) sumADCZPC = hdata->GetMean();
- else if(esdInd==5) sumADCZPA = hdata->GetMean();
- else if(esdInd==8) pmQZNC = hdata->GetMean();
- else if(esdInd==9) pmQZNA = hdata->GetMean();
- else if(esdInd==10) pmQZPC = hdata->GetMean();
- else if(esdInd==11) pmQZPA = hdata->GetMean();
- else if(esdInd==12) pmCZNC = hdata->GetMean();
- else if(esdInd==13) pmCZNA = hdata->GetMean();
- else if(esdInd==14) pmCZPC = hdata->GetMean();
- else if(esdInd==15) pmCZPA = hdata->GetMean();
+ if(esdInd==0) sumADCZNC = hdata->GetMean();
+ else if(esdInd==1) sumADCZNA = hdata->GetMean();
+ else if(esdInd==2) sumADCZPC = hdata->GetMean();
+ else if(esdInd==3) sumADCZPA = hdata->GetMean();
+ else if(esdInd==6) pmQZNC = hdata->GetMean();
+ else if(esdInd==7) pmQZNA = hdata->GetMean();
+ else if(esdInd==8) pmQZPC = hdata->GetMean();
+ else if(esdInd==9) pmQZPA = hdata->GetMean();
+ else if(esdInd==10) pmCZNC = hdata->GetMean();
+ else if(esdInd==11) pmCZNA = hdata->GetMean();
+ else if(esdInd==12) pmCZPC = hdata->GetMean();
+ else if(esdInd==13) pmCZPA = hdata->GetMean();
}
//
// --- Check whether 2*|Mean ZNA - Mean ZNC|/(Mean ZNA + Mean ZNC) < percentageDiff
// Checks for cosmic events
// ====================================================================
else if (AliRecoParam::ConvertIndex(specie) == AliRecoParam::kCosmic) {
- AliWarning(Form("\n\t No check implemented in ZDC QA for %s task\n",taskName));
+ AliWarning(Form("\n\t No check needed in ZDC QA for %s task\n",taskName));
return ;
} // Cosmic
if(TMath::Abs(count)>1.e-10) test[specie] = test[specie]/count;
Add2DigitsList(hDigPMCZPC, 10, expert, !image);
Add2DigitsList(hDigPMCZPA, 11, expert, !image);
//
- // ------------------- LOW GAIN CHAIN ---------------------------
- TH1F * hDigZNCTotlg = new TH1F("hDigZNCTotlg", "Digit lg signal in ZNC", 100, 0., 6000.);
- TH1F * hDigZNATotlg = new TH1F("hDigZNATotlg", "Digit lg signal in ZNA", 100, 0., 6000.);
- TH1F * hDigZPCTotlg = new TH1F("hDigZPCTotlg", "Digit lg signal in ZPC", 100, 0., 6000.);
- TH1F * hDigZPATotlg = new TH1F("hDigZPATotlg", "Digit lg signal in ZPA", 100, 0., 6000.);
- Add2DigitsList(hDigZNCTotlg, 12, expert, !image);
- Add2DigitsList(hDigZNATotlg, 13, expert, !image);
- Add2DigitsList(hDigZPCTotlg, 14, expert, !image);
- Add2DigitsList(hDigZPATotlg, 15, expert, !image);
- //
- TH1F * hDigSumQZNClg = new TH1F("hDigSumQZNClg", "Signal in 4 ZNC PMQlg",100, 0., 4000.);
- TH1F * hDigSumQZNAlg = new TH1F("hDigSumQZNAlg", "Signal in 4 ZNA PMQlg",100, 0., 4000.);
- TH1F * hDigSumQZPClg = new TH1F("hDigSumQZPClg", "Signal in 4 ZPC PMQlg",100, 0., 4000.);
- TH1F * hDigSumQZPAlg = new TH1F("hDigSumQZPAlg", "Signal in 4 ZPA PMQlg",100, 0., 4000.);
- Add2DigitsList(hDigSumQZNClg, 16, expert, !image);
- Add2DigitsList(hDigSumQZNAlg, 17, expert, !image);
- Add2DigitsList(hDigSumQZPClg, 18, expert, !image);
- Add2DigitsList(hDigSumQZPAlg, 19, expert, !image);
- //
- TH1F * hDigPMCZNClg = new TH1F("hDigPMCZNClg", "Signal in ZNC PMClg",100, 0., 4000.);
- TH1F * hDigPMCZNAlg = new TH1F("hDigPMCZNAlg", "Signal in ZNA PMClg",100, 0., 4000.);
- TH1F * hDigPMCZPClg = new TH1F("hDigPMCZPClg", "Signal in ZPC PMClg",100, 0., 4000.);
- TH1F * hDigPMCZPAlg = new TH1F("hDigPMCZPAlg", "Signal in ZPA PMClg",100, 0., 4000.);
- Add2DigitsList(hDigPMCZNClg, 20, expert, !image);
- Add2DigitsList(hDigPMCZNAlg, 21, expert, !image);
- Add2DigitsList(hDigPMCZPClg, 22, expert, !image);
- Add2DigitsList(hDigPMCZPAlg, 23, expert, !image);
-
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line
}
//____________________________________________________________________________
Add2RawsList(hZPASpectrum, 3, expert, !image);
Add2RawsList(hZEM1Spectrum, 4, expert, !image);
Add2RawsList(hZEM2Spectrum, 5, expert, !image);
- //
- TH2F * hZNCpmCvsPMq = new TH2F("hZNCpmCvsPMq", "ZNC;PMC [ADC counts];Sum(PMQ) [ADC counts]",50,8.,1208.,50,8., 1208.);
- TH2F * hZPCpmCvsPMq = new TH2F("hZPCpmCvsPMq", "ZPC;PMC [ADC counts];Sum(PMQ) [ADC counts]",50,8.,1208.,50,8., 1208.);
- TH2F * hZNApmCvsPMq = new TH2F("hZNApmCvsPMq", "ZNA;PMC [ADC counts];Sum(PMQ) [ADC counts]",50,8.,1208.,50,8., 1208.);
- TH2F * hZPApmCvsPMq = new TH2F("hZPApmCvsPMq", "ZPA;PMC [ADC counts];Sum(PMQ) [ADC counts]",50,8.,1208.,50,8., 1208.);
- Add2RawsList(hZNCpmCvsPMq, 6, expert, !image);
- Add2RawsList(hZNApmCvsPMq, 7, expert, !image);
- Add2RawsList(hZPCpmCvsPMq, 8, expert, !image);
- Add2RawsList(hZPApmCvsPMq, 9, expert, !image);
TH1F * hRawPMCZNC = new TH1F("hRawPMCZNC", "Raw ZNC PMC;Amplitude [ADC counts];Counts",100, 8., 1208.);
TH1F * hRawPMCZNA = new TH1F("hRawPMCZNA", "Raw ZNA PMC;Amplitude [ADC counts];Counts",100, 8., 1208.);
TH1F * hRawPMCZPC = new TH1F("hRawPMCZPC", "Raw ZPC PMC;Amplitude [ADC counts];Counts",100, 8., 1208.);
TH1F * hRawPMCZPA = new TH1F("hRawPMCZPA", "Raw ZPA PMC;Amplitude [ADC counts];Counts",100, 8., 1208.);
- Add2RawsList(hRawPMCZNC, 10, expert, !image);
- Add2RawsList(hRawPMCZNA, 11, expert, !image);
- Add2RawsList(hRawPMCZPC, 12, expert, !image);
- Add2RawsList(hRawPMCZPA, 13, expert, !image);
+ Add2RawsList(hRawPMCZNC, 6, expert, !image);
+ Add2RawsList(hRawPMCZNA, 7, expert, !image);
+ Add2RawsList(hRawPMCZPC, 8, expert, !image);
+ Add2RawsList(hRawPMCZPA, 9, expert, !image);
TH1F * hRawSumQZNC = new TH1F("hRawSumQZNC", "Raw sumQ ZNC;Amplitude [ADC counts];Counts",100, 0., 1200.);
TH1F * hRawSumQZNA = new TH1F("hRawSumQZNA", "Raw sumQ ZNA;Amplitude [ADC counts];Counts",100, 0., 1200.);
TH1F * hRawSumQZPC = new TH1F("hRawSumQZPC", "Raw sumQ ZPC;Amplitude [ADC counts];Counts",100, 0., 1200.);
TH1F * hRawSumQZPA = new TH1F("hRawSumQZPA", "Raw sumQ ZPA;Amplitude [ADC counts];Counts",100, 0., 1200.);
- Add2RawsList(hRawSumQZNC, 14, expert, !image);
- Add2RawsList(hRawSumQZNA, 15, expert, !image);
- Add2RawsList(hRawSumQZPC, 16, expert, !image);
- Add2RawsList(hRawSumQZPA, 17, expert, !image);
+ Add2RawsList(hRawSumQZNC, 10, expert, !image);
+ Add2RawsList(hRawSumQZNA, 11, expert, !image);
+ Add2RawsList(hRawSumQZPC, 12, expert, !image);
+ Add2RawsList(hRawSumQZPA, 13, expert, !image);
TH1F * hRawTDCZEM1 = new TH1F("hRawTDCZEM1", "Raw TDC ZEM1;TDC [ns]",160, -350., -310.);
- Add2RawsList(hRawTDCZEM1, 18, expert, !image);
+ Add2RawsList(hRawTDCZEM1, 14, expert, !image);
TH1F * hRawTDCZPC = new TH1F("hRawTDCZPC", "Raw TDC ZPC;TDC [ns]",160, -350., -310.);
- Add2RawsList(hRawTDCZPC, 19, expert, !image);
+ Add2RawsList(hRawTDCZPC, 15, expert, !image);
TProfile * hRawADCProfs = new TProfile("hRawADCProfs", "ADC profiles;ADC id;Mean ADC values",22,-0.5,21.5,10.,1210.,"");
- Add2RawsList(hRawADCProfs, 20, expert, !image);
+ Add2RawsList(hRawADCProfs, 16, expert, !image);
TProfile * hRawTDCProfs = new TProfile("hRawTDCProfs", "TDC profiles;TDC id;Mean TDC values",6,0.5,6.5,-340.,-300.,"S");
- Add2RawsList(hRawTDCProfs, 21, expert, !image);
+ Add2RawsList(hRawTDCProfs, 17, expert, !image);
TH1F * hRawADCs = new TH1F("hRawADCs", "ADCs;ADC id;Mean ADC values",22,-0.5,21.5);
- Add2RawsList(hRawADCs, 22, !expert, image);
+ Add2RawsList(hRawADCs, 18, !expert, image);
TH1F * hRawTDCs = new TH1F("hRawTDCs", "TDCs;TDC id;Mean TDC values",6,0.5,6.5);
- hRawTDCs->SetMaximum(-300); hRawTDCs->SetMinimum(-340);
- Add2RawsList(hRawTDCs, 23, !expert, image);
+// hRawTDCs->SetMaximum(-300); hRawTDCs->SetMinimum(-340);
+ Add2RawsList(hRawTDCs, 19, !expert, image);
TH2F *hZNCrawCentr = new TH2F("hZNCrawCentr", "Centroid in ZNC;X (cm);Y(cm)", 100, -5.,5.,100,-5.,5.);
- Add2RawsList(hZNCrawCentr, 24, expert, !image);
+ Add2RawsList(hZNCrawCentr, 20, expert, !image);
TH2F *hZNArawCentr = new TH2F("hZNArawCentr", "Centroid in ZNA;X (cm);Y(cm)", 100, -5.,5.,100,-5.,5.);
- Add2RawsList(hZNArawCentr, 25, expert, !image);
+ Add2RawsList(hZNArawCentr, 21, expert, !image);
- TH2F *hTimeZDC = new TH2F("fHistTimeZDC", "ZDC;TDC timing A+C vs C-A; events", 120,-30,30,120,-100,-40);
- Add2RawsList(hTimeZDC, 26, expert, !image);
+ TH2F *hTimeZDC = new TH2F("fTimeZDC", "ZDC;TDC timing A+C vs C-A; events", 20,-30,30,120,-100,-40);
+ Add2RawsList(hTimeZDC, 22, expert, !image);
+ //
+ ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line
}
//____________________________________________________________________________
Add2RecPointsList(hRecPMCZNA, 9 , expert, !image);
Add2RecPointsList(hRecPMCZPC, 10, expert, !image);
Add2RecPointsList(hRecPMCZPA, 11, expert, !image);
+ //
+ ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line
}
//____________________________________________________________________________
const Bool_t expert = kTRUE ;
const Bool_t image = kTRUE ;
- TH2F * hZNCcentr = new TH2F("hZNCcentr", "Centroid in ZNC;X (cm);Y(cm)", 100, -5.,5.,100,-5.,5.);
- TH2F * hZNAcentr = new TH2F("hZNAcentr", "Centroid in ZNA;X (cm);Y(cm)", 100, -5.,5.,100,-5.,5.);
- Add2ESDsList(hZNCcentr, 0, !expert, image);
- Add2ESDsList(hZNAcentr, 1, !expert, image);
- //
// ------------------- HIGH GAIN CHAIN ---------------------------
TH1F * hESDZNCTot = new TH1F("hESDZNCTot", "Energy in ZNC", 100, 0., 4000.);
TH1F * hESDZNATot = new TH1F("hESDZNATot", "Energy in ZNA", 100, 0., 4000.);
TH1F * hESDZPCTot = new TH1F("hESDZPCTot", "Energy in ZPC", 100, 0., 4000.);
TH1F * hESDZPATot = new TH1F("hESDZPATot", "Energy in ZPA", 100, 0., 4000.);
- Add2ESDsList(hESDZNCTot, 2, !expert, image);
- Add2ESDsList(hESDZNATot, 3, !expert, image);
- Add2ESDsList(hESDZPCTot, 4, !expert, image);
- Add2ESDsList(hESDZPATot, 5, !expert, image);
+ Add2ESDsList(hESDZNCTot, 0, !expert, image);
+ Add2ESDsList(hESDZNATot, 1, !expert, image);
+ Add2ESDsList(hESDZPCTot, 2, !expert, image);
+ Add2ESDsList(hESDZPATot, 3, !expert, image);
//
TH1F * hESDZEM1 = new TH1F("hESDZEM1", "Energy in ZEM1", 100, 0., 2000.);
TH1F * hESDZEM2 = new TH1F("hESDZEM2", "Energy in ZEM2", 100, 0., 2000.);
- Add2ESDsList(hESDZEM1,6, !expert, image);
- Add2ESDsList(hESDZEM2,7, !expert, image);
+ Add2ESDsList(hESDZEM1,4, !expert, image);
+ Add2ESDsList(hESDZEM2,5, !expert, image);
//
TH1F * hESDSumQZNC = new TH1F("hESDSumQZNC", "Sum of 4 ZNC energy",100, 0., 2000.);
TH1F * hESDSumQZNA = new TH1F("hESDSumQZNA", "Sum of 4 ZNA energy",100, 0., 2000.);
TH1F * hESDSumQZPC = new TH1F("hESDSumQZPC", "Sum of 4 ZPC energy",100, 0., 2000.);
TH1F * hESDSumQZPA = new TH1F("hESDSumQZPA", "Sum of 4 ZPA energy",100, 0., 2000.);
- Add2ESDsList(hESDSumQZNC, 8, expert, !image);
- Add2ESDsList(hESDSumQZNA, 9, expert, !image);
- Add2ESDsList(hESDSumQZPC, 10, expert, !image);
- Add2ESDsList(hESDSumQZPA, 11, expert, !image);
+ Add2ESDsList(hESDSumQZNC, 6, expert, !image);
+ Add2ESDsList(hESDSumQZNA, 7, expert, !image);
+ Add2ESDsList(hESDSumQZPC, 8, expert, !image);
+ Add2ESDsList(hESDSumQZPA, 9, expert, !image);
//
TH1F * hESDPMCZNC = new TH1F("hESDPMCZNC", "Energy in ZNC PMC",100, 0., 2000.);
TH1F * hESDPMCZNA = new TH1F("hESDPMCZNA", "Energy in ZNA PMC",100, 0., 2000.);
TH1F * hESDPMCZPC = new TH1F("hESDPMCZPC", "Energy in ZPC PMC",100, 0., 2000.);
TH1F * hESDPMCZPA = new TH1F("hESDPMCZPA", "Energy in ZPA PMC",100, 0., 2000.);
- Add2ESDsList(hESDPMCZNC, 12, expert, !image);
- Add2ESDsList(hESDPMCZNA, 13, expert, !image);
- Add2ESDsList(hESDPMCZPC, 14, expert, !image);
- Add2ESDsList(hESDPMCZPA, 15, expert, !image);
+ Add2ESDsList(hESDPMCZNC, 10, expert, !image);
+ Add2ESDsList(hESDPMCZNA, 11, expert, !image);
+ Add2ESDsList(hESDPMCZPC, 12, expert, !image);
+ Add2ESDsList(hESDPMCZPA, 13, expert, !image);
//
- // ------------------- LOW GAIN CHAIN ---------------------------
- TH1F * hESDSumQZNClg = new TH1F("hESDSumQZNClg", "Sum of 4 lg ZNC sectors",100, 0., 4000.);
- TH1F * hESDSumQZNAlg = new TH1F("hESDSumQZNAlg", "Sum of 4 lg ZNA sectors",100, 0., 4000.);
- TH1F * hESDSumQZPClg = new TH1F("hESDSumQZPClg", "Sum of 4 lg ZPC sectors",100, 0., 4000.);
- TH1F * hESDSumQZPAlg = new TH1F("hESDSumQZPAlg", "Sum of 4 lg ZPA sectors",100, 0., 4000.);
- Add2ESDsList(hESDSumQZNClg, 16, expert, !image);
- Add2ESDsList(hESDSumQZNAlg, 17, expert, !image);
- Add2ESDsList(hESDSumQZPClg, 18, expert, !image);
- Add2ESDsList(hESDSumQZPAlg, 19, expert, !image);
- //
- TH1F * hESDPMCZNClg = new TH1F("hESDPMCZNClg", "Signal in common ZNC lg PMT",100, 0., 4000.);
- TH1F * hESDPMCZNAlg = new TH1F("hESDPMCZNAlg", "Signal in common ZNA lg PMT",100, 0., 4000.);
- TH1F * hESDPMCZPClg = new TH1F("hESDPMCZPClg", "Signal in common ZPC lg PMT",100, 0., 4000.);
- TH1F * hESDPMCZPAlg = new TH1F("hESDPMCZPAlg", "Signal in common ZPA lg PMT",100, 0., 4000.);
- Add2ESDsList(hESDPMCZNClg, 20, expert, !image);
- Add2ESDsList(hESDPMCZNAlg, 21, expert, !image);
- Add2ESDsList(hESDPMCZPClg, 22, expert, !image);
- Add2ESDsList(hESDPMCZPAlg, 23, expert, !image);
+ ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line
}
//___________________________________________________________________________
Float_t adcSum_ZNC=0., adcSum_ZNA=0., adcSum_ZPC=0., adcSum_ZPA=0.;
Float_t adcSumQ_ZNC=0., adcSumQ_ZNA=0., adcSumQ_ZPC=0., adcSumQ_ZPA=0.;
- Float_t adcSum_ZNC_lg=0., adcSum_ZNA_lg=0., adcSum_ZPC_lg=0., adcSum_ZPA_lg=0.;
- Float_t adcSumQ_ZNC_lg=0., adcSumQ_ZNA_lg=0., adcSumQ_ZPC_lg=0., adcSumQ_ZPA_lg=0.;
+ //Float_t adcSum_ZNC_lg=0., adcSum_ZNA_lg=0., adcSum_ZPC_lg=0., adcSum_ZPA_lg=0.;
+ //Float_t adcSumQ_ZNC_lg=0., adcSumQ_ZNA_lg=0., adcSumQ_ZPC_lg=0., adcSumQ_ZPA_lg=0.;
Int_t ndig = digitTree->GetEntries();
for(Int_t i=0; i<ndig; i++){
if(digit->GetSector(0)==1 && digit->GetSector(1)!=5){
adcSum_ZNC += digit->GetADCValue(0);
- adcSum_ZNC_lg += digit->GetADCValue(1);
+ //adcSum_ZNC_lg += digit->GetADCValue(1);
//
if(digit->GetSector(1)!=0){
adcSumQ_ZNC += digit->GetADCValue(0);
- adcSumQ_ZNC_lg+= digit->GetADCValue(1);
+ //adcSumQ_ZNC_lg+= digit->GetADCValue(1);
}
else{
- GetDigitsData(8)->Fill(digit->GetADCValue(0));
- GetDigitsData(20)->Fill(digit->GetADCValue(1));
+ FillDigitsData(8,digit->GetADCValue(0));
+ //FillDigitsData(20,digit->GetADCValue(1));
}
}
else if(digit->GetSector(0)==2){
adcSum_ZPC += digit->GetADCValue(0);
- adcSum_ZPC_lg += digit->GetADCValue(1);
+ //adcSum_ZPC_lg += digit->GetADCValue(1);
//
if(digit->GetSector(1)!=0){
adcSumQ_ZPC += digit->GetADCValue(0);
- adcSumQ_ZPC_lg+= digit->GetADCValue(1);
+ //adcSumQ_ZPC_lg+= digit->GetADCValue(1);
}
else{
- GetDigitsData(10)->Fill(digit->GetADCValue(0));
- GetDigitsData(22)->Fill(digit->GetADCValue(1));
+ FillDigitsData(10,digit->GetADCValue(0));
+ //FillDigitsData(22,digit->GetADCValue(1));
}
}
else if(digit->GetSector(0)==4 && digit->GetSector(1)!=5){
adcSum_ZNA += digit->GetADCValue(0);
- adcSum_ZNA_lg += digit->GetADCValue(1);
+ //adcSum_ZNA_lg += digit->GetADCValue(1);
//
if(digit->GetSector(1)!=0){
adcSumQ_ZNA += digit->GetADCValue(0);
- adcSumQ_ZNA_lg+= digit->GetADCValue(1);
+ //adcSumQ_ZNA_lg+= digit->GetADCValue(1);
}
else{
- GetDigitsData(9)->Fill(digit->GetADCValue(0));
- GetDigitsData(21)->Fill(digit->GetADCValue(1));
+ FillDigitsData(9,digit->GetADCValue(0));
+ //FillDigitsData(21,digit->GetADCValue(1));
}
}
else if(digit->GetSector(0)==5){
adcSum_ZPA += digit->GetADCValue(0);
- adcSum_ZPA_lg += digit->GetADCValue(1);
+ //adcSum_ZPA_lg += digit->GetADCValue(1);
//
if(digit->GetSector(1)!=0){
adcSumQ_ZPA += digit->GetADCValue(0);
- adcSumQ_ZPA_lg+= digit->GetADCValue(1);
+ //adcSumQ_ZPA_lg+= digit->GetADCValue(1);
}
else{
- GetDigitsData(11)->Fill(digit->GetADCValue(0));
- GetDigitsData(23)->Fill(digit->GetADCValue(1));
+ FillDigitsData(11,digit->GetADCValue(0));
+ //FillDigitsData(23,digit->GetADCValue(1));
}
}
}
//
- GetDigitsData(0)->Fill(adcSum_ZNC);
- GetDigitsData(1)->Fill(adcSum_ZNA);
- GetDigitsData(2)->Fill(adcSum_ZPC);
- GetDigitsData(3)->Fill(adcSum_ZPA);
+ FillDigitsData(0,adcSum_ZNC);
+ FillDigitsData(1,adcSum_ZNA);
+ FillDigitsData(2,adcSum_ZPC);
+ FillDigitsData(3,adcSum_ZPA);
//
- GetDigitsData(4)->Fill(adcSumQ_ZNC);
- GetDigitsData(5)->Fill(adcSumQ_ZNA);
- GetDigitsData(6)->Fill(adcSumQ_ZPC);
- GetDigitsData(7)->Fill(adcSumQ_ZPA);
- //
- GetDigitsData(12)->Fill(adcSum_ZNC_lg);
- GetDigitsData(13)->Fill(adcSum_ZNA_lg);
- GetDigitsData(14)->Fill(adcSum_ZPC_lg);
- GetDigitsData(15)->Fill(adcSum_ZPA_lg);
- //
- GetDigitsData(16)->Fill(adcSumQ_ZNC_lg);
- GetDigitsData(17)->Fill(adcSumQ_ZNA_lg);
- GetDigitsData(18)->Fill(adcSumQ_ZPC_lg);
- GetDigitsData(19)->Fill(adcSumQ_ZPA_lg);
+ FillDigitsData(4,adcSumQ_ZNC);
+ FillDigitsData(5,adcSumQ_ZNA);
+ FillDigitsData(6,adcSumQ_ZPC);
+ FillDigitsData(7,adcSumQ_ZPA);
delete digit;
digit=0;
-
+ //
+ IncEvCountCycleDigits();
+ IncEvCountTotalDigits();
+ //
}
// Check if histograms already created for this Event Specie
if(!GetRawsData(0)) InitRaws();
-
// Parameters for mean value pedestal subtraction
int const kNch = 24;
Float_t meanPed[2*kNch];
}
else{
zncpmC = pedSubVal;
- GetRawsData(10)->Fill(zncpmC);
+ FillRawsData(6,zncpmC);
}
indZNC++;
- GetRawsData(20)->Fill(pedindex, pedSubVal);
+ FillRawsData(16, pedindex, pedSubVal);
}
}
else if(det == 2){
if(quad!=0) zpcSumQ += pedSubVal;
else{
zpcpmC = pedSubVal;
- GetRawsData(12)->Fill(zpcpmC);
+ FillRawsData(8,zpcpmC);
}
indZPC++;
- GetRawsData(20)->Fill(pedindex, pedSubVal);
+ FillRawsData(16, pedindex, pedSubVal);
}
}
else if(det == 3){
if(quad==1){
if(gain == 0){
pedSubVal = (Float_t) (stream.GetADCValue()-meanPed[pedindex]);
- GetRawsData(4)->Fill(pedSubVal);
-
- GetRawsData(20)->Fill(pedindex, pedSubVal);
+ FillRawsData(4,pedSubVal);
+ FillRawsData(16,pedindex, pedSubVal);
}
}
else if(quad==2){
if(gain == 0){
pedSubVal = (Float_t) (stream.GetADCValue()-meanPed[pedindex]);
- GetRawsData(5)->Fill(pedSubVal);
-
- GetRawsData(20)->Fill(pedindex, pedSubVal);
+ FillRawsData(5,pedSubVal);
+ FillRawsData(16,pedindex, pedSubVal);
}
}
}
}
else{
znapmC = pedSubVal;
- GetRawsData(11)->Fill(znapmC);
+ FillRawsData(7,znapmC);
}
indZNA++;
- GetRawsData(20)->Fill(pedindex, pedSubVal);
+ FillRawsData(16,pedindex, pedSubVal);
+ // RS: invalid
//GetRawsData(22)->SetBinContent(pedindex+1, GetRawsData(20)->GetBinContent(pedindex+1));
//GetRawsData(22)->SetBinError(pedindex+1, GetRawsData(20)->GetBinError(pedindex+1));
}
if(quad!=0) zpaSumQ += pedSubVal;
else{
zpapmC = pedSubVal;
- GetRawsData(13)->Fill(zpapmC);
+ FillRawsData(9,zpapmC);
}
indZPA++;
- GetRawsData(20)->Fill(pedindex, pedSubVal);
+ FillRawsData(16,pedindex, pedSubVal);
+ // RS: invalid
//GetRawsData(22)->SetBinContent(pedindex+1, GetRawsData(20)->GetBinContent(pedindex+1));
//GetRawsData(22)->SetBinError(pedindex+1, GetRawsData(20)->GetBinError(pedindex+1));
}
}
if(isZNCFired && indZNC==5){
- GetRawsData(0)->Fill(zncSignal);
- GetRawsData(6)->Fill(zncpmC, zncSumQ);
- GetRawsData(14)->Fill(zncSumQ);
+ FillRawsData(0,zncSignal);
+ FillRawsData(10,zncSumQ);
//
Float_t xZNC, yZNC;
if(denZNC!=0){
yZNC = numYZNC/denZNC;
}
else xZNC = yZNC = 999.;
- GetRawsData(24)->Fill(xZNC, yZNC);
+ FillRawsData(20,xZNC, yZNC);
}
if(isZPCFired && indZPC==5){
- GetRawsData(2)->Fill(zpcSignal);
- GetRawsData(8)->Fill(zpcpmC, zpcSumQ);
- GetRawsData(16)->Fill(zpcSumQ);
+ FillRawsData(2,zpcSignal);
+ FillRawsData(12,zpcSumQ);
}
if(isZNAFired && indZNA==5){
- GetRawsData(1)->Fill(znaSignal);
- GetRawsData(7)->Fill(znapmC, znaSumQ);
- GetRawsData(15)->Fill(znaSumQ);
+ FillRawsData(1,znaSignal);
+ FillRawsData(11,znaSumQ);
//
Float_t xZNA, yZNA;
if(denZNA!=0){
yZNA = numYZNA/denZNA;
}
else xZNA = yZNA = 999.;
- GetRawsData(25)->Fill(xZNA, yZNA);
+ FillRawsData(21,xZNA, yZNA);
}
if(isZPAFired && indZPA==5){
- GetRawsData(3)->Fill(zpaSignal);
- GetRawsData(9)->Fill(zpapmC, zpaSumQ);
- GetRawsData(17)->Fill(zpaSumQ);
+ FillRawsData(3,zpaSignal);
+ FillRawsData(13,zpaSumQ);
}
if(indZNC==5){
for(Int_t iHit=0; iHit<10; iHit++){
if(zncTDC[iHit]!=-999.){
if(zncTDC[iHit]-tdcGate>-340. && zncTDC[iHit]-tdcGate<-300.)
- GetRawsData(21)->Fill(1, zncTDC[iHit]-tdcGate);
- //GetRawsData(23)->SetBinContent(1, GetRawsData(21)->GetBinContent(1));
+ FillRawsData(17,1, zncTDC[iHit]-tdcGate);
}
if(zpcTDC[iHit]!=-999.){
Float_t diffZPC = zpcTDC[iHit]-tdcGate;
- GetRawsData(19)->Fill(diffZPC);
- if(diffZPC>-340. && diffZPC<-300.) GetRawsData(21)->Fill(2, diffZPC);
- //GetRawsData(23)->SetBinContent(2, GetRawsData(21)->GetBinContent(3));
+ FillRawsData(15,diffZPC);
+ if(diffZPC>-340. && diffZPC<-300.) FillRawsData(17,2, diffZPC);
}
if(znaTDC[iHit]!=-999.){
if(znaTDC[iHit]-tdcGate>-340. && znaTDC[iHit]-tdcGate<-300.)
- GetRawsData(21)->Fill(3, znaTDC[iHit]-tdcGate);
- //GetRawsData(23)->SetBinContent(3, GetRawsData(21)->GetBinContent(5));
+ FillRawsData(17,3, znaTDC[iHit]-tdcGate);
}
if(zpaTDC[iHit]!=-999.){
if(zpaTDC[iHit]-tdcGate>-340. && zpaTDC[iHit]-tdcGate<-300.)
- GetRawsData(21)->Fill(4, zpaTDC[iHit]-tdcGate);
- //GetRawsData(23)->SetBinContent(4, GetRawsData(21)->GetBinContent(7));
+ FillRawsData(17,4, zpaTDC[iHit]-tdcGate);
}
if(zem1TDC[iHit]!=-999.){
Float_t diffZEM1 = zem1TDC[iHit]-tdcGate;
- GetRawsData(18)->Fill(diffZEM1);
- if(diffZEM1>-340. && diffZEM1<-300.) GetRawsData(21)->Fill(5, diffZEM1);
- //GetRawsData(23)->SetBinContent(5, GetRawsData(21)->GetBinContent(8));
+ FillRawsData(14,diffZEM1);
+ if(diffZEM1>-340. && diffZEM1<-300.) FillRawsData(17,5, diffZEM1);
}
if(zem2TDC[iHit]!=-999.){
if(zem2TDC[iHit]-tdcGate>-340. && zem2TDC[iHit]-tdcGate<-300.)
- GetRawsData(21)->Fill(6, zem2TDC[iHit]-tdcGate);
- //GetRawsData(23)->SetBinContent(6, GetRawsData(21)->GetBinContent(9));
+ FillRawsData(17,6, zem2TDC[iHit]-tdcGate);
}
if(zncSumTDC[iHit]!=-999.){
Float_t tdcC = zncSumTDC[iHit]-l0;
Float_t tdcA = znaSumTDC[iHit]-l0;
//if (((tdcC-tdcA-refDelta)*(tdcC-tdcA-refDelta)/(sigmaDelta*sigmaDelta) +
//(tdcC+tdcA-refSum)*(tdcC+tdcA-refSum)/(sigmaSum*sigmaSum))< 1.0)
- GetRawsData(26)->Fill(tdcC-tdcA,tdcC+tdcA);
+ FillRawsData(22,tdcC-tdcA,tdcC+tdcA);
}
}
// else{
// AliDebug(1,Form("Skipping non-physics event for QA -> event type %d \n", rawReader->GetType()));
// }
+//
+ IncEvCountCycleRaws();
+ IncEvCountTotalRaws();
+ //
}
//____________________________________________________________________________
sum_ZNA += reco.GetZP1HREnTow(i);
sum_ZPA += reco.GetZP2HREnTow(i);
if(i==0){
- GetRecPointsData(8)->Fill(reco.GetZN1HREnTow(i));
- GetRecPointsData(9)->Fill(reco.GetZN2HREnTow(i));
- GetRecPointsData(10)->Fill(reco.GetZP1HREnTow(i));
- GetRecPointsData(11)->Fill(reco.GetZP2HREnTow(i));
+ FillRecPointsData(8,reco.GetZN1HREnTow(i));
+ FillRecPointsData(9,reco.GetZN2HREnTow(i));
+ FillRecPointsData(10,reco.GetZP1HREnTow(i));
+ FillRecPointsData(11,reco.GetZP2HREnTow(i));
}
else{
sumQ_ZNC += reco.GetZN1HREnTow(i);
}
}
- GetRecPointsData(0)->Fill(sum_ZNC);
- GetRecPointsData(1)->Fill(sum_ZNA);
- GetRecPointsData(2)->Fill(sum_ZPC);
- GetRecPointsData(3)->Fill(sum_ZPA);
+ FillRecPointsData(0,sum_ZNC);
+ FillRecPointsData(1,sum_ZNA);
+ FillRecPointsData(2,sum_ZPC);
+ FillRecPointsData(3,sum_ZPA);
//
- GetRecPointsData(4)->Fill(sumQ_ZNC);
- GetRecPointsData(5)->Fill(sumQ_ZNA);
- GetRecPointsData(6)->Fill(sumQ_ZPC);
- GetRecPointsData(7)->Fill(sumQ_ZPA);
-
+ FillRecPointsData(4,sumQ_ZNC);
+ FillRecPointsData(5,sumQ_ZNA);
+ FillRecPointsData(6,sumQ_ZPC);
+ FillRecPointsData(7,sumQ_ZPA);
+ //
+ IncEvCountCycleRecPoints();
+ IncEvCountTotalRecPoints();
+ //
}
//____________________________________________________________________________
AliESDZDC * zdcESD = esd->GetESDZDC();
//
- TString beamType = esd->GetBeamType();
+ /*TString beamType = esd->GetBeamType();
Double_t centr_ZNC[2]={999.,999}, centr_ZNA[2]={999.,999};
if(((beamType.CompareTo("pp"))==0) || ((beamType.CompareTo("p-p"))==0)
||((beamType.CompareTo("PP"))==0) || ((beamType.CompareTo("P-P"))==0)){
zdcESD->GetZNCentroidInPbPb(beamEne, centr_ZNC, centr_ZNA);
}
else printf("\n WARNING!!! AliZDCQADataMakerRec::MakeESDs: can't calculate centroids for beam type: %s\n\n",beamType.Data());
- GetESDsData(0)->Fill(centr_ZNC[0], centr_ZNC[1]);
- GetESDsData(1)->Fill(centr_ZNA[0], centr_ZNA[1]);
-
- //
- GetESDsData(2)->Fill(esd->GetZDCN1Energy());
- GetESDsData(3)->Fill(esd->GetZDCN2Energy());
- GetESDsData(4)->Fill(esd->GetZDCP1Energy());
- GetESDsData(5)->Fill(esd->GetZDCP2Energy());
- GetESDsData(6)->Fill(esd->GetZDCEMEnergy(0));
- GetESDsData(7)->Fill(esd->GetZDCEMEnergy(1));
+ FillESDsData(0,centr_ZNC[0], centr_ZNC[1]);
+ FillESDsData(1,centr_ZNA[0], centr_ZNA[1]);*/
+
+ FillESDsData(0,esd->GetZDCN1Energy());
+ FillESDsData(1,esd->GetZDCN2Energy());
+ FillESDsData(2,esd->GetZDCP1Energy());
+ FillESDsData(3,esd->GetZDCP2Energy());
+ FillESDsData(4,esd->GetZDCEMEnergy(0));
+ FillESDsData(5,esd->GetZDCEMEnergy(1));
//
Double_t sumQZNC=0., sumQZPC=0., sumQZNA=0., sumQZPA=0.;
- Double_t sumQZNC_lg=0., sumQZPC_lg=0., sumQZNA_lg=0., sumQZPA_lg=0.;
+ //Double_t sumQZNC_lg=0., sumQZPC_lg=0., sumQZNA_lg=0., sumQZPA_lg=0.;
//
const Double_t *towZNC, *towZPC, *towZNA, *towZPA;
- const Double_t *towZNC_lg, *towZPC_lg, *towZNA_lg, *towZPA_lg;
+ //const Double_t *towZNC_lg, *towZPC_lg, *towZNA_lg, *towZPA_lg;
//
towZNC = zdcESD->GetZN1TowerEnergy();
towZPC = zdcESD->GetZP1TowerEnergy();
towZNA = zdcESD->GetZN2TowerEnergy();
towZPA = zdcESD->GetZP2TowerEnergy();
//
- towZNC_lg = zdcESD->GetZN1TowerEnergyLR();
+ /*towZNC_lg = zdcESD->GetZN1TowerEnergyLR();
towZPC_lg = zdcESD->GetZP1TowerEnergyLR();
towZNA_lg = zdcESD->GetZN2TowerEnergyLR();
- towZPA_lg = zdcESD->GetZP2TowerEnergyLR();
+ towZPA_lg = zdcESD->GetZP2TowerEnergyLR();*/
//
for(Int_t i=0; i<5; i++){
if(i==0){
- GetESDsData(12)->Fill(towZNC[i]);
- GetESDsData(13)->Fill(towZNA[i]);
- GetESDsData(14)->Fill(towZPC[i]);
- GetESDsData(15)->Fill(towZPA[i]);
- //
- GetESDsData(20)->Fill(towZNC_lg[i]);
- GetESDsData(21)->Fill(towZNA_lg[i]);
- GetESDsData(22)->Fill(towZPC_lg[i]);
- GetESDsData(23)->Fill(towZPA_lg[i]);
+ FillESDsData(10,towZNC[i]);
+ FillESDsData(11,towZNA[i]);
+ FillESDsData(12,towZPC[i]);
+ FillESDsData(13,towZPA[i]);
}
else{
sumQZNC += towZNC[i];
sumQZPC += towZPC[i];
sumQZNA += towZNA[i];
sumQZPA += towZPA[i];
- //
- sumQZNC_lg += towZNC_lg[i];
- sumQZPC_lg += towZPC_lg[i];
- sumQZNA_lg += towZNA_lg[i];
- sumQZPA_lg += towZPA_lg[i];
}
}
- GetESDsData(8)->Fill(sumQZNC);
- GetESDsData(9)->Fill(sumQZNA);
- GetESDsData(10)->Fill(sumQZPC);
- GetESDsData(11)->Fill(sumQZPA);
+ FillESDsData(6,sumQZNC);
+ FillESDsData(7,sumQZNA);
+ FillESDsData(8,sumQZPC);
+ FillESDsData(9,sumQZPA);
+ //
+ IncEvCountCycleESDs();
+ IncEvCountTotalESDs();
//
- GetESDsData(16)->Fill(sumQZNC_lg);
- GetESDsData(17)->Fill(sumQZNA_lg);
- GetESDsData(18)->Fill(sumQZPC_lg);
- GetESDsData(19)->Fill(sumQZPA_lg);
}
//____________________________________________________________________________
{
//Detector specific actions at end of cycle
// do the QA checking
- if( task == AliQAv1::kRAWS){
- if (!GetRawsData(20) || !GetRawsData(21) || !GetRawsData(24) || !GetRawsData(25)) {
- printf(" WARNING!!! AliZDCQADataMaker Rec -> Not all histogram for DQM found!\n");
- }
- else{
- for(Int_t ibin=1; ibin<=GetRawsData(20)->GetNbinsX(); ibin++){
- GetRawsData(22)->SetBinContent(ibin, GetRawsData(20)->GetBinContent(ibin));
- GetRawsData(22)->SetBinError(ibin, GetRawsData(20)->GetBinError(ibin));
- GetRawsData(22)->SetLineColor(kBlue); GetRawsData(22)->SetLineWidth(2);
- }
- for(Int_t ibin=1; ibin<=GetRawsData(21)->GetNbinsX(); ibin++){
- GetRawsData(23)->SetBinContent(ibin, GetRawsData(21)->GetBinContent(ibin));
- GetRawsData(23)->SetBinError(ibin, GetRawsData(21)->GetBinError(ibin));
- GetRawsData(23)->SetLineColor(kAzure-3); GetRawsData(23)->SetLineWidth(2);
- }
- }
- }
+ //
+ ResetEventTrigClasses();
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) { // RS: loop over event types
+ //
+ if (!IsValidEventSpecie(specie, list)) continue;
+ SetEventSpecie(AliRecoParam::ConvertIndex(specie));
+ //
+ for (int itc=-1;itc<GetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class
+ //
+ if( task == AliQAv1::kRAWS) {
+ TH1* h16 = GetRawsData(16, itc);
+ TH1* h17 = GetRawsData(17, itc);
+ TH1* h18 = GetRawsData(18, itc);
+ TH1* h19 = GetRawsData(19, itc);
+ // TH1* h20 = GetRawsData(20, itc);
+ // TH1* h21 = GetRawsData(21, itc);
+ if (!h16 || !h17 || !h18 || !h19) {
+ AliWarning("AliZDCQADataMaker Rec -> Not all histogram for DQM found!");
+ AliWarning(Form("for specie %s and trigger class %s",
+ AliRecoParam::GetEventSpecieName(specie), AliQADataMaker::GetTrigClassName(itc)));
+ }
+ else{
+ h16->Draw("");
+ for(Int_t ibin=1; ibin<=h16->GetNbinsX(); ibin++){
+ h18->SetBinContent(ibin, h16->GetBinContent(ibin));
+ h18->SetBinError(ibin, h16->GetBinError(ibin));
+ }
+ for(Int_t ibin=1; ibin<=h17->GetNbinsX(); ibin++){
+ h19->SetBinContent(ibin, h17->GetBinContent(ibin));
+ h19->SetBinError(ibin, h17->GetBinError(ibin));
+ }
+ h18->SetLineColor(kBlue); h18->SetLineWidth(2);
+ h19->SetLineColor(kAzure-3); h19->SetLineWidth(2);
+ }
+ }
+ } // loop over t
+ } // loop over species
AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list) ;
}
Add2HitsList(hHitsPMCZPC, 10, expert, !image);\r
Add2HitsList(hHitsPMCZPA, 11, expert, !image);\r
\r
- TH2F * hHitsZNCh = new TH2F("hHitsZNCh", "Hits centroid in ZNC;Centroid position [cm];Counts", 100, -5.,5.,100,-5.,5.);\r
- TH2F * hHitsZNAh = new TH2F("hHitsZNAh", "Hits centroid in ZNA;Centroid position [cm];Counts", 100, -5.,5.,100,-5.,5.);\r
- Add2HitsList(hHitsZNCh, 12, !expert, image);\r
- Add2HitsList(hHitsZNAh, 13, !expert, image);\r
- // NB -> For the moment no check is performesd on ZP centroids\r
- TH2F * hHitsZPCh = new TH2F("hHitsZPCh", "Hits centroid in ZPC;Centroid position [cm];Counts", 100,-12.,12.,100,-12.,12.); \r
- TH2F * hHitsZPAh = new TH2F("hHitsZPAh", "Hits centroid in ZPA;Centroid position [cm];Counts", 100,-12.,12.,100,-12.,12.); \r
- Add2HitsList(hHitsZPCh, 14, !expert, image);\r
- Add2HitsList(hHitsZPAh, 15, !expert, image);\r
+ ClonePerTrigClass(AliQAv1::kHITS); // this should be the last line\r
}\r
\r
\r
Add2DigitsList(hDigPMCZPC, 10, expert, !image);\r
Add2DigitsList(hDigPMCZPA, 11, expert, !image);\r
// \r
- // ------------------- LOW GAIN CHAIN ---------------------------\r
- TH1F * hDigZNCTotlg = new TH1F("hDigZNCTotlg", "Digit lg signal in ZNC", 100, 0., 6000.);\r
- TH1F * hDigZNATotlg = new TH1F("hDigZNATotlg", "Digit lg signal in ZNA", 100, 0., 6000.);\r
- TH1F * hDigZPCTotlg = new TH1F("hDigZPCTotlg", "Digit lg signal in ZPC", 100, 0., 6000.);\r
- TH1F * hDigZPATotlg = new TH1F("hDigZPATotlg", "Digit lg signal in ZPA", 100, 0., 6000.);\r
- Add2DigitsList(hDigZNCTotlg, 12, expert, !image);\r
- Add2DigitsList(hDigZNATotlg, 13, expert, !image);\r
- Add2DigitsList(hDigZPCTotlg, 14, expert, !image);\r
- Add2DigitsList(hDigZPATotlg, 15, expert, !image);\r
//\r
- TH1F * hDigSumQZNClg = new TH1F("hDigSumQZNClg", "Signal in 4 ZNC PMQlg",100, 0., 4000.);\r
- TH1F * hDigSumQZNAlg = new TH1F("hDigSumQZNAlg", "Signal in 4 ZNA PMQlg",100, 0., 4000.);\r
- TH1F * hDigSumQZPClg = new TH1F("hDigSumQZPClg", "Signal in 4 ZPC PMQlg",100, 0., 4000.);\r
- TH1F * hDigSumQZPAlg = new TH1F("hDigSumQZPAlg", "Signal in 4 ZPA PMQlg",100, 0., 4000.);\r
- Add2DigitsList(hDigSumQZNClg, 16, expert, !image);\r
- Add2DigitsList(hDigSumQZNAlg, 17, expert, !image);\r
- Add2DigitsList(hDigSumQZPClg, 18, expert, !image);\r
- Add2DigitsList(hDigSumQZPAlg, 19, expert, !image);\r
- //\r
- TH1F * hDigPMCZNClg = new TH1F("hDigPMCZNClg", "Signal in ZNC PMClg",100, 0., 4000.);\r
- TH1F * hDigPMCZNAlg = new TH1F("hDigPMCZNAlg", "Signal in ZNA PMClg",100, 0., 4000.);\r
- TH1F * hDigPMCZPClg = new TH1F("hDigPMCZPClg", "Signal in ZPC PMClg",100, 0., 4000.);\r
- TH1F * hDigPMCZPAlg = new TH1F("hDigPMCZPAlg", "Signal in ZPA PMClg",100, 0., 4000.);\r
- Add2DigitsList(hDigPMCZNClg, 20, expert, !image);\r
- Add2DigitsList(hDigPMCZNAlg, 21, expert, !image);\r
- Add2DigitsList(hDigPMCZPClg, 22, expert, !image);\r
- Add2DigitsList(hDigPMCZPAlg, 23, expert, !image);\r
-\r
+ ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line\r
}\r
\r
//____________________________________________________________________________\r
adcSumQ_ZNC += hit->GetLightPMQ();\r
adcSum_ZNC += hit->GetLightPMC() + hit->GetLightPMQ();\r
//\r
- GetHitsData(8)->Fill(hit->GetLightPMQ());\r
- //\r
- GetHitsData(12)->Fill(hit->GetXImpact(),hit->GetYImpact()); \r
+ FillHitsData(8,hit->GetLightPMC());\r
}\r
else if(hit->GetVolume(0)==4){\r
adcSumQ_ZNA += hit->GetLightPMQ();\r
adcSum_ZNA += hit->GetLightPMC() + hit->GetLightPMQ();\r
//\r
- GetHitsData(9)->Fill(hit->GetLightPMQ());\r
- //\r
- GetHitsData(13)->Fill(hit->GetXImpact(), hit->GetYImpact());\r
+ FillHitsData(9,hit->GetLightPMC());\r
}\r
else if(hit->GetVolume(0)==2){\r
adcSumQ_ZNC += hit->GetLightPMQ();\r
adcSum_ZNC += hit->GetLightPMC() + hit->GetLightPMQ();\r
//\r
- GetHitsData(10)->Fill(hit->GetLightPMQ());\r
- //\r
- GetHitsData(14)->Fill(hit->GetXImpact(), hit->GetYImpact());\r
+ FillHitsData(10,hit->GetLightPMC());\r
}\r
else if(hit->GetVolume(0)==5){\r
adcSumQ_ZNC += hit->GetLightPMQ();\r
adcSum_ZNC += hit->GetLightPMC() + hit->GetLightPMQ();\r
//\r
- GetHitsData(11)->Fill(hit->GetLightPMQ());\r
- //\r
- GetHitsData(15)->Fill(hit->GetXImpact(), hit->GetYImpact());\r
+ FillHitsData(11,hit->GetLightPMC());\r
}\r
//\r
- GetHitsData(0)->Fill(adcSum_ZNC);\r
- GetHitsData(1)->Fill(adcSum_ZNA);\r
- GetHitsData(2)->Fill(adcSum_ZPC);\r
- GetHitsData(3)->Fill(adcSum_ZPA);\r
+ FillHitsData(0,adcSum_ZNC);\r
+ FillHitsData(1,adcSum_ZNA);\r
+ FillHitsData(2,adcSum_ZPC);\r
+ FillHitsData(3,adcSum_ZPA);\r
//\r
- GetHitsData(4)->Fill(adcSumQ_ZNC);\r
- GetHitsData(5)->Fill(adcSumQ_ZNA);\r
- GetHitsData(6)->Fill(adcSumQ_ZPC);\r
- GetHitsData(7)->Fill(adcSumQ_ZPA);\r
+ FillHitsData(4,adcSumQ_ZNC);\r
+ FillHitsData(5,adcSumQ_ZNA);\r
+ FillHitsData(6,adcSumQ_ZPC);\r
+ FillHitsData(7,adcSumQ_ZPA);\r
}\r
}\r
\r
MakeHits() ; \r
fHitsArray->Clear() ; \r
} \r
-\r
+ //\r
+ IncEvCountCycleHits();\r
+ IncEvCountTotalHits();\r
+ //\r
}\r
\r
//___________________________________________________________________________\r
\r
Float_t adcSum_ZNC=0., adcSum_ZNA=0., adcSum_ZPC=0., adcSum_ZPA=0.;\r
Float_t adcSumQ_ZNC=0., adcSumQ_ZNA=0., adcSumQ_ZPC=0., adcSumQ_ZPA=0.;\r
- Float_t adcSum_ZNC_lg=0., adcSum_ZNA_lg=0., adcSum_ZPC_lg=0., adcSum_ZPA_lg=0.;\r
- Float_t adcSumQ_ZNC_lg=0., adcSumQ_ZNA_lg=0., adcSumQ_ZPC_lg=0., adcSumQ_ZPA_lg=0.;\r
+ // Float_t adcSum_ZNC_lg=0., adcSum_ZNA_lg=0., adcSum_ZPC_lg=0., adcSum_ZPA_lg=0.;\r
+ // Float_t adcSumQ_ZNC_lg=0., adcSumQ_ZNA_lg=0., adcSumQ_ZPC_lg=0., adcSumQ_ZPA_lg=0.;\r
\r
Int_t ndig = digitTree->GetEntries();\r
for(Int_t i=0; i<ndig; i++){\r
\r
if(digit->GetSector(0)==1 && digit->GetSector(1)!=5){\r
adcSum_ZNC += digit->GetADCValue(0);\r
- adcSum_ZNC_lg += digit->GetADCValue(1);\r
+ //adcSum_ZNC_lg += digit->GetADCValue(1);\r
//\r
if(digit->GetSector(1)!=0){\r
adcSumQ_ZNC += digit->GetADCValue(0);\r
- adcSumQ_ZNC_lg+= digit->GetADCValue(1);\r
+ //adcSumQ_ZNC_lg+= digit->GetADCValue(1);\r
}\r
else{\r
- GetDigitsData(8)->Fill(digit->GetADCValue(0));\r
- GetDigitsData(20)->Fill(digit->GetADCValue(1));\r
+ FillDigitsData(8,digit->GetADCValue(0));\r
+ //FillDigitsData(20,digit->GetADCValue(1));\r
}\r
}\r
else if(digit->GetSector(0)==2){\r
adcSum_ZPC += digit->GetADCValue(0);\r
- adcSum_ZPC_lg += digit->GetADCValue(1);\r
+ //adcSum_ZPC_lg += digit->GetADCValue(1);\r
//\r
if(digit->GetSector(1)!=0){\r
adcSumQ_ZPC += digit->GetADCValue(0);\r
- adcSumQ_ZPC_lg+= digit->GetADCValue(1);\r
+ //adcSumQ_ZPC_lg+= digit->GetADCValue(1);\r
}\r
else{\r
- GetDigitsData(10)->Fill(digit->GetADCValue(0));\r
- GetDigitsData(22)->Fill(digit->GetADCValue(1));\r
+ FillDigitsData(10,digit->GetADCValue(0));\r
+ //FillDigitsData(22,digit->GetADCValue(1));\r
}\r
}\r
else if(digit->GetSector(0)==4 && digit->GetSector(1)!=5){\r
adcSum_ZNA += digit->GetADCValue(0);\r
- adcSum_ZNA_lg += digit->GetADCValue(1);\r
+ //adcSum_ZNA_lg += digit->GetADCValue(1);\r
//\r
if(digit->GetSector(1)!=0){\r
adcSumQ_ZNA += digit->GetADCValue(0);\r
- adcSumQ_ZNA_lg+= digit->GetADCValue(1);\r
+ //adcSumQ_ZNA_lg+= digit->GetADCValue(1);\r
}\r
else{\r
- GetDigitsData(9)->Fill(digit->GetADCValue(0));\r
- GetDigitsData(21)->Fill(digit->GetADCValue(1));\r
+ FillDigitsData(9,digit->GetADCValue(0));\r
+ //FillDigitsData(21,digit->GetADCValue(1));\r
}\r
}\r
else if(digit->GetSector(0)==5){\r
adcSum_ZPA += digit->GetADCValue(0);\r
- adcSum_ZPA_lg += digit->GetADCValue(1);\r
+ //adcSum_ZPA_lg += digit->GetADCValue(1);\r
//\r
if(digit->GetSector(1)!=0){\r
adcSumQ_ZPA += digit->GetADCValue(0);\r
- adcSumQ_ZPA_lg+= digit->GetADCValue(1);\r
+ //adcSumQ_ZPA_lg+= digit->GetADCValue(1);\r
}\r
else{\r
- GetDigitsData(11)->Fill(digit->GetADCValue(0));\r
- GetDigitsData(23)->Fill(digit->GetADCValue(1));\r
+ FillDigitsData(11,digit->GetADCValue(0));\r
+ //FillDigitsData(23,digit->GetADCValue(1));\r
}\r
}\r
}\r
//\r
- GetDigitsData(0)->Fill(adcSum_ZNC);\r
- GetDigitsData(1)->Fill(adcSum_ZNA);\r
- GetDigitsData(2)->Fill(adcSum_ZPC);\r
- GetDigitsData(3)->Fill(adcSum_ZPA);\r
+ FillDigitsData(0,adcSum_ZNC);\r
+ FillDigitsData(1,adcSum_ZNA);\r
+ FillDigitsData(2,adcSum_ZPC);\r
+ FillDigitsData(3,adcSum_ZPA);\r
//\r
- GetDigitsData(4)->Fill(adcSumQ_ZNC);\r
- GetDigitsData(5)->Fill(adcSumQ_ZNA);\r
- GetDigitsData(6)->Fill(adcSumQ_ZPC);\r
- GetDigitsData(7)->Fill(adcSumQ_ZPA);\r
+ FillDigitsData(4,adcSumQ_ZNC);\r
+ FillDigitsData(5,adcSumQ_ZNA);\r
+ FillDigitsData(6,adcSumQ_ZPC);\r
+ FillDigitsData(7,adcSumQ_ZPA);\r
//\r
- GetDigitsData(12)->Fill(adcSum_ZNC_lg);\r
- GetDigitsData(13)->Fill(adcSum_ZNA_lg);\r
- GetDigitsData(14)->Fill(adcSum_ZPC_lg);\r
- GetDigitsData(15)->Fill(adcSum_ZPA_lg);\r
+ IncEvCountCycleDigits();\r
+ IncEvCountTotalDigits();\r
//\r
- GetDigitsData(16)->Fill(adcSumQ_ZNC_lg);\r
- GetDigitsData(17)->Fill(adcSumQ_ZNA_lg);\r
- GetDigitsData(18)->Fill(adcSumQ_ZPC_lg);\r
- GetDigitsData(19)->Fill(adcSumQ_ZPA_lg);\r
-\r
}\r
\r
//____________________________________________________________________________\r
{\r
// Detector specific actions at end of cycle\r
// do the QA checking\r
+ ResetEventTrigClasses();\r
AliQAChecker::Instance()->Run(AliQAv1::kZDC, task, list); \r
}\r