X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=TPC%2FAliTPCQADataMakerRec.cxx;h=f49be1a2daae00d937a2a2ecc2f4bc6128fd6d57;hb=bf74e6db589d0589575d5d90ca46a8defc58e86f;hp=674a55d0fd556d62f8e7cb0fe906e7fdcb851585;hpb=c75bf2f1d97fa5ad59cf013b8ce8b0f4ecca8d14;p=u%2Fmrichter%2FAliRoot.git diff --git a/TPC/AliTPCQADataMakerRec.cxx b/TPC/AliTPCQADataMakerRec.cxx index 674a55d0fd5..f49be1a2daa 100644 --- a/TPC/AliTPCQADataMakerRec.cxx +++ b/TPC/AliTPCQADataMakerRec.cxx @@ -49,6 +49,9 @@ // --- ROOT system --- #include +#include +#include +#include // --- Standard library --- @@ -58,29 +61,40 @@ #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), + fBeautifyOption(1), // 0:no beautify, !=0:beautify RAW + fOccHighLimit(1e-4), // high limit for accepting occupancy values + fQmaxLowLimit(8), // low limit for accepting Qmax values + fQmaxHighLimit(40) // high limit for accepting Qmax values { // 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() + AliQADataMakerRec(), + fTPCdataQA(NULL), + fBeautifyOption(qadm.GetBeautifyOption()), + fOccHighLimit(qadm.GetOccHighLimit()), + fQmaxLowLimit(qadm.GetQmaxLowLimit()), + fQmaxHighLimit(qadm.GetQmaxHighLimit()) { //copy ctor // Does not copy the calibration object, instead InitRaws have to be @@ -88,30 +102,18 @@ 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; + // // 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"); + } //__________________________________________________________________ @@ -122,110 +124,398 @@ AliTPCQADataMakerRec& AliTPCQADataMakerRec::operator = (const AliTPCQADataMakerR new(this) AliTPCQADataMakerRec(qadm); return *this; } + +//__________________________________________________________________ +AliTPCQADataMakerRec::~AliTPCQADataMakerRec() +{ + // Destructor + 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 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 - - // 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, 0); + + 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 + TH1F* hQAOccVsEvent = fTPCdataQA[specie]->GetHistOccupancyVsEvent(); + TH1F* hQANclVsEvent = fTPCdataQA[specie]->GetHistNclustersVsEvent(); + + // 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)); + } + + histRawsOccupancyVsEvent->GetXaxis()->SetRange(hQAOccVsEvent->GetXaxis()->GetFirst(), hQAOccVsEvent->GetXaxis()->GetLast()); + histRawsNclustersVsEvent->GetXaxis()->SetRange(hQANclVsEvent->GetXaxis()->GetFirst(), hQANclVsEvent->GetXaxis()->GetLast()); + + // Normalize histograms + histRawsOccupancyVsSector->Divide(hNormOcc); + histRawsNClustersPerEventVsSector->Scale(1.0/Float_t(eventCounter)); + histRawsQVsSector->Divide(hNormNclusters); + histRawsQmaxVsSector->Divide(hNormNclusters); + delete hNormOcc; + delete hNormNclusters; + + if(fBeautifyOption!=0) { + // Help make the histogram easier to interpret for the DQM shifter + + histRawsOccupancyVsSector->ResetBit(AliQAv1::GetQABit()); + histRawsQmaxVsSector->ResetBit(AliQAv1::GetQABit()); + + histRawsOccupancyVsSector->SetMinimum(0.0); + if(histRawsOccupancyVsSector->GetMaximum()<1.5*fOccHighLimit) + histRawsOccupancyVsSector->SetMaximum(1.5*fOccHighLimit); + + histRawsQmaxVsSector->SetMinimum(0.0); + if(histRawsQmaxVsSector->GetMaximum()<1.5*fQmaxHighLimit) + histRawsQmaxVsSector->SetMaximum(1.5*fQmaxHighLimit); + + Double_t xminOcc = histRawsOccupancyVsSector->GetXaxis()->GetXmin(); + Double_t xmaxOcc = histRawsOccupancyVsSector->GetXaxis()->GetXmax(); + Double_t yminOcc = histRawsOccupancyVsSector->GetMinimum(); + Double_t ymaxOcc = histRawsOccupancyVsSector->GetMaximum(); + + Double_t xminQmax = histRawsQmaxVsSector->GetXaxis()->GetXmin(); + Double_t xmaxQmax = histRawsQmaxVsSector->GetXaxis()->GetXmax(); + Double_t yminQmax = histRawsQmaxVsSector->GetMinimum(); + Double_t ymaxQmax = histRawsQmaxVsSector->GetMaximum(); + + TBox* boxOccOk = new TBox(xminOcc,0,xmaxOcc,fOccHighLimit); + boxOccOk->SetFillColor(kGreen); + histRawsOccupancyVsSector->GetListOfFunctions()->Add(boxOccOk); + + TBox* boxQmaxOk = new TBox(xminQmax,fQmaxLowLimit,xmaxQmax,fQmaxHighLimit); + boxQmaxOk->SetFillColor(kGreen); + histRawsQmaxVsSector->GetListOfFunctions()->Add(boxQmaxOk); + + + for(Int_t bin = 1; bin <= 72; bin++) { + + if(histRawsOccupancyVsSector->GetBinContent(bin)<=0 || + histRawsOccupancyVsSector->GetBinContent(bin)>fOccHighLimit) { + + histRawsOccupancyVsSector->SetBit(AliQAv1::GetQABit()); + + TBox* boxErr = + new TBox(histRawsOccupancyVsSector->GetXaxis()->GetBinLowEdge(bin), yminOcc, + histRawsOccupancyVsSector->GetXaxis()->GetBinUpEdge(bin), ymaxOcc); + boxErr->SetFillColor(kRed); + histRawsOccupancyVsSector->GetListOfFunctions()->Add(boxErr); + } + + if(histRawsQmaxVsSector->GetBinContent(bin)GetBinContent(bin)>fQmaxHighLimit) { + + // Mark that histogram has error + histRawsQmaxVsSector->SetBit(AliQAv1::GetQABit()); + + TBox* boxErr = + new TBox(histRawsQmaxVsSector->GetXaxis()->GetBinLowEdge(bin), yminQmax, + histRawsQmaxVsSector->GetXaxis()->GetBinUpEdge(bin), ymaxQmax); + boxErr->SetFillColor(kRed); + histRawsQmaxVsSector->GetListOfFunctions()->Add(boxErr); + } + } + + // Now we have to add a copy of the histograms to draw + // because the boxes covers the data points + TH1F* hOccCopy = new TH1F(*histRawsOccupancyVsSector); + hOccCopy->SetOption("SAME P"); + histRawsOccupancyVsSector->GetListOfFunctions()->Add(hOccCopy); + + TH1F* hQmaxCopy = new TH1F(*histRawsQmaxVsSector); + hQmaxCopy->SetOption("SAME P"); + histRawsQmaxVsSector->GetListOfFunctions()->Add(hQmaxCopy); + + } // end beautify + } } } - - 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); + + // This means we are not running DQM so do not beautify + SetBeautifyOption(0); } //____________________________________________________________________________ void AliTPCQADataMakerRec::InitRaws() { - fTPCdataQA = new AliTPCdataQA(); - fTPCdataQA->SetRangeTime(0, 999); // take all 1000 time bins + // + // Adding the raw + // + + // Modified: 7/7 - 2008 + // 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 + 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(100, 920); // set time bin interval +// 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", " 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 + TH1F* hOccHelp = fTPCdataQA[0]->GetHistOccupancyVsEvent(); + TH1F * histRawsOccupancyVsEvent = + new TH1F("hRawsOccupancyVsEvent", hOccHelp->GetTitle(), + hOccHelp->GetXaxis()->GetNbins(), + hOccHelp->GetXaxis()->GetXmin(), hOccHelp->GetXaxis()->GetXmax()); + histRawsOccupancyVsEvent->SetMarkerStyle(20); + histRawsOccupancyVsEvent->SetOption("P"); + histRawsOccupancyVsEvent->SetStats(kFALSE); + Add2RawsList(histRawsOccupancyVsEvent, kRawsOccupancyVsEvent, !expert, image, !saveCorr); + + // Get histogram information from data QA to build copy + TH1F* hNclHelp = fTPCdataQA[0]->GetHistNclustersVsEvent(); + TH1F * histRawsNclustersVsEvent = + new TH1F("hRawsNclustersVsEvent", hNclHelp->GetTitle(), + hNclHelp->GetXaxis()->GetNbins(), + hNclHelp->GetXaxis()->GetXmin(), hNclHelp->GetXaxis()->GetXmax()); + histRawsNclustersVsEvent->SetMarkerStyle(20); + histRawsNclustersVsEvent->SetOption("P"); + histRawsNclustersVsEvent->SetStats(kFALSE); + 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); + + // This means we are not running DQM so do not beautify + SetBeautifyOption(0); } //____________________________________________________________________________ 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); + + // This means we are not running DQM so do not beautify + SetBeautifyOption(0); } //____________________________________________________________________________ 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++) { @@ -239,10 +529,10 @@ void AliTPCQADataMakerRec::MakeESDs(AliESDEvent * esd) 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()); } } @@ -253,30 +543,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 // - 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::MakeDigits(TTree* digitTree) +{ + + 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()); + } } //____________________________________________________________________________ void AliTPCQADataMakerRec::MakeRecPoints(TTree* recTree) { - AliTPCClustersRow *clrow = new AliTPCClustersRow(); - clrow->SetClass("AliTPCclusterMI"); - clrow->SetArray(0); - clrow->GetArray()->ExpandCreateFast(10000); + AliTPCClustersRow clrow; + clrow.SetClass("AliTPCclusterMI"); + clrow.SetArray(0); + clrow.GetArray()->ExpandCreateFast(10000); + AliTPCClustersRow * pclrow = &clrow; TBranch* branch = recTree->GetBranch("Segment"); - branch->SetAddress(&clrow); + + branch->SetAddress(&pclrow); 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(); + const Int_t nClusters = clrow.GetArray()->GetEntriesFast(); for (Int_t icl=0; icl < nClusters; icl++){ AliTPCclusterMI* cluster = - (AliTPCclusterMI*)clrow->GetArray()->At(icl); + (AliTPCclusterMI*)clrow.GetArray()->At(icl); Float_t Qmax = cluster->GetMax(); Float_t Q = cluster->GetQ(); @@ -284,24 +606,41 @@ 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; } + +//____________________________________________________________________________ +void AliTPCQADataMakerRec::LoadMaps() +{ + TString path = gSystem->Getenv("ALICE_ROOT"); + 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"; + fMapping[i] = new AliTPCAltroMapping(path2.Data()); + } +} +