X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCQADataMakerRec.cxx;h=f6358435cf0678d0cbf323ca85becbadbb92f24f;hb=b3849ff32a9559a0639dd295e964d37c857f3692;hp=96423d3b2e059d89489f5012dde5531d130ab1a7;hpb=12ed89e4b950651dbebecf42cd2833ddb726a310;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCQADataMakerRec.cxx b/TPC/AliTPCQADataMakerRec.cxx index 96423d3b2e0..f6358435cf0 100644 --- a/TPC/AliTPCQADataMakerRec.cxx +++ b/TPC/AliTPCQADataMakerRec.cxx @@ -21,28 +21,30 @@ Produces the data needed to calculate the quality assurance. All data must be mergeable objects. P. Christiansen, Lund, January 2008 -*/ -/* - Implementation: + Updated June 2010: + ================== + + 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:-) - 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. + 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" @@ -51,6 +53,9 @@ #include #include #include +#include +#include +#include // --- Standard library --- @@ -63,24 +68,26 @@ #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), fHistRawsOccupancyVsSector(0), - fHistRawsNClustersPerEventVsSector(0), fHistRawsQVsSector(0), - fHistRawsQmaxVsSector(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; } @@ -88,15 +95,11 @@ AliTPCQADataMakerRec::AliTPCQADataMakerRec() : //____________________________________________________________________________ AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) : AliQADataMakerRec(), - fTPCdataQA(0), - fHistESDclusters(0),fHistESDratio(0), fHistESDpt(0), - fHistRawsOccupancy(0), fHistRawsOccupancyVsSector(0), - fHistRawsNClustersPerEventVsSector(0), fHistRawsQVsSector(0), - fHistRawsQmaxVsSector(0), - fHistRecPointsQmaxShort(0), fHistRecPointsQmaxMedium(0), - fHistRecPointsQmaxLong(0), fHistRecPointsQShort(0), - fHistRecPointsQMedium(0), fHistRecPointsQLong(0), - fHistRecPointsRow(0) + 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 @@ -104,6 +107,10 @@ AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) : 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; @@ -111,32 +118,7 @@ AliTPCQADataMakerRec::AliTPCQADataMakerRec(const AliTPCQADataMakerRec& qadm) : // 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"); - fHistRawsOccupancyVsSector = - (TH1F*)fRawsQAList->FindObject("hRawsOccupancyVsSector"); - fHistRawsNClustersPerEventVsSector = - (TH1F*)fRawsQAList->FindObject("hRawsNClustersPerEventVsSector"); - fHistRawsQVsSector = (TH1F*)fRawsQAList->FindObject("hRawsQVsSector"); - fHistRawsQmaxVsSector = (TH1F*)fRawsQAList->FindObject("hRawsQmaxVsSector"); - - 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"); + } //__________________________________________________________________ @@ -152,119 +134,168 @@ AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerR 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 - const Int_t eventCounter = fTPCdataQA->GetEventCounter(); - if(eventCounter>0) { // some TPC data has been processed - - // Reset histograms and refill them - fHistRawsOccupancy->Reset(); - fHistRawsOccupancyVsSector->Reset(); - fHistRawsNClustersPerEventVsSector->Reset(); - fHistRawsQVsSector->Reset(); - fHistRawsQmaxVsSector->Reset(); + + 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* hNorm72 = new TH1F("hNorm72", "histogram to normalize 72 sectors", - 72, 0, 72); - hNorm72->Sumw2(); - TH1F* hNorm108 = new TH1F("hNorm108", "histogram to normalize 108 sectors (medium and long pads are split up)", - 108, 0, 108); - hNorm108->Sumw2(); - - for (Int_t iSec = 0; iSec < 72; iSec++) { - - AliTPCCalROC* occupancyROC = - fTPCdataQA->GetNoThreshold()->GetCalROC(iSec); - AliTPCCalROC* nclusterROC = - fTPCdataQA->GetNLocalMaxima()->GetCalROC(iSec); - AliTPCCalROC* qROC = - fTPCdataQA->GetMeanCharge()->GetCalROC(iSec); - AliTPCCalROC* qmaxROC = - fTPCdataQA->GetMaxCharge()->GetCalROC(iSec); - - const Int_t nRows = occupancyROC->GetNrows(); - for (Int_t iRow = 0; iRow < nRows; iRow++) { - - Int_t helpSector = iSec; - if(iRow>=64) - helpSector += 36; // OROC (long pads) - - const Int_t nPads = occupancyROC->GetNPads(iRow); - for (Int_t iPad = 0; iPad < nPads; iPad++) { + 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++) { - fHistRawsOccupancy->Fill(occupancyROC->GetValue(iRow, iPad)); - hNorm72->Fill(iSec); - fHistRawsOccupancyVsSector - ->Fill(iSec, occupancyROC->GetValue(iRow, iPad)); - - const Int_t nClusters = TMath::Nint(nclusterROC->GetValue(iRow, iPad)); - - if(nClusters>0) { + 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++) { - fHistRawsNClustersPerEventVsSector->Fill(iSec, nClusters); - hNorm108->Fill(helpSector, nClusters); - fHistRawsQVsSector->Fill(helpSector, - nClusters*qROC->GetValue(iRow, iPad)); - fHistRawsQmaxVsSector->Fill(helpSector, - nClusters*qmaxROC->GetValue(iRow, iPad)); - } - } - } - } // end loop over sectors + 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 - // Normalize histograms - fHistRawsOccupancyVsSector->Divide(hNorm72); - fHistRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter)); - fHistRawsQVsSector->Divide(hNorm108); - fHistRawsQmaxVsSector->Divide(hNorm108); - delete hNorm72; - delete hNorm108; - + // 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); } //____________________________________________________________________________ @@ -278,94 +309,142 @@ void AliTPCQADataMakerRec::InitRaws() // 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 - Add2RawsList(fTPCdataQA, 0); // This is used by the AMORE monitoring + 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; + + 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) + } - fHistRawsOccupancy = + TH1F * histRawsOccupancy = new TH1F("hRawsOccupancy", "Occupancy (all pads); Occupancy; Counts", 100, 0, 1); - fHistRawsOccupancy->Sumw2(); - Add2RawsList(fHistRawsOccupancy, 1); - - fHistRawsOccupancyVsSector = + histRawsOccupancy->Sumw2(); + Add2RawsList(histRawsOccupancy, kRawsOccupancy, expert, !image, !saveCorr); + + TH1F * histRawsOccupancyVsSector = new TH1F("hRawsOccupancyVsSector", "Occupancy vs sector; Sector; Occupancy", 72, 0, 72); - fHistRawsOccupancyVsSector->Sumw2(); - Add2RawsList(fHistRawsOccupancyVsSector, 2); + histRawsOccupancyVsSector->Sumw2(); + histRawsOccupancyVsSector->SetMarkerStyle(20); + histRawsOccupancyVsSector->SetOption("P"); + histRawsOccupancyVsSector->SetStats(kFALSE); + Add2RawsList(histRawsOccupancyVsSector, kRawsOccupancyVsSector, !expert, image, !saveCorr); - fHistRawsNClustersPerEventVsSector = + TH1F * histRawsNClustersPerEventVsSector = new TH1F("hRawsNClustersPerEventVsSector", "Nclusters per event vs sector; Sector; Nclusters per event", 72, 0, 72); - fHistRawsNClustersPerEventVsSector->Sumw2(); - Add2RawsList(fHistRawsNClustersPerEventVsSector, 3); + histRawsNClustersPerEventVsSector->Sumw2(); + Add2RawsList(histRawsNClustersPerEventVsSector, kRawsNClustersPerEventVsSector, expert, !image, !saveCorr); + + TH1F * histRawsQVsSector = + new TH1F("hRawsQVsSector", " vs sector; Sector; ", + 72, 0, 72); + histRawsQVsSector->Sumw2(); + Add2RawsList(histRawsQVsSector, kRawsQVsSector, expert, !image, !saveCorr); + + TH1F * histRawsQmaxVsSector = + new TH1F("hRawsQmaxVsSector", " vs sector; Sector; ", + 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); - fHistRawsQVsSector = - new TH1F("hRawsQVsSector", " vs sector (OROC med: 36-71, long: 72-107); Sector; ", - 108, 0, 108); - fHistRawsQVsSector->Sumw2(); - Add2RawsList(fHistRawsQVsSector, 4); - - fHistRawsQmaxVsSector = - new TH1F("hRawsQmaxVsSector", " vs sector (OROC med: 36-71, long: 72-107); Sector; ", - 108, 0, 108); - fHistRawsQmaxVsSector->Sumw2(); - Add2RawsList(fHistRawsQmaxVsSector, 5); + // 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", 100, 0, 300); - fHistRecPointsQmaxShort->Sumw2(); - Add2RecPointsList(fHistRecPointsQmaxShort, 0); + histRecPointsQmaxShort->Sumw2(); + Add2RecPointsList(histRecPointsQmaxShort, kQmaxShort, !expert, image); - fHistRecPointsQmaxMedium = + TH1F * histRecPointsQmaxMedium = new TH1F("hRecPointsQmaxMedium", "Qmax distrbution (medium pads); Qmax; Counts", 100, 0, 300); - fHistRecPointsQmaxMedium->Sumw2(); - Add2RecPointsList(fHistRecPointsQmaxMedium, 1); + histRecPointsQmaxMedium->Sumw2(); + Add2RecPointsList(histRecPointsQmaxMedium, kQmaxMedium, !expert, image); - fHistRecPointsQmaxLong = + TH1F * histRecPointsQmaxLong = new TH1F("hRecPointsQmaxLong", "Qmax distrbution (long pads); Qmax; Counts", 100, 0, 300); - fHistRecPointsQmaxLong->Sumw2(); - Add2RecPointsList(fHistRecPointsQmaxLong, 2); + histRecPointsQmaxLong->Sumw2(); + Add2RecPointsList(histRecPointsQmaxLong, kQmaxLong, !expert, image); - fHistRecPointsQShort = + TH1F * histRecPointsQShort = new TH1F("hRecPointsQShort", "Q distrbution (short pads); Q; Counts", 100, 0, 2000); - fHistRecPointsQShort->Sumw2(); - Add2RecPointsList(fHistRecPointsQShort, 3); + histRecPointsQShort->Sumw2(); + Add2RecPointsList(histRecPointsQShort, kQShort, !expert, image); - fHistRecPointsQMedium = + TH1F * histRecPointsQMedium = new TH1F("hRecPointsQMedium", "Q distrbution (medium pads); Q; Counts", 100, 0, 2000); - fHistRecPointsQMedium->Sumw2(); - Add2RecPointsList(fHistRecPointsQMedium, 4); + histRecPointsQMedium->Sumw2(); + Add2RecPointsList(histRecPointsQMedium, kQMedium, !expert, image); - fHistRecPointsQLong = + TH1F * histRecPointsQLong = new TH1F("hRecPointsQLong", "Q distrbution (long pads); Q; Counts", 100, 0, 2000); - fHistRecPointsQLong->Sumw2(); - Add2RecPointsList(fHistRecPointsQLong, 5); + 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++) { @@ -380,9 +459,9 @@ void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd) Int_t nTPCclusters = track->GetTPCNcls(); Int_t nTPCclustersFindable = track->GetTPCNclsF(); if ( nTPCclustersFindable<=0) continue; - fHistESDclusters->Fill(nTPCclusters); - fHistESDratio->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable)); - fHistESDpt->Fill(track->Pt()); + GetESDsData(KClusters)->Fill(nTPCclusters); + GetESDsData(kRatio)->Fill(Float_t(nTPCclusters)/Float_t(nTPCclustersFindable)); + GetESDsData(kPt)->Fill(track->Pt()); } } @@ -393,31 +472,62 @@ void AliTPCQADataMakerRec::MakeRaws(AliRawReader* rawReader) // 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 // - rawReader->Reset() ; - 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(); @@ -425,26 +535,24 @@ void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree) 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; } //____________________________________________________________________________ @@ -454,6 +562,9 @@ void AliTPCQADataMakerRec::LoadMaps() 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"; @@ -461,3 +572,62 @@ void AliTPCQADataMakerRec::LoadMaps() } } +//____________________________________________________________________________ +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; +}