X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONQADataMakerRec.cxx;h=5b9cec41f9b93e6a35f24d02aed8df4d648eb004;hb=0b936dc01b2ff324e3256c1b5c63dd67f372e976;hp=700963187f0d7863bc932a854fc724ec07c03adb;hpb=57acd2d2f484e474d764cf49c17bf8a0af5bdd5e;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONQADataMakerRec.cxx b/MUON/AliMUONQADataMakerRec.cxx index 700963187f0..5b9cec41f9b 100644 --- a/MUON/AliMUONQADataMakerRec.cxx +++ b/MUON/AliMUONQADataMakerRec.cxx @@ -29,7 +29,7 @@ #include "AliMUONRawStreamTracker.h" #include "AliMUONRawStreamTrigger.h" #include "AliMUONRegHeader.h" -#include "AliMUONTrackerCalibratedDataMaker.h" +#include "AliMUONTrackerDataMaker.h" #include "AliMUONTriggerDisplay.h" #include "AliMUONVCluster.h" #include "AliMUONVClusterStore.h" @@ -40,6 +40,7 @@ #include "AliMUONTrack.h" #include "AliMUONTrackParam.h" #include "AliMUONESDInterface.h" +#include "AliMUONCalibrationData.h" #include "AliMpBusPatch.h" #include "AliMpCDB.h" #include "AliMpConstants.h" @@ -49,6 +50,7 @@ #include "AliMpLocalBoard.h" #include "AliMpStationType.h" #include "AliMpTriggerCrate.h" +#include "AliMpDCSNamer.h" #include "AliRawEventHeaderBase.h" // --- AliRoot header files --- @@ -61,6 +63,7 @@ #include "AliRawReader.h" #include "AliQAChecker.h" #include "AliCodeTimer.h" +#include "AliDCSValue.h" // --- ROOT system --- #include @@ -213,65 +216,220 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra } } } - - if ( task == AliQA::kESDS ) { - // Normalize ESD histos - TH1* h; - Int_t bin; - AliMpDEIterator it; - it.First(); - while ( !it.IsDone()) { - Int_t detElemId = it.CurrentDEId(); + // Normalize RecPoints histos + if ( task == AliQA::kRECPOINTS ) { + + TH1* hTrackerClusterChargePerChMean = GetRecPointsData(kTrackerClusterChargePerChMean); + TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(kTrackerClusterChargePerChSigma); + TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(kTrackerClusterMultiplicityPerChMean); + TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(kTrackerClusterMultiplicityPerChSigma); + TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(kTrackerClusterChargePerDEMean); + TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(kTrackerClusterMultiplicityPerDEMean); + + // loop over chambers + for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) { + + TH1* hTrackerClusterChargePerChamber = GetRecPointsData(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()); + + TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(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(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* hTrackerClusterMultiplicityPerDE = GetRecPointsData(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()); + + it.Next(); + } + + } + + } - if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger ) { + // Normalize ESD histos + if ( task == AliQA::kESDS ) { - h = GetESDsData(kESDnClustersPerDE); - Double_t nClusters = h->GetBinContent(h->GetXaxis()->FindFixBin((Double_t)detElemId)); + Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries(); + if (nTracks <= 0) continue; - if (nClusters > 0) { - - h = GetESDsData(kESDClusterChargePerDE); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - h->SetBinContent(bin, h->GetBinContent(bin)/nClusters); - - h = GetESDsData(kESDClusterMultPerDE); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - h->SetBinContent(bin, h->GetBinContent(bin)/nClusters); - - h = GetESDsData(kESDResidualXPerDEMean); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - Double_t meanResX = h->GetBinContent(bin)/nClusters; - h->SetBinContent(bin, meanResX); - - h = GetESDsData(kESDResidualYPerDEMean); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - Double_t meanResY = h->GetBinContent(bin)/nClusters; - h->SetBinContent(bin, meanResY); - - h = GetESDsData(kESDResidualXPerDESigma); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - if (nClusters > 1) h->SetBinContent(bin, TMath::Sqrt(h->GetBinContent(bin)/nClusters - meanResX*meanResX)); - else h->SetBinContent(bin, 0.); - - h = GetESDsData(kESDResidualYPerDESigma); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - if (nClusters > 1) h->SetBinContent(bin, TMath::Sqrt(h->GetBinContent(bin)/nClusters - meanResY*meanResY)); - else h->SetBinContent(bin, 0.); - } + TH1* hESDnClustersPerCh = GetESDsData(kESDnClustersPerCh); + TH1* hESDnClustersPerDE = GetESDsData(kESDnClustersPerDE); + TH1* hESDClusterChargePerChMean = GetESDsData(kESDClusterChargePerChMean); + TH1* hESDClusterChargePerChSigma = GetESDsData(kESDClusterChargePerChSigma); + TH1* hESDClusterSizePerChMean = GetESDsData(kESDClusterSizePerChMean); + TH1* hESDClusterSizePerChSigma = GetESDsData(kESDClusterSizePerChSigma); + TH1* hESDResidualXPerChMean = GetESDsData(kESDResidualXPerChMean); + TH1* hESDResidualXPerChSigma = GetESDsData(kESDResidualXPerChSigma); + TH1* hESDResidualYPerChMean = GetESDsData(kESDResidualYPerChMean); + TH1* hESDResidualYPerChSigma = GetESDsData(kESDResidualYPerChSigma); + TH1* hESDLocalChi2XPerChMean = GetESDsData(kESDLocalChi2XPerChMean); + TH1* hESDLocalChi2YPerChMean = GetESDsData(kESDLocalChi2YPerChMean); + TH1* hESDClusterChargePerDE = GetESDsData(kESDClusterChargePerDE); + TH1* hESDClusterSizePerDE = GetESDsData(kESDClusterSizePerDE); + TH1* hESDResidualXPerDEMean = GetESDsData(kESDResidualXPerDEMean); + TH1* hESDResidualXPerDESigma = GetESDsData(kESDResidualXPerDESigma); + TH1* hESDResidualYPerDEMean = GetESDsData(kESDResidualYPerDEMean); + TH1* hESDResidualYPerDESigma = GetESDsData(kESDResidualYPerDESigma); + TH1* hESDLocalChi2XPerDEMean = GetESDsData(kESDLocalChi2XPerDEMean); + TH1* hESDLocalChi2YPerDEMean = GetESDsData(kESDLocalChi2YPerDEMean); + TH1* hESDnTotClustersPerCh = GetESDsData(kESDnTotClustersPerCh); + TH1* hESDnTotClustersPerDE = GetESDsData(kESDnTotClustersPerDE); + TH1* hESDnTotFullClustersPerDE = GetESDsData(kESDnTotFullClustersPerDE); + TH1* hESDSumClusterChargePerDE = GetESDsData(kESDSumClusterChargePerDE); + TH1* hESDSumClusterSizePerDE = GetESDsData(kESDSumClusterSizePerDE); + TH1* hESDSumResidualXPerDE = GetESDsData(kESDSumResidualXPerDE); + TH1* hESDSumResidualYPerDE = GetESDsData(kESDSumResidualYPerDE); + TH1* hESDSumResidualX2PerDE = GetESDsData(kESDSumResidualX2PerDE); + TH1* hESDSumResidualY2PerDE = GetESDsData(kESDSumResidualY2PerDE); + TH1* hESDSumLocalChi2XPerDE = GetESDsData(kESDSumLocalChi2XPerDE); + TH1* hESDSumLocalChi2YPerDE = GetESDsData(kESDSumLocalChi2YPerDE); + + 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(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(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(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(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(kESDLocalChi2XInCh+iCh); + Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS(); + hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean()); + hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError()); + + TH1* hESDLocalChi2YInCh = GetESDsData(kESDLocalChi2YInCh+iCh); + Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS(); + hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean()); + hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->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, TMath::Sqrt(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, TMath::Sqrt(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)); + + } 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()); + + } + + 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()); + + } + + it.Next(); + } + } - - it.Next(); - } - - Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries(); - if (nTracks > 0) { - GetESDsData(kESDnClustersPerCh)->Scale(1./nTracks); - GetESDsData(kESDnClustersPerDE)->Scale(1./nTracks); + } + } - } + // do the QA checking AliQAChecker::Instance()->Run(AliQA::kMUON, task, list) ; } @@ -318,9 +476,44 @@ void AliMUONQADataMakerRec::InitRaws() histoTitle = Form("Chamber %i: Scalers %s", 11+iChamber, cathName.Data()); TH2F* h5 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber, histoTitle); - Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,forExpert); + Add2RawsList(h5, kTriggerScalersDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert); } } + + TH2F* h6 = new TH2F("hTriggerRPCI", "Trigger RPC currents", + 4, 10.5, 14.5, + 18, -0.5, 17.5); + h6->GetXaxis()->SetTitle("Chamber"); + h6->GetYaxis()->SetTitle("RPC"); + Add2RawsList(h6, kTriggerRPCi, forExpert); + + TH2F* h7 = new TH2F("hTriggerRPCHV", "Trigger RPC HV", + 4, 10.5, 14.5, + 18, -0.5, 17.5); + h7->GetXaxis()->SetTitle("Chamber"); + h7->GetYaxis()->SetTitle("RPC"); + Add2RawsList(h7, kTriggerRPChv, forExpert); + + for(Int_t iChamber=0; iChamberGetXaxis()->SetBinLabel(1, "One-bin histogram: bin is filled at each scaler event."); + h10->GetYaxis()->SetTitle("Cumulated scaler time (s)"); + Add2RawsList(h10, kTriggerScalersTime, !forExpert); Int_t nbp(0); TIter next(AliMpDDLStore::Instance()->CreateBusPatchIterator()); @@ -333,6 +526,20 @@ void AliMUONQADataMakerRec::InitRaws() nbp,-0.5,nbp-0.5); Add2RawsList(hbp,kTrackerBusPatchOccupancy,!forExpert); + + const Bool_t histogram(kFALSE); + + fTrackerDataMaker = new AliMUONTrackerDataMaker(GetRecoParam(), + AliCDBManager::Instance()->GetRun(), + 0x0, + AliCDBManager::Instance()->GetDefaultStorage()->GetURI(), + "NOGAIN", + histogram, + 0.0,0.0); + + fTrackerDataMaker->Data()->DisableChannelLevel(); // to save up disk space, we only store starting at the manu level + + fTrackerDataMaker->SetRunning(kTRUE); fIsInitRaws = kTRUE; } @@ -351,72 +558,98 @@ void AliMUONQADataMakerRec::InitRecPoints() //____________________________________________________________________________ void AliMUONQADataMakerRec::InitRecPointsTracker() { - /// create Reconstructed Points histograms in RecPoints subdir for the - /// MUON tracker subsystem. - + /// create Reconstructed Points histograms in RecPoints subdir for the + /// MUON tracker subsystem. + AliCodeTimerAuto(""); Bool_t forExpert(kTRUE); + TH1I *h1I; + TH1F *h1F; + TH2F *h2F; - AliMpDEIterator it; - - it.First(); - - Int_t ndes(0); - - while ( !it.IsDone()) - { - Int_t detElemId = it.CurrentDEId(); - - it.Next(); - - if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger ) - { - ndes = TMath::Max(ndes,detElemId); - - TH1* h = new TH1I(Form("hTrackerClusterMultiplicityForDE%04d",detElemId), - Form("Multiplicity of the clusters in detection element %d",detElemId), - 100,0,100); - - h->GetXaxis()->SetTitle("Detection Element Id"); - - Add2RecPointsList(h,kTrackerClusterMultiplicityPerDE+detElemId,forExpert); - - h = new TH1I(Form("hTrackerClusterChargeForDE%04d",detElemId), - Form("Charge of the clusters in detection element %d",detElemId), - 100,0,1000); - - h->GetXaxis()->SetTitle("Detection Element Id"); - - Add2RecPointsList(h,kTrackerClusterChargePerDE+detElemId,forExpert); - - } - - } - - TH1* h = new TH1I("hTrackerNumberOfClustersPerDE","Number of clusters per detection element", - ndes, 0.5, ndes + 0.5); - - h->GetXaxis()->SetTitle("Detection Element Id"); - - Add2RecPointsList(h, kTrackerNumberOfClustersPerDE,!forExpert); - - for ( Int_t i = 0; i < AliMpConstants::NofTrackingChambers(); ++i ) - { - TH1* h1 = new TH1I("hTrackerNumberOfClustersPerChamber","Number of clusters per chamber", - AliMpConstants::NofTrackingChambers(),-0.5,AliMpConstants::NofTrackingChambers()-0.5); - Add2RecPointsList(h1,kTrackerNumberOfClustersPerChamber,forExpert); - h1 = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i), - Form("Cluster multiplicity for chamber %d",i), - 100,0,100); - Add2RecPointsList(h1,kTrackerClusterMultiplicityPerChamber+i,forExpert); - h1 = new TH1I(Form("hTrackerClusterChargeForChamber%d",i), - Form("Cluster charge for chamber %d",i), - 100,0,1000); - Add2RecPointsList(h1,kTrackerClusterChargePerChamber+i,forExpert); - } - - fIsInitRecPointsTracker=kTRUE; + // histograms per chamber + Int_t nCh = AliMpConstants::NofTrackingChambers(); + for ( Int_t i = 0; i < nCh; ++i ) + { + h1I = new TH1I(Form("hTrackerClusterMultiplicityForChamber%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 100,0,100); + Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerChamber+i,forExpert); + + h1I = new TH1I(Form("hTrackerClusterChargeForChamber%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500,0,5000); + Add2RecPointsList(h1I,kTrackerClusterChargePerChamber+i,forExpert); + + Float_t rMax = AliMUONConstants::Rmax(i/2); + h2F = new TH2F(Form("hTrackerClusterHitMapForChamber%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1), 100, -rMax, rMax, 100, -rMax, rMax); + Add2RecPointsList(h2F, kTrackerClusterHitMapPerChamber+i,forExpert); + } + + // summary histograms per chamber + h1I = new TH1I("hTrackerNumberOfClustersPerChamber", "Number of clusters per chamber;chamber ID;n_{clusters}", nCh,-0.5,nCh-0.5); + Add2RecPointsList(h1I,kTrackerNumberOfClustersPerChamber,forExpert); + + h1F = new TH1F("hTrackerClusterMultiplicityPerChMean", "cluster mean size per chamber;chamber ID; (n_{pads})", nCh,-0.5,nCh-0.5); + h1F->SetOption("P"); + h1F->SetMarkerStyle(kFullDotMedium); + h1F->SetMarkerColor(kRed); + Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChMean,forExpert); + + h1F = new TH1F("hTrackerClusterMultiplicityPerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh,-0.5,nCh-0.5); + h1F->SetOption("P"); + h1F->SetMarkerStyle(kFullDotMedium); + h1F->SetMarkerColor(kRed); + Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerChSigma,forExpert); + + h1F = new TH1F("hTrackerClusterChargePerChMean", "cluster mean charge per chamber;chamber ID; (ADC counts)", nCh,-0.5,nCh-0.5); + h1F->SetOption("P"); + h1F->SetMarkerStyle(kFullDotMedium); + h1F->SetMarkerColor(kRed); + Add2RecPointsList(h1F, kTrackerClusterChargePerChMean,forExpert); + + h1F = new TH1F("hTrackerClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh,-0.5,nCh-0.5); + h1F->SetOption("P"); + h1F->SetMarkerStyle(kFullDotMedium); + h1F->SetMarkerColor(kRed); + Add2RecPointsList(h1F, kTrackerClusterChargePerChSigma,forExpert); + + // histograms per DE + Int_t ndes(0); + AliMpDEIterator it; + it.First(); + while ( !it.IsDone()) + { + Int_t detElemId = it.CurrentDEId(); + + if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger ) + { + ndes = TMath::Max(ndes,detElemId); + + h1I = new TH1I(Form("hTrackerClusterMultiplicityForDE%04d",detElemId), Form("cluster size distribution in detection element %d;size (n_{pads})",detElemId), 100,0,100); + Add2RecPointsList(h1I,kTrackerClusterMultiplicityPerDE+detElemId,forExpert); + + h1I = new TH1I(Form("hTrackerClusterChargeForDE%04d",detElemId), Form("cluster charge distribution in detection element %d;charge (ADC counts)",detElemId), 500,0,5000); + Add2RecPointsList(h1I,kTrackerClusterChargePerDE+detElemId,forExpert); + } + + it.Next(); + } + + // summary histograms per DE + h1I = new TH1I("hTrackerNumberOfClustersPerDE", "Number of clusters per detection element;DetElem ID;n_{clusters}", ndes+1,-0.5,ndes+0.5); + Add2RecPointsList(h1I, kTrackerNumberOfClustersPerDE,!forExpert); + + h1F = new TH1F("hTrackerClusterMultiplicityPerDEMean", "cluster mean size per DE;DetElem ID; (n_{pads})", ndes+1,-0.5,ndes+0.5); + h1F->SetOption("P"); + h1F->SetMarkerStyle(kFullDotMedium); + h1F->SetMarkerColor(kRed); + Add2RecPointsList(h1F, kTrackerClusterMultiplicityPerDEMean,forExpert); + + h1F = new TH1F("hTrackerClusterChargePerDEMean", "cluster mean charge per DE;DetElem ID; (ADC counts)", ndes+1,-0.5,ndes+0.5); + h1F->SetOption("P"); + h1F->SetMarkerStyle(kFullDotMedium); + h1F->SetMarkerColor(kRed); + Add2RecPointsList(h1F, kTrackerClusterChargePerDEMean,forExpert); + + fIsInitRecPointsTracker=kTRUE; } //____________________________________________________________________________ @@ -457,13 +690,13 @@ void AliMUONQADataMakerRec::InitRecPointsTrigger() histoTitle = Form("Chamber %i: Fired pads %s", 11+iChamber, cathName.Data()); TH2F* h3 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto(histoName, AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber, histoTitle); - Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,forExpert); + Add2RecPointsList(h3, kTriggerDigitsDisplay + AliMpConstants::NofTriggerChambers()*iCath + iChamber,!forExpert); } } TH2F* h4 = (TH2F*)triggerDisplay.GetEmptyDisplayHisto("hFiredBoardsDisplay", AliMUONTriggerDisplay::kDisplayBoards, 0, 0, "Fired boards"); - Add2RecPointsList(h4, kTriggerBoardsDisplay,forExpert); + Add2RecPointsList(h4, kTriggerBoardsDisplay,!forExpert); fIsInitRecPointsTrigger = kTRUE; } @@ -480,110 +713,203 @@ void AliMUONQADataMakerRec::InitESDs() Int_t nDE = 1100; // track info - TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks", 20, 0., 20.); + TH1F* hESDnTracks = new TH1F("hESDnTracks", "number of tracks;n_{tracks}", 20, 0., 20.); Add2ESDsList(hESDnTracks, kESDnTracks,!forExpert); - TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger", 20, 0., 20.); + TH1F* hESDMatchTrig = new TH1F("hESDMatchTrig", "number of tracks matched with trigger;n_{tracks}", 20, 0., 20.); Add2ESDsList(hESDMatchTrig, kESDMatchTrig,!forExpert); - TH1F* hESDMomentum = new TH1F("hESDMomentum", "P distribution", 300, 0., 300); + TH1F* hESDMomentum = new TH1F("hESDMomentum", "momentum distribution;p (GeV/c)", 300, 0., 300); Add2ESDsList(hESDMomentum, kESDMomentum,forExpert); - TH1F* hESDPt = new TH1F("hESDPt", "Pt distribution", 200, 0., 50); + TH1F* hESDPt = new TH1F("hESDPt", "transverse momentum distribution;p_{t} (GeV/c)", 200, 0., 50); Add2ESDsList(hESDPt, kESDPt,forExpert); - TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution", 200, -4.5, -2.); + TH1F* hESDRapidity = new TH1F("hESDRapidity", "rapidity distribution;rapidity", 200, -4.5, -2.); Add2ESDsList(hESDRapidity, kESDRapidity,forExpert); - TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized chi2 distribution", 500, 0., 50.); + TH1F* hESDChi2 = new TH1F("hESDChi2", "normalized #chi^{2} distribution;#chi^{2} / ndf", 500, 0., 50.); Add2ESDsList(hESDChi2, kESDChi2,forExpert); + TH1F* hESDProbChi2 = new TH1F("hESDProbChi2", "distribution of probability of #chi^{2};prob(#chi^{2})", 100, 0., 1.); + Add2ESDsList(hESDProbChi2, kESDProbChi2,forExpert); + // cluster info for (Int_t i = 0; i < nCh; i++) { Float_t rMax = AliMUONConstants::Rmax(i/2); - TH2F* hESDClusterHitMap = new TH2F(Form("hESDClusterHitMap%d",i+1), Form("cluster position distribution in chamber %d",i+1), + TH2F* hESDClusterHitMap = new TH2F(Form("hESDClusterHitMap%d",i+1), Form("cluster position distribution in chamber %d;X (cm);Y (cm)",i+1), 100, -rMax, rMax, 100, -rMax, rMax); Add2ESDsList(hESDClusterHitMap, kESDClusterHitMap+i,forExpert); } - TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of clusters per track", 20, 0., 20.); + TH1F* hESDnClustersPerTrack = new TH1F("hESDnClustersPerTrack", "number of associated clusters per track;n_{clusters}", 20, 0., 20.); Add2ESDsList(hESDnClustersPerTrack, kESDnClustersPerTrack,!forExpert); - TH1F* hESDnClustersPerCh = new TH1F("hESDnClustersPerCh", "number of clusters per chamber per track;chamber ID", nCh, 0, nCh); + TH1F* hESDnClustersPerCh = new TH1F("hESDnClustersPerCh", "averaged number of clusters per chamber per track;chamber ID;", nCh, -0.5, nCh-0.5); hESDnClustersPerCh->SetFillColor(kRed); Add2ESDsList(hESDnClustersPerCh, kESDnClustersPerCh,forExpert); - TH1F* hESDnClustersPerDE = new TH1F("hESDnClustersPerDE", "number of clusters per DE per track;DetElem ID", nDE, 0, nDE); + TH1F* hESDnClustersPerDE = new TH1F("hESDnClustersPerDE", "averaged number of clusters per DE per track;DetElem ID;", nDE+1, -0.5, nDE+0.5); hESDnClustersPerDE->SetFillColor(kRed); Add2ESDsList(hESDnClustersPerDE, kESDnClustersPerDE,forExpert); - TH1F* hESDClusterCharge = new TH1F("hESDClusterCharge", "cluster charge distribution", 500, 0., 5000.); - Add2ESDsList(hESDClusterCharge, kESDClusterCharge,forExpert); - for (Int_t i = 0; i < nCh; i++) { - TH1F* hESDClusterChargeInCh = new TH1F(Form("hESDClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d",i+1), 500, 0., 5000.); + TH1F* hESDClusterChargeInCh = new TH1F(Form("hESDClusterChargeInCh%d",i+1), Form("cluster charge distribution in chamber %d;charge (ADC counts)",i+1), 500, 0., 5000.); Add2ESDsList(hESDClusterChargeInCh, kESDClusterChargeInCh+i,forExpert); } - TH1F* hESDClusterChargePerDE = new TH1F("hESDClusterChargePerDE", "cluster mean charge per DE;DetElem ID", nDE, 0, nDE); + TH1F* hESDClusterChargePerChMean = new TH1F("hESDClusterChargePerChMean", "cluster mean charge per chamber;chamber ID; (ADC counts)", nCh, -0.5, nCh-0.5); + hESDClusterChargePerChMean->SetOption("P"); + hESDClusterChargePerChMean->SetMarkerStyle(kFullDotMedium); + hESDClusterChargePerChMean->SetMarkerColor(kRed); + Add2ESDsList(hESDClusterChargePerChMean, kESDClusterChargePerChMean,forExpert); + + TH1F* hESDClusterChargePerChSigma = new TH1F("hESDClusterChargePerChSigma", "cluster charge dispersion per chamber;chamber ID;#sigma_{charge} (ADC counts)", nCh, -0.5, nCh-0.5); + hESDClusterChargePerChSigma->SetOption("P"); + hESDClusterChargePerChSigma->SetMarkerStyle(kFullDotMedium); + hESDClusterChargePerChSigma->SetMarkerColor(kRed); + Add2ESDsList(hESDClusterChargePerChSigma, kESDClusterChargePerChSigma,forExpert); + + TH1F* hESDClusterChargePerDE = new TH1F("hESDClusterChargePerDE", "cluster mean charge per DE;DetElem ID; (ADC counts)", nDE+1, -0.5, nDE+0.5); hESDClusterChargePerDE->SetOption("P"); hESDClusterChargePerDE->SetMarkerStyle(kFullDotMedium); hESDClusterChargePerDE->SetMarkerColor(kRed); Add2ESDsList(hESDClusterChargePerDE, kESDClusterChargePerDE,forExpert); - TH1F* hESDClusterMult = new TH1F("hESDClusterMult", "cluster multiplicity distribution", 200, 0., 200.); - Add2ESDsList(hESDClusterMult, kESDClusterMult,forExpert); - for (Int_t i = 0; i < nCh; i++) { - TH1F* hESDClusterMultInCh = new TH1F(Form("hESDClusterMultInCh%d",i+1), Form("cluster multiplicity distribution in chamber %d",i+1), 200, 0., 200.); - Add2ESDsList(hESDClusterMultInCh, kESDClusterMultInCh+i,forExpert); + TH1F* hESDClusterSizeInCh = new TH1F(Form("hESDClusterSizeInCh%d",i+1), Form("cluster size distribution in chamber %d;size (n_{pads})",i+1), 200, 0., 200.); + Add2ESDsList(hESDClusterSizeInCh, kESDClusterSizeInCh+i,forExpert); } - TH1F* hESDClusterMultPerDE = new TH1F("hESDClusterMultPerDE", "cluster mean multiplicity per DE;DetElem ID", nDE, 0, nDE); - hESDClusterMultPerDE->SetOption("P"); - hESDClusterMultPerDE->SetMarkerStyle(kFullDotMedium); - hESDClusterMultPerDE->SetMarkerColor(kRed); - Add2ESDsList(hESDClusterMultPerDE, kESDClusterMultPerDE,forExpert); + TH1F* hESDClusterSizePerChMean = new TH1F("hESDClusterSizePerChMean", "cluster mean size per chamber;chamber ID; (n_{pads})", nCh, -0.5, nCh-0.5); + hESDClusterSizePerChMean->SetOption("P"); + hESDClusterSizePerChMean->SetMarkerStyle(kFullDotMedium); + hESDClusterSizePerChMean->SetMarkerColor(kRed); + Add2ESDsList(hESDClusterSizePerChMean, kESDClusterSizePerChMean,forExpert); - // cluster - track info - TH1F* hESDResidualX = new TH1F("hESDResidualX", "cluster-track residual-X distribution", 1000, -5., 5.); - Add2ESDsList(hESDResidualX, kESDResidualX,forExpert); + TH1F* hESDClusterSizePerChSigma = new TH1F("hESDClusterSizePerChSigma", "cluster size dispersion per chamber;chamber ID;#sigma_{size} (n_{pads})", nCh, -0.5, nCh-0.5); + hESDClusterSizePerChSigma->SetOption("P"); + hESDClusterSizePerChSigma->SetMarkerStyle(kFullDotMedium); + hESDClusterSizePerChSigma->SetMarkerColor(kRed); + Add2ESDsList(hESDClusterSizePerChSigma, kESDClusterSizePerChSigma,forExpert); - TH1F* hESDResidualY = new TH1F("hESDResidualY", "cluster-track residual-Y distribution", 1000, -1., 1.); - Add2ESDsList(hESDResidualY, kESDResidualY,forExpert); + TH1F* hESDClusterSizePerDE = new TH1F("hESDClusterSizePerDE", "cluster mean size per DE;DetElem ID; (n_{pads})", nDE+1, -0.5, nDE+0.5); + hESDClusterSizePerDE->SetOption("P"); + hESDClusterSizePerDE->SetMarkerStyle(kFullDotMedium); + hESDClusterSizePerDE->SetMarkerColor(kRed); + Add2ESDsList(hESDClusterSizePerDE, kESDClusterSizePerDE,forExpert); + // cluster - track info for (Int_t i = 0; i < nCh; i++) { - TH1F* hESDResidualXInCh = new TH1F(Form("hESDResidualXInCh%d",i+1), Form("cluster-track residual-X distribution in chamber %d",i+1), 1000, -5., 5.); + TH1F* hESDResidualXInCh = new TH1F(Form("hESDResidualXInCh%d",i+1), Form("cluster-track residual-X distribution in chamber %d;#Delta_{X} (cm)",i+1), 1000, -5., 5.); Add2ESDsList(hESDResidualXInCh, kESDResidualXInCh+i,forExpert); - TH1F* hESDResidualYInCh = new TH1F(Form("hESDResidualYInCh%d",i+1), Form("cluster-track residual-Y distribution in chamber %d",i+1), 1000, -1., 1.); + TH1F* hESDResidualYInCh = new TH1F(Form("hESDResidualYInCh%d",i+1), Form("cluster-track residual-Y distribution in chamber %d;#Delta_{Y} (cm)",i+1), 1000, -1., 1.); Add2ESDsList(hESDResidualYInCh, kESDResidualYInCh+i,forExpert); + + TH1F* hESDLocalChi2XInCh = new TH1F(Form("hESDLocalChi2XInCh%d",i+1), Form("local chi2-X distribution in chamber %d;local #chi^{2}_{X}",i+1), 1000, 0., 25); + Add2ESDsList(hESDLocalChi2XInCh, kESDLocalChi2XInCh+i,forExpert); + + TH1F* hESDLocalChi2YInCh = new TH1F(Form("hESDLocalChi2YInCh%d",i+1), Form("local chi2-Y distribution in chamber %d;local #chi^{2}_{Y}",i+1), 1000, 0., 25); + Add2ESDsList(hESDLocalChi2YInCh, kESDLocalChi2YInCh+i,forExpert); } - TH1F* hESDResidualXPerDEMean = new TH1F("hESDResidualXPerDEMean", "cluster-track residual-X per DE: mean;DetElem ID", nDE, 0, nDE); + TH1F* hESDResidualXPerChMean = new TH1F("hESDResidualXPerChMean", "cluster-track residual-X per Ch: mean;chamber ID;<#Delta_{X}> (cm)", nCh, -0.5, nCh-0.5); + hESDResidualXPerChMean->SetOption("P"); + hESDResidualXPerChMean->SetMarkerStyle(kFullDotMedium); + hESDResidualXPerChMean->SetMarkerColor(kRed); + Add2ESDsList(hESDResidualXPerChMean, kESDResidualXPerChMean,forExpert); + + TH1F* hESDResidualYPerChMean = new TH1F("hESDResidualYPerChMean", "cluster-track residual-Y per Ch: mean;chamber ID;<#Delta_{Y}> (cm)", nCh, -0.5, nCh-0.5); + hESDResidualYPerChMean->SetOption("P"); + hESDResidualYPerChMean->SetMarkerStyle(kFullDotMedium); + hESDResidualYPerChMean->SetMarkerColor(kRed); + Add2ESDsList(hESDResidualYPerChMean, kESDResidualYPerChMean,forExpert); + + TH1F* hESDResidualXPerChSigma = new TH1F("hESDResidualXPerChSigma", "cluster-track residual-X per Ch: sigma;chamber ID;#sigma_{X} (cm)", nCh, -0.5, nCh-0.5); + hESDResidualXPerChSigma->SetOption("P"); + hESDResidualXPerChSigma->SetMarkerStyle(kFullDotMedium); + hESDResidualXPerChSigma->SetMarkerColor(kRed); + Add2ESDsList(hESDResidualXPerChSigma, kESDResidualXPerChSigma,forExpert); + + TH1F* hESDResidualYPerChSigma = new TH1F("hESDResidualYPerChSigma", "cluster-track residual-Y per Ch: sigma;chamber ID;#sigma_{Y} (cm)", nCh, -0.5, nCh-0.5); + hESDResidualYPerChSigma->SetOption("P"); + hESDResidualYPerChSigma->SetMarkerStyle(kFullDotMedium); + hESDResidualYPerChSigma->SetMarkerColor(kRed); + Add2ESDsList(hESDResidualYPerChSigma, kESDResidualYPerChSigma,forExpert); + + TH1F* hESDLocalChi2XPerChMean = new TH1F("hESDLocalChi2XPerChMean", "local chi2-X per Ch: mean;chamber ID;", nCh, -0.5, nCh-0.5); + hESDLocalChi2XPerChMean->SetOption("P"); + hESDLocalChi2XPerChMean->SetMarkerStyle(kFullDotMedium); + hESDLocalChi2XPerChMean->SetMarkerColor(kRed); + Add2ESDsList(hESDLocalChi2XPerChMean, kESDLocalChi2XPerChMean,forExpert); + + TH1F* hESDLocalChi2YPerChMean = new TH1F("hESDLocalChi2YPerChMean", "local chi2-Y per Ch: mean;chamber ID;", nCh, -0.5, nCh-0.5); + hESDLocalChi2YPerChMean->SetOption("P"); + hESDLocalChi2YPerChMean->SetMarkerStyle(kFullDotMedium); + hESDLocalChi2YPerChMean->SetMarkerColor(kRed); + Add2ESDsList(hESDLocalChi2YPerChMean, kESDLocalChi2YPerChMean,forExpert); + + TH1F* hESDResidualXPerDEMean = new TH1F("hESDResidualXPerDEMean", "cluster-track residual-X per DE: mean;DetElem ID;<#Delta_{X}> (cm)", nDE+1, -0.5, nDE+0.5); hESDResidualXPerDEMean->SetOption("P"); hESDResidualXPerDEMean->SetMarkerStyle(kFullDotMedium); hESDResidualXPerDEMean->SetMarkerColor(kRed); Add2ESDsList(hESDResidualXPerDEMean, kESDResidualXPerDEMean,forExpert); - TH1F* hESDResidualYPerDEMean = new TH1F("hESDResidualYPerDEMean", "cluster-track residual-Y per DE: mean;DetElem ID", nDE, 0, nDE); + TH1F* hESDResidualYPerDEMean = new TH1F("hESDResidualYPerDEMean", "cluster-track residual-Y per DE: mean;DetElem ID;<#Delta_{Y}> (cm)", nDE+1, -0.5, nDE+0.5); hESDResidualYPerDEMean->SetOption("P"); hESDResidualYPerDEMean->SetMarkerStyle(kFullDotMedium); hESDResidualYPerDEMean->SetMarkerColor(kRed); Add2ESDsList(hESDResidualYPerDEMean, kESDResidualYPerDEMean,forExpert); - TH1F* hESDResidualXPerDESigma = new TH1F("hESDResidualXPerDESigma", "cluster-track residual-X per DE: sigma;DetElem ID", nDE, 0, nDE); + TH1F* hESDResidualXPerDESigma = new TH1F("hESDResidualXPerDESigma", "cluster-track residual-X per DE: sigma;DetElem ID;#sigma_{X} (cm)", nDE+1, -0.5, nDE+0.5); hESDResidualXPerDESigma->SetOption("P"); hESDResidualXPerDESigma->SetMarkerStyle(kFullDotMedium); hESDResidualXPerDESigma->SetMarkerColor(kRed); Add2ESDsList(hESDResidualXPerDESigma, kESDResidualXPerDESigma,forExpert); - TH1F* hESDResidualYPerDESigma = new TH1F("hESDResidualYPerDESigma", "cluster-track residual-Y per DE: sigma;DetElem ID", nDE, 0, nDE); + TH1F* hESDResidualYPerDESigma = new TH1F("hESDResidualYPerDESigma", "cluster-track residual-Y per DE: sigma;DetElem ID;#sigma_{Y} (cm)", nDE+1, -0.5, nDE+0.5); hESDResidualYPerDESigma->SetOption("P"); hESDResidualYPerDESigma->SetMarkerStyle(kFullDotMedium); hESDResidualYPerDESigma->SetMarkerColor(kRed); Add2ESDsList(hESDResidualYPerDESigma, kESDResidualYPerDESigma,forExpert); + TH1F* hESDLocalChi2XPerDEMean = new TH1F("hESDLocalChi2XPerDEMean", "local chi2-X per DE: mean;DetElem ID;", nDE+1, -0.5, nDE+0.5); + hESDLocalChi2XPerDEMean->SetOption("P"); + hESDLocalChi2XPerDEMean->SetMarkerStyle(kFullDotMedium); + hESDLocalChi2XPerDEMean->SetMarkerColor(kRed); + Add2ESDsList(hESDLocalChi2XPerDEMean, kESDLocalChi2XPerDEMean,forExpert); + + TH1F* hESDLocalChi2YPerDEMean = new TH1F("hESDLocalChi2YPerDEMean", "local chi2-Y per DE: mean;DetElem ID;", nDE+1, -0.5, nDE+0.5); + hESDLocalChi2YPerDEMean->SetOption("P"); + hESDLocalChi2YPerDEMean->SetMarkerStyle(kFullDotMedium); + hESDLocalChi2YPerDEMean->SetMarkerColor(kRed); + Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean,forExpert); + + // intermediate histograms + TH1F* hESDnTotClustersPerCh = new TH1F("hESDnTotClustersPerCh", "total number of associated clusters per chamber;chamber ID;#Sigma(n_{clusters})", nCh, -0.5, nCh-0.5); + Add2ESDsList(hESDnTotClustersPerCh, kESDnTotClustersPerCh, forExpert); + TH1F* hESDnTotClustersPerDE = new TH1F("hESDnTotClustersPerDE", "total number of associated clusters per DE;DetElem ID;#Sigma(n_{clusters})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDnTotClustersPerDE, kESDnTotClustersPerDE, forExpert); + TH1F* hESDnTotFullClustersPerDE = new TH1F("hESDnTotFullClustersPerDE", "total number of associated clusters containing pad info per DE;DetElem ID;#Sigma(n_{full clusters})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDnTotFullClustersPerDE, kESDnTotFullClustersPerDE, forExpert); + TH1F* hESDSumClusterChargePerDE = new TH1F("hESDSumClusterChargePerDE", "sum of cluster charge per DE;DetElem ID;#Sigma(charge) (ADC counts)", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumClusterChargePerDE, kESDSumClusterChargePerDE, forExpert); + TH1F* hESDSumClusterSizePerDE = new TH1F("hESDSumClusterSizePerDE", "sum of cluster size per DE;DetElem ID;#Sigma(size) (n_{pads})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumClusterSizePerDE, kESDSumClusterSizePerDE, forExpert); + TH1F* hESDSumResidualXPerDE = new TH1F("hESDSumResidualXPerDE", "sum of cluster-track residual-X per DE;DetElem ID;#Sigma(#Delta_{X}) (cm)", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumResidualXPerDE, kESDSumResidualXPerDE, forExpert); + TH1F* hESDSumResidualYPerDE = new TH1F("hESDSumResidualYPerDE", "sum of cluster-track residual-Y per DE;DetElem ID;#Sigma(#Delta_{Y}) (cm)", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumResidualYPerDE, kESDSumResidualYPerDE, forExpert); + TH1F* hESDSumResidualX2PerDE = new TH1F("hESDSumResidualX2PerDE", "sum of cluster-track residual-X**2 per DE;DetElem ID;#Sigma(#Delta_{X}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumResidualX2PerDE, kESDSumResidualX2PerDE, forExpert); + TH1F* hESDSumResidualY2PerDE = new TH1F("hESDSumResidualY2PerDE", "sum of cluster-track residual-Y**2 per DE;DetElem ID;#Sigma(#Delta_{Y}^{2}) (cm^{2})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumResidualY2PerDE, kESDSumResidualY2PerDE, forExpert); + TH1F* hESDSumLocalChi2XPerDE = new TH1F("hESDSumLocalChi2XPerDE", "sum of local chi2-X per DE;DetElem ID;#Sigma(local #chi^{2}_{X})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumLocalChi2XPerDE, kESDSumLocalChi2XPerDE, forExpert); + TH1F* hESDSumLocalChi2YPerDE = new TH1F("hESDSumLocalChi2YPerDE", "sum of local chi2-Y per DE;DetElem ID;#Sigma(local #chi^{2}_{Y})", nDE+1, -0.5, nDE+0.5); + Add2ESDsList(hESDSumLocalChi2YPerDE, kESDSumLocalChi2YPerDE, forExpert); + fIsInitESDs = kTRUE; } @@ -612,29 +938,8 @@ void AliMUONQADataMakerRec::MakeRaws(AliRawReader* rawReader) void AliMUONQADataMakerRec::MakeRawsTracker(AliRawReader* rawReader) { /// make QA for rawdata tracker - - if (!fTrackerDataMaker) - { - const Bool_t histogram(kFALSE); - const Bool_t fastDecoder(kTRUE); - -// fTrackerDataMaker = new AliMUONTrackerRawDataMaker(rawReader,histogram,fastDecoder,takeRawReaderOwnership); - - fTrackerDataMaker = new AliMUONTrackerCalibratedDataMaker(GetRecoParam(), - AliCDBManager::Instance()->GetRun(), - rawReader, - AliCDBManager::Instance()->GetDefaultStorage()->GetURI(), - "NOGAIN", - histogram, - 0.0,0.0, - fastDecoder); - - fTrackerDataMaker->Data()->DisableChannelLevel(); // to save up disk space, we only store starting at the manu level - - fTrackerDataMaker->SetRunning(kTRUE); - } - - ((AliMUONTrackerCalibratedDataMaker*)fTrackerDataMaker)->SetRawReader(rawReader); + + ((AliMUONTrackerDataMaker*)fTrackerDataMaker)->SetRawReader(rawReader); fTrackerDataMaker->ProcessEvent(); } @@ -659,6 +964,12 @@ void AliMUONQADataMakerRec::MakeRawsTrigger(AliRawReader* rawReader) AliMUONDDLTrigger* ddlTrigger = rawStreamTrig.GetDDLTrigger(); AliMUONDarcHeader* darcHeader = ddlTrigger->GetDarcHeader(); + if (darcHeader->GetGlobalFlag()){ + UInt_t nOfClocks = darcHeader->GetGlobalClock(); + Double_t nOfSeconds = ((Double_t) nOfClocks) / 40e6; // 1 clock each 25 ns + ((TH1F*)GetRawsData(kTriggerScalersTime))->Fill(1., nOfSeconds); + } + Int_t nReg = darcHeader->GetRegHeaderEntries(); for(Int_t iReg = 0; iReg < nReg ;iReg++) @@ -761,6 +1072,7 @@ void AliMUONQADataMakerRec::MakeRecPointsTracker(TTree* clustersTree) GetRecPointsData(kTrackerNumberOfClustersPerChamber)->Fill(chamberId); GetRecPointsData(kTrackerClusterChargePerChamber+chamberId)->Fill(cluster->GetCharge()); GetRecPointsData(kTrackerClusterMultiplicityPerChamber+chamberId)->Fill(cluster->GetNDigits()); + GetRecPointsData(kTrackerClusterHitMapPerChamber+chamberId)->Fill(cluster->GetX(),cluster->GetY()); } @@ -856,6 +1168,7 @@ void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd) GetESDsData(kESDPt)->Fill(esdTrack->Pt()); GetESDsData(kESDRapidity)->Fill(esdTrack->Y()); GetESDsData(kESDChi2)->Fill(track->GetNormalizedChi2()); + GetESDsData(kESDProbChi2)->Fill(TMath::Prob(track->GetGlobalChi2(),track->GetNDF())); GetESDsData(kESDnClustersPerTrack)->Fill(track->GetNClusters()); // loop over clusters @@ -867,30 +1180,34 @@ void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd) Int_t deID = cluster->GetDetElemId(); Double_t residualX = cluster->GetX() - trackParam->GetNonBendingCoor(); Double_t residualY = cluster->GetY() - trackParam->GetBendingCoor(); + Double_t localChi2X = (cluster->GetErrX2() > 0.) ? residualX*residualX/cluster->GetErrX2() : 0.; + Double_t localChi2Y = (cluster->GetErrY2() > 0.) ? residualY*residualY/cluster->GetErrY2() : 0.; GetESDsData(kESDClusterHitMap+chId)->Fill(cluster->GetX(), cluster->GetY()); - GetESDsData(kESDnClustersPerCh)->Fill(chId); - GetESDsData(kESDnClustersPerDE)->Fill(deID); + GetESDsData(kESDnTotClustersPerCh)->Fill(chId); + GetESDsData(kESDnTotClustersPerDE)->Fill(deID); - GetESDsData(kESDClusterCharge)->Fill(cluster->GetCharge()); GetESDsData(kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge()); - GetESDsData(kESDClusterChargePerDE)->Fill(deID, cluster->GetCharge()); + GetESDsData(kESDSumClusterChargePerDE)->Fill(deID, cluster->GetCharge()); if (cluster->GetNDigits() > 0) { // discard clusters with pad not stored in ESD - GetESDsData(kESDClusterMult)->Fill(cluster->GetNDigits()); - GetESDsData(kESDClusterMultInCh+chId)->Fill(cluster->GetNDigits()); - GetESDsData(kESDClusterMultPerDE)->Fill(deID, cluster->GetNDigits()); + GetESDsData(kESDnTotFullClustersPerDE)->Fill(deID); + GetESDsData(kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits()); + GetESDsData(kESDSumClusterSizePerDE)->Fill(deID, cluster->GetNDigits()); } - GetESDsData(kESDResidualX)->Fill(residualX); - GetESDsData(kESDResidualY)->Fill(residualY); GetESDsData(kESDResidualXInCh+chId)->Fill(residualX); GetESDsData(kESDResidualYInCh+chId)->Fill(residualY); - GetESDsData(kESDResidualXPerDEMean)->Fill(deID, residualX); - GetESDsData(kESDResidualYPerDEMean)->Fill(deID, residualY); - GetESDsData(kESDResidualXPerDESigma)->Fill(deID, residualX*residualX); - GetESDsData(kESDResidualYPerDESigma)->Fill(deID, residualY*residualY); + GetESDsData(kESDSumResidualXPerDE)->Fill(deID, residualX); + GetESDsData(kESDSumResidualYPerDE)->Fill(deID, residualY); + GetESDsData(kESDSumResidualX2PerDE)->Fill(deID, residualX*residualX); + GetESDsData(kESDSumResidualY2PerDE)->Fill(deID, residualY*residualY); + + GetESDsData(kESDLocalChi2XInCh+chId)->Fill(localChi2X); + GetESDsData(kESDLocalChi2YInCh+chId)->Fill(localChi2Y); + GetESDsData(kESDSumLocalChi2XPerDE)->Fill(deID, localChi2X); + GetESDsData(kESDSumLocalChi2YPerDE)->Fill(deID, localChi2Y); trackParam = static_cast(track->GetTrackParamAtCluster()->After(trackParam)); } @@ -915,6 +1232,7 @@ void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task) /// Display trigger information in a user-friendly way: /// from local board and strip numbers to their position on chambers // + if(task!=AliQA::kRECPOINTS && task!=AliQA::kRAWS) return; AliMUONTriggerDisplay triggerDisplay; @@ -933,7 +1251,7 @@ void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task) ERaw hindex = ( iCath == 0 ) ? kTriggerScalersBP : kTriggerScalersNBP; histoStrips = (TH3F*)GetRawsData(hindex); - if(histoStrips->GetEntries()==0) return; // No scalers found + if(histoStrips->GetEntries()==0) continue; // No scalers found } for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++) @@ -948,11 +1266,130 @@ void AliMUONQADataMakerRec::DisplayTriggerInfo(AliQA::TASKINDEX_t task) histoStrips->GetXaxis()->SetRange(bin,bin); TH2F* inputHisto = (TH2F*)histoStrips->Project3D("zy"); triggerDisplay.FillDisplayHistogram(inputHisto, histoDisplayStrips, AliMUONTriggerDisplay::kDisplayStrips, iCath, iChamber); + if(task==AliQA::kRAWS) { + Float_t acquisitionTime = ((TH1F*)GetRawsData(kTriggerScalersTime))->GetBinContent(1); + histoDisplayStrips->Scale(1./acquisitionTime); + } } // iChamber } // iCath - if(task!=AliQA::kRECPOINTS) return; - TH1F* histoBoards = (TH1F*)GetRecPointsData(kTriggeredBoards); - TH2F* histoDisplayBoards = (TH2F*)GetRecPointsData(kTriggerBoardsDisplay); - triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0); + if(task==AliQA::kRAWS){ + TH2F* histoI = (TH2F*) GetRawsData(kTriggerRPCi); + TH2F* histoHV = (TH2F*) GetRawsData(kTriggerRPChv); + FillTriggerDCSHistos(); + for (Int_t iChamber = 0; iChamber < AliMpConstants::NofTriggerChambers(); iChamber++) { + Int_t bin = histoI->GetXaxis()->FindBin(11+iChamber); + TH2F* histoDisplayI = (TH2F*)GetRawsData(kTriggerIDisplay + iChamber); + triggerDisplay.FillDisplayHistogram(histoI->ProjectionY("_px", bin, bin), histoDisplayI, AliMUONTriggerDisplay::kDisplaySlats, 0, iChamber); + TH2F* histoDisplayHV = (TH2F*)GetRawsData(kTriggerHVDisplay + iChamber); + bin = histoHV->GetXaxis()->FindBin(11+iChamber); + triggerDisplay.FillDisplayHistogram(histoHV->ProjectionY("_px", bin, bin), histoDisplayHV, AliMUONTriggerDisplay::kDisplaySlats, 0, iChamber); + } + } + + if(task==AliQA::kRECPOINTS){ + TH1F* histoBoards = (TH1F*)GetRecPointsData(kTriggeredBoards); + TH2F* histoDisplayBoards = (TH2F*)GetRecPointsData(kTriggerBoardsDisplay); + triggerDisplay.FillDisplayHistogram(histoBoards, histoDisplayBoards, AliMUONTriggerDisplay::kDisplayBoards, 0, 0); + } +} + + +//_____________________________________________________________________________ +Bool_t +AliMUONQADataMakerRec::FillTriggerDCSHistos() +{ + /// Get HV and currents values for one trigger chamber + + AliCodeTimerAuto(""); + + AliMUONCalibrationData calibrationData(AliCDBManager::Instance()->GetRun()); + + TMap* triggerDcsMap = calibrationData.TriggerDCS(); + + if ( !triggerDcsMap ) + { + AliError("Cannot fill DCS histos, as triggerDcsMap is NULL"); + return kFALSE; + } + + AliMpDEIterator deIt; + + deIt.First(); + + AliMpDCSNamer triggerDcsNamer("TRIGGER"); + + TH2* currHisto = 0x0; + + Bool_t error = kFALSE; + + while ( !deIt.IsDone() ) + { + Int_t detElemId = deIt.CurrentDEId(); + + if ( AliMpDEManager::GetStationType(detElemId) == AliMp::kStationTrigger) { + + Int_t iChamber = AliMpDEManager::GetChamberId(detElemId); + Int_t slat = detElemId%100; + + for(Int_t iMeas=0; iMeas(triggerDcsMap->FindObject(currAlias.Data())); + + if (!triggerDcsPair) + { + AliError(Form("Did not find expected alias (%s) for DE %d", + currAlias.Data(),detElemId)); + error = kTRUE; + } + else + { + TObjArray* values = static_cast(triggerDcsPair->Value()); + if (!values) + { + AliError(Form("Could not get values for alias %s",currAlias.Data())); + error = kTRUE; + } + else + { + TIter next(values); + AliDCSValue* val; + + while ( ( val = static_cast(next()) ) ) + { + Float_t hvi = val->GetFloat(); + + AliDebug(2, Form("Value %f", hvi)); + + switch(iMeas){ + case AliMpDCSNamer::kDCSI: + currHisto = (TH2F*) GetRawsData(kTriggerRPCi); + break; + case AliMpDCSNamer::kDCSHV: + currHisto = (TH2F*) GetRawsData(kTriggerRPChv); + break; + } + Int_t binX = currHisto->GetXaxis()->FindBin(iChamber+1); + Int_t binY = currHisto->GetYaxis()->FindBin(slat); + currHisto->SetBinContent(binX, binY, hvi); + } // loop on values + } // if (!values) + } // if (!triggerDcsPair) + } // loop on measured types (HV and currents) + } // if (stationType == kStationTrigger) + + deIt.Next(); + } + return error; +} + +//____________________________________________________________________________ +AliMUONVTrackerData* AliMUONQADataMakerRec::GetTrackerData() const +{ + + return fTrackerDataMaker->Data(); + }