From: ivana Date: Fri, 13 Feb 2009 11:08:14 +0000 (+0000) Subject: - Update and add new ESD QA histograms X-Git-Url: http://git.uio.no/git/?a=commitdiff_plain;h=5a240757bd78901da589c49d12109dbdd63cfe46;p=u%2Fmrichter%2FAliRoot.git - Update and add new ESD QA histograms - Fix bug in recovering the local trigger deviation from ghost ESDMuon tracks - Fix coding conventions violations (Philippe P.) --- diff --git a/MUON/AliMUONClusterStoreV2Iterator.cxx b/MUON/AliMUONClusterStoreV2Iterator.cxx index 19907f4bf52..884b753ce28 100644 --- a/MUON/AliMUONClusterStoreV2Iterator.cxx +++ b/MUON/AliMUONClusterStoreV2Iterator.cxx @@ -40,7 +40,7 @@ ClassImp(AliMUONClusterStoreV2Iterator) AliMUONClusterStoreV2Iterator::AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2* store, Int_t firstChamberId, Int_t lastChamberId) : TIterator(), - fStore(store), + fkStore(store), fFirstChamberId(firstChamberId), fLastChamberId(lastChamberId), fCurrentChamberId(-1), @@ -91,7 +91,7 @@ TObject* AliMUONClusterStoreV2Iterator::Next() fCurrentChamberId++; delete fChamberIterator; - fChamberIterator = static_cast(fStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator(); + fChamberIterator = static_cast(fkStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator(); o = NextInCurrentChamber(); } @@ -105,5 +105,5 @@ void AliMUONClusterStoreV2Iterator::Reset() /// Reset the iterator fCurrentChamberId = fFirstChamberId; delete fChamberIterator; - fChamberIterator = static_cast(fStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator(); + fChamberIterator = static_cast(fkStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator(); } diff --git a/MUON/AliMUONClusterStoreV2Iterator.h b/MUON/AliMUONClusterStoreV2Iterator.h index 41f601ce886..2d838e857c5 100644 --- a/MUON/AliMUONClusterStoreV2Iterator.h +++ b/MUON/AliMUONClusterStoreV2Iterator.h @@ -44,7 +44,7 @@ private: /// Overriden TIterator virtual operator= AliMUONClusterStoreV2Iterator& operator=(const TIterator& rhs); - const AliMUONClusterStoreV2* fStore; ///< store to iterate upon + const AliMUONClusterStoreV2* fkStore; ///< store to iterate upon Int_t fFirstChamberId; ///< first chamber Int_t fLastChamberId; ///< last chamber Int_t fCurrentChamberId; ///< current chamber diff --git a/MUON/AliMUONESDInterface.cxx b/MUON/AliMUONESDInterface.cxx index 0dc6afb8254..928ea6046b0 100644 --- a/MUON/AliMUONESDInterface.cxx +++ b/MUON/AliMUONESDInterface.cxx @@ -447,7 +447,7 @@ void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam) fgRecoParam = new AliMUONRecoParam(*recoParam); - }else { + } else { fgRecoParam = AliMUONRecoParam::GetLowFluxParam(); fgRecoParam->SetTrackingMode("KALMAN"); @@ -751,10 +751,9 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLoca locTrg.SetLoCircuit(esdTrack.LoCircuit()); locTrg.SetLoStripX(esdTrack.LoStripX()); locTrg.SetLoStripY(esdTrack.LoStripY()); - locTrg.SetLoDev(esdTrack.LoDev()); + locTrg.SetDeviation(esdTrack.LoDev()); locTrg.SetLoLpt(esdTrack.LoLpt()); locTrg.SetLoHpt(esdTrack.LoHpt()); - locTrg.SetLoSdev(1); locTrg.SetLoTrigY(1); locTrg.SetX1Pattern(esdTrack.GetTriggerX1Pattern()); locTrg.SetX2Pattern(esdTrack.GetTriggerX2Pattern()); diff --git a/MUON/AliMUONLocalTrigger.cxx b/MUON/AliMUONLocalTrigger.cxx index 87a8b6bf76b..6ac51c699ce 100644 --- a/MUON/AliMUONLocalTrigger.cxx +++ b/MUON/AliMUONLocalTrigger.cxx @@ -252,16 +252,31 @@ void AliMUONLocalTrigger::Print(Option_t* opt) const //---------------------------------------------------------------------- Int_t AliMUONLocalTrigger::GetDeviation() const { -/// return deviation - - Int_t deviation = LoDev(); - Int_t sign = 0; - if ( !LoSdev() && deviation ) sign=-1; - if ( !LoSdev() && !deviation ) sign= 0; - if ( LoSdev() == 1 ) sign=+1; - deviation *= sign; - deviation += 15; - return deviation; + /// return deviation + + Int_t deviation = LoDev(); + Int_t sign = 0; + if ( !LoSdev() && deviation ) sign=-1; + if ( !LoSdev() && !deviation ) sign= 0; + if ( LoSdev() == 1 ) sign=+1; + deviation *= sign; + deviation += 15; + return deviation; +} + +//---------------------------------------------------------------------- +void AliMUONLocalTrigger::SetDeviation(Int_t deviation) +{ + /// set LoDev and LoSDev according to deviation + + deviation -= 15; + if (deviation > 0) { + SetLoDev(deviation); + SetLoSdev(1); + } else { + SetLoDev(-deviation); + SetLoSdev(0); + } } //---------------------------------------------------------------------- diff --git a/MUON/AliMUONLocalTrigger.h b/MUON/AliMUONLocalTrigger.h index 1f53b94626b..5644e9dd6e6 100644 --- a/MUON/AliMUONLocalTrigger.h +++ b/MUON/AliMUONLocalTrigger.h @@ -68,8 +68,8 @@ class AliMUONLocalTrigger : public TObject { Char_t GetLoDecision() const; - /// return deviation Int_t GetDeviation() const; + void SetDeviation(Int_t deviation); /// Trigger response X strips Bool_t IsTrigX(); diff --git a/MUON/AliMUONQADataMakerRec.cxx b/MUON/AliMUONQADataMakerRec.cxx index 5b9def304ba..b1e21e3b86c 100644 --- a/MUON/AliMUONQADataMakerRec.cxx +++ b/MUON/AliMUONQADataMakerRec.cxx @@ -96,7 +96,18 @@ fDigitStore(0x0), fTriggerStore(0x0), fDigitMaker(0x0), fClusterStore(0x0), -fTrackerDataMaker(0x0) +fTrackerDataMaker(0x0), +fhESDnTotClustersPerCh(0x0), +fhESDnTotClustersPerDE(0x0), +fhESDnTotFullClustersPerDE(0x0), +fhESDSumClusterChargePerDE(0x0), +fhESDSumClusterSizePerDE(0x0), +fhESDSumResidualXPerDE(0x0), +fhESDSumResidualYPerDE(0x0), +fhESDSumResidualX2PerDE(0x0), +fhESDSumResidualY2PerDE(0x0), +fhESDSumLocalChi2XPerDE(0x0), +fhESDSumLocalChi2YPerDE(0x0) { /// ctor @@ -125,7 +136,18 @@ fDigitStore(0x0), fTriggerStore(0x0), fDigitMaker(0x0), fClusterStore(0x0), -fTrackerDataMaker(0x0) +fTrackerDataMaker(0x0), +fhESDnTotClustersPerCh(0x0), +fhESDnTotClustersPerDE(0x0), +fhESDnTotFullClustersPerDE(0x0), +fhESDSumClusterChargePerDE(0x0), +fhESDSumClusterSizePerDE(0x0), +fhESDSumResidualXPerDE(0x0), +fhESDSumResidualYPerDE(0x0), +fhESDSumResidualX2PerDE(0x0), +fhESDSumResidualY2PerDE(0x0), +fhESDSumLocalChi2XPerDE(0x0), +fhESDSumLocalChi2YPerDE(0x0) { ///copy ctor @@ -170,6 +192,17 @@ AliMUONQADataMakerRec::~AliMUONQADataMakerRec() delete fDigitMaker; delete fClusterStore; delete fTrackerDataMaker; + delete fhESDnTotClustersPerCh; + delete fhESDnTotClustersPerDE; + delete fhESDnTotFullClustersPerDE; + delete fhESDSumClusterChargePerDE; + delete fhESDSumClusterSizePerDE; + delete fhESDSumResidualXPerDE; + delete fhESDSumResidualYPerDE; + delete fhESDSumResidualX2PerDE; + delete fhESDSumResidualY2PerDE; + delete fhESDSumLocalChi2XPerDE; + delete fhESDSumLocalChi2YPerDE; } //____________________________________________________________________________ @@ -217,64 +250,155 @@ void AliMUONQADataMakerRec::EndOfDetectorCycle(AliQA::TASKINDEX_t task, TObjArra } } + // Normalize ESD histos if ( task == AliQA::kESDS ) { - // Normalize ESD histos - TH1* h; - Int_t bin; - AliMpDEIterator it; - it.First(); - while ( !it.IsDone()) { - - Int_t detElemId = it.CurrentDEId(); - - if ( AliMpDEManager::GetStationType(detElemId) != AliMp::kStationTrigger ) { - h = GetESDsData(kESDnClustersPerDE); - Double_t nClusters = h->GetBinContent(h->GetXaxis()->FindFixBin((Double_t)detElemId)); + Double_t nTracks = GetESDsData(kESDnClustersPerTrack)->GetEntries(); + if (nTracks <= 0) continue; + + 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); - if (nClusters > 0) { + hESDnClustersPerCh->Reset(); + hESDnClustersPerDE->Reset(); + hESDnClustersPerCh->Add(fhESDnTotClustersPerCh, 1./nTracks); + hESDnClustersPerDE->Add(fhESDnTotClustersPerDE, 1./nTracks); + + // loop over chambers + for (Int_t iCh = 0; iCh < AliMUONConstants::NTrackingCh(); iCh++) { - h = GetESDsData(kESDClusterChargePerDE); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - h->SetBinContent(bin, h->GetBinContent(bin)/nClusters); + 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()); - h = GetESDsData(kESDClusterMultPerDE); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - h->SetBinContent(bin, h->GetBinContent(bin)/nClusters); + 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()); - h = GetESDsData(kESDResidualXPerDEMean); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - Double_t meanResX = h->GetBinContent(bin)/nClusters; - h->SetBinContent(bin, meanResX); + 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()); - h = GetESDsData(kESDResidualYPerDEMean); - bin = h->GetXaxis()->FindFixBin((Double_t)detElemId); - Double_t meanResY = h->GetBinContent(bin)/nClusters; - h->SetBinContent(bin, meanResY); + 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()); - 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.); + 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 = fhESDnTotClustersPerDE->GetBinContent(iDE+1); + if (nClusters > 1) { + + hESDClusterChargePerDE->SetBinContent(iDE+1, fhESDSumClusterChargePerDE->GetBinContent(iDE+1)/nClusters); + hESDClusterChargePerDE->SetBinError(iDE+1, sigmaCharge/TMath::Sqrt(nClusters)); + + Double_t meanResX = fhESDSumResidualXPerDE->GetBinContent(iDE+1)/nClusters; + hESDResidualXPerDEMean->SetBinContent(iDE+1, meanResX); + hESDResidualXPerDEMean->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(nClusters)); + hESDResidualXPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(fhESDSumResidualX2PerDE->GetBinContent(iDE+1)/nClusters - meanResX*meanResX)); + hESDResidualXPerDESigma->SetBinError(iDE+1, sigmaResidualX/TMath::Sqrt(2.*nClusters)); + + Double_t meanResY = fhESDSumResidualYPerDE->GetBinContent(iDE+1)/nClusters; + hESDResidualYPerDEMean->SetBinContent(iDE+1, meanResY); + hESDResidualYPerDEMean->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(nClusters)); + hESDResidualYPerDESigma->SetBinContent(iDE+1, TMath::Sqrt(fhESDSumResidualY2PerDE->GetBinContent(iDE+1)/nClusters - meanResY*meanResY)); + hESDResidualYPerDESigma->SetBinError(iDE+1, sigmaResidualY/TMath::Sqrt(2.*nClusters)); + + hESDLocalChi2XPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2XPerDE->GetBinContent(iDE+1)/nClusters); + hESDLocalChi2XPerDEMean->SetBinError(iDE+1, sigmaLocalChi2X/TMath::Sqrt(nClusters)); + + hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2YPerDE->GetBinContent(iDE+1)/nClusters); + hESDLocalChi2YPerDEMean->SetBinError(iDE+1, sigmaLocalChi2Y/TMath::Sqrt(nClusters)); + + } else { + + hESDClusterChargePerDE->SetBinContent(iDE+1, fhESDSumClusterChargePerDE->GetBinContent(iDE+1)); + hESDClusterChargePerDE->SetBinError(iDE+1, hESDClusterChargeInCh->GetXaxis()->GetXmax()); + + hESDResidualXPerDEMean->SetBinContent(iDE+1, fhESDSumResidualXPerDE->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, fhESDSumResidualYPerDE->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, fhESDSumLocalChi2XPerDE->GetBinContent(iDE+1)); + hESDLocalChi2XPerDEMean->SetBinError(iDE+1, hESDLocalChi2XInCh->GetXaxis()->GetXmax()); + + hESDLocalChi2YPerDEMean->SetBinContent(iDE+1, fhESDSumLocalChi2YPerDE->GetBinContent(iDE+1)); + hESDLocalChi2YPerDEMean->SetBinError(iDE+1, hESDLocalChi2YInCh->GetXaxis()->GetXmax()); + + } + + Double_t nFullClusters = fhESDnTotFullClustersPerDE->GetBinContent(iDE+1); + if (nFullClusters > 1) { + + hESDClusterSizePerDE->SetBinContent(iDE+1, fhESDSumClusterSizePerDE->GetBinContent(iDE+1)/nFullClusters); + hESDClusterSizePerDE->SetBinError(iDE+1, sigmaSize/TMath::Sqrt(nFullClusters)); + + } else { + + hESDClusterSizePerDE->SetBinContent(iDE+1, fhESDSumClusterSizePerDE->GetBinContent(iDE+1)); + hESDClusterSizePerDE->SetBinError(iDE+1, hESDClusterSizeInCh->GetXaxis()->GetXmax()); + + } + + it.Next(); + } - 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.); - } - } - - 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) ; } @@ -514,110 +638,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, nCh); 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, 0, nDE); 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, nCh); + 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, nCh); + 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, 0, nDE); 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, nCh); + 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, nCh); + 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, 0, nDE); + 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, nCh); + 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, nCh); + 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, nCh); + 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, nCh); + 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, nCh); + 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, nCh); + 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, 0, nDE); 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, 0, nDE); 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, 0, nDE); 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, 0, nDE); 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, 0, nDE); + 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, 0, nDE); + hESDLocalChi2YPerDEMean->SetOption("P"); + hESDLocalChi2YPerDEMean->SetMarkerStyle(kFullDotMedium); + hESDLocalChi2YPerDEMean->SetMarkerColor(kRed); + Add2ESDsList(hESDLocalChi2YPerDEMean, kESDLocalChi2YPerDEMean,forExpert); + + // temporary histograms + fhESDnTotClustersPerCh = new TH1F("fhESDnTotClustersPerCh", "total number of associated clusters per chamber;chamber ID", nCh, 0, nCh); + fhESDnTotClustersPerCh->SetDirectory(0); + fhESDnTotClustersPerDE = new TH1F("fhESDnTotClustersPerDE", "total number of associated clusters per DE;DetElem ID", nDE, 0, nDE); + fhESDnTotClustersPerDE->SetDirectory(0); + fhESDnTotFullClustersPerDE = new TH1F("fhESDnTotFullClustersPerDE", "total number of associated clusters containing pad info per DE;DetElem ID", nDE, 0, nDE); + fhESDnTotFullClustersPerDE->SetDirectory(0); + fhESDSumClusterChargePerDE = new TH1F("fhESDSumClusterChargePerDE", "sum of cluster charge per DE;DetElem ID;ADC counts", nDE, 0, nDE); + fhESDSumClusterChargePerDE->SetDirectory(0); + fhESDSumClusterSizePerDE = new TH1F("fhESDSumClusterSizePerDE", "sum of cluster size per DE;DetElem ID;averaged number of associated pads", nDE, 0, nDE); + fhESDSumClusterSizePerDE->SetDirectory(0); + fhESDSumResidualXPerDE = new TH1F("fhESDSumResidualXPerDE", "sum of cluster-track residual-X per DE;DetElem ID", nDE, 0, nDE); + fhESDSumResidualXPerDE->SetDirectory(0); + fhESDSumResidualYPerDE = new TH1F("fhESDSumResidualYPerDE", "sum of cluster-track residual-Y per DE;DetElem ID", nDE, 0, nDE); + fhESDSumResidualYPerDE->SetDirectory(0); + fhESDSumResidualX2PerDE = new TH1F("fhESDSumResidualX2PerDE", "sum of cluster-track residual-X**2 per DE;DetElem ID", nDE, 0, nDE); + fhESDSumResidualX2PerDE->SetDirectory(0); + fhESDSumResidualY2PerDE = new TH1F("fhESDSumResidualY2PerDE", "sum of cluster-track residual-Y**2 per DE;DetElem ID", nDE, 0, nDE); + fhESDSumResidualY2PerDE->SetDirectory(0); + fhESDSumLocalChi2XPerDE = new TH1F("fhESDSumLocalChi2XPerDE", "sum of local chi2-X per DE;DetElem ID", nDE, 0, nDE); + fhESDSumLocalChi2XPerDE->SetDirectory(0); + fhESDSumLocalChi2YPerDE = new TH1F("fhESDSumLocalChi2YPerDE", "sum of local chi2-Y per DE;DetElem ID", nDE, 0, nDE); + fhESDSumLocalChi2YPerDE->SetDirectory(0); + fIsInitESDs = kTRUE; } @@ -863,6 +1080,10 @@ void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd) return; } + // use event specie from RecoParam + AliRecoParam::EventSpecie_t savedEventSpecie = fEventSpecie; + if (GetRecoParam()) SetEventSpecie(static_cast(GetRecoParam()->GetEventSpecie())); + // load ESD event in the interface AliMUONESDInterface esdInterface; if (GetRecoParam()) AliMUONESDInterface::ResetTracker(GetRecoParam()); @@ -890,6 +1111,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 @@ -901,30 +1123,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); + fhESDnTotClustersPerCh->Fill(chId); + fhESDnTotClustersPerDE->Fill(deID); - GetESDsData(kESDClusterCharge)->Fill(cluster->GetCharge()); GetESDsData(kESDClusterChargeInCh+chId)->Fill(cluster->GetCharge()); - GetESDsData(kESDClusterChargePerDE)->Fill(deID, cluster->GetCharge()); + fhESDSumClusterChargePerDE->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()); + fhESDnTotFullClustersPerDE->Fill(deID); + GetESDsData(kESDClusterSizeInCh+chId)->Fill(cluster->GetNDigits()); + fhESDSumClusterSizePerDE->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); + fhESDSumResidualXPerDE->Fill(deID, residualX); + fhESDSumResidualYPerDE->Fill(deID, residualY); + fhESDSumResidualX2PerDE->Fill(deID, residualX*residualX); + fhESDSumResidualY2PerDE->Fill(deID, residualY*residualY); + + GetESDsData(kESDLocalChi2XInCh+chId)->Fill(localChi2X); + GetESDsData(kESDLocalChi2YInCh+chId)->Fill(localChi2Y); + fhESDSumLocalChi2XPerDE->Fill(deID, localChi2X); + fhESDSumLocalChi2YPerDE->Fill(deID, localChi2Y); trackParam = static_cast(track->GetTrackParamAtCluster()->After(trackParam)); } @@ -933,6 +1159,9 @@ void AliMUONQADataMakerRec::MakeESDs(AliESDEvent* esd) GetESDsData(kESDMatchTrig)->Fill(nTrackMatchTrig); + // restore event specie + SetEventSpecie(savedEventSpecie); + } //____________________________________________________________________________ diff --git a/MUON/AliMUONQADataMakerRec.h b/MUON/AliMUONQADataMakerRec.h index 3b86a251801..295b67bbb80 100644 --- a/MUON/AliMUONQADataMakerRec.h +++ b/MUON/AliMUONQADataMakerRec.h @@ -77,32 +77,43 @@ private: /// ESD histograms indices enum EESD { - kESDnTracks = 0, ///< number of tracks - kESDMatchTrig = 1, ///< number of tracks matched with trigger - kESDMomentum = 2, ///< P distribution - kESDPt = 3, ///< Pt distribution - kESDRapidity = 4, ///< rapidity distribution - kESDChi2 = 5, ///< normalized chi2 distribution + kESDnTracks = 0, ///< number of tracks + kESDMatchTrig = 1, ///< number of tracks matched with trigger + kESDMomentum = 2, ///< P distribution + kESDPt = 3, ///< Pt distribution + kESDRapidity = 4, ///< rapidity distribution + kESDChi2 = 5, ///< normalized chi2 distribution + kESDProbChi2 = 6, ///< distribution of probability of chi2 - kESDClusterHitMap = 6, ///< cluster position distribution in chamber i - kESDnClustersPerTrack = 16, ///< number of clusters per track - kESDnClustersPerCh = 17, ///< number of clusters per chamber - kESDnClustersPerDE = 18, ///< number of clusters per DE - kESDClusterCharge = 19, ///< cluster charge distribution - kESDClusterChargeInCh = 20, ///< cluster charge distribution in chamber i - kESDClusterChargePerDE = 30, ///< cluster charge per DE: mean +- dispersion - kESDClusterMult = 31, ///< cluster multiplicity distribution - kESDClusterMultInCh = 32, ///< cluster multiplicity distribution in chamber i - kESDClusterMultPerDE = 42, ///< cluster multiplicity per DE: mean +- dispersion + kESDClusterHitMap = 7, ///< cluster position distribution in chamber i + kESDnClustersPerTrack = 17, ///< number of clusters per track + kESDnClustersPerCh = 18, ///< number of clusters per chamber per track + kESDnClustersPerDE = 19, ///< number of clusters per DE per track + kESDClusterChargeInCh = 20, ///< cluster charge distribution in chamber i + kESDClusterChargePerChMean = 30, ///< cluster charge per Ch: mean + kESDClusterChargePerChSigma = 31, ///< cluster charge per Ch: dispersion + kESDClusterChargePerDE = 32, ///< cluster charge per DE: mean + kESDClusterSizeInCh = 33, ///< cluster size distribution in chamber i + kESDClusterSizePerChMean = 43, ///< cluster size per Ch: mean + kESDClusterSizePerChSigma = 44, ///< cluster size per Ch: dispersion + kESDClusterSizePerDE = 45, ///< cluster size per DE: mean - kESDResidualX = 43, ///< cluster-track residual-X distribution - kESDResidualY = 44, ///< cluster-track residual-Y distribution - kESDResidualXInCh = 45, ///< cluster-track residual-X distribution in chamber i - kESDResidualYInCh = 55, ///< cluster-track residual-Y distribution in chamber i - kESDResidualXPerDEMean = 65, ///< cluster-track residual-X per DE: mean - kESDResidualYPerDEMean = 66, ///< cluster-track residual-Y per DE: mean - kESDResidualXPerDESigma = 67, ///< cluster-track residual-X per DE: sigma - kESDResidualYPerDESigma = 68 ///< cluster-track residual-Y per DE: sigma + kESDResidualXInCh = 46, ///< cluster-track residual-X distribution in chamber i + kESDResidualYInCh = 56, ///< cluster-track residual-Y distribution in chamber i + kESDResidualXPerChMean = 66, ///< cluster-track residual-X per Ch: mean + kESDResidualYPerChMean = 67, ///< cluster-track residual-Y per Ch: mean + kESDResidualXPerChSigma = 68, ///< cluster-track residual-X per Ch: dispersion + kESDResidualYPerChSigma = 69, ///< cluster-track residual-Y per Ch: dispersion + kESDResidualXPerDEMean = 70, ///< cluster-track residual-X per DE: mean + kESDResidualYPerDEMean = 71, ///< cluster-track residual-Y per DE: mean + kESDResidualXPerDESigma = 72, ///< cluster-track residual-X per DE: dispersion + kESDResidualYPerDESigma = 73, ///< cluster-track residual-Y per DE: dispersion + kESDLocalChi2XInCh = 74, ///< local chi2-X distribution in chamber i + kESDLocalChi2YInCh = 84, ///< local chi2-Y distribution in chamber i + kESDLocalChi2XPerChMean = 94, ///< local chi2-X per Ch: mean + kESDLocalChi2YPerChMean = 95, ///< local chi2-Y per Ch: mean + kESDLocalChi2XPerDEMean = 96, ///< local chi2-X per DE: mean + kESDLocalChi2YPerDEMean = 97 ///< local chi2-Y per DE: mean }; private: @@ -130,8 +141,20 @@ private: AliMUONVClusterStore* fClusterStore; //!< pointer to cluster store AliMUONVTrackerDataMaker* fTrackerDataMaker; //!< tracker data accumulation - - ClassDef(AliMUONQADataMakerRec,4) // MUON Quality assurance data maker + + TH1F* fhESDnTotClustersPerCh; //!< total number of associated clusters per chamber + TH1F* fhESDnTotClustersPerDE; //!< total number of associated clusters per DE + TH1F* fhESDnTotFullClustersPerDE; //!< total number of associated clusters containing pad info per DE + TH1F* fhESDSumClusterChargePerDE; //!< sum of cluster charge per DE + TH1F* fhESDSumClusterSizePerDE; //!< sum of cluster size per DE + TH1F* fhESDSumResidualXPerDE; //!< sum of cluster-track residual-X per DE + TH1F* fhESDSumResidualYPerDE; //!< sum of cluster-track residual-Y per DE + TH1F* fhESDSumResidualX2PerDE; //!< sum of cluster-track residual-X**2 per DE + TH1F* fhESDSumResidualY2PerDE; //!< sum of cluster-track residual-Y**2 per DE + TH1F* fhESDSumLocalChi2XPerDE; //!< sum of local chi2-X per DE + TH1F* fhESDSumLocalChi2YPerDE; //!< sum of local chi2-X per DE + + ClassDef(AliMUONQADataMakerRec,5) // MUON Quality assurance data maker }; #endif diff --git a/MUON/AliMUONRefitter.cxx b/MUON/AliMUONRefitter.cxx index fe4b8b27fe5..eefd745265d 100644 --- a/MUON/AliMUONRefitter.cxx +++ b/MUON/AliMUONRefitter.cxx @@ -25,6 +25,7 @@ #include "AliMUONPreClusterFinderV2.h" #include "AliMUONPreClusterFinderV3.h" #include "AliMUONSimpleClusterServer.h" +#include "AliMUONReconstructor.h" #include "AliMUONTrackReconstructor.h" #include "AliMUONTrackReconstructorK.h" #include "AliMUONRecoParam.h" @@ -63,11 +64,11 @@ ClassImp(AliMUONRefitter) //_____________________________________________________________________________ AliMUONRefitter::AliMUONRefitter(const AliMUONRecoParam* recoParam) : TObject(), - fRecoParam(recoParam), + fkRecoParam(recoParam), + fkESDInterface(0x0), fGeometryTransformer(0x0), fClusterServer(0x0), - fTracker(0x0), - fESDInterface(0x0) + fTracker(0x0) { /// Default constructor CreateGeometryTransformer(); @@ -94,7 +95,7 @@ AliMUONVTrackStore* AliMUONRefitter::ReconstructFromDigits() /// re-reconstruct all tracks and attached clusters from the digits /// it is the responsability of the user to delete the returned store - if (!fESDInterface) { + if (!fkESDInterface) { AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct"); return 0x0; } @@ -105,7 +106,7 @@ AliMUONVTrackStore* AliMUONRefitter::ReconstructFromDigits() // loop over tracks and refit them (create new tracks) AliMUONTrack *track; - TIter next(fESDInterface->CreateTrackIterator()); + TIter next(fkESDInterface->CreateTrackIterator()); while ((track = static_cast(next()))) { AliMUONTrack *newTrack = RetrackFromDigits(*track); newTrackStore->Add(newTrack); @@ -121,7 +122,7 @@ AliMUONVTrackStore* AliMUONRefitter::ReconstructFromClusters() /// refit all tracks from the attached clusters /// it is the responsability of the user to delete the returned store - if (!fESDInterface) { + if (!fkESDInterface) { AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct"); return 0x0; } @@ -132,7 +133,7 @@ AliMUONVTrackStore* AliMUONRefitter::ReconstructFromClusters() // loop over tracks and refit them (create new tracks) AliMUONTrack *track; - TIter next(fESDInterface->CreateTrackIterator()); + TIter next(fkESDInterface->CreateTrackIterator()); while ((track = static_cast(next()))) { AliMUONTrack* newTrack = newTrackStore->Add(*track); if (!fTracker->RefitTrack(*newTrack)) newTrackStore->Remove(*newTrack); @@ -147,13 +148,13 @@ AliMUONTrack* AliMUONRefitter::RetrackFromDigits(UInt_t trackId) /// refit track "trackId" from the digits (i.e. re-clusterized the attached clusters) /// it is the responsability of the user to delete the returned track - if (!fESDInterface) { + if (!fkESDInterface) { AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct"); return 0x0; } // get the track to refit - AliMUONTrack* track = fESDInterface->FindTrack(trackId); + AliMUONTrack* track = fkESDInterface->FindTrack(trackId); return track ? RetrackFromDigits(*track) : 0x0; } @@ -164,13 +165,13 @@ AliMUONTrack* AliMUONRefitter::RetrackFromClusters(UInt_t trackId) /// refit track "trackId" form the clusters (i.e. do not re-clusterize) /// it is the responsability of the user to delete the returned track - if (!fESDInterface) { + if (!fkESDInterface) { AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct"); return 0x0; } // get the track to refit - AliMUONTrack* track = fESDInterface->FindTrack(trackId); + AliMUONTrack* track = fkESDInterface->FindTrack(trackId); if (!track) return 0x0; // refit the track (create a new one) @@ -190,13 +191,13 @@ AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t trackId, UInt_t clust /// several new clusters may be reconstructed /// it is the responsability of the user to delete the returned store - if (!fESDInterface) { + if (!fkESDInterface) { AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct"); return 0x0; } // get the cluster to re-clusterize - AliMUONVCluster* cluster = fESDInterface->FindCluster(trackId,clusterId); + AliMUONVCluster* cluster = fkESDInterface->FindCluster(trackId,clusterId); if (!cluster) return 0x0; // check if digits exist @@ -210,9 +211,9 @@ AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t trackId, UInt_t clust if (!clusterStore) return 0x0; // re-clusterize - TIter next(fESDInterface->CreateDigitIterator(trackId, clusterId)); + TIter next(fkESDInterface->CreateDigitIterator(trackId, clusterId)); fClusterServer->UseDigits(next); - fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),GetRecoParam()); + fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),fkRecoParam); return clusterStore; } @@ -224,13 +225,13 @@ AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t clusterId) /// several new clusters may be reconstructed /// it is the responsability of the user to delete the returned store - if (!fESDInterface) { + if (!fkESDInterface) { AliError("the refitter must be connected to an ESDInterface containing the ESD event to reconstruct"); return 0x0; } // get the cluster to re-clusterize - AliMUONVCluster* cluster = fESDInterface->FindCluster(clusterId); + AliMUONVCluster* cluster = fkESDInterface->FindCluster(clusterId); if (!cluster) return 0x0; // check if digits exist @@ -244,9 +245,9 @@ AliMUONVClusterStore* AliMUONRefitter::ReClusterize(UInt_t clusterId) if (!clusterStore) return 0x0; // re-clusterize - TIter next(fESDInterface->CreateDigitIteratorInCluster(clusterId)); + TIter next(fkESDInterface->CreateDigitIteratorInCluster(clusterId)); fClusterServer->UseDigits(next); - fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),GetRecoParam()); + fClusterServer->Clusterize(cluster->GetChamberId(),*clusterStore,AliMpArea(),fkRecoParam); return clusterStore; } @@ -264,7 +265,7 @@ void AliMUONRefitter::CreateGeometryTransformer() void AliMUONRefitter::CreateClusterServer(AliMUONGeometryTransformer& transformer) { /// Create cluster server - AliMUONVClusterFinder* clusterFinder = AliMUONReconstructor::CreateClusterFinder(GetRecoParam()->GetClusteringMode()); + AliMUONVClusterFinder* clusterFinder = AliMUONReconstructor::CreateClusterFinder(fkRecoParam->GetClusteringMode()); fClusterServer = clusterFinder ? new AliMUONSimpleClusterServer(clusterFinder,transformer) : 0x0; } @@ -278,7 +279,7 @@ AliMUONTrack* AliMUONRefitter::RetrackFromDigits(const AliMUONTrack& track) // check if digits exist UInt_t trackId = track.GetUniqueID(); - if (fESDInterface->GetNDigits(trackId) == 0) { + if (fkESDInterface->GetNDigits(trackId) == 0) { AliError(Form("no digit attached to track #%d",trackId)); return 0x0; } @@ -297,16 +298,16 @@ AliMUONTrack* AliMUONRefitter::RetrackFromDigits(const AliMUONTrack& track) // loop over clusters, re-clusterize and build new tracks AliMUONVCluster* cluster; - TIter nextCluster(fESDInterface->CreateClusterIterator(trackId)); + TIter nextCluster(fkESDInterface->CreateClusterIterator(trackId)); while ((cluster = static_cast(nextCluster()))) { // reset the new cluster store newClusterStore->Clear(); // re-clusterize current cluster - TIter nextDigit(fESDInterface->CreateDigitIterator(trackId, cluster->GetUniqueID())); + TIter nextDigit(fkESDInterface->CreateDigitIterator(trackId, cluster->GetUniqueID())); fClusterServer->UseDigits(nextDigit); - Int_t nNewClusters = fClusterServer->Clusterize(cluster->GetChamberId(),*newClusterStore,AliMpArea(),GetRecoParam()); + Int_t nNewClusters = fClusterServer->Clusterize(cluster->GetChamberId(),*newClusterStore,AliMpArea(),fkRecoParam); // check that re-clusterizing succeeded if (nNewClusters == 0) { diff --git a/MUON/AliMUONRefitter.h b/MUON/AliMUONRefitter.h index fd522959113..b69b71841e4 100644 --- a/MUON/AliMUONRefitter.h +++ b/MUON/AliMUONRefitter.h @@ -32,7 +32,7 @@ public: virtual ~AliMUONRefitter(); /// connect to the ESD interface containing MUON data to refit - void Connect(AliMUONESDInterface* esdInterface) {fESDInterface = esdInterface;} + void Connect(const AliMUONESDInterface* esdInterface) {fkESDInterface = esdInterface;} // re-reconstruct all tracks (clusters) in the ESD event AliMUONVTrackStore* ReconstructFromDigits(); @@ -62,15 +62,13 @@ private: void AddClusterToTracks(const AliMUONVClusterStore &localClusterStore, AliMUONVTrackStore &trackStore); - const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; } - private: - const AliMUONRecoParam* fRecoParam; ///< pointer to reco param (not owner) + const AliMUONRecoParam* fkRecoParam; ///< pointer to reco param (not owner) + const AliMUONESDInterface* fkESDInterface; ///< container of MUON tracks/clusters/digits (not owner) AliMUONGeometryTransformer* fGeometryTransformer; ///< geometry transformer (owner) AliMUONVClusterServer* fClusterServer; ///< clusterizer (owner) AliMUONVTrackReconstructor* fTracker; ///< tracker (owner) - AliMUONESDInterface* fESDInterface; ///< container of MUON tracks/clusters/digits (not owner) ClassDef(AliMUONRefitter,0) diff --git a/MUON/AliMUONTrack.cxx b/MUON/AliMUONTrack.cxx index d0b61545e04..ee682658566 100644 --- a/MUON/AliMUONTrack.cxx +++ b/MUON/AliMUONTrack.cxx @@ -1000,14 +1000,22 @@ Int_t AliMUONTrack::ClustersInCommon(AliMUONTrack* track, Bool_t inSt345) const return clustersInCommon; } + //__________________________________________________________________________ +Int_t AliMUONTrack::GetNDF() const +{ + /// return the number of degrees of freedom + + Int_t ndf = 2 * GetNClusters() - 5; + return (ndf > 0) ? ndf : 0; +} + //__________________________________________________________________________ Double_t AliMUONTrack::GetNormalizedChi2() const { - /// return the chi2 value divided by the number of degrees of freedom (or 1.e10 if ndf < 0) + /// return the chi2 value divided by the number of degrees of freedom (or FLT_MAX if ndf <= 0) - Double_t numberOfDegFree = (2. * GetNClusters() - 5.); - if (numberOfDegFree > 0.) return fGlobalChi2 / numberOfDegFree; - else return fGlobalChi2; // system is under-constraint + Double_t ndf = (Double_t) GetNDF(); + return (ndf > 0.) ? fGlobalChi2 / ndf : FLT_MAX; } //__________________________________________________________________________ diff --git a/MUON/AliMUONTrack.h b/MUON/AliMUONTrack.h index 8d9144d49ec..1deb5b3e7be 100644 --- a/MUON/AliMUONTrack.h +++ b/MUON/AliMUONTrack.h @@ -90,6 +90,7 @@ class AliMUONTrack : public TObject Int_t ClustersInCommon(AliMUONTrack* track, Bool_t inSt345 = kFALSE) const; + Int_t GetNDF() const; Double_t GetNormalizedChi2() const; Int_t CompatibleTrack(AliMUONTrack* track, Double_t sigma2Cut, Bool_t compatibleCluster[10]) const; diff --git a/MUON/AliMUONTrackReconstructor.cxx b/MUON/AliMUONTrackReconstructor.cxx index f903ed748b7..154622334e5 100644 --- a/MUON/AliMUONTrackReconstructor.cxx +++ b/MUON/AliMUONTrackReconstructor.cxx @@ -35,6 +35,7 @@ #include "AliMUONTrack.h" #include "AliMUONTrackParam.h" #include "AliMUONTrackExtrap.h" +#include "AliMUONRecoParam.h" #include "AliMpArea.h" diff --git a/MUON/AliMUONTrackReconstructorK.cxx b/MUON/AliMUONTrackReconstructorK.cxx index cb3bcc1720e..912cdf49d4c 100644 --- a/MUON/AliMUONTrackReconstructorK.cxx +++ b/MUON/AliMUONTrackReconstructorK.cxx @@ -37,6 +37,7 @@ #include "AliMUONTrack.h" #include "AliMUONTrackParam.h" #include "AliMUONTrackExtrap.h" +#include "AliMUONRecoParam.h" #include "AliMpArea.h" diff --git a/MUON/AliMUONVTrackReconstructor.cxx b/MUON/AliMUONVTrackReconstructor.cxx index cb6fd661189..21edde3888f 100644 --- a/MUON/AliMUONVTrackReconstructor.cxx +++ b/MUON/AliMUONVTrackReconstructor.cxx @@ -73,6 +73,8 @@ #include "AliMUONVClusterServer.h" #include "AliMUONVTriggerStore.h" #include "AliMUONVTriggerTrackStore.h" +#include "AliMUONRecoParam.h" + #include "AliMpDEManager.h" #include "AliMpArea.h" @@ -98,7 +100,7 @@ AliMUONVTrackReconstructor::AliMUONVTrackReconstructor(const AliMUONRecoParam* r fRecTracksPtr(0x0), fNRecTracks(0), fClusterServer(clusterServer), -fRecoParam(recoParam) +fkRecoParam(recoParam) { /// Constructor for class AliMUONVTrackReconstructor /// WARNING: if clusterServer=0x0, no clusterization will be possible at this level @@ -473,7 +475,7 @@ Double_t AliMUONVTrackReconstructor::TryOneCluster(const AliMUONTrackParam &trac } //__________________________________________________________________________ -Bool_t AliMUONVTrackReconstructor::TryOneClusterFast(const AliMUONTrackParam &trackParam, AliMUONVCluster* cluster) +Bool_t AliMUONVTrackReconstructor::TryOneClusterFast(const AliMUONTrackParam &trackParam, const AliMUONVCluster* cluster) { /// Test the compatibility between the track and the cluster /// given the track resolution + the maximum-distance-to-track value diff --git a/MUON/AliMUONVTrackReconstructor.h b/MUON/AliMUONVTrackReconstructor.h index 78acfe265b5..195892653c3 100644 --- a/MUON/AliMUONVTrackReconstructor.h +++ b/MUON/AliMUONVTrackReconstructor.h @@ -11,8 +11,6 @@ /// // Author: Philippe Pillot -#include "AliMUONReconstructor.h" - #include class AliMUONTrack; @@ -50,7 +48,7 @@ class AliMUONVTrackReconstructor : public TObject { const AliMUONVTriggerStore& triggerStore, const AliMUONTrackHitPattern& trackHitPattern); - const AliMUONRecoParam* GetRecoParam() const { return fRecoParam; } + const AliMUONRecoParam* GetRecoParam() const { return fkRecoParam; } /// re-fit the given track virtual Bool_t RefitTrack(AliMUONTrack &track, Bool_t enableImprovement = kTRUE) = 0; @@ -63,7 +61,7 @@ class AliMUONVTrackReconstructor : public TObject { AliMUONVClusterServer* fClusterServer; ///< reference to our cluster server - const AliMUONRecoParam* fRecoParam; ///< reference to reco parameters + const AliMUONRecoParam* fkRecoParam; ///< reference to reco parameters // Functions AliMUONVTrackReconstructor (const AliMUONVTrackReconstructor& rhs); ///< copy constructor @@ -97,7 +95,7 @@ class AliMUONVTrackReconstructor : public TObject { Double_t TryOneCluster(const AliMUONTrackParam &trackParam, AliMUONVCluster* cluster, AliMUONTrackParam &trackParamAtCluster, Bool_t updatePropagator = kFALSE); - Bool_t TryOneClusterFast(const AliMUONTrackParam &trackParam, AliMUONVCluster* cluster); + Bool_t TryOneClusterFast(const AliMUONTrackParam &trackParam, const AliMUONVCluster* cluster); Double_t TryTwoClustersFast(const AliMUONTrackParam &trackParamAtCluster1, AliMUONVCluster* cluster2, AliMUONTrackParam &trackParamAtCluster2);