- 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 19907f4bf5282dbdf63d4e6637ca46818db0ce2c..884b753ce289758a579b28ff131ce39e48a01b6d 100644 (file)
--- 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<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator();
+    fChamberIterator = static_cast<AliMpExMap*>(fkStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator();
     
     o = NextInCurrentChamber();
   }
@@ -105,5 +105,5 @@ void AliMUONClusterStoreV2Iterator::Reset()
   /// Reset the iterator
   fCurrentChamberId = fFirstChamberId;
   delete fChamberIterator;
-  fChamberIterator = static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator();
+  fChamberIterator = static_cast<AliMpExMap*>(fkStore->fMap->UncheckedAt(fCurrentChamberId))->CreateIterator();
 }

diff --git a/MUON/AliMUONClusterStoreV2Iterator.h b/MUON/AliMUONClusterStoreV2Iterator.h
index 41f601ce886d5dbf169ee37a08e53310be13a39b..2d838e857c5785a6398587e370c762480f99db84 100644 (file)
--- 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 0dc6afb82547166fd19415340da6f7bc030290d6..928ea6046b03979ad1d9eb9e57bfb83f9103a24f 100644 (file)
--- 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 87a8b6bf76b1ed3795c0ab3a1b3fa91059bf5b16..6ac51c699ce1a14f533319ff27089a70992d2494 100644 (file)
--- 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 1f53b94626b56eacc4ad07fca02ec391a9b4b4ce..5644e9dd6e678e99762676ffad7bd025e12a24e9 100644 (file)
--- 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 5b9def304ba72a480202a260ba030ae0aca3d51f..b1e21e3b86c1ebd5cdc64866ab34ff7686263046 100644 (file)
--- 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;<n_{clusters}>", 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;<n_{clusters}>", 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;<charge> (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;<charge> (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;<size> (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;<size> (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;<local #chi^{2}_{X}>", 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;<local #chi^{2}_{Y}>", 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;<local #chi^{2}_{X}>", 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;<local #chi^{2}_{Y}>", 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<AliRecoParam::EventSpecie_t>(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<AliMUONTrackParam*>(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 3b86a25180178bc3c30615b7cd8d5ea884169c29..295b67bbb80331cf8381078299151628bb099054 100644 (file)
--- 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 fe4b8b27fe50fdd6556169cb5511a3a666b687f8..eefd745265d82475186a5bf0df809de37a56121b 100644 (file)
--- 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<AliMUONTrack*>(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<AliMUONTrack*>(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<AliMUONVCluster*>(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 fd5229591136716895adce61cfa279cb10355399..b69b71841e4dfad82a569f3850255a271ada06bf 100644 (file)
--- 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 d0b61545e04a8bdf89c4220dfee43486c23e6013..ee682658566e512bf7b062c98096eb8ade9588dd 100644 (file)
--- 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 8d9144d49ec4863834b7b4544817ac3a30d74acc..1deb5b3e7be8d0ec0dea43789f2e334568cbb44c 100644 (file)
--- 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 f903ed748b7c77d82eba81c198309e2f4240399c..154622334e5550f4ff9df07efbce2e86a4387de5 100644 (file)
--- 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 cb3bcc1720e9fc06d0b8c6dc3fb62cdbd326b0fb..912cdf49d4cf4cbb5a9819947fd1ad2629f8fe6a 100644 (file)
--- 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 cb6fd661189cad77c434e04adda5d21b11ee0687..21edde3888f07d0e7f03fb250b7ab41d02a18e32 100644 (file)
--- 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 78acfe265b555de791651cdc72f39da50b1831e3..195892653c3824f2836f11c2a267409388a56a41 100644 (file)
--- a/MUON/AliMUONVTrackReconstructor.h
+++ b/MUON/AliMUONVTrackReconstructor.h
@@ -11,8 +11,6 @@
 ///
 //  Author: Philippe Pillot
 
-#include "AliMUONReconstructor.h"
-
 #include <TObject.h>
 
 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);