Produces the data needed to calculate the quality assurance.
All data must be mergeable objects.
P. Christiansen, Lund, January 2008
-*/
-/*
- Implementation:
+ Updated June 2010:
+ ==================
- We have chosen to have the histograms as non-persistent meber to
- allow better debugging. In the copy constructor we then have to
- assign the pointers to the existing histograms in the copied
- list. This have been implemented but not tested.
+ The "beautification" of the online DQM histograms have been moved to
+ an amore macro.
+
+ The per event RAW histograms have been modified in AliTPCdataQA and
+ the copies have therefore also been modified here.
+
+ The AliTPCdataQA can now be configured a bit from here: time bin
+ range (extended default range to 1-1000, event range at start:
+ 0-100000, 1000 events per bin). (At least the parameters are not
+ hardcoded:-)
+
+ Implementation:
+ ===============
For the QA of the RAW data we use the class, AliTPCdataQA, from the
existing TPC Calibration framework (which is more advanced than the
- standard QA framework) and extract the histograms at the end. This
- has been tested with zero-suppressed data. The Analyse method of the
- AliTPCdataQA class is called in the method, EndOfDetectorCycle, and
- there also: 1d histogram(s) are projected and added to the QA list.
-*/
-
-/*
- TODO:
- Sumw2 for RAW histogram(s)?
- RecPoints and ESD could have many more histograms
+ standard QA framework) and extract the histograms at the end. The
+ Analyse method of the AliTPCdataQA class is called in the method,
+ EndOfDetectorCycle, and there also: 1d histogram(s) are projected
+ and added to the QA list.
*/
#include "AliTPCQADataMakerRec.h"
#include <TClonesArray.h>
#include <TString.h>
#include <TSystem.h>
+#include <TBox.h>
+#include <TLine.h>
+#include <TAxis.h>
// --- Standard library ---
#include "AliESDtrack.h"
#include "AliLog.h"
#include "AliTPCCalPad.h"
+#include "AliTPCCalROC.h"
#include "AliTPCClustersRow.h"
#include "AliTPCclusterMI.h"
+#include "AliSimDigits.h"
+
ClassImp(AliTPCQADataMakerRec)
//____________________________________________________________________________
AliTPCQADataMakerRec::AliTPCQADataMakerRec() :
- AliQADataMakerRec(AliQA::GetDetName(AliQA::kTPC),
- "TPC Rec Quality Assurance Data Maker"),
- fTPCdataQA(0),
- fHistESDclusters(0),fHistESDratio(0), fHistESDpt(0),
- fHistRawsOccupancy(0),
- fHistRecPointsQmaxShort(0), fHistRecPointsQmaxMedium(0),
- fHistRecPointsQmaxLong(0), fHistRecPointsQShort(0),
- fHistRecPointsQMedium(0), fHistRecPointsQLong(0),
- fHistRecPointsRow(0)
+AliQADataMakerRec(AliQAv1::GetDetName(AliQAv1::kTPC),
+ "TPC Rec Quality Assurance Data Maker"),
+fTPCdataQA(NULL),
+fRawMaxEvents(100000),
+fRawEventsPerBin(1000),
+fRawFirstTimeBin(1),
+fRawLastTimeBin(1000)
{
// ctor
+ fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
+ fTPCdataQA[specie] = NULL ;
+
for(Int_t i = 0; i < 6; i++)
fMapping[i] = 0;
}
//____________________________________________________________________________
AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) :
AliQADataMakerRec(),
- fTPCdataQA(0),
- fHistESDclusters(0), //! Clusters per ESD track
- fHistESDratio(0), //! Ratio of clusters to findables
- fHistESDpt(0), //! Pt spectrum
-
- fHistRawsOccupancy(0),//! Pad occupancy (1 entry per pad)
-
- fHistRecPointsQmaxShort(0), //! Qmax (short pads)
- fHistRecPointsQmaxMedium(0),//! Qmax (medium pads)
- fHistRecPointsQmaxLong(0), //! Qmax (long pads)
- fHistRecPointsQShort(0), //! Q (short pads)
- fHistRecPointsQMedium(0), //! Q (medium pads)
- fHistRecPointsQLong(0), //! Q (long pads)
- fHistRecPointsRow(0) //! Row distribution
+ fTPCdataQA(NULL),
+ fRawMaxEvents(qadm.GetRawMaxEvents()),
+ fRawEventsPerBin(qadm.GetRawEventsPerBin()),
+ fRawFirstTimeBin(qadm.GetRawFirstTimeBin()),
+ fRawLastTimeBin(qadm.GetRawLastTimeBin())
{
//copy ctor
// Does not copy the calibration object, instead InitRaws have to be
SetName((const char*)qadm.GetName()) ;
SetTitle((const char*)qadm.GetTitle());
+ fTPCdataQA = new AliTPCdataQA*[AliRecoParam::kNSpecies] ;
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
+ fTPCdataQA[specie] = NULL ;
+
for(Int_t i = 0; i < 6; i++)
fMapping[i] = 0;
// Associate class histogram objects to the copies in the list
// Could also be done with the indexes
//
- fHistESDclusters = (TH1F*)fESDsQAList->FindObject("hESDclusters");
- fHistESDratio = (TH1F*)fESDsQAList->FindObject("hESDratio");
- fHistESDpt = (TH1F*)fESDsQAList->FindObject("hESDpt");
-
- fHistRawsOccupancy = (TH1F*)fRawsQAList->FindObject("hRawsOccupancy");
-
- fHistRecPointsQmaxShort =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsQmaxShort");
- fHistRecPointsQmaxMedium =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsQmaxMedium");
- fHistRecPointsQmaxLong =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsQmaxLong");
- fHistRecPointsQShort =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsQShort");
- fHistRecPointsQMedium =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsQMedium");
- fHistRecPointsQLong =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsQLong");
- fHistRecPointsRow =
- (TH1F*)fRecPointsQAList->FindObject("hRecPointsRow");
+
}
//__________________________________________________________________
AliTPCQADataMakerRec::~AliTPCQADataMakerRec()
{
// Destructor
- delete fTPCdataQA;
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++)
+ if ( fTPCdataQA[specie] != NULL )
+ delete fTPCdataQA[specie] ;
+ delete[] fTPCdataQA;
for(Int_t i = 0; i < 6; i++)
delete fMapping[i];
}
//____________________________________________________________________________
-void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArray * list)
+void AliTPCQADataMakerRec::EndOfDetectorCycle(AliQAv1::TASKINDEX_t task, TObjArray ** list)
{
//Detector specific actions at end of cycle
+
+ 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
- if(fTPCdataQA) { // do the final step of the QA for Raw data
-
- fTPCdataQA->Analyse(); // 31/1-08 Analyse is now protected against
+ fTPCdataQA[specie]->Analyse(); // 31/1-08 Analyse is now protected against
// RAW data files with no TPC data
-
- //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
- if(fTPCdataQA->GetNoThreshold()) {
- fHistRawsOccupancy = fTPCdataQA->GetNoThreshold()->MakeHisto1D(0, 1, -1);
- //Add2RawsList(fHistRawsOccupancy, 1);
+
+ 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 ( !histRawsOccupancy ||
+ !histRawsOccupancyVsSector ||
+ !histRawsNClustersPerEventVsSector ||
+ !histRawsQVsSector ||
+ !histRawsQmaxVsSector ||
+ !histRawsOccupancyVsEvent ||
+ !histRawsNclustersVsEvent ) {
+ 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();
+ 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++) {
+
+ 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));
+
+ if(nClusters>0) {
+
+ hNormNclusters->Fill(iSec,nClusters);
+ histRawsNClustersPerEventVsSector->Fill(iSec, nClusters);
+ histRawsQVsSector->Fill(iSec,
+ nClusters*qROC->GetValue(iRow, iPad));
+ histRawsQmaxVsSector->Fill(iSec,
+ nClusters*qmaxROC->GetValue(iRow, iPad));
+ }
+ }
+ }
+ } // 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()) {
+
+ 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++) {
+
+ histRawsOccupancyVsEvent->SetBinContent(bin, hQAOccVsEvent->GetBinContent(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;
+
+ }
}
}
-
- AliQAChecker::Instance()->Run(AliQA::kTPC, task, list) ;
+ AliQAChecker::Instance()->Run(AliQAv1::kTPC, task, list) ;
}
+
//____________________________________________________________________________
void AliTPCQADataMakerRec::InitESDs()
{
//create ESDs histograms in ESDs subdir
- fHistESDclusters =
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
+ TH1F * histESDclusters =
new TH1F("hESDclusters", "N TPC clusters per track; N clusters; Counts",
160, 0, 160);
- fHistESDclusters->Sumw2();
- Add2ESDsList(fHistESDclusters, 0);
+ histESDclusters->Sumw2();
+ Add2ESDsList(histESDclusters, KClusters, !expert, image);
- fHistESDratio =
+ TH1F * histESDratio =
new TH1F("hESDratio", "Ratio: TPC clusters / findable; Ratio: cluster/findable; Counts",
100, 0, 1);
- fHistESDratio->Sumw2();
- Add2ESDsList(fHistESDratio, 1);
+ histESDratio->Sumw2();
+ Add2ESDsList(histESDratio, kRatio, !expert, image);
- fHistESDpt =
+ TH1F * histESDpt =
new TH1F("hESDpt", "P_{T} distribution; p_{T} [GeV/c]; Counts",
50, 0, 5);
- fHistESDpt->Sumw2();
- Add2ESDsList(fHistESDpt, 2);
+ histESDpt->Sumw2();
+ Add2ESDsList(histESDpt, kPt, !expert, image);
}
//____________________________________________________________________________
// Laurent Aphecetche pointed out that the mapping was read from file
// for each event, so now we read in the map here and set if for
// the raw data qa
- fTPCdataQA = new AliTPCdataQA();
- LoadMaps(); // Load Altro maps
- fTPCdataQA->SetAltroMapping(fMapping); // set Altro mapping
- fTPCdataQA->SetRangeTime(100, 920); // set time bin interval
+ const Bool_t expert = kTRUE ;
+ const Bool_t saveCorr = kTRUE ;
+ const Bool_t image = kTRUE ;
+
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+
+ // It might happen that we will be in this method a few times because
+ // we create all dataQAs at the first call to this method
+ if(fTPCdataQA[specie]!=0) // data QA already created
+ continue;
- Add2RawsList(fTPCdataQA, 0);
+ fTPCdataQA[specie] =
+ new AliTPCdataQA(AliRecoParam::ConvertIndex(specie));
+ LoadMaps(); // Load Altro maps
+ fTPCdataQA[specie]->SetAltroMapping(fMapping); // set Altro mapping
+ fTPCdataQA[specie]->SetRangeTime(fRawFirstTimeBin, fRawLastTimeBin); // set time bin interval
+ fTPCdataQA[specie]->SetMaxEvents(fRawMaxEvents);
+ fTPCdataQA[specie]->SetEventsPerBin(fRawEventsPerBin);
+// Add2RawsList(fTPCdataQA, kTPCdataQ, !expert, image, !saveCorrA); // This is used by the AMORE monitoring <------- THIS WILL FAIL (YS)
+ }
+
+ TH1F * histRawsOccupancy =
+ new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts",
+ 100, 0, 1);
+ histRawsOccupancy->Sumw2();
+ Add2RawsList(histRawsOccupancy, kRawsOccupancy, expert, !image, !saveCorr);
+
+ TH1F * histRawsOccupancyVsSector =
+ new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy",
+ 72, 0, 72);
+ histRawsOccupancyVsSector->Sumw2();
+ histRawsOccupancyVsSector->SetMarkerStyle(20);
+ histRawsOccupancyVsSector->SetOption("P");
+ histRawsOccupancyVsSector->SetStats(kFALSE);
+ Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, !expert, image, !saveCorr);
+
+ TH1F * histRawsNClustersPerEventVsSector =
+ new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event",
+ 72, 0, 72);
+ histRawsNClustersPerEventVsSector->Sumw2();
+ Add2RawsList(histRawsNClustersPerEventVsSector, kRawsNClustersPerEventVsSector, expert, !image, !saveCorr);
+
+ TH1F * histRawsQVsSector =
+ new TH1F("hRawsQVsSector", "<Q> vs sector; Sector; <Q>",
+ 72, 0, 72);
+ histRawsQVsSector->Sumw2();
+ Add2RawsList(histRawsQVsSector, kRawsQVsSector, expert, !image, !saveCorr);
+
+ TH1F * histRawsQmaxVsSector =
+ new TH1F("hRawsQmaxVsSector", "<Qmax> vs sector; Sector; <Qmax>",
+ 72, 0, 72);
+ histRawsQmaxVsSector->Sumw2();
+ histRawsQmaxVsSector->SetMarkerStyle(20);
+ histRawsQmaxVsSector->SetOption("P");
+ histRawsQmaxVsSector->SetStats(kFALSE);
+ Add2RawsList(histRawsQmaxVsSector, kRawsQmaxVsSector, !expert, image, !saveCorr);
+
+ // Get histogram information from data QA to build copy
+ const TH1F* hOccHelp = fTPCdataQA[0]->GetHistOccupancyVsEvent();
+ TH1F * histRawsOccupancyVsEvent =
+ CreateEventsHistCopy(hOccHelp, "hRawsOccupancyVsEvent");
+ Add2RawsList(histRawsOccupancyVsEvent, kRawsOccupancyVsEvent, expert, !image, !saveCorr);
+
+ // Get histogram information from data QA to build copy
+ const TH1F* hNclHelp = fTPCdataQA[0]->GetHistNclustersVsEvent();
+ TH1F * histRawsNclustersVsEvent =
+ CreateEventsHistCopy(hNclHelp, "hRawsNclustersVsEvent");
+ Add2RawsList(histRawsNclustersVsEvent, kRawsNclustersVsEvent, expert, !image, !saveCorr);
+}
+
+//____________________________________________________________________________
+void AliTPCQADataMakerRec::InitDigits()
+{
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+ TH1F * histDigitsADC =
+ new TH1F("hDigitsADC", "Digit ADC distribution; ADC; Counts",
+ 1000, 0, 1000);
+ histDigitsADC->Sumw2();
+ Add2DigitsList(histDigitsADC, kDigitsADC, !expert, image);
}
//____________________________________________________________________________
void AliTPCQADataMakerRec::InitRecPoints()
{
- fHistRecPointsQmaxShort =
+ const Bool_t expert = kTRUE ;
+ const Bool_t image = kTRUE ;
+
+ TH1F * histRecPointsQmaxShort =
new TH1F("hRecPointsQmaxShort", "Qmax distrbution (short pads); Qmax; Counts",
- 200, 0, 1000);
- fHistRecPointsQmaxShort->Sumw2();
- Add2RecPointsList(fHistRecPointsQmaxShort, 0);
+ 100, 0, 300);
+ histRecPointsQmaxShort->Sumw2();
+ Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort, !expert, image);
- fHistRecPointsQmaxMedium =
+ TH1F * histRecPointsQmaxMedium =
new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts",
- 200, 0, 1000);
- fHistRecPointsQmaxMedium->Sumw2();
- Add2RecPointsList(fHistRecPointsQmaxMedium, 1);
+ 100, 0, 300);
+ histRecPointsQmaxMedium->Sumw2();
+ Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium, !expert, image);
- fHistRecPointsQmaxLong =
+ TH1F * histRecPointsQmaxLong =
new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts",
- 200, 0, 1000);
- fHistRecPointsQmaxLong->Sumw2();
- Add2RecPointsList(fHistRecPointsQmaxLong, 2);
+ 100, 0, 300);
+ histRecPointsQmaxLong->Sumw2();
+ Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong, !expert, image);
- fHistRecPointsQShort =
+ TH1F * histRecPointsQShort =
new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts",
- 200, 0, 5000);
- fHistRecPointsQShort->Sumw2();
- Add2RecPointsList(fHistRecPointsQShort, 3);
+ 100, 0, 2000);
+ histRecPointsQShort->Sumw2();
+ Add2RecPointsList(histRecPointsQShort, kQShort, !expert, image);
- fHistRecPointsQMedium =
+ TH1F * histRecPointsQMedium =
new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts",
- 200, 0, 5000);
- fHistRecPointsQMedium->Sumw2();
- Add2RecPointsList(fHistRecPointsQMedium, 4);
+ 100, 0, 2000);
+ histRecPointsQMedium->Sumw2();
+ Add2RecPointsList(histRecPointsQMedium, kQMedium, !expert, image);
- fHistRecPointsQLong =
+ TH1F * histRecPointsQLong =
new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts",
- 200, 0, 5000);
- fHistRecPointsQLong->Sumw2();
- Add2RecPointsList(fHistRecPointsQLong, 5);
+ 100, 0, 2000);
+ histRecPointsQLong->Sumw2();
+ Add2RecPointsList(histRecPointsQLong, kQLong, !expert, image);
- fHistRecPointsRow =
+ TH1F * histRecPointsRow =
new TH1F("hRecPointsRow", "Clusters per row; Row; Counts",
159, 0, 159);
- fHistRecPointsRow->Sumw2();
- Add2RecPointsList(fHistRecPointsRow, 6);
+ histRecPointsRow->Sumw2();
+ Add2RecPointsList(histRecPointsRow, kRow, !expert, image);
}
//____________________________________________________________________________
void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd)
{
// make QA data from ESDs
-
+
const Int_t nESDTracks = esd->GetNumberOfTracks();
Int_t nTPCtracks = 0;
for(Int_t i = 0; i < nESDTracks; i++) {
Int_t nTPCclusters = track->GetTPCNcls();
Int_t nTPCclustersFindable = track->GetTPCNclsF();
-
- fHistESDclusters->Fill(nTPCclusters);
- fHistESDratio->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
- fHistESDpt->Fill(track->Pt());
+ if ( nTPCclustersFindable<=0) continue;
+ GetESDsData(KClusters)->Fill(nTPCclusters);
+ GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable));
+ GetESDsData(kPt)->Fill(track->Pt());
}
}
// To make QA for the RAW data we use the TPC Calibration framework
// to handle the data and then in the end extract the data
//
- fTPCdataQA->ProcessEvent(rawReader);
+
+ GetRawsData(0); // dummy call to init raw data
+ rawReader->Reset() ;
+ if (! fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)] ) {
+ AliError("Something unexpected here!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!") ;
+ } else {
+ fTPCdataQA[AliRecoParam::AConvert(fEventSpecie)]->ProcessEvent(rawReader);
+ }
}
//____________________________________________________________________________
-void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
+void AliTPCQADataMakerRec::MakeDigits(TTree* digitTree)
{
- AliTPCClustersRow *clrow = new AliTPCClustersRow();
- clrow->SetClass("AliTPCclusterMI");
- clrow->SetArray(0);
- clrow->GetArray()->ExpandCreateFast(10000);
+
+ TBranch* branch = digitTree->GetBranch("Segment");
+ AliSimDigits* digArray = 0;
+ branch->SetAddress(&digArray);
+
+ Int_t nEntries = Int_t(digitTree->GetEntries());
+
+ for (Int_t n = 0; n < nEntries; n++) {
+
+ digitTree->GetEvent(n);
+
+ if (digArray->First())
+ do {
+ Float_t dig = digArray->CurrentDigit();
+
+ GetDigitsData(kDigitsADC)->Fill(dig);
+ } while (digArray->Next());
+ }
+}
- TBranch* branch = recTree->GetBranch("Segment");
+//____________________________________________________________________________
+void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree)
+{
+
+ AliTPCClustersRow* clrow = 0x0;
+ TBranch* branch = recTree->GetBranch("Segment");
branch->SetAddress(&clrow);
+ TClonesArray * clarray = 0x0;
const Int_t nEntries = Int_t(recTree->GetEntries());
for (Int_t i = 0; i < nEntries; i++) {
branch->GetEntry(i);
-
- const Int_t nClusters = clrow->GetArray()->GetEntriesFast();
+
+ clarray = clrow->GetArray();
+
+ if (!clarray) continue;
+
+ const Int_t nClusters = clarray->GetEntriesFast();
for (Int_t icl=0; icl < nClusters; icl++){
AliTPCclusterMI* cluster =
- (AliTPCclusterMI*)clrow->GetArray()->At(icl);
+ (AliTPCclusterMI*)clarray->At(icl);
Float_t Qmax = cluster->GetMax();
Float_t Q = cluster->GetQ();
if(cluster->GetDetector()<36) { // IROC (short pads)
- fHistRecPointsQmaxShort->Fill(Qmax);
- fHistRecPointsQShort->Fill(Q);
+ GetRecPointsData(kQmaxShort)->Fill(Qmax);
+ GetRecPointsData(kQShort)->Fill(Q);
} else { // OROC (medium and long pads)
row += 63;
if(cluster->GetRow()<64) { // medium pads
- fHistRecPointsQmaxMedium->Fill(Qmax);
- fHistRecPointsQMedium->Fill(Q);
+ GetRecPointsData(kQmaxMedium)->Fill(Qmax);
+ GetRecPointsData(kQMedium)->Fill(Q);
} else { // long pads
- fHistRecPointsQmaxLong->Fill(Qmax);
- fHistRecPointsQLong->Fill(Q);
+ GetRecPointsData(kQmaxLong)->Fill(Qmax);
+ GetRecPointsData(kQLong)->Fill(Q);
}
}
- fHistRecPointsRow->Fill(row);
+ GetRecPointsData(kRow)->Fill(row);
} // end loop over clusters
} // end loop over tree
-
- delete clrow;
}
//____________________________________________________________________________
path += "/TPC/mapping/Patch";
for(Int_t i = 0; i < 6; i++) {
+
+ if(fMapping[i]!=0) // mapping already loaded
+ continue;
TString path2 = path;
path2 += i;
path2 += ".data";
}
}
+//____________________________________________________________________________
+void AliTPCQADataMakerRec::ResetDetector(AliQAv1::TASKINDEX_t task)
+{
+ // Overwrites general method for RAW data.
+ // The AliTPCdataQA elements that does the internal processing are
+ // in the case they have processed data deleted and new are created
+
+ if ( task != AliQAv1::kRAWS )
+ AliQADataMakerRec::ResetDetector(task);
+
+ for (Int_t specie = 0 ; specie < AliRecoParam::kNSpecies ; specie++) {
+
+ if ( fTPCdataQA[specie] != NULL) { // exist
+
+ if(fTPCdataQA[specie]->GetEventCounter()>0) { // has processed data
+
+ // old configuration
+ Int_t firstTime = fTPCdataQA[specie]->GetFirstTimeBin();
+ Int_t lastTime = fTPCdataQA[specie]->GetLastTimeBin();
+ Int_t minADC = fTPCdataQA[specie]->GetAdcMin();
+ Int_t maxADC = fTPCdataQA[specie]->GetAdcMax();
+
+ //delete old
+ delete fTPCdataQA[specie];
+
+ // create new
+ fTPCdataQA[specie] = new AliTPCdataQA(AliRecoParam::ConvertIndex(specie));
+ // configure new
+ LoadMaps(); // Load Altro maps
+ fTPCdataQA[specie]->SetAltroMapping(fMapping);
+ fTPCdataQA[specie]->SetRangeTime(firstTime, lastTime);
+ fTPCdataQA[specie]->SetRangeAdc(minADC, maxADC);
+ // Here we want to restore the default configuration because
+ // the max events and events are adjusted for the last run
+ fTPCdataQA[specie]->SetMaxEvents(fRawMaxEvents);
+ fTPCdataQA[specie]->SetEventsPerBin(fRawEventsPerBin);
+ }
+ }
+ }
+}
+
+//____________________________________________________________________________
+TH1F* AliTPCQADataMakerRec::CreateEventsHistCopy(const TH1F* hist,
+ const Char_t* copyName)
+{
+ // This method is used to create a copy of the event histograms
+
+ TH1F* histCopy = new TH1F(copyName, hist->GetTitle(),
+ hist->GetXaxis()->GetNbins(),
+ hist->GetXaxis()->GetXmin(),
+ hist->GetXaxis()->GetXmax());
+ histCopy->GetXaxis()->SetTitle(hist->GetXaxis()->GetTitle());
+ histCopy->GetYaxis()->SetTitle(hist->GetYaxis()->GetTitle());
+ histCopy->SetMarkerStyle(20);
+ histCopy->SetOption("P");
+ histCopy->SetStats(kFALSE);
+
+ return histCopy;
+}