X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=MUON%2FAliMUONTrackerQADataMakerRec.cxx;h=95e4649d3847e063795e6f5fd2a1fff116d7d9a2;hb=6dd9ec100e601f0c46e7cba86ad4cbb9e1bfebb3;hp=7a98807fb85fcad108f63b3759a4972c7ecd2c72;hpb=9074a9a9d01618af9e23647ea6fef771c62d98a2;p=u%2Fmrichter%2FAliRoot.git diff --git a/MUON/AliMUONTrackerQADataMakerRec.cxx b/MUON/AliMUONTrackerQADataMakerRec.cxx index 7a98807fb85..95e4649d384 100644 --- a/MUON/AliMUONTrackerQADataMakerRec.cxx +++ b/MUON/AliMUONTrackerQADataMakerRec.cxx @@ -169,177 +169,249 @@ void AliMUONTrackerQADataMakerRec::InsertTrackerData(Int_t specie, void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleESDs(Int_t, TObjArray**) { /// Normalize ESD histograms - - if (!GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)) return; - - AliCodeTimerAuto("",0); - - Double_t nTracks = GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)->GetEntries(); - if (nTracks <= 0) return; - - TH1* hESDnClustersPerCh = GetESDsData(AliMUONQAIndices::kESDnClustersPerCh); - TH1* hESDnClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnClustersPerDE); - TH1* hESDClusterChargePerChMean = GetESDsData(AliMUONQAIndices::kESDClusterChargePerChMean); - TH1* hESDClusterChargePerChSigma = GetESDsData(AliMUONQAIndices::kESDClusterChargePerChSigma); - TH1* hESDClusterSizePerChMean = GetESDsData(AliMUONQAIndices::kESDClusterSizePerChMean); - TH1* hESDClusterSizePerChSigma = GetESDsData(AliMUONQAIndices::kESDClusterSizePerChSigma); - TH1* hESDResidualXPerChMean = GetESDsData(AliMUONQAIndices::kESDResidualXPerChMean); - TH1* hESDResidualXPerChSigma = GetESDsData(AliMUONQAIndices::kESDResidualXPerChSigma); - TH1* hESDResidualYPerChMean = GetESDsData(AliMUONQAIndices::kESDResidualYPerChMean); - TH1* hESDResidualYPerChSigma = GetESDsData(AliMUONQAIndices::kESDResidualYPerChSigma); - TH1* hESDLocalChi2XPerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerChMean); - TH1* hESDLocalChi2YPerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerChMean); - TH1* hESDLocalChi2PerChMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2PerChMean); - TH1* hESDClusterChargePerDE = GetESDsData(AliMUONQAIndices::kESDClusterChargePerDE); - TH1* hESDClusterSizePerDE = GetESDsData(AliMUONQAIndices::kESDClusterSizePerDE); - TH1* hESDResidualXPerDEMean = GetESDsData(AliMUONQAIndices::kESDResidualXPerDEMean); - TH1* hESDResidualXPerDESigma = GetESDsData(AliMUONQAIndices::kESDResidualXPerDESigma); - TH1* hESDResidualYPerDEMean = GetESDsData(AliMUONQAIndices::kESDResidualYPerDEMean); - TH1* hESDResidualYPerDESigma = GetESDsData(AliMUONQAIndices::kESDResidualYPerDESigma); - TH1* hESDLocalChi2XPerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerDEMean); - TH1* hESDLocalChi2YPerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerDEMean); - TH1* hESDLocalChi2PerDEMean = GetESDsData(AliMUONQAIndices::kESDLocalChi2PerDEMean); - TH1* hESDnTotClustersPerCh = GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh); - TH1* hESDnTotClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE); - TH1* hESDnTotFullClustersPerDE = GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE); - TH1* hESDSumClusterChargePerDE = GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE); - TH1* hESDSumClusterSizePerDE = GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE); - TH1* hESDSumResidualXPerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE); - TH1* hESDSumResidualYPerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE); - TH1* hESDSumResidualX2PerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE); - TH1* hESDSumResidualY2PerDE = GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE); - TH1* hESDSumLocalChi2XPerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE); - TH1* hESDSumLocalChi2YPerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE); - TH1* hESDSumLocalChi2PerDE = GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE); - - hESDnClustersPerCh->Reset(); - hESDnClustersPerDE->Reset(); - hESDnClustersPerCh->Add(hESDnTotClustersPerCh, 1./nTracks); - hESDnClustersPerDE->Add(hESDnTotClustersPerDE, 1./nTracks); - - // loop over chambers - for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) { - - TH1* hESDClusterChargeInCh = GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+iCh); - Double_t sigmaCharge = hESDClusterChargeInCh->GetRMS(); - hESDClusterChargePerChMean->SetBinContent(iCh+1, hESDClusterChargeInCh->GetMean()); - hESDClusterChargePerChMean->SetBinError(iCh+1, hESDClusterChargeInCh->GetMeanError()); - hESDClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge); - hESDClusterChargePerChSigma->SetBinError(iCh+1, hESDClusterChargeInCh->GetRMSError()); - - TH1* hESDClusterSizeInCh = GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+iCh); - Double_t sigmaSize = hESDClusterSizeInCh->GetRMS(); - hESDClusterSizePerChMean->SetBinContent(iCh+1, hESDClusterSizeInCh->GetMean()); - hESDClusterSizePerChMean->SetBinError(iCh+1, hESDClusterSizeInCh->GetMeanError()); - hESDClusterSizePerChSigma->SetBinContent(iCh+1, sigmaSize); - hESDClusterSizePerChSigma->SetBinError(iCh+1, hESDClusterSizeInCh->GetRMSError()); - - TH1* hESDResidualXInCh = GetESDsData(AliMUONQAIndices::kESDResidualXInCh+iCh); - Double_t sigmaResidualX = hESDResidualXInCh->GetRMS(); - hESDResidualXPerChMean->SetBinContent(iCh+1, hESDResidualXInCh->GetMean()); - hESDResidualXPerChMean->SetBinError(iCh+1, hESDResidualXInCh->GetMeanError()); - hESDResidualXPerChSigma->SetBinContent(iCh+1, sigmaResidualX); - hESDResidualXPerChSigma->SetBinError(iCh+1, hESDResidualXInCh->GetRMSError()); - - TH1* hESDResidualYInCh = GetESDsData(AliMUONQAIndices::kESDResidualYInCh+iCh); - Double_t sigmaResidualY = hESDResidualYInCh->GetRMS(); - hESDResidualYPerChMean->SetBinContent(iCh+1, hESDResidualYInCh->GetMean()); - hESDResidualYPerChMean->SetBinError(iCh+1, hESDResidualYInCh->GetMeanError()); - hESDResidualYPerChSigma->SetBinContent(iCh+1, sigmaResidualY); - hESDResidualYPerChSigma->SetBinError(iCh+1, hESDResidualYInCh->GetRMSError()); - - TH1* hESDLocalChi2XInCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+iCh); - Double_t sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS(); - hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean()); - hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError()); - - TH1* hESDLocalChi2YInCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+iCh); - Double_t sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS(); - hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean()); - hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError()); - - TH1* hESDLocalChi2InCh = GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+iCh); - Double_t sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS(); - hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean()); - hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError()); - - // loop over DE into chamber iCh - AliMpDEIterator it; - it.First(iCh); - while ( !it.IsDone()) { - - Int_t iDE = it.CurrentDEId(); - - Double_t nClusters = hESDnTotClustersPerDE->GetBinContent(iDE+1); - if (nClusters > 1) { - - hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters); - hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters)); - - Double_t meanResX = hESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters; - hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX); - hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters)); - hESDResidualXPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX)); - hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters)); - - Double_t meanResY = hESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters; - hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY); - hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters)); - hESDResidualYPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY)); - hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters)); - - hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters); - hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters)); - - hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters); - hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters)); - - hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)/nClusters); - hESDLocalChi2PerDEMean->SetBinError(iDE+1, sigmaLocalChi2/TMath::Sqrt(nClusters)); - - } else { - - hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)); - hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax()); - - hESDResidualXPerDEMean->SetBinContent(iDE+1, hESDSumResidualXPerDE->GetBinContent(iDE+1)); - hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax()); - hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.); - hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax()); - - hESDResidualYPerDEMean->SetBinContent(iDE+1, hESDSumResidualYPerDE->GetBinContent(iDE+1)); - hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax()); - hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.); - hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax()); - - hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)); - hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax()); - - hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)); - hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax()); - - hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)); - hESDLocalChi2PerDEMean->SetBinError(iDE+1, hESDLocalChi2InCh->GetXaxis()->GetXmax()); - + // + Bool_t firstFill = kTRUE; + // + for (int itc=-1;itcGetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class + // + TH1* hESDnClustersPerTr = Master()->GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack, itc); + if (! hESDnClustersPerTr) continue; + Double_t nTracks = hESDnClustersPerTr->GetEntries(); + if (nTracks <= 0) continue; + // + if (firstFill) { AliCodeTimerAuto("",0); firstFill = kFALSE;} + + TH1* hESDnClustersPerCh = Master()->GetESDsData(AliMUONQAIndices::kESDnClustersPerCh,itc); + TH1* hESDnClustersPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDnClustersPerDE,itc); + TH1* hESDClusterChargePerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargePerChMean,itc); + TH1* hESDClusterChargePerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargePerChSigma,itc); + TH1* hESDClusterSizePerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizePerChMean,itc); + TH1* hESDClusterSizePerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizePerChSigma,itc); + TH1* hESDResidualXPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerChMean,itc); + TH1* hESDResidualXPerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerChSigma,itc); + TH1* hESDResidualYPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerChMean,itc); + TH1* hESDResidualYPerChSigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerChSigma,itc); + TH1* hESDLocalChi2XPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerChMean,itc); + TH1* hESDLocalChi2YPerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerChMean,itc); + TH1* hESDLocalChi2PerChMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2PerChMean,itc); + TH1* hESDClusterChargePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargePerDE,itc); + TH1* hESDClusterSizePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizePerDE,itc); + TH1* hESDResidualXPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerDEMean,itc); + TH1* hESDResidualXPerDESigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXPerDESigma,itc); + TH1* hESDResidualYPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerDEMean,itc); + TH1* hESDResidualYPerDESigma = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYPerDESigma,itc); + TH1* hESDLocalChi2XPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2XPerDEMean,itc); + TH1* hESDLocalChi2YPerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2YPerDEMean,itc); + TH1* hESDLocalChi2PerDEMean = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2PerDEMean,itc); + TH1* hESDnTotClustersPerCh = Master()->GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh,itc); + TH1* hESDnTotClustersPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE,itc); + TH1* hESDnTotFullClustersPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE,itc); + TH1* hESDSumClusterChargePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE,itc); + TH1* hESDSumClusterSizePerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE,itc); + TH1* hESDSumResidualXPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE,itc); + TH1* hESDSumResidualYPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE,itc); + TH1* hESDSumResidualX2PerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE,itc); + TH1* hESDSumResidualY2PerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE,itc); + TH1* hESDSumLocalChi2XPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE,itc); + TH1* hESDSumLocalChi2YPerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE,itc); + TH1* hESDSumLocalChi2PerDE = Master()->GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE,itc); + // + if (hESDnClustersPerCh && hESDnTotClustersPerCh) { + hESDnClustersPerCh->Reset(); + hESDnClustersPerCh->Add(hESDnTotClustersPerCh, 1./nTracks); + } + if (hESDnClustersPerDE && hESDnTotClustersPerDE) { + hESDnClustersPerDE->Reset(); + hESDnClustersPerDE->Add(hESDnTotClustersPerDE, 1./nTracks); + } + // + // loop over chambers + for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) { + // + double sigmaCharge=0,sigmaSize=0,sigmaResidualX=0,sigmaResidualY=0,sigmaLocalChi2X=0,sigmaLocalChi2Y=0,sigmaLocalChi2=0; + // + TH1* hESDClusterChargeInCh = Master()->GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+iCh,itc); + if (hESDClusterChargeInCh) { + sigmaCharge = hESDClusterChargeInCh->GetRMS(); + if (hESDClusterChargePerChMean) { + hESDClusterChargePerChMean->SetBinContent(iCh+1, hESDClusterChargeInCh->GetMean()); + hESDClusterChargePerChMean->SetBinError(iCh+1, hESDClusterChargeInCh->GetMeanError()); + } + if (hESDClusterChargePerChSigma) { + hESDClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge); + hESDClusterChargePerChSigma->SetBinError(iCh+1, hESDClusterChargeInCh->GetRMSError()); + } } - - Double_t nFullClusters = hESDnTotFullClustersPerDE->GetBinContent(iDE+1); - if (nFullClusters > 1) { - - hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters); - hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters)); - - } else { - - hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)); - hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax()); - + // + TH1* hESDClusterSizeInCh = Master()->GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+iCh,itc); + if (hESDClusterSizeInCh) { + sigmaSize = hESDClusterSizeInCh->GetRMS(); + if (hESDClusterSizePerChMean) { + hESDClusterSizePerChMean->SetBinContent(iCh+1, hESDClusterSizeInCh->GetMean()); + hESDClusterSizePerChMean->SetBinError(iCh+1, hESDClusterSizeInCh->GetMeanError()); + } + if (hESDClusterSizePerChSigma) { + hESDClusterSizePerChSigma->SetBinContent(iCh+1, sigmaSize); + hESDClusterSizePerChSigma->SetBinError(iCh+1, hESDClusterSizeInCh->GetRMSError()); + } + } + // + TH1* hESDResidualXInCh = Master()->GetESDsData(AliMUONQAIndices::kESDResidualXInCh+iCh,itc); + if (hESDResidualXInCh) { + sigmaResidualX = hESDResidualXInCh->GetRMS(); + if (hESDResidualXPerChMean) { + hESDResidualXPerChMean->SetBinContent(iCh+1, hESDResidualXInCh->GetMean()); + hESDResidualXPerChMean->SetBinError(iCh+1, hESDResidualXInCh->GetMeanError()); + } + if (hESDResidualXPerChSigma) { + hESDResidualXPerChSigma->SetBinContent(iCh+1, sigmaResidualX); + hESDResidualXPerChSigma->SetBinError(iCh+1, hESDResidualXInCh->GetRMSError()); + } + } + // + TH1* hESDResidualYInCh = Master()->GetESDsData(AliMUONQAIndices::kESDResidualYInCh+iCh,itc); + if (hESDResidualYInCh) { + sigmaResidualY = hESDResidualYInCh->GetRMS(); + if (hESDResidualYPerChMean) { + hESDResidualYPerChMean->SetBinContent(iCh+1, hESDResidualYInCh->GetMean()); + hESDResidualYPerChMean->SetBinError(iCh+1, hESDResidualYInCh->GetMeanError()); + } + if (hESDResidualYPerChSigma) { + hESDResidualYPerChSigma->SetBinContent(iCh+1, sigmaResidualY); + hESDResidualYPerChSigma->SetBinError(iCh+1, hESDResidualYInCh->GetRMSError()); + } + } + // + TH1* hESDLocalChi2XInCh = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+iCh,itc); + if (hESDLocalChi2XInCh) { + sigmaLocalChi2X = hESDLocalChi2XInCh->GetRMS(); + if (hESDLocalChi2XPerChMean) { + hESDLocalChi2XPerChMean->SetBinContent(iCh+1, hESDLocalChi2XInCh->GetMean()); + hESDLocalChi2XPerChMean->SetBinError(iCh+1, hESDLocalChi2XInCh->GetMeanError()); + } } + // + TH1* hESDLocalChi2YInCh = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+iCh,itc); + if (hESDLocalChi2YInCh) { + sigmaLocalChi2Y = hESDLocalChi2YInCh->GetRMS(); + if (hESDLocalChi2YPerChMean) { + hESDLocalChi2YPerChMean->SetBinContent(iCh+1, hESDLocalChi2YInCh->GetMean()); + hESDLocalChi2YPerChMean->SetBinError(iCh+1, hESDLocalChi2YInCh->GetMeanError()); + } + } + // + TH1* hESDLocalChi2InCh = Master()->GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+iCh,itc); + if (hESDLocalChi2InCh) { + sigmaLocalChi2 = hESDLocalChi2InCh->GetRMS(); + if (hESDLocalChi2PerChMean) { + hESDLocalChi2PerChMean->SetBinContent(iCh+1, hESDLocalChi2InCh->GetMean()); + hESDLocalChi2PerChMean->SetBinError(iCh+1, hESDLocalChi2InCh->GetMeanError()); + } + } + // + // loop over DE into chamber iCh + AliMpDEIterator it; + it.First(iCh); + while ( !it.IsDone()) { + + Int_t iDE = it.CurrentDEId(); + + Double_t nClusters = hESDnTotClustersPerDE ? hESDnTotClustersPerDE->GetBinContent(iDE+1) : 0; + if (nClusters > 1) { + + if (hESDClusterChargePerDE && hESDSumClusterChargePerDE) { + hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters); + hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters)); + } + + if (hESDResidualXPerDEMean && hESDResidualXPerDESigma && hESDSumResidualXPerDE) { + Double_t meanResX = hESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters; + hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX); + hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters)); + // + hESDResidualXPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX)); + hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters)); + } + // + if (hESDResidualYPerDEMean && hESDResidualYPerDESigma && hESDSumResidualYPerDE) { + Double_t meanResY = hESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters; + hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY); + hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters)); + hESDResidualYPerDESigma->SetBinContent(iDE+1, ProtectedSqrt(hESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY)); + hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters)); + } + // + if (hESDLocalChi2XPerDEMean && hESDSumLocalChi2XPerDE) { + hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters); + hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters)); + } + // + if (hESDLocalChi2YPerDEMean && hESDSumLocalChi2YPerDE) { + hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters); + hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters)); + } + // + if (hESDLocalChi2PerDEMean && hESDSumLocalChi2PerDE) { + hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)/nClusters); + hESDLocalChi2PerDEMean->SetBinError(iDE+1, sigmaLocalChi2/TMath::Sqrt(nClusters)); + } + } + else { + if (hESDClusterChargePerDE && hESDClusterChargeInCh && hESDSumClusterChargePerDE) { + hESDClusterChargePerDE->SetBinContent(iDE+1, hESDSumClusterChargePerDE->GetBinContent(iDE+1)); + hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax()); + } + // + if (hESDResidualXPerDEMean && hESDResidualXPerDESigma && hESDSumResidualXPerDE && hESDResidualXInCh) { + hESDResidualXPerDEMean->SetBinContent(iDE+1, hESDSumResidualXPerDE->GetBinContent(iDE+1)); + hESDResidualXPerDEMean->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax()); + hESDResidualXPerDESigma->SetBinContent(iDE+1, 0.); + hESDResidualXPerDESigma->SetBinError(iDE+1, hESDResidualXInCh->GetXaxis()->GetXmax()); + } + // + if (hESDResidualYPerDEMean && hESDResidualYPerDESigma && hESDSumResidualYPerDE && hESDResidualYInCh) { + hESDResidualYPerDEMean->SetBinContent(iDE+1, hESDSumResidualYPerDE->GetBinContent(iDE+1)); + hESDResidualYPerDEMean->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax()); + hESDResidualYPerDESigma->SetBinContent(iDE+1, 0.); + hESDResidualYPerDESigma->SetBinError(iDE+1, hESDResidualYInCh->GetXaxis()->GetXmax()); + } + // + if (hESDLocalChi2XPerDEMean && hESDSumLocalChi2XPerDE && hESDLocalChi2XInCh) { + hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2XPerDE->GetBinContent(iDE+1)); + hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax()); + } + // + if (hESDLocalChi2YPerDEMean && hESDSumLocalChi2YPerDE && hESDLocalChi2YInCh) { + hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2YPerDE->GetBinContent(iDE+1)); + hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax()); + } + // + if (hESDLocalChi2PerDEMean && hESDSumLocalChi2PerDE && hESDLocalChi2InCh) { + hESDLocalChi2PerDEMean->SetBinContent(iDE+1, hESDSumLocalChi2PerDE->GetBinContent(iDE+1)); + hESDLocalChi2PerDEMean->SetBinError(iDE+1, hESDLocalChi2InCh->GetXaxis()->GetXmax()); + } + } - it.Next(); - } + Double_t nFullClusters = hESDnTotFullClustersPerDE ? hESDnTotFullClustersPerDE->GetBinContent(iDE+1) : 0; + if (nFullClusters > 1) { + if (hESDClusterSizePerDE && hESDSumClusterSizePerDE) { + hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters); + hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters)); + } + } + else { + if (hESDClusterSizePerDE && hESDSumClusterSizePerDE) { + hESDClusterSizePerDE->SetBinContent(iDE+1, hESDSumClusterSizePerDE->GetBinContent(iDE+1)); + hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax()); + } + } + + it.Next(); + } // while + + } // iCh loop - } + } // trigger classes loop } @@ -347,87 +419,106 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleESDs(Int_t, TObjArray**) void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRecPoints(Int_t specie, TObjArray** list) { /// Normalize RecPoints histograms - - if (!GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean)) return; - - AliCodeTimerAuto("",0); - - TH1* hTrackerClusterChargePerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean); - TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChSigma); - TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChMean); - TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChSigma); - TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDEMean); - TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDEMean); - - // loop over chambers - for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) { + // + Bool_t firstFill=kTRUE, needIns0=kTRUE, needIns1=kTRUE; + // + for (int itc=-1;itcGetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class + + TH1* hTrackerClusterChargePerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChMean,itc); + if (!hTrackerClusterChargePerChMean) continue; + // + if (firstFill) { AliCodeTimerAuto("",0); firstFill = kFALSE;} + + TH1* hTrackerClusterChargePerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChSigma,itc); + TH1* hTrackerClusterMultiplicityPerChMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChMean,itc); + TH1* hTrackerClusterMultiplicityPerChSigma = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChSigma,itc); + TH1* hTrackerClusterChargePerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDEMean,itc); + TH1* hTrackerClusterMultiplicityPerDEMean = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDEMean,itc); + + // loop over chambers + for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) { - TH1* hTrackerClusterChargePerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+iCh); - Double_t sigmaCharge = hTrackerClusterChargePerChamber->GetRMS(); - hTrackerClusterChargePerChMean->SetBinContent(iCh+1, hTrackerClusterChargePerChamber->GetMean()); - hTrackerClusterChargePerChMean->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetMeanError()); - hTrackerClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge); - hTrackerClusterChargePerChSigma->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetRMSError()); - - TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+iCh); - Double_t sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS(); - hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean()); - hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError()); - hTrackerClusterMultiplicityPerChSigma->SetBinContent(iCh+1, sigmaSize); - hTrackerClusterMultiplicityPerChSigma->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetRMSError()); - - // loop over DE into chamber iCh - AliMpDEIterator it; - it.First(iCh); - while ( !it.IsDone()) { - - Int_t iDE = it.CurrentDEId(); - - TH1* hTrackerClusterChargePerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+iDE); - hTrackerClusterChargePerDEMean->SetBinContent(iDE+1, hTrackerClusterChargePerDE->GetMean()); - Double_t nClusters = hTrackerClusterChargePerDE->GetEntries(); - if (nClusters > 1) hTrackerClusterChargePerDEMean->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters)); - else hTrackerClusterChargePerDEMean->SetBinError(iDE+1, hTrackerClusterChargePerChamber->GetXaxis()->GetXmax()); + TH1* hTrackerClusterChargePerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+iCh,itc); + Double_t sigmaCharge = 0; + if (hTrackerClusterChargePerChamber) { + sigmaCharge = hTrackerClusterChargePerChamber->GetRMS(); + hTrackerClusterChargePerChMean->SetBinContent(iCh+1, hTrackerClusterChargePerChamber->GetMean()); + hTrackerClusterChargePerChMean->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetMeanError()); + // + if (hTrackerClusterChargePerChSigma) { + hTrackerClusterChargePerChSigma->SetBinContent(iCh+1, sigmaCharge); + hTrackerClusterChargePerChSigma->SetBinError(iCh+1, hTrackerClusterChargePerChamber->GetRMSError()); + } + } + // + TH1* hTrackerClusterMultiplicityPerChamber = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+iCh,itc); + Double_t sigmaSize = 0; + if (hTrackerClusterMultiplicityPerChamber) { + sigmaSize = hTrackerClusterMultiplicityPerChamber->GetRMS(); + if (hTrackerClusterMultiplicityPerChMean) { + hTrackerClusterMultiplicityPerChMean->SetBinContent(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMean()); + hTrackerClusterMultiplicityPerChMean->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetMeanError()); + } + if (hTrackerClusterMultiplicityPerChSigma) { + hTrackerClusterMultiplicityPerChSigma->SetBinContent(iCh+1, sigmaSize); + hTrackerClusterMultiplicityPerChSigma->SetBinError(iCh+1, hTrackerClusterMultiplicityPerChamber->GetRMSError()); + } + } + // + // loop over DE into chamber iCh + AliMpDEIterator it; + it.First(iCh); + while ( !it.IsDone()) { - TH1* hTrackerClusterMultiplicityPerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+iDE); - hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean()); - nClusters = hTrackerClusterMultiplicityPerDE->GetEntries(); - if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters)); - else hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, hTrackerClusterMultiplicityPerChamber->GetXaxis()->GetXmax()); + Int_t iDE = it.CurrentDEId(); - it.Next(); + TH1* hTrackerClusterChargePerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+iDE,itc); + if (hTrackerClusterChargePerDEMean && hTrackerClusterChargePerDE) { + hTrackerClusterChargePerDEMean->SetBinContent(iDE+1, hTrackerClusterChargePerDE->GetMean()); + Double_t nClusters = hTrackerClusterChargePerDE->GetEntries(); + if (nClusters > 1) hTrackerClusterChargePerDEMean->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters)); + else hTrackerClusterChargePerDEMean->SetBinError(iDE+1, hTrackerClusterChargePerChamber ? + hTrackerClusterChargePerChamber->GetXaxis()->GetXmax() : 0); + } + TH1* hTrackerClusterMultiplicityPerDE = GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+iDE,itc); + if (hTrackerClusterMultiplicityPerDEMean && hTrackerClusterMultiplicityPerDE) { + hTrackerClusterMultiplicityPerDEMean->SetBinContent(iDE+1, hTrackerClusterMultiplicityPerDE->GetMean()); + Double_t nClusters = hTrackerClusterMultiplicityPerDE->GetEntries(); + if (nClusters > 1) hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nClusters)); + else hTrackerClusterMultiplicityPerDEMean->SetBinError(iDE+1, hTrackerClusterMultiplicityPerChamber ? + hTrackerClusterMultiplicityPerChamber->GetXaxis()->GetXmax() : 0); + } + it.Next(); + } } - } - if ( MappingCheckRecPoints(specie) ) - { - InsertTrackerData(specie,list,MappingCheckRecPoints(specie)->CreateData("RecPoints"),AliMUONQAIndices::kTrackerRecPoints,kTRUE); - } - - if ( TrackerRecData(specie) ) - { - /// put the trackerdata in the pipeline - InsertTrackerData(specie,list,TrackerRecData(specie),AliMUONQAIndices::kTrackerData); + if (needIns0 && MappingCheckRecPoints(specie) ) { // RS: I guess this should not be in the itc loop, do this only once + InsertTrackerData(specie,list,MappingCheckRecPoints(specie)->CreateData("RecPoints"),AliMUONQAIndices::kTrackerRecPoints,kTRUE); + needIns0 = kFALSE; + } - TH1* hbp = GetRecPointsData(AliMUONQAIndices::kTrackerBusPatchOccupancy); - TH1* hnevents = GetRecPointsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed); - TH1* hddl = GetRecPointsData(AliMUONQAIndices::kTrackerDDLOccupancy); - TH1* hddlevents = GetRecPointsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed); + if ( TrackerRecData(specie) ) { + /// put the trackerdata in the pipeline + if (needIns1) { // RS: I guess this should not be in the itc loop, do this only once + InsertTrackerData(specie,list,TrackerRecData(specie),AliMUONQAIndices::kTrackerData); + needIns1 = kFALSE; + } + TH1* hbp = GetRecPointsData(AliMUONQAIndices::kTrackerBusPatchOccupancy,itc); + TH1* hnevents = GetRecPointsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed,itc); + TH1* hddl = GetRecPointsData(AliMUONQAIndices::kTrackerDDLOccupancy,itc); + TH1* hddlevents = GetRecPointsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed,itc); - if ( !hbp || !hnevents || !hddl || !hddlevents) - { - AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents)); - return; + if (itc==-1 && (!hbp || !hnevents || !hddl || !hddlevents)) { //RS: produce error only for trigger-blind class + AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents)); + continue; // return; // RS: the histos might be booked for some trigger class only + } + // + ProjectTrackerData(TrackerRecData(specie),*hbp,*hnevents,*hddl,*hddlevents); } - - ProjectTrackerData(TrackerRecData(specie), - *hbp,*hnevents,*hddl,*hddlevents); - } - else - { - AliError(Form("TrackerRecData is null for specie %s",AliRecoParam::GetEventSpecieName(specie))); - } - + else { + AliError(Form("TrackerRecData is null for specie %s",AliRecoParam::GetEventSpecieName(specie))); + } + } // RS: loop over eventual clones per trigger class } //____________________________________________________________________________ @@ -441,20 +532,30 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleDigits(Int_t specie, TObjAr /// put the trackerdata in the pipeline InsertTrackerData(specie,list,TrackerCalData(specie),AliMUONQAIndices::kTrackerData); + // + for (int itc=-1;itcGetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class + // + TH1* hbp = GetDigitsData(AliMUONQAIndices::kTrackerBusPatchOccupancy, itc); + TH1* hnevents = GetDigitsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed, itc); + TH1* hddl = GetDigitsData(AliMUONQAIndices::kTrackerDDLOccupancy, itc); + TH1* hddlevents = GetDigitsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed, itc); - TH1* hbp = GetDigitsData(AliMUONQAIndices::kTrackerBusPatchOccupancy); - TH1* hnevents = GetDigitsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed); - TH1* hddl = GetDigitsData(AliMUONQAIndices::kTrackerDDLOccupancy); - TH1* hddlevents = GetDigitsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed); - - if ( !hbp || !hnevents || !hddl || !hddlevents) - { - AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents)); - return; - } - - ProjectTrackerData(TrackerCalData(specie), - *hbp,*hnevents,*hddl,*hddlevents); + if ( (!hbp || !hnevents || !hddl || !hddlevents) ) + { + if (itc==-1) + { + // report error only for trigger-blind class + AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents)); + continue; //return; // RS + } + else + { + continue; + } + } + // + ProjectTrackerData(TrackerCalData(specie), *hbp,*hnevents,*hddl,*hddlevents); + } // RS: loop over eventual clones per trigger class } } @@ -564,48 +665,51 @@ void AliMUONTrackerQADataMakerRec::EndOfDetectorCycleRaws(Int_t specie, TObjArra /// put the trackerdata in the pipeline InsertTrackerData(specie,list,TrackerDataMaker(specie)->Data(),AliMUONQAIndices::kTrackerData); TrackerDataMaker(specie)->SetOwnerOfData(kFALSE); // now that it's attached to list, list will take care of the deletion - - TH1* hbp = GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy); - TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed); - TH1* hddl = GetRawsData(AliMUONQAIndices::kTrackerDDLOccupancy); - TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed); - - if ( !hbp || !hnevents || !hddl || !hddlevents) - { - AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents)); - return; - } - - ProjectTrackerData(TrackerDataMaker(specie)->Data(), - *hbp,*hnevents,*hddl,*hddlevents); - - if ( fLogger->NumberOfEntries() > 0 ) - { - // readout errors - FillReadoutStatus(*fLogger,TrackerDataMaker(specie)->Data()); - fLogger->Clear(); - } + // + for (int itc=-1;itcGetNTrigClasses();itc++) { // RS: loop over eventual clones per trigger class + + TH1* hbp = GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy, itc); + TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofGoodPhysicsEventsUsed, itc); + TH1* hddl = GetRawsData(AliMUONQAIndices::kTrackerDDLOccupancy, itc); + TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsUsed, itc); + // + if (!hbp || !hnevents || !hddl || !hddlevents) { + if (itc==-1) AliError(Form("Missing some histograms : cannot work : hbp=%p hnevents=%p hddl=%p hddlevents=%p",hbp,hnevents,hddl,hddlevents)); + continue; // return; // RS + } + // + ProjectTrackerData(TrackerDataMaker(specie)->Data(), *hbp,*hnevents,*hddl,*hddlevents); + // + FillReadoutStatus(*fLogger,TrackerDataMaker(specie)->Data(), itc); + } // RS: loop over eventual clones per trigger class + // } } //____________________________________________________________________________ -void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data) +void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUONVTrackerData* data, Int_t trigCl) { + // RS: I am not sure if this part is valid for looping over trigger classes (loggers are not cloned) + if (trigCl!=-1) return; // For the moment only trigCl==-1 will be processed (i.e. trigger-blind histos) + log.ResetItr(); TString msg; Int_t occurence; - TH1* hparity = GetRawsData(AliMUONQAIndices::kTrackerBusPatchParityErrors); + TH1* hparity = GetRawsData(AliMUONQAIndices::kTrackerBusPatchParityErrors, trigCl); - TH1* htoken = GetRawsData(AliMUONQAIndices::kTrackerBusPatchTokenLostErrors); + TH1* htoken = GetRawsData(AliMUONQAIndices::kTrackerBusPatchTokenLostErrors, trigCl); - TH1* hpadding = GetRawsData(AliMUONQAIndices::kTrackerBusPatchPaddingErrors); + TH1* hpadding = GetRawsData(AliMUONQAIndices::kTrackerBusPatchPaddingErrors, trigCl); - TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus); + TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus, trigCl); + + TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen, trigCl); + + // + if (!hparity || !htoken || !hpadding || !hrostatus || !hnevents) return; - TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen); - Int_t nevents = TMath::Nint(hnevents->GetBinContent(1)); if ( !nevents ) @@ -613,10 +717,16 @@ void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUON TPaveText* text = new TPaveText(0,0,0.99,0.99,"NDC"); text->AddText("FATAL : 0 event seen ? That's NOT normal..."); text->SetFillColor(2); // red = FATAL + hrostatus->GetListOfFunctions()->Delete(); hrostatus->GetListOfFunctions()->Add(text); return; } + hparity->Reset(); + htoken->Reset(); + hpadding->Reset(); + hrostatus->Reset(); + ///////////////////////////////////////////////////////////////// /// Start by counting the number of errors ///////////////////////////////////////////////////////////////// @@ -629,7 +739,7 @@ void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUON { Int_t dsp(-1),iddl(-1),ecode(-1); - sscanf(msg.Data(),"Lost token error detected with address 0x%X of DDL %d and code %d.", + sscanf(msg.Data(),"Lost token error detected with address 0x%10X of DDL %10d and code %10d.", &dsp,&iddl,&ecode); Int_t localBP = ((dsp >> 16)- 4)*5 + 1; Int_t buspatch = localBP + iddl*100; @@ -737,14 +847,9 @@ void AliMUONTrackerQADataMakerRec::FillReadoutStatus(AliMUONLogger& log, AliMUON void AliMUONTrackerQADataMakerRec::FillEventSize(AliRawReader* rawReader) { /// Fill event size histogram(s) + // RS: substituted explicit histo filling by QA framework filling accounting for cloned histos - TH1* hnevents = GetRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen); - - TH1* hddlevents = GetRawsData(AliMUONQAIndices::kTrackerDDLNofEventsSeen); - - TH1* hDDLEventSize = GetRawsData(AliMUONQAIndices::kTrackerDDLEventSize); - - hnevents->Fill(0.0); + FillRawsData(AliMUONQAIndices::kTrackerNofPhysicsEventsSeen,0.0); Int_t offset = AliDAQ::DdlIDOffset("MUONTRK"); @@ -755,8 +860,8 @@ void AliMUONTrackerQADataMakerRec::FillEventSize(AliRawReader* rawReader) if (rawReader->ReadHeader() ) { UInt_t ddlsize = rawReader->GetEquipmentSize(); - hDDLEventSize->Fill(i+offset,ddlsize); - hddlevents->Fill(i+offset); + FillRawsData(AliMUONQAIndices::kTrackerDDLEventSize,i+offset,ddlsize); + FillRawsData(AliMUONQAIndices::kTrackerDDLNofEventsSeen,i+offset); } } rawReader->Reset(); @@ -858,7 +963,7 @@ void AliMUONTrackerQADataMakerRec::BookHistograms(AliQAv1::TASKINDEX_t task) // for raw data, we differentiate events seen from events used to be able to detect // severe decoder errors that lead to no event decoded (i.e. zero event used) even if // events are there (i.e non-zero event seen). - hnevents = new TH1F("kTrackerNofPhysicsEventsSeen","Number of physics events seen",1,-0.5,0.5); + hnevents = new TH1F("hTrackerNofPhysicsEventsSeen","Number of physics events seen",1,-0.5,0.5); // this one will count the number of physics event the rawdatamaker is *seeing* TAxis* a = hnevents->GetXaxis(); a->SetBinLabel(1,"NPhysicsEvents"); @@ -866,7 +971,7 @@ void AliMUONTrackerQADataMakerRec::BookHistograms(AliQAv1::TASKINDEX_t task) Master()->Add2List(hnevents,AliMUONQAIndices::kTrackerNofPhysicsEventsSeen,task,expert,!image,!saveCorr); } - hnevents = new TH1F("kTrackerNofGoodPhysicsEventsUsed","Number of good physics events used",1,-0.5,0.5); + hnevents = new TH1F("hTrackerNofGoodPhysicsEventsUsed","Number of good physics events used",1,-0.5,0.5); // this one will get its content from the TrackerData, i.e. it will count the number of *good* physics events *used* // (i.e. not empty and with no fatal readout error) TAxis* a = hnevents->GetXaxis(); @@ -952,6 +1057,9 @@ void AliMUONTrackerQADataMakerRec::InitRaws() h->SetStats(kFALSE); Add2RawsList(h,AliMUONQAIndices::kTrackerDDLEventSizePerEvent,kFALSE,kTRUE,kFALSE); + Add2RawsList(new TH1F("hTrackerIsThere","tracker is there",1,0,1),AliMUONQAIndices::kTrackerIsThere,kTRUE,kFALSE,kFALSE); + // + //ClonePerTrigClass(AliQAv1::kRAWS); // this should be the last line DONE at parent level } //__________________________________________________________________ @@ -974,6 +1082,8 @@ void AliMUONTrackerQADataMakerRec::InitDigits() /// Book histograms that are common to Raws and Digits BookHistograms(AliQAv1::kDIGITSR); + // + //ClonePerTrigClass(AliQAv1::kDIGITS); // this should be the last line DONE at parent level } //____________________________________________________________________________ @@ -1076,6 +1186,8 @@ void AliMUONTrackerQADataMakerRec::InitRecPoints() Add2RecPointsList(h1F, AliMUONQAIndices::kTrackerClusterChargePerDEMean, !expert, image); MappingCheckRecPoints(AliRecoParam::AConvert(Master()->GetEventSpecie()),kTRUE); + // + //ClonePerTrigClass(AliQAv1::kRECPOINTS); // this should be the last line DONE at parent level } //____________________________________________________________________________ @@ -1309,6 +1421,8 @@ void AliMUONTrackerQADataMakerRec::InitESDs() Add2ESDsList(hESDSumLocalChi2YPerDE, AliMUONQAIndices::kESDSumLocalChi2YPerDE, expert, !image); TH1F* hESDSumLocalChi2PerDE = new TH1F("hESDSumLocalChi2PerDE", "sum of local chi2 (~0.5*(#chi^{2}_{X}+#chi^{2}_{Y})) per DE;DetElem ID;#Sigma(local #chi^{2})", nDE+1, -0.5, nDE+0.5); Add2ESDsList(hESDSumLocalChi2PerDE, AliMUONQAIndices::kESDSumLocalChi2PerDE, expert, !image); + // + //ClonePerTrigClass(AliQAv1::kESDS); // this should be the last line DONE at parent level } //____________________________________________________________________________ @@ -1318,14 +1432,12 @@ void AliMUONTrackerQADataMakerRec::MakeRaws(AliRawReader* rawReader) AliCodeTimerAuto(Form("%s",AliRecoParam::GetEventSpecieName(AliRecoParam::AConvert(Master()->GetEventSpecie()))),0); - AliInfo(Form("rawReader class=%s",rawReader->ClassName())); - /// forces init GetRawsData(AliMUONQAIndices::kTrackerBusPatchOccupancy); AliMUONTrackerDataMaker* dm = static_cast(TrackerDataMaker(AliRecoParam::AConvert(Master()->GetEventSpecie()))); - dm->SetRawReader(rawReader); + dm->SetRawReader(rawReader); Int_t eventType = rawReader->GetType(); @@ -1337,11 +1449,10 @@ void AliMUONTrackerQADataMakerRec::MakeRaws(AliRawReader* rawReader) if ( dm->LastEventWasEmpty() ) { - TH1* hrostatus = GetRawsData(AliMUONQAIndices::kTrackerReadoutStatus); - - if (hrostatus) hrostatus->Fill(1.0*AliMUONQAIndices::kTrackerRawNofEmptyEvents); - } + FillRawsData(AliMUONQAIndices::kTrackerReadoutStatus,1.0*AliMUONQAIndices::kTrackerRawNofEmptyEvents); + } } + // } //__________________________________________________________________ @@ -1386,8 +1497,8 @@ void AliMUONTrackerQADataMakerRec::MakeDigits(TTree* digitsTree) } } } - TrackerCalData(AliRecoParam::AConvert(Master()->GetEventSpecie()))->Add(oneEventData); + // } //____________________________________________________________________________ @@ -1433,14 +1544,14 @@ void AliMUONTrackerQADataMakerRec::MakeRecPoints(TTree* clustersTree) Int_t detElemId = cluster->GetDetElemId(); Int_t chamberId = AliMpDEManager::GetChamberId(detElemId); - GetRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerDE)->Fill(detElemId); - GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+detElemId)->Fill(cluster->GetCharge()); - GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+detElemId)->Fill(cluster->GetNDigits()); - - GetRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerChamber)->Fill(chamberId); - GetRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+chamberId)->Fill(cluster->GetCharge()); - GetRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+chamberId)->Fill(cluster->GetNDigits()); - GetRecPointsData(AliMUONQAIndices::kTrackerClusterHitMapPerChamber+chamberId)->Fill(cluster->GetX(),cluster->GetY()); + FillRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerDE,detElemId); + FillRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerDE+detElemId,cluster->GetCharge()); + FillRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerDE+detElemId,cluster->GetNDigits()); + + FillRecPointsData(AliMUONQAIndices::kTrackerNumberOfClustersPerChamber,chamberId); + FillRecPointsData(AliMUONQAIndices::kTrackerClusterChargePerChamber+chamberId,cluster->GetCharge()); + FillRecPointsData(AliMUONQAIndices::kTrackerClusterMultiplicityPerChamber+chamberId,cluster->GetNDigits()); + FillRecPointsData(AliMUONQAIndices::kTrackerClusterHitMapPerChamber+chamberId,cluster->GetX(),cluster->GetY()); if ( mcr ) mcr->Store(*cluster); @@ -1463,7 +1574,8 @@ void AliMUONTrackerQADataMakerRec::MakeRecPoints(TTree* clustersTree) TrackerRecData(AliRecoParam::AConvert(Master()->GetEventSpecie()))->Add(oneEventData); - fClusterStore->Clear(); + fClusterStore->Clear(); + // } //____________________________________________________________________________ @@ -1479,7 +1591,7 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd) else AliError("Unable to get recoParam: use default ones for residual calculation"); esdInterface.LoadEvent(*esd); - GetESDsData(AliMUONQAIndices::kESDnTracks)->Fill(esdInterface.GetNTracks()); + FillESDsData(AliMUONQAIndices::kESDnTracks,esdInterface.GetNTracks()); Int_t nTrackMatchTrig = 0; @@ -1496,14 +1608,14 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd) if (esdTrack->ContainTriggerData()) nTrackMatchTrig++; - GetESDsData(AliMUONQAIndices::kESDMomentum)->Fill(esdTrack->P()); - GetESDsData(AliMUONQAIndices::kESDPt)->Fill(esdTrack->Pt()); - GetESDsData(AliMUONQAIndices::kESDRapidity)->Fill(esdTrack->Y()); - GetESDsData(AliMUONQAIndices::kESDChi2)->Fill(track->GetNormalizedChi2()); - GetESDsData(AliMUONQAIndices::kESDProbChi2)->Fill(TMath::Prob(track->GetGlobalChi2(),track->GetNDF())); - GetESDsData(AliMUONQAIndices::kESDThetaX)->Fill(esdTrack->GetThetaXUncorrected() / TMath::Pi() * 180.); - GetESDsData(AliMUONQAIndices::kESDThetaY)->Fill(esdTrack->GetThetaYUncorrected() / TMath::Pi() * 180.); - GetESDsData(AliMUONQAIndices::kESDnClustersPerTrack)->Fill(track->GetNClusters()); + FillESDsData(AliMUONQAIndices::kESDMomentum,esdTrack->P()); + FillESDsData(AliMUONQAIndices::kESDPt,esdTrack->Pt()); + FillESDsData(AliMUONQAIndices::kESDRapidity,esdTrack->Y()); + FillESDsData(AliMUONQAIndices::kESDChi2,track->GetNormalizedChi2()); + FillESDsData(AliMUONQAIndices::kESDProbChi2,TMath::Prob(track->GetGlobalChi2(),track->GetNDF())); + FillESDsData(AliMUONQAIndices::kESDThetaX,esdTrack->GetThetaXUncorrected() / TMath::Pi() * 180.); + FillESDsData(AliMUONQAIndices::kESDThetaY,esdTrack->GetThetaYUncorrected() / TMath::Pi() * 180.); + FillESDsData(AliMUONQAIndices::kESDnClustersPerTrack,track->GetNClusters()); // loop over clusters AliMUONTrackParam* trackParam = static_cast(track->GetTrackParamAtCluster()->First()); @@ -1520,33 +1632,33 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd) Double_t localChi2Y = (sigmaResidualY2 > 0.) ? residualY*residualY/sigmaResidualY2 : 0.; Double_t localChi2 = 0.5 * trackParam->GetLocalChi2(); - GetESDsData(AliMUONQAIndices::kESDClusterHitMap+chId)->Fill(cluster->GetX(), cluster->GetY()); + FillESDsData(AliMUONQAIndices::kESDClusterHitMap+chId,cluster->GetX(), cluster->GetY()); - GetESDsData(AliMUONQAIndices::kESDnTotClustersPerCh)->Fill(chId); - GetESDsData(AliMUONQAIndices::kESDnTotClustersPerDE)->Fill(deID); + FillESDsData(AliMUONQAIndices::kESDnTotClustersPerCh,chId); + FillESDsData(AliMUONQAIndices::kESDnTotClustersPerDE,deID); - GetESDsData(AliMUONQAIndices::kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge()); - GetESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE)->Fill(deID, cluster->GetCharge()); + FillESDsData(AliMUONQAIndices::kESDClusterChargeInCh+chId,cluster->GetCharge()); + FillESDsData(AliMUONQAIndices::kESDSumClusterChargePerDE,deID, cluster->GetCharge()); if (cluster->GetNDigits() > 0) { // discard clusters with pad not stored in ESD - GetESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE)->Fill(deID); - GetESDsData(AliMUONQAIndices::kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits()); - GetESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE)->Fill(deID, cluster->GetNDigits()); + FillESDsData(AliMUONQAIndices::kESDnTotFullClustersPerDE,deID); + FillESDsData(AliMUONQAIndices::kESDClusterSizeInCh+chId,cluster->GetNDigits()); + FillESDsData(AliMUONQAIndices::kESDSumClusterSizePerDE,deID, cluster->GetNDigits()); } - GetESDsData(AliMUONQAIndices::kESDResidualXInCh+chId)->Fill(residualX); - GetESDsData(AliMUONQAIndices::kESDResidualYInCh+chId)->Fill(residualY); - GetESDsData(AliMUONQAIndices::kESDSumResidualXPerDE)->Fill(deID, residualX); - GetESDsData(AliMUONQAIndices::kESDSumResidualYPerDE)->Fill(deID, residualY); - GetESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE)->Fill(deID, residualX*residualX); - GetESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE)->Fill(deID, residualY*residualY); + FillESDsData(AliMUONQAIndices::kESDResidualXInCh+chId,residualX); + FillESDsData(AliMUONQAIndices::kESDResidualYInCh+chId,residualY); + FillESDsData(AliMUONQAIndices::kESDSumResidualXPerDE,deID, residualX); + FillESDsData(AliMUONQAIndices::kESDSumResidualYPerDE,deID, residualY); + FillESDsData(AliMUONQAIndices::kESDSumResidualX2PerDE,deID, residualX*residualX); + FillESDsData(AliMUONQAIndices::kESDSumResidualY2PerDE,deID, residualY*residualY); - GetESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+chId)->Fill(localChi2X); - GetESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+chId)->Fill(localChi2Y); - GetESDsData(AliMUONQAIndices::kESDLocalChi2InCh+chId)->Fill(localChi2); - GetESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE)->Fill(deID, localChi2X); - GetESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE)->Fill(deID, localChi2Y); - GetESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE)->Fill(deID, localChi2); + FillESDsData(AliMUONQAIndices::kESDLocalChi2XInCh+chId,localChi2X); + FillESDsData(AliMUONQAIndices::kESDLocalChi2YInCh+chId,localChi2Y); + FillESDsData(AliMUONQAIndices::kESDLocalChi2InCh+chId,localChi2); + FillESDsData(AliMUONQAIndices::kESDSumLocalChi2XPerDE,deID, localChi2X); + FillESDsData(AliMUONQAIndices::kESDSumLocalChi2YPerDE,deID, localChi2Y); + FillESDsData(AliMUONQAIndices::kESDSumLocalChi2PerDE,deID, localChi2); trackParam = static_cast(track->GetTrackParamAtCluster()->After(trackParam)); @@ -1554,8 +1666,8 @@ void AliMUONTrackerQADataMakerRec::MakeESDs(AliESDEvent* esd) } - GetESDsData(AliMUONQAIndices::kESDMatchTrig)->Fill(nTrackMatchTrig); - + FillESDsData(AliMUONQAIndices::kESDMatchTrig,nTrackMatchTrig); + // } //____________________________________________________________________________ @@ -1573,8 +1685,6 @@ AliMUONTrackerQADataMakerRec::ResetDetectorRaws(TObjArray* list) /// Reset those histograms that must be reset (and only those), plus /// the trackerdata itself. - AliInfo(""); - TIter next(list); TObject* o; while ( ( o = next() ) ) @@ -1586,44 +1696,45 @@ AliMUONTrackerQADataMakerRec::ResetDetectorRaws(TObjArray* list) if ( !hn.Contains("TrackerBusPatchConfig") ) { - AliInfo(Form("Resetting %s",hn.Data())); - - if ( hn.Contains("DDLMeanEventSize") ) - { - h->Print(); - h->GetListOfFunctions()->ls(); - cout << ">>>>>" << endl; - } + AliDebug(1,Form("Resetting %s",hn.Data())); h->Reset(); - - if ( hn.Contains("DDLMeanEventSize") ) - { - h->Print(); - h->GetListOfFunctions()->ls(); - cout << "<<<<<<" << endl; - } } else { - // AliDebug(1,Form("Will not reset histogram %s",hn.Data())); - AliInfo(Form("Will not reset histogram %s",hn.Data())); + AliDebug(1,Form("Will not reset histogram %s",hn.Data())); } + continue; } - else - { - AliMUONVTrackerData* d = dynamic_cast(o); - if (d) - { - AliDebug(1,Form("Resetting %s",d->GetName())); - d->Clear(); + // RS account for the case when this histos were cloned per trigger class + TObjArray* harr = dynamic_cast(o); + if (harr) { + TString hn(harr->GetName()); + if ( !hn.Contains("TrackerBusPatchConfig") ) { + + AliDebug(1,Form("Resetting clones of %s",hn.Data())); + + TIter nextCl(harr); + TH1* hc = 0; + while ( (hc=dynamic_cast(nextCl())) ) hc->Reset(); } - else - { - AliError(Form("Found an object of class %s. Do not know how to reset.",o->ClassName())); + else { + AliDebug(1,Form("Will not reset clones of histogram %s",hn.Data())); } + continue; + } + // + AliMUONVTrackerData* d = dynamic_cast(o); + if (d) { + AliDebug(1,Form("Resetting %s",d->GetName())); + d->Clear(); + } + else { + AliError(Form("Found an object of class %s. Do not know how to reset.",o->ClassName())); } } + + fLogger->Clear(); } //____________________________________________________________________________ @@ -1636,7 +1747,6 @@ TObjArray* AliMUONTrackerQADataMakerRec::GetArray(TObjArray*& array, Bool_t crea if ( create ) { array = new TObjArray(AliRecoParam::kNSpecies); - array->SetOwner(kTRUE); } } @@ -1746,6 +1856,7 @@ AliMUONTrackerQADataMakerRec::MappingCheckRecPoints(Int_t specieIndex, Bool_t cr if (array) { o = array->At(specieIndex); + array->SetOwner(kTRUE); if (!o && create) { AliMUONQAMappingCheck* mcheck = new AliMUONQAMappingCheck(RunNumber());