- new interface beween MUON objects (track/cluster/digit) and ESD objects (track...
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2008 14:43:15 +0000 (14:43 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 10 Mar 2008 14:43:15 +0000 (14:43 +0000)
--> removed most of dependences towards ESD objects in the MUON code

Two ways of using this interface:
1) converting individual objects using static ESD <--> MUON conversion methods
2) loading an entire ESD event into the interface and using the member methods to access MUON objects

Philippe Pillot

19 files changed:
EVE/EveDet/AliEveMUONData.cxx
EVE/EveDet/AliEveMUONTrack.cxx
MUON/AliMUONESDInterface.cxx [new file with mode: 0644]
MUON/AliMUONESDInterface.h [new file with mode: 0644]
MUON/AliMUONRawClusterV2.cxx
MUON/AliMUONRawClusterV2.h
MUON/AliMUONRecoCheck.cxx
MUON/AliMUONTrack.cxx
MUON/AliMUONTrack.h
MUON/AliMUONTrackParam.cxx
MUON/AliMUONTrackParam.h
MUON/AliMUONTracker.cxx
MUON/AliMUONVCluster.cxx
MUON/AliMUONVCluster.h
MUON/MUONAlignment.C
MUON/MUONefficiency.C
MUON/MUONmassPlot_ESD.C
MUON/MUONrecLinkDef.h
MUON/libMUONrec.pkg

index 95cad37b9d3302fb8b904013b5a107363e4a759a..22652740fa8b9ff333b019708c42530d6f847864 100644 (file)
@@ -28,6 +28,7 @@
 #include "AliMUONVDigitStore.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrack.h"
+#include "AliMUONESDInterface.h"
 #include "AliESDMuonTrack.h"
 #include "AliESDEvent.h"
 #include "TTree.h"
@@ -268,6 +269,7 @@ void AliEveMUONData::LoadRecPointsFromESD(Char_t *fileName)
   AliMUONVCluster *cluster;
   AliMUONTrackParam *trackParam;
   AliESDMuonTrack *esdTrack;
+  AliMUONTrack muonTrack;
   Int_t detElemId, chamber, nTrackParam;
   Double_t clsX, clsY, clsZ, charge;
   
@@ -280,7 +282,7 @@ void AliEveMUONData::LoadRecPointsFromESD(Char_t *fileName)
   for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
     esdTrack = esdEvent->GetMuonTrack(iTrack);
     if (!esdTrack->ClustersStored()) continue;
-    AliMUONTrack muonTrack(*esdTrack);
+    AliMUONESDInterface::ESDToMUON(*esdTrack,muonTrack);
     nTrackParam = muonTrack.GetTrackParamAtCluster()->GetEntries();
     for(Int_t iCluster = 0; iCluster < nTrackParam; iCluster++) {
       trackParam = (AliMUONTrackParam *) muonTrack.GetTrackParamAtCluster()->At(iCluster);
index 79682e4cc5fab4d4e2d934f16481c0f878ec993d..99d443d35b7f1f06f1e84ddc95e8d2bc6a3341ab 100644 (file)
@@ -25,6 +25,7 @@
 #include <AliMUONTriggerTrack.h>
 #include <AliMUONTrackParam.h>
 #include <AliMUONConstants.h>
+#include <AliMUONESDInterface.h>
 
 #include <TClonesArray.h>
 #include <TMath.h>
@@ -785,7 +786,7 @@ void AliEveMUONTrack::MakeESDTrack(AliESDMuonTrack *mtrack)
 
   fTrack = new AliMUONTrack();
   AliMUONTrackParam trackParam;
-  trackParam.GetParamFrom(*mtrack);
+  AliMUONESDInterface::GetParamAtVertex(*mtrack, trackParam);
   fTrack->SetTrackParamAtVertex(&trackParam);
   fTrack->SetMatchTrigger(mtrack->GetMatchTrigger());
 
diff --git a/MUON/AliMUONESDInterface.cxx b/MUON/AliMUONESDInterface.cxx
new file mode 100644 (file)
index 0000000..9c4c3cc
--- /dev/null
@@ -0,0 +1,808 @@
+/**************************************************************************
+* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+*                                                                        *
+* Author: The ALICE Off-line Project.                                    *
+* Contributors are mentioned in the code where appropriate.              *
+*                                                                        *
+* Permission to use, copy, modify and distribute this software and its   *
+* documentation strictly for non-commercial purposes is hereby granted   *
+* without fee, provided that the above copyright notice appears in all   *
+* copies and that both the copyright notice and this permission notice   *
+* appear in the supporting documentation. The authors make no claims     *
+* about the suitability of this software for any purpose. It is          *
+* provided "as is" without express or implied warranty.                  *
+**************************************************************************/
+
+// $Id$
+
+#include "AliMUONESDInterface.h"
+#include "AliMUONTrack.h"
+#include "AliMUONVTrackStore.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterStore.h"
+#include "AliMUONVDigit.h"
+#include "AliMUONVDigitStore.h"
+#include "AliMUON1DMapIterator.h"
+#include "AliMUON2DMapIterator.h"
+#include "AliMUONTrackParam.h"
+#include "AliMUONTrackExtrap.h"
+#include "AliMUONConstants.h"
+
+#include "AliMpVSegmentation.h"
+#include "AliMpSegmentation.h"
+#include "AliMpIntPair.h"
+#include "AliMpPad.h"
+
+#include "AliESDEvent.h"
+#include "AliESDMuonTrack.h"
+#include "AliESDMuonCluster.h"
+#include "AliESDMuonPad.h"
+#include "AliLog.h"
+
+#include <TClass.h>
+#include <TIterator.h>
+#include <TMath.h>
+#include <TMatrixD.h>
+#include <Riostream.h>
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONESDInterface
+///
+/// There are 2 way of using thid converter between MUON track/cluster/digit
+/// and ESDMuon track/cluster/pad:
+/// 
+/// 1) using the static methods converting the objects one by one
+///
+/// 2) loading a whole ESDEvent and using the getters and/or the iterators
+///    to access the corresponding MUON objects
+///
+/// \author Philippe Pillot
+//-----------------------------------------------------------------------------
+
+/// \cond CLASSIMP
+ClassImp(AliMUONESDInterface)
+/// \endcond
+
+TString AliMUONESDInterface::fgTrackStoreName = "AliMUONTrackStoreV1";
+TString AliMUONESDInterface::fgClusterStoreName = "AliMUONClusterStoreV2";
+TString AliMUONESDInterface::fgDigitStoreName = "AliMUONDigitStoreV2R";
+
+//_____________________________________________________________________________
+AliMUONESDInterface::AliMUONESDInterface()
+: TObject(),
+  fTracks(0x0),
+  fDigits(0x0),
+  fTrackMap(0x0),
+  fClusterMap(0x0),
+  fDigitMap(0x0)
+{
+  /// Default constructor
+}
+
+//_____________________________________________________________________________
+AliMUONESDInterface::~AliMUONESDInterface()
+{
+  /// Destructor
+  delete fTracks;
+  delete fDigits;
+  delete fTrackMap;
+  delete fClusterMap;
+  delete fDigitMap;
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
+//                    methods to play with internal objects                    //
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::Clear(Option_t*)
+{
+  /// clear memory
+  delete fTracks; fTracks = 0x0;
+  delete fDigits; fDigits = 0x0;
+  delete fTrackMap; fTrackMap = 0x0;
+  delete fClusterMap; fClusterMap = 0x0;
+  delete fDigitMap; fDigitMap = 0x0;
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::Reset()
+{
+  /// reset stores and maps
+  
+  if (fTracks) fTracks->Clear("C");
+  else fTracks = NewTrackStore();
+  
+  if (fDigits) fDigits->Clear("C");
+  else fDigits = NewDigitStore();
+  
+  if (fTrackMap) fTrackMap->Clear();
+  else fTrackMap = new AliMpExMap(kTRUE);
+  fTrackMap->SetOwner(kFALSE);
+  
+  if (fClusterMap) fClusterMap->Clear();
+  else fClusterMap = new AliMpExMap(kTRUE);
+  fClusterMap->SetOwner(kTRUE);
+  
+  if (fDigitMap) fDigitMap->Clear("C");
+  else fDigitMap = new TClonesArray("AliMpExMap",10);
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::LoadEvent(AliESDEvent& esdEvent)
+{
+  /// Extract MUON data from the given ESD event
+  
+  // reset data members
+  Reset();
+  
+  // loop over ESD tracks and fill the stores
+  Int_t nTracks = (Int_t) esdEvent.GetNumberOfMuonTracks(); 
+  for (Int_t iTrack = 0; iTrack <  nTracks; iTrack++) {
+    
+    // get ESD track
+    AliESDMuonTrack* esdTrack = esdEvent.GetMuonTrack(iTrack);
+    
+    // add it to track store
+    AliMUONTrack* track = Add(*esdTrack, *fTracks);
+    
+    // fill track map
+    fTrackMap->Add(iTrack, track);
+    
+    // prepare cluster map
+    fClusterMap->Add(iTrack, new AliMpExMap(kTRUE));
+    AliMpExMap* cMap = (AliMpExMap*) fClusterMap->GetObjectFast(iTrack);
+    cMap->SetOwner(kFALSE);
+    
+    // prepare digit maps
+    AliMpExMap* dMaps = new((*fDigitMap)[iTrack]) AliMpExMap(kTRUE);
+    dMaps->SetOwner(kTRUE);
+    
+    // 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);
+      
+      // get the corresponding MUON cluster
+      AliMUONVCluster* cluster = FindClusterInTrack(*track, esdCluster->GetUniqueID());
+      
+      // fill cluster map
+      cMap->Add(cluster->GetUniqueID(), cluster);
+      
+      // prepare digit map
+      dMaps->Add(esdCluster->GetUniqueID(), new AliMpExMap(kTRUE));
+      AliMpExMap* dMap = (AliMpExMap*) dMaps->GetObjectFast(iCluster);
+      dMap->SetOwner(kFALSE);
+      
+      // loop over ESD pads
+      Int_t nPads = esdCluster->GetNPads();
+      for (Int_t iPad = 0; iPad <  nPads; iPad++) {
+       
+       // get ESD pad
+       AliESDMuonPad *esdPad = (AliESDMuonPad*) esdCluster->GetPads().UncheckedAt(iPad);
+       
+       // add it to digit store
+       AliMUONVDigit* digit = Add(*esdPad, *fDigits);
+       
+       // fill digit map
+       if (digit) dMap->Add(esdPad->GetUniqueID(), digit);
+       else dMap->Add(esdPad->GetUniqueID(), fDigits->FindObject(esdPad->GetUniqueID()));
+       
+      } // end of loop over pads
+      
+    } // end of loop over clusters
+    
+  } // end of loop over tracks
+  
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNTracks() const
+{
+  /// return the number of tracks
+  return fTrackMap ? fTrackMap->GetSize() : 0;
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNClusters() const
+{
+  /// return the number of clusters
+  Int_t nClusters = 0;
+  Int_t nTracks = GetNTracks();
+  for (Int_t i = 0; i < nTracks; i++) nClusters += GetTrackFast(i)->GetNClusters();
+  return nClusters;
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNClusters(Int_t iTrack) const
+{
+  /// return the number of clusters in track "iTrack"
+  AliMUONTrack* track = GetTrack(iTrack);
+  return track ? track->GetNClusters() : 0;
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNDigits() const
+{
+  /// return the number of digits
+  return fDigits ? fDigits->GetSize() : 0;
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNDigits(Int_t iTrack) const
+{
+  /// return the number of digits in all clusters of track "iTrack"
+  Int_t nDigits = 0;
+  Int_t nClusters = GetNClusters(iTrack);
+  for (Int_t j = 0; j <  nClusters; j++) nDigits += GetClusterFast(iTrack,j)->GetNDigits();
+  return nDigits;
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNDigits(Int_t iTrack, Int_t iCluster) const
+{
+  /// return the number of digits in cluster numbered "iCluster" of track "iTrack"
+  AliMUONVCluster* cluster = GetCluster(iTrack, iCluster);
+  return cluster ? cluster->GetNDigits() : 0;
+}
+
+//___________________________________________________________________________
+Int_t AliMUONESDInterface::GetNDigitsInCluster(UInt_t clusterId) const
+{
+  /// return the number of digits in cluster "clusterId"
+  AliMUONVCluster* cluster = FindCluster(clusterId);
+  return cluster ? cluster->GetNDigits() : 0;
+}
+
+//___________________________________________________________________________
+AliMUONTrack* AliMUONESDInterface::GetTrack(Int_t iTrack) const
+{
+  /// return MUON track "iTrack" (0x0 if not found)
+  AliMUONTrack* track = fTrackMap ? (AliMUONTrack*) fTrackMap->GetObject(iTrack) : 0x0;
+  if (!track) AliWarning(Form("track %d does not exist",iTrack));
+  return track;
+}
+
+//___________________________________________________________________________
+AliMUONVCluster* AliMUONESDInterface::GetCluster(Int_t iTrack, Int_t iCluster) const
+{
+  /// return MUON cluster numbered "iCluster" in track "iTrack" (0x0 if not found)
+  AliMpExMap* cMap = fClusterMap ? (AliMpExMap*) fClusterMap->GetObject(iTrack) : 0x0;
+  AliMUONVCluster* cluster = cMap ? (AliMUONVCluster*) cMap->GetObject(iCluster) : 0x0;
+  if (!cluster) AliWarning(Form("cluster #%d in track %d does not exist",iCluster,iTrack));
+  return cluster;
+}
+
+//___________________________________________________________________________
+AliMUONVDigit* AliMUONESDInterface::GetDigit(Int_t iTrack, Int_t iCluster, Int_t iDigit) const
+{
+  /// return MUON digit numbered "iDigit" in cluster numbered "iCluster" of track "iTrack" (0x0 if not found)
+  AliMpExMap* dMaps = fDigitMap ? (AliMpExMap*) fDigitMap->At(iTrack) : 0x0;
+  AliMpExMap* dMap = dMaps ? (AliMpExMap*) dMaps->GetObject(iCluster) : 0x0;
+  AliMUONVDigit* digit = dMap ? (AliMUONVDigit*) dMap->GetObject(iDigit) : 0x0;
+  if (!digit) AliWarning(Form("digit #%d in cluster #%d of track %d does not exist",iDigit,iCluster,iTrack));
+  return digit;
+}
+
+//___________________________________________________________________________
+AliMUONVCluster* AliMUONESDInterface::FindCluster(UInt_t clusterId) const
+{
+  /// return cluster "clusterId" (0x0 if not found)
+  AliMUONVCluster* cluster = 0x0;
+  
+  Int_t nTracks = GetNTracks();
+  for (Int_t i = 0; i < nTracks; i++) {
+    
+    cluster = (AliMUONVCluster*) ((AliMpExMap*) fClusterMap->GetObjectFast(i))->GetValue(clusterId);
+    if (cluster) break;
+    
+  }
+  
+  if (!cluster) AliWarning(Form("cluster %d does not exist",clusterId));
+  return cluster;
+}
+
+//___________________________________________________________________________
+AliMUONVDigit* AliMUONESDInterface::FindDigit(UInt_t digitId) const
+{
+  /// return digit "digitId" (0x0 if not found)
+  AliMUONVDigit *digit = fDigits ? fDigits->FindObject(digitId) : 0x0;
+  if (!digit) AliWarning(Form("digit %d does not exist",digitId));
+  return digit;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateTrackIterator() const
+{
+  /// return iterator over all tracks
+  return fTracks ? fTracks->CreateIterator() : 0x0;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateClusterIterator() const
+{
+  /// return iterator over all clusters
+  return fClusterMap ? new AliMUON2DMapIterator(*fClusterMap) : 0x0;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateClusterIterator(Int_t iTrack) const
+{
+  /// return iterator over clusters of track "iTrack"
+  AliMpExMap* cMap = fClusterMap ? (AliMpExMap*) fClusterMap->GetObject(iTrack) : 0x0;
+  return cMap ? new AliMUON1DMapIterator(*cMap) : 0x0;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateDigitIterator() const
+{
+  /// return iterator over all digits
+  return fDigits ? fDigits->CreateIterator() : 0x0;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateDigitIterator(Int_t iTrack) const
+{
+  /// return iterator over all digits of track "iTrack"
+  AliMpExMap* dMaps = fDigitMap ? (AliMpExMap*) fDigitMap->At(iTrack) : 0x0;
+  return dMaps ? new AliMUON2DMapIterator(*dMaps) : 0x0;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateDigitIterator(Int_t iTrack, Int_t iCluster) const
+{
+  /// return iterator over digits of cluster numbered "iCluster" in track "iTrack"
+  AliMpExMap* dMaps = fDigitMap ? (AliMpExMap*) fDigitMap->At(iTrack) : 0x0;
+  AliMpExMap* dMap = dMaps ? (AliMpExMap*) dMaps->GetObject(iCluster) : 0x0;
+  return dMap ? new AliMUON1DMapIterator(*dMap) : 0x0;
+}
+
+//___________________________________________________________________________
+TIterator* AliMUONESDInterface::CreateDigitIteratorInCluster(UInt_t clusterId) const
+{
+  /// return iterator over digits of cluster "clusterId"
+  AliMpExMap* dMap = 0x0;
+  
+  Int_t nTracks = GetNTracks();
+  for (Int_t i = 0; i < nTracks; i++) {
+    
+    dMap = (AliMpExMap*) ((AliMpExMap*) fDigitMap->UncheckedAt(i))->GetValue(clusterId);
+    if (dMap) break;
+    
+  }
+  
+  return dMap ? new AliMUON1DMapIterator(*dMap) : 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                               //
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++//
+
+//_____________________________________________________________________________
+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;
+    return 0x0;
+  }
+  return reinterpret_cast<AliMUONVTrackStore*>(classPtr->New());
+}
+
+//_____________________________________________________________________________
+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;
+    return 0x0;
+  }
+  return reinterpret_cast<AliMUONVClusterStore*>(classPtr->New());
+}
+
+//_____________________________________________________________________________
+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;
+    return 0x0;
+  }
+  return reinterpret_cast<AliMUONVDigitStore*>(classPtr->New());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::GetParamAtVertex(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
+{
+  /// Get parameters at vertex from ESDMuon track
+  trackParam.SetZ(esdTrack.GetZ());
+  trackParam.SetNonBendingCoor(esdTrack.GetNonBendingCoor());
+  trackParam.SetNonBendingSlope(TMath::Tan(esdTrack.GetThetaX()));
+  trackParam.SetBendingCoor(esdTrack.GetBendingCoor());
+  trackParam.SetBendingSlope(TMath::Tan(esdTrack.GetThetaY()));
+  trackParam.SetInverseBendingMomentum(esdTrack.GetInverseBendingMomentum());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::GetParamAtDCA(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
+{
+  /// Get parameters at DCA from ESDMuon track
+  trackParam.SetZ(esdTrack.GetZ());
+  trackParam.SetNonBendingCoor(esdTrack.GetNonBendingCoorAtDCA());
+  trackParam.SetNonBendingSlope(TMath::Tan(esdTrack.GetThetaXAtDCA()));
+  trackParam.SetBendingCoor(esdTrack.GetBendingCoorAtDCA());
+  trackParam.SetBendingSlope(TMath::Tan(esdTrack.GetThetaYAtDCA()));
+  trackParam.SetInverseBendingMomentum(esdTrack.GetInverseBendingMomentumAtDCA());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::GetParamAtFirstCluster(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
+{
+  /// Get parameters at first cluster from ESDMuon track
+  trackParam.SetZ(esdTrack.GetZUncorrected());
+  trackParam.SetNonBendingCoor(esdTrack.GetNonBendingCoorUncorrected());
+  trackParam.SetNonBendingSlope(TMath::Tan(esdTrack.GetThetaXUncorrected()));
+  trackParam.SetBendingCoor(esdTrack.GetBendingCoorUncorrected());
+  trackParam.SetBendingSlope(TMath::Tan(esdTrack.GetThetaYUncorrected()));
+  trackParam.SetInverseBendingMomentum(esdTrack.GetInverseBendingMomentumUncorrected());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::GetParamCov(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam)
+{
+  /// Get parameters covariances from ESD track
+  
+  // get ESD covariance matrix
+  TMatrixD covariances(5,5);
+  esdTrack.GetCovariances(covariances);
+  
+  // compute Jacobian to change the coordinate system
+  // from (X,thetaX,Y,thetaY,c/pYZ) to (X,slopeX,Y,slopeY,c/pYZ)
+  Double_t cosThetaX = TMath::Cos(esdTrack.GetThetaXUncorrected());
+  Double_t cosThetaY = TMath::Cos(esdTrack.GetThetaYUncorrected());
+  TMatrixD jacob(5,5);
+  jacob.Zero();
+  jacob(0,0) = 1.;
+  jacob(1,1) = 1. / cosThetaX / cosThetaX;
+  jacob(2,2) = 1.;
+  jacob(3,3) = 1. / cosThetaY / cosThetaY;
+  jacob(4,4) = 1.;
+  
+  // compute covariance matrix in ESD coordinate system
+  TMatrixD tmp(covariances,TMatrixD::kMultTranspose,jacob);
+  trackParam.SetCovariances(TMatrixD(jacob,TMatrixD::kMult,tmp));
+  
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::SetParamAtVertex(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
+{
+  /// Set parameters in ESD track
+  esdTrack.SetZ(trackParam.GetZ());
+  esdTrack.SetNonBendingCoor(trackParam.GetNonBendingCoor());
+  esdTrack.SetThetaX(TMath::ATan(trackParam.GetNonBendingSlope()));
+  esdTrack.SetBendingCoor(trackParam.GetBendingCoor()); 
+  esdTrack.SetThetaY(TMath::ATan(trackParam.GetBendingSlope()));
+  esdTrack.SetInverseBendingMomentum(trackParam.GetInverseBendingMomentum());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::SetParamAtDCA(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
+{
+  /// Set parameters in ESD track
+  esdTrack.SetNonBendingCoorAtDCA(trackParam.GetNonBendingCoor());
+  esdTrack.SetThetaXAtDCA(TMath::ATan(trackParam.GetNonBendingSlope()));
+  esdTrack.SetBendingCoorAtDCA(trackParam.GetBendingCoor()); 
+  esdTrack.SetThetaYAtDCA(TMath::ATan(trackParam.GetBendingSlope()));
+  esdTrack.SetInverseBendingMomentumAtDCA(trackParam.GetInverseBendingMomentum());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::SetParamAtFirstCluster(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
+{
+  /// Set parameters in ESD track
+  esdTrack.SetZUncorrected(trackParam.GetZ());
+  esdTrack.SetNonBendingCoorUncorrected(trackParam.GetNonBendingCoor());
+  esdTrack.SetThetaXUncorrected(TMath::ATan(trackParam.GetNonBendingSlope()));
+  esdTrack.SetBendingCoorUncorrected(trackParam.GetBendingCoor()); 
+  esdTrack.SetThetaYUncorrected(TMath::ATan(trackParam.GetBendingSlope()));
+  esdTrack.SetInverseBendingMomentumUncorrected(trackParam.GetInverseBendingMomentum());
+}
+
+//_________________________________________________________________________
+void AliMUONESDInterface::SetParamCov(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack)
+{
+  /// Set parameters covariances in ESD track
+  
+  // set null matrix if covariances does not exist
+  if (!trackParam.CovariancesExist()) {
+    TMatrixD tmp(5,5);
+    tmp.Zero();
+    esdTrack.SetCovariances(tmp);
+    return;
+  }
+  
+  // compute Jacobian to change the coordinate system
+  // from (X,slopeX,Y,slopeY,c/pYZ) to (X,thetaX,Y,thetaY,c/pYZ)
+  Double_t cosThetaX = TMath::Cos(TMath::ATan(trackParam.GetNonBendingSlope()));
+  Double_t cosThetaY = TMath::Cos(TMath::ATan(trackParam.GetBendingSlope()));
+  TMatrixD jacob(5,5);
+  jacob.Zero();
+  jacob(0,0) = 1.;
+  jacob(1,1) = cosThetaX * cosThetaX;
+  jacob(2,2) = 1.;
+  jacob(3,3) = cosThetaY * cosThetaY;
+  jacob(4,4) = 1.;
+  
+  // compute covariance matrix in ESD coordinate system
+  TMatrixD tmp(trackParam.GetCovariances(),TMatrixD::kMultTranspose,jacob);
+  esdTrack.SetCovariances(TMatrixD(jacob,TMatrixD::kMult,tmp));
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track)
+{
+  /// Transfert data from ESDMuon track to MUON track
+  
+  track.Clear("C");
+  
+  // global info
+  track.SetUniqueID(esdTrack.GetUniqueID());
+  track.FitWithVertex(kFALSE);
+  track.FitWithMCS(kFALSE);
+  track.SetImproved(kFALSE);
+  track.SetVertexErrXY2(0.,0.);
+  track.SetGlobalChi2(esdTrack.GetChi2());
+  track.SetMatchTrigger(esdTrack.GetMatchTrigger());
+  track.SetLoTrgNum(-1);
+  track.SetChi2MatchTrigger(esdTrack.GetChi2MatchTrigger());
+  track.SetTrackID(0);
+  track.SetHitsPatternInTrigCh(esdTrack.GetHitsPatternInTrigCh());
+  track.SetLocalTrigger(esdTrack.LoCircuit(), esdTrack.LoStripX(), esdTrack.LoStripY(),
+                       esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt());
+  
+  // track parameters at vertex
+  AliMUONTrackParam paramAtVertex;
+  GetParamAtVertex(esdTrack, paramAtVertex);
+  track.SetTrackParamAtVertex(&paramAtVertex);
+    
+  // track parameters at first cluster
+  AliMUONTrackParam param;
+  GetParamAtFirstCluster(esdTrack, param);
+  GetParamCov(esdTrack, param);
+  
+  // create empty cluster
+  AliMUONVClusterStore* cStore = NewClusterStore();
+  if (!cStore) return;
+  AliMUONVCluster* cluster = cStore->CreateCluster(0,0,0);
+  
+  // fill TrackParamAtCluster with track parameters at each cluster if available
+  // or with only track parameters at first (fake) cluster if not
+  if(esdTrack.ClustersStored()) {
+    
+    // loop over ESD clusters
+    AliESDMuonCluster *esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().First();
+    while (esdCluster) {
+      
+      // copy cluster information
+      ESDToMUON(*esdCluster, *cluster);
+      
+      // only set the Z parameter to avoid error in the AddTrackParamAtCluster(...) method
+      param.SetZ(cluster->GetZ());
+      
+      // add common track parameters at current cluster
+      track.AddTrackParamAtCluster(param, *cluster, kTRUE);
+      
+      esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().After(esdCluster);
+    }
+    
+    // recompute parameters at first cluster in case of those stored
+    // in ESD are not related to the most upstream cluster
+    AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) track.GetTrackParamAtCluster()->First();
+    firstTrackParam->SetZ(esdTrack.GetZUncorrected()); // reset the z to the one stored in ESD
+    AliMUONTrackExtrap::ExtrapToZCov(firstTrackParam,firstTrackParam->GetClusterPtr()->GetZ());
+    
+    // Compute track parameters and covariances at each cluster from those at the first one
+    track.UpdateCovTrackParamAtCluster();
+    
+  } else {
+    
+    // get number of the first hit chamber (according to the MUONClusterMap if not empty)
+    Int_t firstCh = 0;
+    if (esdTrack.GetMuonClusterMap() != 0) while (!esdTrack.IsInMuonClusterMap(firstCh)) firstCh++;
+    else firstCh = AliMUONConstants::ChamberNumber(param.GetZ());
+    
+    // produce fake cluster at this chamber
+    cluster->SetUniqueID(AliMUONVCluster::BuildUniqueID(firstCh, 0, 0));
+    cluster->SetXYZ(param.GetNonBendingCoor(), param.GetBendingCoor(), param.GetZ());
+    cluster->SetErrXY(0., 0.);
+    
+    // add track parameters at first (fake) cluster
+    track.AddTrackParamAtCluster(param, *cluster, kTRUE);
+    
+  }
+  
+  delete cluster;
+  delete cStore;
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUONVCluster& cluster)
+{
+  /// Transfert data from ESDMuon cluster to MUON cluster
+  
+  cluster.Clear("C");
+  
+  cluster.SetUniqueID(esdCluster.GetUniqueID());
+  cluster.SetXYZ(esdCluster.GetX(), esdCluster.GetY(), esdCluster.GetZ());
+  cluster.SetErrXY(esdCluster.GetErrX(),esdCluster.GetErrY());
+  cluster.SetCharge(esdCluster.GetCharge());
+  cluster.SetChi2(esdCluster.GetChi2());
+  
+  if (esdCluster.PadsStored()) {
+    Int_t nPads = esdCluster.GetNPads();
+    for (Int_t iPad = 0; iPad < nPads; iPad++)
+      cluster.AddDigitId(((AliESDMuonPad*)esdCluster.GetPads().UncheckedAt(iPad))->GetUniqueID());
+  }
+  
+}
+
+//___________________________________________________________________________
+void AliMUONESDInterface::ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit)
+{
+  /// Transfert data from ESDMuon pad to MUON digit
+  
+  const AliMpVSegmentation* seg = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(esdPad.GetDetElemId(), esdPad.GetManuId());  
+  AliMpPad pad = seg->PadByLocation(AliMpIntPair(esdPad.GetManuId(), esdPad.GetManuChannel()), kFALSE);
+  
+  digit.Saturated(kFALSE);
+  digit.Used(kFALSE);
+  digit.Calibrated(kTRUE);
+  digit.SetUniqueID(esdPad.GetUniqueID());
+  digit.SetCharge(esdPad.GetCharge());
+  digit.SetADC(esdPad.GetADC());
+  digit.SetPadXY(pad.GetIndices().GetFirst(), pad.GetIndices().GetSecond());
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONTrack& track, AliESDMuonTrack& esdTrack, const Double_t vertex[3], const AliMUONVDigitStore* digits)
+{
+  /// Transfert data from MUON track to ESDMuon track
+  /// Incorporate the ESDPads if the digits are provided
+  
+  esdTrack.Clear("C");
+  
+  // set param at first cluster
+  AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>((track.GetTrackParamAtCluster())->First());
+  SetParamAtFirstCluster(*trackParam, esdTrack);
+  SetParamCov(*trackParam, esdTrack);
+  
+  // set param at vertex
+  AliMUONTrackParam trackParamAtVtx(*trackParam);
+  AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0], vertex[1], vertex[2], 0., 0.);
+  SetParamAtVertex(trackParamAtVtx, esdTrack);
+  
+  // set param at Distance of Closest Approach
+  AliMUONTrackParam trackParamAtDCA(*trackParam);
+  AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&trackParamAtDCA, vertex[2]);
+  SetParamAtDCA(trackParamAtDCA, esdTrack);
+  
+  // set global info
+  esdTrack.SetUniqueID(track.GetUniqueID());
+  esdTrack.SetChi2(track.GetGlobalChi2());
+  esdTrack.SetNHit(track.GetNClusters());
+  esdTrack.SetLocalTrigger(track.GetLocalTrigger());
+  esdTrack.SetChi2MatchTrigger(track.GetChi2MatchTrigger());
+  esdTrack.SetHitsPatternInTrigCh(track.GetHitsPatternInTrigCh());
+  
+  // set muon cluster info
+  AliESDMuonCluster esdCluster;
+  esdTrack.SetMuonClusterMap(0);
+  while (trackParam) {
+    MUONToESD(*(trackParam->GetClusterPtr()), esdCluster, digits);
+    esdTrack.AddCluster(esdCluster);
+    esdTrack.AddInMuonClusterMap(esdCluster.GetChamberId());
+    trackParam = static_cast<AliMUONTrackParam*>(track.GetTrackParamAtCluster()->After(trackParam));
+  }
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCluster& esdCluster, const AliMUONVDigitStore* digits)
+{
+  /// Transfert data from MUON cluster to ESDMuon cluster
+  /// Incorporate the ESDPads if the digits are provided
+  
+  esdCluster.Clear("C");
+  
+  esdCluster.SetUniqueID(cluster.GetUniqueID());
+  esdCluster.SetXYZ(cluster.GetX(), cluster.GetY(), cluster.GetZ());
+  esdCluster.SetErrXY(cluster.GetErrX(), cluster.GetErrY());
+  
+  if (digits) { // transfert all data...
+    
+    esdCluster.SetCharge(cluster.GetCharge());
+    esdCluster.SetChi2(cluster.GetChi2());
+    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;
+       continue;
+      }
+      MUONToESD(*digit, esdPad);
+      esdCluster.AddPad(esdPad);
+    }
+    
+  } else { // ...or not
+    
+    esdCluster.SetCharge(0.);
+    esdCluster.SetChi2(0.);
+    
+  }
+  
+}
+
+//_____________________________________________________________________________
+void AliMUONESDInterface::MUONToESD(const AliMUONVDigit& digit, AliESDMuonPad& esdPad)
+{
+  /// Transfert data from MUON digit to ESDMuon pad
+  esdPad.SetUniqueID(digit.GetUniqueID());
+  esdPad.SetADC(digit.ADC());
+  esdPad.SetCharge(digit.Charge());
+}
+
+//___________________________________________________________________________
+AliMUONTrack* AliMUONESDInterface::Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore)
+{
+  /// Create MUON track from ESDMuon track and add it to the store
+  /// return a pointer to the track into the store
+  AliMUONTrack* track = trackStore.Add(AliMUONTrack());
+  ESDToMUON(esdTrack, *track);
+  return track;
+}
+
+//___________________________________________________________________________
+AliMUONVCluster* AliMUONESDInterface::Add(const AliESDMuonCluster& esdCluster, AliMUONVClusterStore& clusterStore)
+{
+  /// Create MUON cluster from ESDMuon cluster and add it to the store
+  /// return a pointer to the cluster into the store (0x0 if the cluster already exist)
+  AliMUONVCluster* cluster = clusterStore.Add(esdCluster.GetChamberId(), esdCluster.GetDetElemId(), esdCluster.GetClusterIndex());
+  if (cluster) ESDToMUON(esdCluster, *cluster);
+  return cluster;
+}
+
+//___________________________________________________________________________
+AliMUONVDigit* AliMUONESDInterface::Add(const AliESDMuonPad& esdPad, AliMUONVDigitStore& digitStore)
+{
+  /// Create MUON digit from ESDMuon digit and add it to the store
+  /// return a pointer to the digit into the store (0x0 if the digit already exist)
+  AliMUONVDigit* digit = digitStore.Add(esdPad.GetDetElemId(), esdPad.GetManuId(), esdPad.GetManuChannel(), esdPad.GetCathode(), AliMUONVDigitStore::kDeny);
+  if (digit) ESDToMUON(esdPad, *digit);
+  return digit;
+}
+
diff --git a/MUON/AliMUONESDInterface.h b/MUON/AliMUONESDInterface.h
new file mode 100644 (file)
index 0000000..3933900
--- /dev/null
@@ -0,0 +1,182 @@
+#ifndef ALIMUONESDINTERFACE_H
+#define ALIMUONESDINTERFACE_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup rec
+/// \class AliMUONESDInterface
+/// \brief Converter between MUON track/cluster/digit and ESDMuon track/cluster/pad
+/// 
+//  Author Philippe Pillot
+
+#include <AliMpExMap.h>
+#include <TObject.h>
+#include <TClonesArray.h>
+#include <TString.h>
+
+class AliMUONTrack;
+class AliMUONVTrackStore;
+class AliMUONVCluster;
+class AliMUONVClusterStore;
+class AliMUONVDigit;
+class AliMUONVDigitStore;
+class AliMUONTrackParam;
+class AliESDEvent;
+class AliESDMuonTrack;
+class AliESDMuonCluster;
+class AliESDMuonPad;
+class TIterator;
+
+class AliMUONESDInterface : public TObject
+{
+public: // methods to play with internal objects
+  
+  AliMUONESDInterface();
+  virtual ~AliMUONESDInterface();
+  
+  virtual void Clear(Option_t* = "");
+  
+  void LoadEvent(AliESDEvent& esdEvent);
+  
+  /// Return internal track store
+  AliMUONVTrackStore* GetTracks() const {return fTracks;}
+  /// Return internal track store
+  AliMUONVDigitStore* GetDigits() const {return fDigits;}
+  
+  // Return numbers of tracks/clusters/digits
+  Int_t GetNTracks() const;
+  Int_t GetNClusters() const;
+  Int_t GetNClusters(Int_t iTrack) const;
+  Int_t GetNDigits() const;
+  Int_t GetNDigits(Int_t iTrack) const;
+  Int_t GetNDigits(Int_t iTrack, Int_t iCluster) const;
+  Int_t GetNDigitsInCluster(UInt_t clusterId) const;
+  
+  // Return internal MUON objects (faster than finders)
+  // ordering of the MUON objects is the same as in ESD
+  AliMUONTrack*    GetTrack(Int_t iTrack) const;
+  AliMUONVCluster* GetCluster(Int_t iTrack, Int_t iCluster) const;
+  AliMUONVDigit*   GetDigit(Int_t iTrack, Int_t iCluster, Int_t iDigit) const;
+  
+  // Quickly return internal MUON objects (indices unchecked)
+  // ordering of the MUON objects is the same as in ESD
+  AliMUONTrack*    GetTrackFast(Int_t iTrack) const;
+  AliMUONVCluster* GetClusterFast(Int_t iTrack, Int_t iCluster) const;
+  AliMUONVDigit*   GetDigitFast(Int_t iTrack, Int_t iCluster, Int_t iDigit) const;
+  
+  // Find internal MUON objects (slower than getters)
+  AliMUONVCluster* FindCluster(UInt_t clusterId) const;
+  AliMUONVDigit*   FindDigit(UInt_t digitId) const;
+  
+  // iterate over internal MUON objects
+  TIterator* CreateTrackIterator() const;
+  TIterator* CreateClusterIterator() const;
+  TIterator* CreateClusterIterator(Int_t iTrack) const;
+  TIterator* CreateDigitIterator() const;
+  TIterator* CreateDigitIterator(Int_t iTrack) const;
+  TIterator* CreateDigitIterator(Int_t iTrack, Int_t iCluster) const;
+  TIterator* CreateDigitIteratorInCluster(UInt_t clusterId) const;
+  
+  
+public: // static methods
+  
+  /// Set the version of track store
+  static void UseTrackStore(TString name) {fgTrackStoreName = name;}
+  /// Set the version of cluster store
+  static void UseClusterStore(TString name) {fgClusterStoreName = name;}
+  /// Set the version of digit store
+  static void UseDigitStore(TString name) {fgDigitStoreName = name;}
+  
+  // Create empty stores (use the version defined in this interface)
+  static AliMUONVTrackStore* NewTrackStore();
+  static AliMUONVClusterStore* NewClusterStore();
+  static AliMUONVDigitStore* NewDigitStore();
+  
+  // ESD track parameters --> MUON track parameters
+  static void GetParamAtVertex(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam);
+  static void GetParamAtDCA(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam);
+  static void GetParamAtFirstCluster(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam);
+  static void GetParamCov(const AliESDMuonTrack& esdTrack, AliMUONTrackParam& trackParam);
+  
+  // MUON track parameters --> ESD track parameters
+  static void SetParamAtVertex(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
+  static void SetParamAtDCA(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
+  static void SetParamAtFirstCluster(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
+  static void SetParamCov(const AliMUONTrackParam& trackParam, AliESDMuonTrack& esdTrack);
+  
+  // ESDMuon objects --> MUON objects conversion
+  static void ESDToMUON(const AliESDMuonTrack& esdTrack, AliMUONTrack& track);
+  static void ESDToMUON(const AliESDMuonCluster& esdCluster, AliMUONVCluster& cluster);
+  static void ESDToMUON(const AliESDMuonPad& esdPad, AliMUONVDigit& digit);
+  
+  // MUON objects --> ESDMuon objects conversion
+  static void MUONToESD(const AliMUONTrack& track, AliESDMuonTrack& esdTrack, const Double_t vertex[3], const AliMUONVDigitStore* digits = 0x0);
+  static void MUONToESD(const AliMUONVCluster& cluster, AliESDMuonCluster& esdCluster, const AliMUONVDigitStore* digits = 0x0);
+  static void MUONToESD(const AliMUONVDigit& digit, AliESDMuonPad& esdPad);
+  
+  // Add ESD object into the corresponding MUON store
+  // return a pointer to the corresponding MUON object into the store
+  static AliMUONTrack*    Add(const AliESDMuonTrack& esdTrack, AliMUONVTrackStore& trackStore);
+  static AliMUONVCluster* Add(const AliESDMuonCluster& esdCluster, AliMUONVClusterStore& clusterStore);
+  static AliMUONVDigit*   Add(const AliESDMuonPad& esdPad, AliMUONVDigitStore& digitStore);
+  
+  
+protected:
+  
+  AliMUONESDInterface (const AliMUONESDInterface&); ///< copy constructor
+  AliMUONESDInterface& operator=(const AliMUONESDInterface&); ///< assignment operator
+  
+  
+private:
+  
+  void Reset();
+  AliMUONVCluster* FindClusterInTrack(const AliMUONTrack& track, UInt_t clusterId) const;
+  
+  
+private:
+  
+  static TString fgTrackStoreName;   ///< class name of the track store to use
+  static TString fgClusterStoreName; ///< class name of the cluster store to use
+  static TString fgDigitStoreName;   ///< class name of the digit store to use
+  
+  // data containers
+  AliMUONVTrackStore* fTracks; ///< track container
+  AliMUONVDigitStore* fDigits; ///< digit container
+  
+  // maps (to speed up data retrieval)
+  AliMpExMap*   fTrackMap;   ///< map of tracks
+  AliMpExMap*   fClusterMap; ///< map of clusters
+  TClonesArray* fDigitMap;   ///< map of digits
+    
+    
+  ClassDef(AliMUONESDInterface,0)
+};
+
+
+//___________________________________________________________________________
+inline AliMUONTrack* AliMUONESDInterface::GetTrackFast(Int_t iTrack) const
+{
+  /// return MUON track "iTrack" without any check
+  return (AliMUONTrack*) fTrackMap->GetObjectFast(iTrack);
+}
+
+//___________________________________________________________________________
+inline AliMUONVCluster* AliMUONESDInterface::GetClusterFast(Int_t iTrack, Int_t iCluster) const
+{
+  /// return MUON cluster numbered "iCluster" in track "iTrack" without any check
+  return (AliMUONVCluster*) ((AliMpExMap*) fClusterMap->GetObjectFast(iTrack))->GetObjectFast(iCluster);
+}
+
+//___________________________________________________________________________
+inline AliMUONVDigit* AliMUONESDInterface::GetDigitFast(Int_t iTrack, Int_t iCluster, Int_t iDigit) const
+{
+  /// return MUON digit numbered "iDigit" in cluster numbered "iCluster" of track "iTrack" without any check
+  return (AliMUONVDigit*) ((AliMpExMap*) ((AliMpExMap*) fDigitMap->UncheckedAt(iTrack))->GetObjectFast(iCluster))->GetObjectFast(iDigit);
+}
+
+
+#endif
+
index 08d4b18ca3d0afd4d9df19719afc8b5b819df936..f0f62b8737405f4d49b818a53c78348af5e62ebb 100644 (file)
@@ -27,8 +27,6 @@
 #include "AliMUONRawClusterV2.h"
 #include "AliMUONConstants.h"
 
-#include "AliESDMuonCluster.h"
-#include "AliESDMuonPad.h"
 #include "AliLog.h"
 
 #include <TClonesArray.h>
@@ -71,29 +69,6 @@ AliMUONRawClusterV2::AliMUONRawClusterV2(Int_t chamberId, Int_t detElemId, Int_t
   /// Constructor
 }
 
-//____________________________________________________
-AliMUONRawClusterV2::AliMUONRawClusterV2(const AliESDMuonCluster& cluster)
-: AliMUONVCluster(cluster),
-  fX(cluster.GetX()),
-  fY(cluster.GetY()),
-  fZ(cluster.GetZ()),
-  fErrX2(cluster.GetErrX2()),
-  fErrY2(cluster.GetErrY2()),
-  fQ(cluster.GetCharge()),
-  fChi2(cluster.GetChi2()),
-  fNDigits(cluster.GetNPads()),
-  fDigitsId(0x0)
-
-{
-  /// Copy constructor
-  
-  if (cluster.PadsStored()) {
-    fDigitsId = new UInt_t[fNDigits];
-    for (Int_t i=0; i<fNDigits; i++)
-      fDigitsId[i] = ((AliESDMuonPad*)cluster.GetPads().UncheckedAt(i))->GetUniqueID();
-  }
-}
-
 //____________________________________________________
 AliMUONRawClusterV2::~AliMUONRawClusterV2() 
 {
@@ -150,18 +125,10 @@ AliMUONRawClusterV2 & AliMUONRawClusterV2::operator=(const AliMUONRawClusterV2&
 //____________________________________________________
 void AliMUONRawClusterV2::Clear(Option_t*)
 {
-  /// Reset this cluster, in particular the internal arrays are deleted.
-  
-  fX = FLT_MAX;
-  fY = FLT_MAX;
-  fZ = FLT_MAX;
-  fErrX2 = AliMUONConstants::DefaultNonBendingReso2();
-  fErrY2 = AliMUONConstants::DefaultBendingReso2();
-  fQ = 0.;
-  fChi2 = 0.;
-  fNDigits = 0;
+  /// clear memory
   delete [] fDigitsId;
   fDigitsId = 0x0;
+  fNDigits = 0;
 }
 
 //____________________________________________________
index b8b5b97616f3fb483d8edebcf853b92becb9e658..5087ebb885f97debfdc38acdb3cb8d44e5add968 100644 (file)
 #include "AliMUONVCluster.h"
 #include <TMath.h>
 
-class AliESDMuonCluster;
-
 class AliMUONRawClusterV2 : public AliMUONVCluster {
 
  public:
   AliMUONRawClusterV2();
   AliMUONRawClusterV2(Int_t chamberId, Int_t detElemId, Int_t clusterIndex);
-  AliMUONRawClusterV2(const AliESDMuonCluster& cluster);
   virtual ~AliMUONRawClusterV2();
   AliMUONRawClusterV2(const AliMUONRawClusterV2& cluster);
   AliMUONRawClusterV2 & operator=(const AliMUONRawClusterV2& cluster);
index 144d0769280a9f795fa56cbca853bdc216bc0ac6..4cfa4b784c4f080bbdeadb8c52c73df84b81a3be 100644 (file)
 // ESD data. This is necessary since the track objects that are actually created
 // during offline reconstruction are no longer stored to disk.
 //  - Artur Szostak <artursz@iafrica.com>
+// 25 Jan 2008:
+// Use the new ESDInterface to create MUON objects from ESD data
+// - Philippe Pillot
 
 #include "AliMUONRecoCheck.h"
-#include "AliMUONRawClusterV2.h"
 #include "AliMUONTrack.h"
+#include "AliMUONVTrackStore.h"
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterStore.h"
 #include "AliMUONConstants.h"
-#include "AliMUONTrackStoreV1.h"
+#include "AliMUONESDInterface.h"
 
 #include "AliMCEventHandler.h"
 #include "AliMCEvent.h"
@@ -179,20 +184,12 @@ AliMUONVTrackStore* AliMUONRecoCheck::ReconstructibleTracks(Int_t event)
 void AliMUONRecoCheck::MakeReconstructedTracks()
 {
   /// Make reconstructed tracks
-  fRecoTrackStore = new AliMUONTrackStoreV1();
+  if (!(fRecoTrackStore = AliMUONESDInterface::NewTrackStore())) return;
   
-  Int_t nTracks = Int_t(fESDEvent->GetNumberOfMuonTracks());
-  
-  // loop over all reconstructed tracks
-  for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
-    AliESDMuonTrack* esdTrack = fESDEvent->GetMuonTrack(iTrack);
-    
-    // copy ESD MUON track into standard MUON track
-    AliMUONTrack track(*esdTrack);
-    
-    // add track to the store
-    fRecoTrackStore->Add(track);
-  }
+  // loop over all reconstructed tracks and add them to the store
+  Int_t nTracks = (Int_t) fESDEvent->GetNumberOfMuonTracks();
+  for (Int_t iTrack = 0; iTrack < nTracks; iTrack++)
+    AliMUONESDInterface::Add(*(fESDEvent->GetMuonTrack(iTrack)), *fRecoTrackStore);
   
 }
 
@@ -200,12 +197,16 @@ void AliMUONRecoCheck::MakeReconstructedTracks()
 void AliMUONRecoCheck::MakeTrackRefs()
 {
   /// Make reconstructible tracks
-  AliMUONVTrackStore *tmpTrackRefStore = new AliMUONTrackStoreV1();
+  AliMUONVTrackStore *tmpTrackRefStore = AliMUONESDInterface::NewTrackStore();
+  if (!tmpTrackRefStore) return;
   
   Double_t x, y, z, pX, pY, pZ, bendingSlope, nonBendingSlope, inverseBendingMomentum;
   TParticle* particle;
   TClonesArray* trackRefs;
   Int_t nTrackRef = fMCEventHandler->MCEvent()->GetNumberOfTracks();
+  AliMUONVClusterStore* cStore = AliMUONESDInterface::NewClusterStore();
+  if (!cStore) return;
+  AliMUONVCluster* hit = cStore->CreateCluster(0,0,0);
   
   // loop over simulated tracks
   for (Int_t iTrackRef  = 0; iTrackRef < nTrackRef; ++iTrackRef) {
@@ -240,9 +241,9 @@ void AliMUONRecoCheck::MakeTrackRefs()
       if (chamberId < 0 || chamberId >= AliMUONConstants::NTrackingCh()) continue;
       
       // set hit parameters
-      AliMUONRawClusterV2 hit(chamberId, 0, 0);
-      hit.SetXYZ(x,y,z);
-      hit.SetErrXY(0.,0.);
+      hit->SetUniqueID(AliMUONVCluster::BuildUniqueID(chamberId, 0, 0));
+      hit->SetXYZ(x,y,z);
+      hit->SetErrXY(0.,0.);
       
       // compute track parameters at hit
       Double_t bendingSlope = 0;
@@ -266,7 +267,7 @@ void AliMUONRecoCheck::MakeTrackRefs()
       trackParam.SetInverseBendingMomentum(inverseBendingMomentum);
       
       // add track parameters at current hit to the track
-      track.AddTrackParamAtCluster(trackParam,hit,kTRUE);
+      track.AddTrackParamAtCluster(trackParam, *hit, kTRUE);
     }
     
     // if none of the track hits was in MUON, goto the next track
@@ -304,14 +305,15 @@ void AliMUONRecoCheck::MakeTrackRefs()
     // add track parameters at vertex
     track.SetTrackParamAtVertex(&trackParamAtVertex);
     
-    // sort trackParamAtCluster and store the track
-    track.GetTrackParamAtCluster()->Sort();
+    // store the track
     track.SetTrackID(iTrackRef);
     tmpTrackRefStore->Add(track);
   }
   
   CleanMuonTrackRef(tmpTrackRefStore);
   
+  delete hit;
+  delete cStore;
   delete tmpTrackRefStore;
 }
 
@@ -321,11 +323,14 @@ void AliMUONRecoCheck::CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefSt
   /// Re-calculate hits parameters because two AliTrackReferences are recorded for
   /// each chamber (one when particle is entering + one when particle is leaving 
   /// the sensitive volume) 
-  fTrackRefStore = new AliMUONTrackStoreV1();
+  if (!(fTrackRefStore = AliMUONESDInterface::NewTrackStore())) return;
   
   Double_t maxGasGap = 1.; // cm 
   Double_t x, y, z, pX, pY, pZ, x1, y1, z1, pX1, pY1, pZ1, z2;
   Double_t bendingSlope,nonBendingSlope,inverseBendingMomentum;
+  AliMUONVClusterStore* cStore = AliMUONESDInterface::NewClusterStore();
+  if (!cStore) return;
+  AliMUONVCluster* hit = cStore->CreateCluster(0,0,0);
   
   // create iterator
   TIter next(tmpTrackRefStore->CreateIterator());
@@ -399,9 +404,9 @@ void AliMUONRecoCheck::CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefSt
       inverseBendingMomentum *= trackParam1->GetCharge();
       
       // set hit parameters
-      AliMUONRawClusterV2 hit(trackParam1->GetClusterPtr()->GetChamberId(), 0, 0);
-      hit.SetXYZ(x,y,z);
-      hit.SetErrXY(0.,0.);
+      hit->SetUniqueID(AliMUONVCluster::BuildUniqueID(trackParam1->GetClusterPtr()->GetChamberId(), 0, 0));
+      hit->SetXYZ(x,y,z);
+      hit->SetErrXY(0.,0.);
       
       // set new track parameters at new hit
       AliMUONTrackParam trackParam;
@@ -413,25 +418,26 @@ void AliMUONRecoCheck::CleanMuonTrackRef(const AliMUONVTrackStore *tmpTrackRefSt
       trackParam.SetInverseBendingMomentum(inverseBendingMomentum);
       
       // add track parameters at current hit to the track
-      newTrack.AddTrackParamAtCluster(trackParam,hit,kTRUE);
+      newTrack.AddTrackParamAtCluster(trackParam, *hit, kTRUE);
       
       iHit1++;
     }
     
-    newTrack.GetTrackParamAtCluster()->Sort();
     newTrack.SetTrackID(track->GetTrackID());
     newTrack.SetTrackParamAtVertex(track->GetTrackParamAtVertex());
     fTrackRefStore->Add(newTrack);
     
   }
   
+  delete hit;
+  delete cStore;
 }
 
 //_____________________________________________________________________________
 void AliMUONRecoCheck::MakeReconstructibleTracks()
 {
   /// Isolate the reconstructible tracks
-  fRecoTrackRefStore = new AliMUONTrackStoreV1();
+  if (!(fRecoTrackRefStore = AliMUONESDInterface::NewTrackStore())) return;
   
   // create iterator on trackRef
   TIter next(fTrackRefStore->CreateIterator());
index 87ff85aeba580c070631e6506400d54c45543e32..8a38f42b8f07055e5ccf7a3a5e269db454c06f09 100644 (file)
 
 #include "AliMUONTrack.h"
 
-#include "AliMUONRawClusterV2.h" 
+#include "AliMUONVCluster.h"
+#include "AliMUONVClusterStore.h"
 #include "AliMUONObjectPair.h"
 #include "AliMUONConstants.h"
 #include "AliMUONTrackExtrap.h"
 
 #include "AliLog.h"
-#include "AliESDMuonTrack.h"
-#include "AliESDMuonCluster.h"
 
 #include <TMath.h>
 #include <TMatrixD.h>
@@ -191,106 +190,6 @@ AliMUONTrack::AliMUONTrack(AliMUONObjectPair *segment)
   
 }
 
-//__________________________________________________________________________
-AliMUONTrack::AliMUONTrack(AliESDMuonTrack &esdTrack)
-  : TObject(),
-    fTrackParamAtCluster(new TClonesArray("AliMUONTrackParam",10)),
-    fFitWithVertex(kFALSE),
-    fVertexErrXY2(),
-    fFitWithMCS(kFALSE),
-    fClusterWeightsNonBending(0x0),
-    fClusterWeightsBending(0x0),
-    fGlobalChi2(esdTrack.GetChi2()),
-    fImproved(kFALSE),
-    fMatchTrigger(esdTrack.GetMatchTrigger()),
-    floTrgNum(-1),
-    fChi2MatchTrigger(esdTrack.GetChi2MatchTrigger()),
-    fTrackID(0),
-    fTrackParamAtVertex(new AliMUONTrackParam()),
-    fHitsPatternInTrigCh(esdTrack.GetHitsPatternInTrigCh()),
-    fLocalTrigger(0)
-{
-  /// Constructor from ESD muon track
-  /// Compute track parameters and covariances at each cluster if available
-  /// or store parameters and covariances at first (fake) cluster only if not
-  
-  fTrackParamAtCluster->SetOwner(kTRUE);
-  
-  fVertexErrXY2[0] = 0.;
-  fVertexErrXY2[1] = 0.;
-  
-  // global info
-  SetLocalTrigger(esdTrack.LoCircuit(), esdTrack.LoStripX(), esdTrack.LoStripY(),
-                 esdTrack.LoDev(), esdTrack.LoLpt(), esdTrack.LoHpt());
-  
-  // track parameters at vertex
-  fTrackParamAtVertex->GetParamFrom(esdTrack);
-  
-  // track parameters at first cluster
-  AliMUONTrackParam param;
-  param.GetParamFromUncorrected(esdTrack);
-  param.GetCovFrom(esdTrack);
-  
-  // fill fTrackParamAtCluster with track parameters at each cluster if available
-  if(esdTrack.ClustersStored()) {
-    
-    // loop over ESD clusters
-    AliESDMuonCluster *esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().First();
-    while (esdCluster) {
-      
-      // copy cluster information
-      AliMUONRawClusterV2 cluster(*esdCluster);
-      
-      // only set the Z parameter to avoid error in the AddTrackParamAtCluster(...) method
-      param.SetZ(cluster.GetZ());
-      
-      // add common track parameters at current cluster
-      AddTrackParamAtCluster(param, cluster, kTRUE);
-      
-      esdCluster = (AliESDMuonCluster*) esdTrack.GetClusters().After(esdCluster);
-    }
-    
-    // sort array of track parameters at clusters
-    fTrackParamAtCluster->Sort();
-    
-    // check that parameters stored in ESD are parameters at the most upstream cluster
-    // (convert Z position values to Float_t because of Double32_t in ESD track)
-    AliMUONTrackParam *firstTrackParam = (AliMUONTrackParam*) fTrackParamAtCluster->First();
-    if (((Float_t)firstTrackParam->GetZ()) != ((Float_t)esdTrack.GetZUncorrected())) {
-      
-      AliError("track parameters are not given at the most upstream stored cluster");
-      fTrackParamAtCluster->Clear("C");
-      
-    } else {
-      
-      // Compute track parameters and covariances at each cluster from info at the first one
-      UpdateCovTrackParamAtCluster();
-      
-    }
-    
-  }
-  
-  // fill fTrackParamAtCluster with track parameters at first (fake) cluster
-  // if first cluster not found or clusters not available
-  if (GetNClusters() == 0) {
-    
-    // get number of the first hit chamber (according to the MUONClusterMap if not empty)
-    Int_t firstCh = 0;
-    if (esdTrack.GetMuonClusterMap() != 0) while (!esdTrack.IsInMuonClusterMap(firstCh)) firstCh++;
-    else firstCh = AliMUONConstants::ChamberNumber(param.GetZ());
-    
-    // produce fake cluster at this chamber
-    AliMUONRawClusterV2 fakeCluster(firstCh, 0, 0);
-    fakeCluster.SetXYZ(param.GetNonBendingCoor(), param.GetBendingCoor(), param.GetZ());
-    fakeCluster.SetErrXY(0., 0.);
-    
-    // add track parameters at first (fake) cluster
-    AddTrackParamAtCluster(param, fakeCluster, kTRUE);
-    
-  }
-  
-}
-
 //__________________________________________________________________________
 AliMUONTrack::AliMUONTrack(const AliMUONTrack& track)
   : TObject(track),
index e0ee7d4eddffe3f651f6e268e878143e83ebe4f2..14d0d1316c2409f84f52d414ed4853d258906f65 100644 (file)
 
 class AliMUONVCluster;
 class AliMUONObjectPair;
-class AliESDMuonTrack;
 
 class AliMUONTrack : public TObject 
 {
  public:
   AliMUONTrack(); // Default constructor
   AliMUONTrack(AliMUONObjectPair *segment); // Constructor from a segment
-  AliMUONTrack(AliESDMuonTrack& esdTrack); // Constructor from an ESD muon track
   virtual ~AliMUONTrack(); // Destructor
   AliMUONTrack (const AliMUONTrack& track); // copy constructor
   AliMUONTrack& operator=(const AliMUONTrack& track); // assignment operator
index 139aeb1e3163ed25c417b0aac0fa102351f4886d..abcb58e3c06a7feb1bc468e204cedaaa9d77604d 100644 (file)
@@ -24,7 +24,6 @@
 #include "AliMUONTrackParam.h"
 #include "AliMUONVCluster.h"
 
-#include "AliESDMuonTrack.h"
 #include "AliLog.h"
 
 #include <TMath.h>
@@ -186,136 +185,6 @@ AliMUONTrackParam::Clear(Option_t* /*opt*/)
   if(fOwnCluster) {
     delete fClusterPtr; fClusterPtr = 0x0;
   }
-}
-
-  //_________________________________________________________________________
-void AliMUONTrackParam::GetParamFrom(const AliESDMuonTrack& esdMuonTrack)
-{
-  /// Get parameters from ESD track
-  fZ = esdMuonTrack.GetZ(); 
-  fParameters(0,0) = esdMuonTrack.GetNonBendingCoor();
-  fParameters(1,0) = TMath::Tan(esdMuonTrack.GetThetaX());
-  fParameters(2,0) = esdMuonTrack.GetBendingCoor(); 
-  fParameters(3,0) = TMath::Tan(esdMuonTrack.GetThetaY());
-  fParameters(4,0) = esdMuonTrack.GetInverseBendingMomentum();
-}
-
-  //_________________________________________________________________________
-void AliMUONTrackParam::SetParamFor(AliESDMuonTrack& esdMuonTrack) const
-{
-  /// Set parameters in ESD track
-  esdMuonTrack.SetZ(fZ);
-  esdMuonTrack.SetNonBendingCoor(fParameters(0,0));
-  esdMuonTrack.SetThetaX(TMath::ATan(fParameters(1,0)));
-  esdMuonTrack.SetBendingCoor(fParameters(2,0)); 
-  esdMuonTrack.SetThetaY(TMath::ATan(fParameters(3,0)));
-  esdMuonTrack.SetInverseBendingMomentum(fParameters(4,0));
-}
-
-  //_________________________________________________________________________
-void AliMUONTrackParam::GetParamFromDCA(const AliESDMuonTrack& esdMuonTrack)
-{
-  /// Get parameters from ESD track
-  fZ = esdMuonTrack.GetZ(); 
-  fParameters(0,0) = esdMuonTrack.GetNonBendingCoorAtDCA();
-  fParameters(1,0) = TMath::Tan(esdMuonTrack.GetThetaXAtDCA());
-  fParameters(2,0) = esdMuonTrack.GetBendingCoorAtDCA(); 
-  fParameters(3,0) = TMath::Tan(esdMuonTrack.GetThetaYAtDCA());
-  fParameters(4,0) = esdMuonTrack.GetInverseBendingMomentumAtDCA();
-}
-
-  //_________________________________________________________________________
-void AliMUONTrackParam::SetParamForDCA(AliESDMuonTrack& esdMuonTrack) const
-{
-  /// Set parameters in ESD track
-  esdMuonTrack.SetNonBendingCoorAtDCA(fParameters(0,0));
-  esdMuonTrack.SetThetaXAtDCA(TMath::ATan(fParameters(1,0)));
-  esdMuonTrack.SetBendingCoorAtDCA(fParameters(2,0)); 
-  esdMuonTrack.SetThetaYAtDCA(TMath::ATan(fParameters(3,0)));
-  esdMuonTrack.SetInverseBendingMomentumAtDCA(fParameters(4,0));
-}
-
-//_________________________________________________________________________
-void AliMUONTrackParam::GetParamFromUncorrected(const AliESDMuonTrack& esdMuonTrack)
-{
-  /// Get parameters from ESD track
-  fZ = esdMuonTrack.GetZUncorrected(); 
-  fParameters(0,0) = esdMuonTrack.GetNonBendingCoorUncorrected();
-  fParameters(1,0) = TMath::Tan(esdMuonTrack.GetThetaXUncorrected());
-  fParameters(2,0) = esdMuonTrack.GetBendingCoorUncorrected(); 
-  fParameters(3,0) = TMath::Tan(esdMuonTrack.GetThetaYUncorrected());
-  fParameters(4,0) = esdMuonTrack.GetInverseBendingMomentumUncorrected();
-}
-
-//_________________________________________________________________________
-void AliMUONTrackParam::SetParamForUncorrected(AliESDMuonTrack& esdMuonTrack) const
-{
-  /// Set parameters in ESD track
-  esdMuonTrack.SetZUncorrected(fZ);
-  esdMuonTrack.SetNonBendingCoorUncorrected(fParameters(0,0));
-  esdMuonTrack.SetThetaXUncorrected(TMath::ATan(fParameters(1,0)));
-  esdMuonTrack.SetBendingCoorUncorrected(fParameters(2,0)); 
-  esdMuonTrack.SetThetaYUncorrected(TMath::ATan(fParameters(3,0)));
-  esdMuonTrack.SetInverseBendingMomentumUncorrected(fParameters(4,0));
-}
-
-//_________________________________________________________________________
-void AliMUONTrackParam::GetCovFrom(const AliESDMuonTrack& esdMuonTrack)
-{
-  /// Get parameters covariances from ESD track
-  
-  // Get ESD covariance matrix
-  if (!fCovariances) fCovariances = new TMatrixD(5,5);
-  esdMuonTrack.GetCovariances(*fCovariances);
-
-  // compute Jacobian to change the coordinate system
-  // from (X,thetaX,Y,thetaY,c/pYZ) to (X,slopeX,Y,slopeY,c/pYZ)
-  Double_t cosThetaX = TMath::Cos(TMath::ATan(fParameters(1,0)));
-  Double_t cosThetaY = TMath::Cos(TMath::ATan(fParameters(3,0)));
-  TMatrixD jacob(5,5);
-  jacob.Zero();
-  jacob(0,0) = 1.;
-  jacob(1,1) = 1. / cosThetaX / cosThetaX;
-  jacob(2,2) = 1.;
-  jacob(3,3) = 1. / cosThetaY / cosThetaY;
-  jacob(4,4) = 1.;
-  
-  // compute covariance matrix in ESD coordinate system
-  TMatrixD tmp(*fCovariances,TMatrixD::kMultTranspose,jacob);
-  *fCovariances = TMatrixD(jacob,TMatrixD::kMult,tmp);
-  
-}
-
-  //_________________________________________________________________________
-void AliMUONTrackParam::SetCovFor(AliESDMuonTrack& esdMuonTrack) const
-{
-  /// Set parameters covariances in ESD track
-  
-  // set null matrix if covariances does not exist
-  if (!fCovariances) {
-    TMatrixD tmp(5,5);
-    tmp.Zero();
-    esdMuonTrack.SetCovariances(tmp);
-    return;
-  }
-  
-  // compute Jacobian to change the coordinate system
-  // from (X,slopeX,Y,slopeY,c/pYZ) to (X,thetaX,Y,thetaY,c/pYZ)
-  Double_t cosThetaX = TMath::Cos(TMath::ATan(fParameters(1,0)));
-  Double_t cosThetaY = TMath::Cos(TMath::ATan(fParameters(3,0)));
-  TMatrixD jacob(5,5);
-  jacob.Zero();
-  jacob(0,0) = 1.;
-  jacob(1,1) = cosThetaX * cosThetaX;
-  jacob(2,2) = 1.;
-  jacob(3,3) = cosThetaY * cosThetaY;
-  jacob(4,4) = 1.;
-  
-  // compute covariance matrix in ESD coordinate system
-  TMatrixD tmp(*fCovariances,TMatrixD::kMultTranspose,jacob);
-  TMatrixD tmp2(jacob,TMatrixD::kMult,tmp);
-  esdMuonTrack.SetCovariances(tmp2);
-
 }
 
   //__________________________________________________________________________
index 753d2eac8baa0d6e6f73fd861283f401cc325acc..1fa228611c1a1a90073dc81b8a3674ffad38c609 100644 (file)
@@ -18,7 +18,6 @@
 #include <TMatrixD.h>
 
 class AliMUONVCluster;
-class AliESDMuonTrack;
 
 class AliMUONTrackParam : public TObject 
 {
@@ -29,16 +28,6 @@ class AliMUONTrackParam : public TObject
   AliMUONTrackParam(const AliMUONTrackParam& theMUONTrackParam);
   AliMUONTrackParam& operator=(const  AliMUONTrackParam& theMUONTrackParam);
 
-  void GetParamFrom(const AliESDMuonTrack& esdMuonTrack);
-  void SetParamFor(AliESDMuonTrack& esdMuonTrack) const;
-  void GetParamFromDCA(const AliESDMuonTrack& esdMuonTrack);
-  void SetParamForDCA(AliESDMuonTrack& esdMuonTrack) const;
-  void GetParamFromUncorrected(const AliESDMuonTrack& esdMuonTrack);
-  void SetParamForUncorrected(AliESDMuonTrack& esdMuonTrack) const;
-  
-  void GetCovFrom(const AliESDMuonTrack& esdMuonTrack);
-  void SetCovFor(AliESDMuonTrack& esdMuonTrack) const;
-
   // Get and Set methods for data
        /// return Z coordinate (cm)
   Double_t GetZ() const {return fZ;}
index af0c7242927bbb43d550d6589f86387e67a6f7f6..26d64d66d8ca1fda153d502af56782be694dd5ac 100644 (file)
 #include "AliMUONTriggerTrackStoreV1.h"
 #include "AliMUONClusterStoreV2.h"
 #include "AliMUONVTriggerStore.h"
+#include "AliMUONESDInterface.h"
 
 #include "AliESDEvent.h"
-#include "AliESDMuonTrack.h"
-#include "AliESDMuonCluster.h"
-#include "AliESDMuonPad.h"
 #include "AliESDVertex.h"
+#include "AliESDMuonTrack.h"
 #include "AliLog.h"
 #include "AliCodeTimer.h"
 
@@ -198,105 +197,36 @@ void AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) c
   AliDebug(1,"");
   AliCodeTimerAuto("")
   
-  // Random number to decide whether to save additional cluster info or not for the current event
-  Double_t rand = 0.;
-  if (AliMUONReconstructor::GetRecoParam()->SaveFullClusterInESD()) rand = gRandom->Uniform(0.,100.);
+  AliMUONTrack* track;
+  AliESDMuonTrack esdTrack;
+  Double_t vertex[3] = {0., 0., 0.};
+  TIter next(trackStore.CreateIterator());
   
-  // Get vertex 
-  Double_t vertex[3] = {0};
-  Double_t errXVtx = 0., errYVtx = 0.;
+  // get ITS vertex
   const AliESDVertex* esdVert = esd->GetVertex(); 
-  if (esdVert->GetNContributors()) 
-  {
+  if (esdVert->GetNContributors()) {
     esdVert->GetXYZ(vertex);
-    errXVtx = esdVert->GetXRes();
-    errYVtx = esdVert->GetYRes();
     AliDebug(1,Form("found vertex (%e,%e,%e)",vertex[0],vertex[1],vertex[2]));
   }
   
-  AliMUONTrack* track;
-  AliMUONVCluster* cluster;
-  AliMUONVDigit* digit;
-  TIter next(trackStore.CreateIterator());
-  
-  while ( ( track = static_cast<AliMUONTrack*>(next()) ) )
-  {
-    AliMUONTrackParam* trackParam = static_cast<AliMUONTrackParam*>((track->GetTrackParamAtCluster())->First());
+  // fill ESD event including all info in ESD cluster if required and only for the given fraction of events
+  if (AliMUONReconstructor::GetRecoParam()->SaveFullClusterInESD() && 
+      gRandom->Uniform(100.) <= AliMUONReconstructor::GetRecoParam()->GetPercentOfFullClusterInESD()) {
     
-    // new ESD muon track
-    AliESDMuonTrack esdTrack;
-    
-    /// Extrapolate to vertex (which is set to (0,0,0) if not available, see above)
-    AliMUONTrackParam trackParamAtVtx(*trackParam);
-    AliMUONTrackExtrap::ExtrapToVertex(&trackParamAtVtx, vertex[0], vertex[1], vertex[2], errXVtx, errYVtx);
-    
-    /// Extrapolate to vertex plan (which is set to z=0 if not available, see above)
-    AliMUONTrackParam trackParamAtDCA(*trackParam);
-    AliMUONTrackExtrap::ExtrapToVertexWithoutBranson(&trackParamAtDCA, vertex[2]);
-    
-    // at first station
-    trackParam->SetParamForUncorrected(esdTrack);
-    trackParam->SetCovFor(esdTrack);
-    
-    // at vertex
-    trackParamAtVtx.SetParamFor(esdTrack);
-    
-    // at Distance of Closest Approach
-    trackParamAtDCA.SetParamForDCA(esdTrack);
+    while ( ( track = static_cast<AliMUONTrack*>(next()) ) ) {
+      AliMUONESDInterface::MUONToESD(*track, esdTrack, vertex, &fDigitStore);
+      esd->AddMuonTrack(&esdTrack);
+    }
     
-    // global info
-    esdTrack.SetChi2(track->GetGlobalChi2());
-    esdTrack.SetNHit(track->GetNClusters());
-    esdTrack.SetLocalTrigger(track->GetLocalTrigger());
-    esdTrack.SetChi2MatchTrigger(track->GetChi2MatchTrigger());
-    esdTrack.SetHitsPatternInTrigCh(track->GetHitsPatternInTrigCh());
+  } else {
     
-    // muon cluster info
-    while (trackParam) {
-      cluster = trackParam->GetClusterPtr();
-      
-      // new ESD muon cluster
-      AliESDMuonCluster esdCluster;
-      
-      // fill minimum info in ESD cluster
-      esdCluster.SetUniqueID(cluster->GetUniqueID());
-      esdCluster.SetXYZ(cluster->GetX(), cluster->GetY(), cluster->GetZ());
-      esdCluster.SetErrXY(cluster->GetErrX(), cluster->GetErrY());
-      
-      // fill additional info in ESD cluster if required and only for a fraction of events
-      if (AliMUONReconstructor::GetRecoParam()->SaveFullClusterInESD() && 
-         rand <= AliMUONReconstructor::GetRecoParam()->GetPercentOfFullClusterInESD()) {
-       
-       esdCluster.SetCharge(cluster->GetCharge());
-       esdCluster.SetChi2(cluster->GetChi2());
-       
-       // fill ESD pad with digit info
-       for (Int_t i=0; i<cluster->GetNDigits(); i++) {
-         digit = fDigitStore.FindObject(cluster->GetDigitId(i));
-         
-         // new ESD muon pad
-         AliESDMuonPad esdPad;
-         
-         esdPad.SetUniqueID(digit->GetUniqueID());
-         esdPad.SetADC(digit->ADC());
-         esdPad.SetCharge(digit->Charge());
-         
-         // add pad info in ESD cluster
-         esdCluster.AddPad(esdPad);
-       }
-       
-      }
-      
-      // add cluster info in ESD track
-      esdTrack.AddCluster(esdCluster);
-      esdTrack.AddInMuonClusterMap(cluster->GetChamberId());
-      
-      trackParam = static_cast<AliMUONTrackParam*>(track->GetTrackParamAtCluster()->After(trackParam));
+    while ( ( track = static_cast<AliMUONTrack*>(next()) ) ) {
+      AliMUONESDInterface::MUONToESD(*track, esdTrack, vertex);
+      esd->AddMuonTrack(&esdTrack);
     }
     
-    // storing ESD MUON Track into ESD Event 
-    esd->AddMuonTrack(&esdTrack);
-  } // end of loop on tracks
+  }
+  
 }
 
 //_____________________________________________________________________________
index 2792b75e424f013ff125544a4fab63c45fcef3d7..1b3e8163718fc671833a4d3765cb22cef098f3ba 100644 (file)
@@ -25,7 +25,6 @@
 
 #include "AliMUONVCluster.h"
 
-#include "AliESDMuonCluster.h"
 #include "AliLog.h"
 
 #include <Riostream.h>
@@ -48,14 +47,6 @@ AliMUONVCluster::AliMUONVCluster(Int_t chamberId, Int_t detElemId, Int_t cluster
   SetUniqueID(BuildUniqueID(chamberId, detElemId, clusterIndex));
 }
 
-//_____________________________________________________________________________
-AliMUONVCluster::AliMUONVCluster(const AliESDMuonCluster& cluster)
-: TObject() 
-{
-  /// constructor
-  SetUniqueID(cluster.GetUniqueID());
-}
-
 //_____________________________________________________________________________
 AliMUONVCluster::~AliMUONVCluster()
 {
index 0a7bec11933c1283df3b36bed6de84937e34503b..0c05e68583e3b94bdbc23e965d7e54f5e8d03d66 100644 (file)
 
 #include <TObject.h>
 
-class AliESDMuonCluster;
-
 class AliMUONVCluster : public TObject {
  public:
   AliMUONVCluster(); // Constructor
   AliMUONVCluster(Int_t chamberId, Int_t detElemId, Int_t clusterIndex);
-  AliMUONVCluster(const AliESDMuonCluster& cluster);
   virtual ~AliMUONVCluster(); // Destructor
   
            /// Clear method (used by TClonesArray)
index f1e38c3910da916d18e6e473e1c21c04adcc01a8..9d7d636d7b75a5ee66002f2cb21f0db0b670d421 100644 (file)
 #include "AliMUONTrackExtrap.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONGeometryTransformer.h"
+#include "AliMUONESDInterface.h"
+
 #include "AliESDEvent.h"
 #include "AliESDMuonTrack.h"
-
 #include "AliMagFMaps.h"
 #include "AliTracker.h"
 #include "AliCDBManager.h"
@@ -205,7 +206,8 @@ void MUONAlignment(Int_t nEvents = 100000, char* geoFilename = "geometry.root",
        fInvBenMom->Fill(invBenMom);
        fBenMom->Fill(1./invBenMom);
        if (TMath::Abs(invBenMom)<=1.04) {
-         AliMUONTrack track(*esdTrack);
+         AliMUONTrack track;
+         AliMUONESDInterface::ESDToMUON(*esdTrack, track);
          alig->ProcessTrack(&track);
          alig->LocalFit(iTrackOk++,trackParams,0);
        }
index 459a7747ea4afde7de44dc9e6a14d68b17dfec48..dd78e036ff884d41c9daf9def914be52f63b16c1 100644 (file)
@@ -35,7 +35,7 @@
 // MUON includes
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
-#include "AliESDMuonTrack.h"
+#include "AliMUONESDInterface.h"
 
 // STEER includes
 #include "AliRun.h"
@@ -48,6 +48,7 @@
 #include "AliESDVertex.h"
 #include "AliTracker.h"
 #include "AliCDBManager.h"
+#include "AliESDMuonTrack.h"
 
 // ROOT includes
 #include "TTree.h"
@@ -353,13 +354,13 @@ Bool_t MUONefficiency( char* filename = "galice.root", char* geoFilename = "geom
 
       // extrapolate to vertex if required and available
       if (ExtrapToVertex > 0 && Vertex->GetNContributors()) {
-        trackParam.GetParamFromUncorrected(*muonTrack);
+       AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack, trackParam);
        AliMUONTrackExtrap::ExtrapToVertex(&trackParam, fXVertex, fYVertex, fZVertex, errXVtx, errYVtx);
-       trackParam.SetParamFor(*muonTrack); // put the new parameters in this copy of AliESDMuonTrack
+       AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack); // put the new parameters in this copy of AliESDMuonTrack
       } else if ((ExtrapToVertex > 0 && !Vertex->GetNContributors()) || ExtrapToVertex == 0){
-        trackParam.GetParamFromUncorrected(*muonTrack);
+       AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack, trackParam);
        AliMUONTrackExtrap::ExtrapToVertex(&trackParam, 0., 0., 0., 0., 0.);
-       trackParam.SetParamFor(*muonTrack); // put the new parameters in this copy of AliESDMuonTrack
+       AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack); // put the new parameters in this copy of AliESDMuonTrack
       }
 
       // Trigger
@@ -416,13 +417,13 @@ Bool_t MUONefficiency( char* filename = "galice.root", char* geoFilename = "geom
           
          // extrapolate to vertex if required and available
          if (ExtrapToVertex > 0 && Vertex->GetNContributors()) {
-           trackParam.GetParamFromUncorrected(*muonTrack2);
+           AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack2, trackParam);
            AliMUONTrackExtrap::ExtrapToVertex(&trackParam, fXVertex, fYVertex, fZVertex, errXVtx, errYVtx);
-           trackParam.SetParamFor(*muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
+           AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
          } else if ((ExtrapToVertex > 0 && !Vertex->GetNContributors()) || ExtrapToVertex == 0){
-            trackParam.GetParamFromUncorrected(*muonTrack2);
+           AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack2, trackParam);
            AliMUONTrackExtrap::ExtrapToVertex(&trackParam, 0., 0., 0., 0., 0.);
-           trackParam.SetParamFor(*muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
+           AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
          }
 
          track2Trigger = muonTrack2->GetMatchTrigger();
index c19866d80dff83a54164e98315fdb2a02e793ae5..7fe6e1ba6fe0a572dd9428791e02560a3c81e8e2 100644 (file)
 #include "AliESDEvent.h"
 #include "AliESDVertex.h"
 #include "AliTracker.h"
+#include "AliESDMuonTrack.h"
 
 // MUON includes
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
-#include "AliESDMuonTrack.h"
+#include "AliMUONESDInterface.h"
 #endif
 
 /// \ingroup macros
@@ -221,13 +222,13 @@ Bool_t MUONmassPlot(char* filename = "generated/galice.root", Int_t ExtrapToVert
 
       // extrapolate to vertex if required and available
       if (ExtrapToVertex > 0 && Vertex->GetNContributors()) {
-        trackParam.GetParamFromUncorrected(*muonTrack);
+       AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack, trackParam);
        AliMUONTrackExtrap::ExtrapToVertex(&trackParam, fXVertex, fYVertex, fZVertex, errXVtx, errYVtx);
-       trackParam.SetParamFor(*muonTrack); // put the new parameters in this copy of AliESDMuonTrack
+       AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack); // put the new parameters in this copy of AliESDMuonTrack
       } else if ((ExtrapToVertex > 0 && !Vertex->GetNContributors()) || ExtrapToVertex == 0){
-        trackParam.GetParamFromUncorrected(*muonTrack);
+       AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack, trackParam);
        AliMUONTrackExtrap::ExtrapToVertex(&trackParam, 0., 0., 0., 0., 0.);
-       trackParam.SetParamFor(*muonTrack); // put the new parameters in this copy of AliESDMuonTrack
+       AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack); // put the new parameters in this copy of AliESDMuonTrack
       }
 
       fCharge1 = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
@@ -274,13 +275,13 @@ Bool_t MUONmassPlot(char* filename = "generated/galice.root", Int_t ExtrapToVert
          
          // extrapolate to vertex if required and available
          if (ExtrapToVertex > 0 && Vertex->GetNContributors()) {
-           trackParam.GetParamFromUncorrected(*muonTrack2);
+           AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack2, trackParam);
            AliMUONTrackExtrap::ExtrapToVertex(&trackParam, fXVertex, fYVertex, fZVertex, errXVtx, errYVtx);
-           trackParam.SetParamFor(*muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
+           AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
          } else if ((ExtrapToVertex > 0 && !Vertex->GetNContributors()) || ExtrapToVertex == 0){
-            trackParam.GetParamFromUncorrected(*muonTrack2);
+           AliMUONESDInterface::GetParamAtFirstCluster(*muonTrack2, trackParam);
            AliMUONTrackExtrap::ExtrapToVertex(&trackParam, 0., 0., 0., 0., 0.);
-           trackParam.SetParamFor(*muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
+           AliMUONESDInterface::SetParamAtVertex(trackParam, *muonTrack2); // put the new parameters in this copy of AliESDMuonTrack
          }
          
          fCharge2 = Int_t(TMath::Sign(1.,muonTrack2->GetInverseBendingMomentum()));
index 589057986bbfd39139f87de371b4334c8836a99f..e7978a767980300c352ddbe2c1789bfe4812f7a7 100644 (file)
@@ -51,6 +51,8 @@
 #pragma link C++ class AliMUONVClusterServer+;
 #pragma link C++ class AliMUONSimpleClusterServer+;
 
+#pragma link C++ class AliMUONESDInterface+;
+
 // calibration
 #pragma link C++ class AliMUONDigitCalibrator+;
 #pragma link C++ class AliMUONPadStatusMaker+;
index 2d4b3110862d9727e28303d54ed78bbc885cea78..9b42109a7713857e1c26754f589447cca8c09e14 100644 (file)
@@ -40,7 +40,8 @@ SRCS:= AliMUONReconstructor.cxx \
        AliMUONQADataMakerRec.cxx \
        AliMUONQAChecker.cxx \
        AliMUONClusterFinderPeakCOG.cxx \
-       AliMUONClusterFinderPeakFit.cxx
+       AliMUONClusterFinderPeakFit.cxx \
+       AliMUONESDInterface.cxx
 
 HDRS:= $(SRCS:.cxx=.h)