]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - MUON/AliMUONESDInterface.cxx
New option to discard mono-cathod clusters (by changing their resolution) and refit...
[u/mrichter/AliRoot.git] / MUON / AliMUONESDInterface.cxx
index 63c73b9861a1bde77c62358e87613fa64b7d9598..504fa93d38deff8c52e47930439c2690caaf5dd5 100644 (file)
@@ -33,6 +33,7 @@
 #include "AliMUONTracker.h"
 #include "AliMUONRecoParam.h"
 #include "AliMUONVTrackReconstructor.h"
+#include "AliMUONCDB.h"
 
 #include "AliMpExMapIterator.h"
 #include "AliMpVSegmentation.h"
@@ -45,6 +46,7 @@
 #include "AliESDMuonPad.h"
 #include "AliLog.h"
 
+#include <TROOT.h>
 #include <TClass.h>
 #include <TIterator.h>
 #include <TMath.h>
@@ -70,6 +72,8 @@
 /// \author Philippe Pillot
 //-----------------------------------------------------------------------------
 
+using std::endl;
+using std::cout;
 /// \cond CLASSIMP
 ClassImp(AliMUONESDInterface)
 /// \endcond
@@ -152,9 +156,12 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent, Bool_t refit)
   // reset data members
   Reset();
   
+  // loop over ESD pads and fill the digit store
+  for (Int_t iPad = 0; iPad < esdEvent.GetNumberOfMuonPads(); iPad++)
+    Add(*(esdEvent.GetMuonPad(iPad)), *fDigits);
+  
   // loop over ESD tracks and fill the stores
-  Int_t nTracks = (Int_t) esdEvent.GetNumberOfMuonTracks(); 
-  for (Int_t iTrack = 0; iTrack <  nTracks; iTrack++) {
+  for (Int_t iTrack = 0; iTrack < esdEvent.GetNumberOfMuonTracks(); iTrack++) {
     
     // get ESD track
     AliESDMuonTrack* esdTrack = esdEvent.GetMuonTrack(iTrack);
@@ -178,15 +185,11 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent, Bool_t refit)
     dMaps->SetOwner(kTRUE);
     fDigitMap->Add(esdTrack->GetUniqueID(), dMaps);
     
-    // loop over ESD clusters
-    Int_t nClusters = esdTrack->GetNClusters();
-    for (Int_t iCluster = 0; iCluster <  nClusters; iCluster++) {
-      
-      // get ESD cluster
-      AliESDMuonCluster *esdCluster = (AliESDMuonCluster*) esdTrack->GetClusters().UncheckedAt(iCluster);
+    // loop over clusters
+    for (Int_t iCluster = 0; iCluster < track->GetNClusters(); iCluster++) {
       
-      // get the corresponding MUON cluster
-      AliMUONVCluster* cluster = FindClusterInTrack(*track, esdCluster->GetUniqueID());
+      // get cluster
+      AliMUONVCluster* cluster = ((AliMUONTrackParam*)track->GetTrackParamAtCluster()->UncheckedAt(iCluster))->GetClusterPtr();
       
       // fill cluster map
       cMap->Add(cluster->GetUniqueID(), cluster);
@@ -194,21 +197,17 @@ void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent, Bool_t refit)
       // prepare digit map
       AliMpExMap* dMap =new AliMpExMap;
       dMap->SetOwner(kFALSE);
-      dMaps->Add(esdCluster->GetUniqueID(), dMap);
+      dMaps->Add(cluster->GetUniqueID(), dMap);
       
-      // loop over ESD pads
-      Int_t nPads = esdCluster->GetNPads();
-      for (Int_t iPad = 0; iPad < nPads; iPad++) {
+      // loop over digits
+      for (Int_t iDigit = 0; iDigit < cluster->GetNDigits(); iDigit++) {
        
-       // get ESD pad
-       AliESDMuonPad *esdPad = (AliESDMuonPad*) esdCluster->GetPads().UncheckedAt(iPad);
-       
-       // add it to digit store
-       AliMUONVDigit* digit = Add(*esdPad, *fDigits);
+       // find the digit
+       AliMUONVDigit* digit = fDigits->FindObject(cluster->GetDigitId(iDigit));
        
        // fill digit map
-       if (digit) dMap->Add(esdPad->GetUniqueID(), digit);
-       else dMap->Add(esdPad->GetUniqueID(), fDigits->FindObject(esdPad->GetUniqueID()));
+       if (digit) dMap->Add(digit->GetUniqueID(), digit);
+       else AliError("a digit is missing");
        
       } // end of loop over pads
       
@@ -285,6 +284,17 @@ Int_t AliMUONESDInterface::GetNTriggers() const
   return fTriggers ? fTriggers->GetSize() : 0;
 }
 
+//___________________________________________________________________________
+Bool_t AliMUONESDInterface::DigitsStored(UInt_t trackId) const
+{
+  /// return kTRUE if digits have been stored for all clusters of track "trackId"
+  AliMUONVCluster *cluster;
+  TIter next(CreateClusterIterator(trackId));
+  while ((cluster = static_cast<AliMUONVCluster*>(next())))
+    if (cluster->GetNDigits() == 0) return kFALSE;
+  return kTRUE;
+}
+
 //___________________________________________________________________________
 AliMUONTrack* AliMUONESDInterface::FindTrack(UInt_t trackId) const
 {
@@ -418,22 +428,6 @@ TIterator* AliMUONESDInterface::CreateLocalTriggerIterator() const
   return fTriggers ? fTriggers->CreateLocalIterator() : 0x0;
 }
 
-//___________________________________________________________________________
-AliMUONVCluster* AliMUONESDInterface::FindClusterInTrack(const AliMUONTrack& track, UInt_t clusterId) const
-{
-  /// find the cluster with the given Id into the track
-  
-  Int_t nClusters = track.GetNClusters();
-  for (Int_t iCluster = 0; iCluster < nClusters; iCluster++) {
-    
-    AliMUONVCluster* cluster = ((AliMUONTrackParam*) track.GetTrackParamAtCluster()->UncheckedAt(iCluster))->GetClusterPtr();
-    if (cluster->GetUniqueID() == clusterId) return cluster;
-    
-  }
-  
-  return 0x0;
-}
-
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
 //                                static methods                               //
 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
@@ -442,22 +436,25 @@ AliMUONVCluster* AliMUONESDInterface::FindClusterInTrack(const AliMUONTrack& tra
 void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam, Bool_t info)
 {
   /// Reset the MUON tracker using "recoParam" if provided.
-  /// If not provided, will use Kalman filter + Smoother
+  /// If not provided, will get them from OCDB.
+  /// Load the magnetic field from OCDB if not already set.
   
   delete fgTracker;
   delete fgRecoParam;
   
   if (recoParam) {
     
+    // use provided recoParam
     fgRecoParam = new AliMUONRecoParam(*recoParam);
     
-    if (info) cout<<"I-AliMUONESDInterface::ResetTracker: will refit tracks with provided RecoParam:"<<endl;
+    if (info) AliInfoClass("will refit tracks with provided RecoParam:");
     
   } else {
     
-    fgRecoParam = AliMUONRecoParam::GetLowFluxParam();
+    // or get them from OCDB
+    fgRecoParam = AliMUONCDB::LoadRecoParam();
     
-    cout<<"W-AliMUONESDInterface::ResetTracker: RecoParam not provided. Will use default LowFlux parametrization:"<<endl;
+    if (!fgRecoParam) AliFatalClass("RecoParam have not been set!");
     
   }
   
@@ -470,10 +467,11 @@ void AliMUONESDInterface::ResetTracker(const AliMUONRecoParam* recoParam, Bool_t
     <<fgRecoParam->GetBendingVertexDispersion()<<" cm"<<endl;
   }
   
-  if (!TGeoGlobalMagField::Instance()->GetField())
-    cout<<"W-AliMUONESDInterface::ResetTracker: Magnetic field has not been set --> assume field is OFF"<<endl;
+  // load magnetic field for track extrapolation if not already set
+  if (!TGeoGlobalMagField::Instance()->GetField() && !AliMUONCDB::LoadField())
+    AliFatalClass("Magnetic field has not been set!");
   
-  fgTracker = AliMUONTracker::CreateTrackReconstructor(fgRecoParam,0x0);
+  fgTracker = AliMUONTracker::CreateTrackReconstructor(fgRecoParam,0x0,0x0);
   
 }
 
@@ -483,10 +481,10 @@ AliMUONVTrackStore* AliMUONESDInterface::NewTrackStore()
   /// Create an empty track store of type fgTrackStoreName
   TClass* classPtr = TClass::GetClass(fgTrackStoreName);
   if (!classPtr || !classPtr->InheritsFrom("AliMUONVTrackStore")) {
-    cout<<"E-AliMUONESDInterface::NewTrackStore: Unable to create store of type "<<fgTrackStoreName.Data()<<endl;
+    AliErrorClass(Form("Unable to create store of type %s", fgTrackStoreName.Data()));
     return 0x0;
   }
-  return reinterpret_cast<AliMUONVTrackStore*>(classPtr->New());
+  return reinterpret_cast<AliMUONVTrackStore*>(gROOT->ProcessLineFast(Form("new %s()",fgTrackStoreName.Data())));
 }
 
 //_____________________________________________________________________________
@@ -495,10 +493,25 @@ AliMUONVClusterStore* AliMUONESDInterface::NewClusterStore()
   /// Create an empty cluster store of type fgClusterStoreName
   TClass* classPtr = TClass::GetClass(fgClusterStoreName);
   if (!classPtr || !classPtr->InheritsFrom("AliMUONVClusterStore")) {
-    cout<<"E-AliMUONESDInterface::NewClusterStore: Unable to create store of type "<<fgClusterStoreName.Data()<<endl;
+    AliErrorClass(Form("Unable to create store of type %s", fgClusterStoreName.Data()));
     return 0x0;
   }
-  return reinterpret_cast<AliMUONVClusterStore*>(classPtr->New());
+  return reinterpret_cast<AliMUONVClusterStore*>(gROOT->ProcessLineFast(Form("new %s()",fgClusterStoreName.Data())));
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONESDInterface::NewCluster()
+{
+  /// Create an empty cluster of type associated to the cluster store of type fgClusterStoreName
+  TClass* classPtr = TClass::GetClass(fgClusterStoreName);
+  if (!classPtr || !classPtr->InheritsFrom("AliMUONVClusterStore")) {
+    AliErrorClass(Form("Unable to create store of type %s", fgClusterStoreName.Data()));
+    return 0x0;
+  }
+  AliMUONVClusterStore* cStore = reinterpret_cast<AliMUONVClusterStore*>(classPtr->New());
+  AliMUONVCluster* cluster = cStore->CreateCluster(0,0,0);
+  delete cStore;
+  return cluster;
 }
 
 //_____________________________________________________________________________
@@ -507,10 +520,25 @@ AliMUONVDigitStore* AliMUONESDInterface::NewDigitStore()
   /// Create an empty digit store of type fgDigitStoreName
   TClass* classPtr = TClass::GetClass(fgDigitStoreName);
   if (!classPtr || !classPtr->InheritsFrom("AliMUONVDigitStore")) {
-    cout<<"E-AliMUONESDInterface::NewDigitStore: Unable to create store of type "<<fgDigitStoreName.Data()<<endl;
+    AliErrorClass(Form("Unable to create store of type %s", fgDigitStoreName.Data()));
     return 0x0;
   }
-  return reinterpret_cast<AliMUONVDigitStore*>(classPtr->New());
+  return reinterpret_cast<AliMUONVDigitStore*>(gROOT->ProcessLineFast(Form("new %s()",fgDigitStoreName.Data())));
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* AliMUONESDInterface::NewDigit()
+{
+  /// Create an empty digit of type associated to the digit store of type fgDigitStoreName
+  TClass* classPtr = TClass::GetClass(fgDigitStoreName);
+  if (!classPtr || !classPtr->InheritsFrom("AliMUONVDigitStore")) {
+    AliErrorClass(Form("Unable to create store of type %s", fgDigitStoreName.Data()));
+    return 0x0;
+  }
+  AliMUONVDigitStore* dStore = reinterpret_cast<AliMUONVDigitStore*>(classPtr->New());
+  AliMUONVDigit* digit = dStore->CreateDigit(0,0,0,0);
+  delete dStore;
+  return digit;
 }
 
 //_____________________________________________________________________________
@@ -519,10 +547,10 @@ AliMUONVTriggerStore* AliMUONESDInterface::NewTriggerStore()
   /// Create an empty trigger store of type fgTriggerStoreName
   TClass* classPtr = TClass::GetClass(fgTriggerStoreName);
   if (!classPtr || !classPtr->InheritsFrom("AliMUONVTriggerStore")) {
-    cout<<"E-AliMUONESDInterface::NewTriggerStore: Unable to create store of type "<<fgTriggerStoreName.Data()<<endl;
+    AliErrorClass(Form("Unable to create store of type %s", fgTriggerStoreName.Data()));
     return 0x0;
   }
-  return reinterpret_cast<AliMUONVTriggerStore*>(classPtr->New());
+  return reinterpret_cast<AliMUONVTriggerStore*>(gROOT->ProcessLineFast(Form("new %s()",fgTriggerStoreName.Data())));
 }
 
 //_____________________________________________________________________________
@@ -531,10 +559,10 @@ AliMUONVTriggerTrackStore* AliMUONESDInterface::NewTriggerTrackStore()
   /// Create an empty trigger track store of type fgTriggerTrackStoreName
   TClass* classPtr = TClass::GetClass(fgTriggerTrackStoreName);
   if (!classPtr || !classPtr->InheritsFrom("AliMUONVTriggerTrackStore")) {
-    cout<<"E-AliMUONESDInterface::NewTriggerTrackStore: Unable to create store of type "<<fgTriggerTrackStoreName.Data()<<endl;
+    AliErrorClass(Form("Unable to create store of type %s", fgTriggerTrackStoreName.Data()));
     return 0x0;
   }
-  return reinterpret_cast<AliMUONVTriggerTrackStore*>(classPtr->New());
+  return reinterpret_cast<AliMUONVTriggerTrackStore*>(gROOT->ProcessLineFast(Form("new %s()",fgTriggerTrackStoreName.Data())));
 }
 
 //_________________________________________________________________________
@@ -670,6 +698,7 @@ void AliMUONESDInterface::SetParamCov(const AliMUONTrackParam& trackParam, AliES
 void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track, Bool_t refit)
 {
   /// Transfert data from ESDMuon track to MUON track.
+  /// ESDMuon track must hold the pointer to the ESD event otherwise we cannot recover the clusters.
   /// If refit = kTRUE, the track parameters at each cluster are obtained by refitting the track
   /// or by extrapolating the parameters at the first one if the refit failed.
   /// If refit = kFALSE, only the track parameters at first cluster are valid.
@@ -695,6 +724,7 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrac
   track.SetMatchTrigger(esdTrack.GetMatchTrigger());
   track.SetChi2MatchTrigger(esdTrack.GetChi2MatchTrigger());
   track.SetHitsPatternInTrigCh(esdTrack.GetHitsPatternInTrigCh());
+  track.SetHitsPatternInTrigChTrk(esdTrack.GetHitsPatternInTrigChTrk());
   track.SetLocalTrigger(esdTrack.LoCircuit(), esdTrack.LoStripX(), esdTrack.LoStripY(),
                        esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt(),
                        esdTrack.GetTriggerWithoutChamber());
@@ -711,17 +741,22 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrac
   GetParamCov(esdTrack, param);
   
   // create empty cluster
-  AliMUONVClusterStore* cStore = NewClusterStore();
-  if (!cStore) return;
-  AliMUONVCluster* cluster = cStore->CreateCluster(0,0,0);
+  AliMUONVCluster* cluster = NewCluster();
   
   // fill TrackParamAtCluster with track parameters at each cluster if available
-  // or with only track parameters at first (fake) cluster if not
-  if(esdTrack.ClustersStored()) {
+  Bool_t clusterFound = kFALSE;
+  if(esdTrack.GetESDEvent()) {
     
-    // loop over ESD clusters
-    AliESDMuonCluster *esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().First();
-    while (esdCluster) {
+    // loop over cluster Id
+    for (Int_t i = 0; i < esdTrack.GetNClusters(); i++) {
+      
+      // recover the ESDMuon cluster
+      AliESDMuonCluster *esdCluster = esdTrack.GetESDEvent()->FindMuonCluster(esdTrack.GetClusterId(i));
+      if (esdCluster) clusterFound = kTRUE;
+      else {
+       AliErrorClass("a cluster is missing in ESD");
+       continue;
+      }
       
       // copy cluster information
       ESDToMUON(*esdCluster, *cluster);
@@ -732,11 +767,10 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrac
       // add common track parameters at current cluster
       track.AddTrackParamAtCluster(param, *cluster, kTRUE);
       
-      esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().After(esdCluster);
     }
     
     // refit the track to get better parameters and covariances at each cluster (temporary disable track improvement)
-    if (refit) {
+    if (clusterFound && refit) {
       
       AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
       AliMUONTrackParam paramSave(*firstTrackParam);
@@ -750,7 +784,10 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrac
       
     }
     
-  } else {
+  }
+  
+  // fill TrackParamAtCluster with only track parameters at first (fake) cluster if no cluster found in ESD
+  if (!clusterFound) {
     
     // get number of the first hit chamber according to the MUONClusterMap
     Int_t firstCh = 0;
@@ -770,7 +807,6 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrac
   track.SetMCLabel(esdTrack.GetLabel());
   
   delete cluster;
-  delete cStore;
   
 }
 
@@ -779,12 +815,12 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLoca
 {
   /// Transfert trigger data from ESDMuon track to the MUONLocalTtrigger object
   
-  // if the ESDMuon track is a ghost then return an empty MUON track
-  if (!esdTrack.ContainTriggerData()) {
-    AliMUONLocalTrigger emptyLocTrg;
-    locTrg = emptyLocTrg;
-    return;
-  }
+  // reset the local trigger content
+  AliMUONLocalTrigger emptyLocTrg;
+  locTrg = emptyLocTrg;
+  
+  // if the ESDMuon track is a ghost then return an empty local trigger
+  if (!esdTrack.ContainTriggerData()) return;
   
   locTrg.SetUniqueID(esdTrack.GetUniqueID());
   locTrg.SetLoCircuit(esdTrack.LoCircuit());
@@ -793,8 +829,10 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONLoca
   locTrg.SetDeviation(esdTrack.LoDev());
   locTrg.SetLoLpt(esdTrack.LoLpt());
   locTrg.SetLoHpt(esdTrack.LoHpt());
-  locTrg.SetTriggerWithoutChamber(esdTrack.GetTriggerWithoutChamber());
-  locTrg.SetLoTrigY(1);
+  for (Int_t ich = 0; ich < 4; ich++)
+    if (esdTrack.TriggerFiredWithoutChamber(ich))
+      locTrg.SetTriggerWithoutChamber(ich);
+  locTrg.SetLoTrigY(0);
   locTrg.SetX1Pattern(esdTrack.GetTriggerX1Pattern());
   locTrg.SetX2Pattern(esdTrack.GetTriggerX2Pattern());
   locTrg.SetX3Pattern(esdTrack.GetTriggerX3Pattern());
@@ -820,11 +858,7 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUON
   cluster.SetChi2(esdCluster.GetChi2());
   cluster.SetMCLabel(esdCluster.GetLabel());
   
-  if (esdCluster.PadsStored()) {
-    Int_t nPads = esdCluster.GetNPads();
-    for (Int_t iPad = 0; iPad < nPads; iPad++)
-      cluster.AddDigitId(((AliESDMuonPad*)esdCluster.GetPads().UncheckedAt(iPad))->GetUniqueID());
-  }
+  cluster.SetDigitsId(esdCluster.GetNPads(), esdCluster.GetPadsId());
   
 }
 
@@ -832,11 +866,10 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUON
 void AliMUONESDInterface::ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit)
 {
   /// Transfert data from ESDMuon pad to MUON digit
+  /// Load mapping from OCDB if not already set
   
-  if (!AliMpSegmentation::Instance(kFALSE)) {
-    cout<<"E-AliMUONESDInterface::ESDToMUON: need mapping segmentation to convert ESD pad to MUON digit"<<endl;
-    return;
-  }
+  if (!AliMpSegmentation::Instance(kFALSE) && !AliMUONCDB::LoadMapping(kTRUE))
+    AliFatalClass("mapping segmentation has not been set!");
   
   const AliMpVSegmentation* seg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(esdPad.GetDetElemId(), esdPad.GetManuId());  
   AliMpPad pad = seg->PadByLocation(esdPad.GetManuId(), esdPad.GetManuChannel(), kFALSE);
@@ -852,13 +885,32 @@ void AliMUONESDInterface::ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit&
 }
 
 //_____________________________________________________________________________
-void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack& esdTrack, const Double_t vertex[3],
+void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDEvent& esd, const Double_t vertex[3],
                                    const AliMUONVDigitStore* digits, const AliMUONLocalTrigger* locTrg)
 {
-  /// Transfert data from MUON track to ESDMuon track
+  /// Transfert data from MUON track to ESD event (ESDTrack + ESDClusters)
   /// Incorporate the ESDPads if the digits are provided
   /// Add trigger info if the MUON track is matched with a trigger track
   
+  // transfert track info
+  AliESDMuonTrack *esdTrack = esd.NewMuonTrack();
+  MUONToESD(track, *esdTrack, vertex, locTrg);
+  
+  // transfert cluster info if any
+  for (Int_t i = 0; i < track.GetNClusters(); i++) {
+    AliMUONTrackParam *param = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->UncheckedAt(i));
+    MUONToESD(*(param->GetClusterPtr()), esd, digits);
+  }
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack& esdTrack,
+                                   const Double_t vertex[3], const AliMUONLocalTrigger* locTrg)
+{
+  /// Transfert data from MUON track to ESDMuon track (ESDMuon track only contains clusters'Id, not cluster themselves)
+  /// Add trigger info if the MUON track is matched with a trigger track
+  
   // empty MUON track -> produce a ghost ESDMuon track if trigger info are available otherwise produce an empty track
   if (track.GetNClusters() == 0) {
     if (locTrg) MUONToESD(*locTrg, esdTrack, track.GetUniqueID());
@@ -875,7 +927,6 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
   // set global info
   esdTrack.SetUniqueID(track.GetUniqueID());
   esdTrack.SetChi2(track.GetGlobalChi2());
-  esdTrack.SetNHit(track.GetNClusters());
   esdTrack.SetLabel(track.GetMCLabel());
   
   // set param at first cluster
@@ -901,12 +952,11 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
   SetParamAtDCA(trackParamAtDCA, esdTrack);
   
   // set muon cluster info
-  AliESDMuonCluster esdCluster;
   esdTrack.SetMuonClusterMap(0);
   while (trackParam) {
-    MUONToESD(*(trackParam->GetClusterPtr()), esdCluster, digits);
-    esdTrack.AddCluster(esdCluster);
-    esdTrack.AddInMuonClusterMap(esdCluster.GetChamberId());
+    AliMUONVCluster *cluster = trackParam->GetClusterPtr();
+    esdTrack.AddClusterId(cluster->GetUniqueID());
+    esdTrack.AddInMuonClusterMap(cluster->GetChamberId());
     trackParam = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->After(trackParam));
   }
   
@@ -917,6 +967,7 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
   esdTrack.SetLocalTrigger(track.GetLocalTrigger());
   esdTrack.SetChi2MatchTrigger(track.GetChi2MatchTrigger());
   esdTrack.SetHitsPatternInTrigCh(track.GetHitsPatternInTrigCh());
+  esdTrack.SetHitsPatternInTrigChTrk(track.GetHitsPatternInTrigChTrk());
   if (locTrg) {
     esdTrack.SetTriggerX1Pattern(locTrg->GetX1Pattern());
     esdTrack.SetTriggerY1Pattern(locTrg->GetY1Pattern());
@@ -939,6 +990,15 @@ void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack&
   
 }
 
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDEvent& esd,
+                                   UInt_t trackId, const AliMUONTriggerTrack* triggerTrack)
+{
+  /// Add in ESD event a ghost ESDMuon track containing only informations about trigger track
+  AliESDMuonTrack *esdTrack = esd.NewMuonTrack();
+  MUONToESD(locTrg, *esdTrack, trackId, triggerTrack);
+}
+
 //_____________________________________________________________________________
 void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuonTrack& esdTrack,
                                    UInt_t trackId, const AliMUONTriggerTrack* triggerTrack)
@@ -968,6 +1028,7 @@ void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuo
   esdTrack.SetTriggerX4Pattern(locTrg.GetX4Pattern());
   esdTrack.SetTriggerY4Pattern(locTrg.GetY4Pattern());
   UShort_t hitPattern = 0;
+  esdTrack.SetHitsPatternInTrigChTrk(hitPattern);
   if(triggerTrack){
     hitPattern = triggerTrack->GetHitsPatternInTrigCh();
     esdTrack.SetHitsPatternInTrigCh(hitPattern);
@@ -980,37 +1041,64 @@ void AliMUONESDInterface::MUONToESD(const AliMUONLocalTrigger& locTrg, AliESDMuo
 }
 
 //_____________________________________________________________________________
-void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCluster& esdCluster, const AliMUONVDigitStore* digits)
+void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDEvent& esd, const AliMUONVDigitStore* digits)
 {
-  /// Transfert data from MUON cluster to ESDMuon cluster
-  /// Incorporate the ESDPads if the digits are provided
+  /// Transfert data from MUON cluster to ESD event if it does not already exist
+  /// Also transfert digits'Id to cluster and digits to ESD if they are provided
   
-  esdCluster.Clear("C");
+  AliESDMuonCluster *esdCluster = esd.FindMuonCluster(cluster.GetUniqueID());
+  if (!esdCluster) esdCluster = esd.NewMuonCluster();
+  else if (!digits || esdCluster->GetNPads() > 0) return;
   
-  esdCluster.SetUniqueID(cluster.GetUniqueID());
-  esdCluster.SetXYZ(cluster.GetX(), cluster.GetY(), cluster.GetZ());
-  esdCluster.SetErrXY(cluster.GetErrX(), cluster.GetErrY());
-  esdCluster.SetCharge(cluster.GetCharge());
-  esdCluster.SetChi2(cluster.GetChi2());
-  esdCluster.SetLabel(cluster.GetMCLabel());
-  
-  if (digits) { // transfert all data if required
+  if (digits) {
+    
+    MUONToESD(cluster, *esdCluster, kTRUE);
     
-    AliESDMuonPad esdPad;
     for (Int_t i=0; i<cluster.GetNDigits(); i++) {
       AliMUONVDigit* digit = digits->FindObject(cluster.GetDigitId(i));
       if (!digit) {
-       cout<<"E-AliMUONESDInterface::MUONToESD: digit "<<cluster.GetDigitId(i)<<" not found"<<endl;
+       AliErrorClass(Form("digit %u not found", cluster.GetDigitId(i)));
        continue;
       }
-      MUONToESD(*digit, esdPad);
-      esdCluster.AddPad(esdPad);
+      MUONToESD(*digit, esd);
     }
     
+  } else {
+    
+    MUONToESD(cluster, *esdCluster, kFALSE);
+    
   }
   
 }
 
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCluster& esdCluster, Bool_t copyPadsId)
+{
+  /// Transfert data from MUON cluster to ESDMuon cluster
+  /// Also transfert digits'Is if required
+  
+  esdCluster.Clear("C");
+  
+  esdCluster.SetUniqueID(cluster.GetUniqueID());
+  esdCluster.SetXYZ(cluster.GetX(), cluster.GetY(), cluster.GetZ());
+  esdCluster.SetErrXY(cluster.GetErrX(), cluster.GetErrY());
+  esdCluster.SetCharge(cluster.GetCharge());
+  esdCluster.SetChi2(cluster.GetChi2());
+  esdCluster.SetLabel(cluster.GetMCLabel());
+  
+  if (copyPadsId) esdCluster.SetPadsId(cluster.GetNDigits(), cluster.GetDigitsId());
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONVDigit& digit, AliESDEvent& esd)
+{
+  /// Transfert data from MUON digit to ESD event if it does not already exist
+  if (esd.FindMuonPad(digit.GetUniqueID())) return;
+  AliESDMuonPad *esdPad = esd.NewMuonPad();
+  MUONToESD(digit, *esdPad);
+}
+
 //_____________________________________________________________________________
 void AliMUONESDInterface::MUONToESD(const AliMUONVDigit& digit, AliESDMuonPad& esdPad)
 {