Implemented a new version of cluster (with its store and iterator):
authorhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 6 Oct 2007 20:33:27 +0000 (20:33 +0000)
committerhristov <hristov@f7af4fe6-9843-0410-8265-dc069ae4e863>
Sat, 6 Oct 2007 20:33:27 +0000 (20:33 +0000)
--> contains only important informations (including an unique ID for each cluster)
--> keeps backward compatibility with old clusters
- Use AliMUONClusterFinderMLEM (with AliMUONPreClusterFinder) as default version for clustering
- removed AliMUONClusterFinderAZ

Philippe P., Laurent

34 files changed:
MUON/AliMUONAlignment.cxx
MUON/AliMUONClusterFinderMLEM.cxx
MUON/AliMUONClusterReconstructor.cxx
MUON/AliMUONClusterReconstructor.h
MUON/AliMUONClusterStoreV1.cxx
MUON/AliMUONClusterStoreV1.h
MUON/AliMUONClusterStoreV2.cxx [new file with mode: 0644]
MUON/AliMUONClusterStoreV2.h [new file with mode: 0644]
MUON/AliMUONClusterStoreV2Iterator.cxx [new file with mode: 0644]
MUON/AliMUONClusterStoreV2Iterator.h [new file with mode: 0644]
MUON/AliMUONDataInterface.cxx
MUON/AliMUONDataInterface.h
MUON/AliMUONHitForRec.cxx
MUON/AliMUONHitForRec.h
MUON/AliMUONPad.cxx
MUON/AliMUONPad.h
MUON/AliMUONPreClusterFinder.cxx
MUON/AliMUONPreClusterFinderV2.cxx
MUON/AliMUONPreClusterFinderV3.cxx
MUON/AliMUONRawCluster.cxx
MUON/AliMUONRawCluster.h
MUON/AliMUONRawClusterV2.cxx [new file with mode: 0644]
MUON/AliMUONRawClusterV2.h [new file with mode: 0644]
MUON/AliMUONReconstructor.cxx
MUON/AliMUONTrackExtrap.cxx
MUON/AliMUONTracker.cxx
MUON/AliMUONVCluster.cxx [new file with mode: 0644]
MUON/AliMUONVCluster.h [new file with mode: 0644]
MUON/AliMUONVClusterStore.cxx
MUON/AliMUONVClusterStore.h
MUON/AliMUONVTrackReconstructor.cxx
MUON/MUONCheckDI.C
MUON/MUONResoEffChamber.C
MUON/MUONTriggerEfficiency.C

index d6bceb2..0e12d05 100644 (file)
@@ -29,7 +29,6 @@
 
 #include "AliMUONAlignment.h"
 #include "AliMUONTrack.h"
-#include "AliMUONRawCluster.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONGeometryTransformer.h"
@@ -43,6 +42,7 @@
 
 #include "AliLog.h"
 
+#include "TMath.h"
 #include "TSystem.h"
 
 /// \cond CLASSIMP
index df101cc..fae9074 100644 (file)
@@ -125,6 +125,7 @@ AliMUONClusterFinderMLEM::Prepare(const AliMpVSegmentation* segmentations[2],
                                   const AliMUONVDigitStore& digitStore)
 {
   /// Prepare for clustering
+//  AliCodeTimerAuto("")
   
   for ( Int_t i = 0; i < 2; ++i )
   {
@@ -167,6 +168,7 @@ AliMUONCluster*
 AliMUONClusterFinderMLEM::NextCluster()
 {
   /// Return next cluster
+//  AliCodeTimerAuto("clustering + pre-clustering")
   
   // if the list of clusters is not void, pick one from there
   TObject* o = fClusterList.At(++fClusterNumber);
@@ -187,9 +189,6 @@ AliMUONClusterFinderMLEM::NextCluster()
     return 0x0;
   }
     
-//  AliCodeTimerAuto("Excluding preclustering")
-    
-
   fClusterList.Delete(); // reset the list of clusters for this pre-cluster
   fClusterNumber = -1; //AZ
   
index 0947d4b..f6767a0 100644 (file)
 
 #include "AliMUONClusterReconstructor.h"
 
-#include "AliLog.h"
 #include "AliMUONCluster.h"
 #include "AliMUONGeometryTransformer.h"
-#include "AliMUONRawCluster.h"
+#include "AliMUONVCluster.h"
 #include "AliMUONVClusterFinder.h"
 #include "AliMUONVClusterStore.h"
 #include "AliMUONVDigit.h"
 #include "AliMUONVDigitStore.h"
+#include "AliMUONPad.h"
+
 #include "AliMpDEIterator.h"
 #include "AliMpDEManager.h"
 #include "AliMpSegmentation.h"
+
+#include "AliLog.h"
+
 #include <Riostream.h>
+#include <float.h>
 
 /// \cond CLASSIMP
 ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
@@ -51,7 +56,8 @@ AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliMUONVClusterFinder*
 : TObject(),
   fClusterFinder(clusterFinder),
   fTransformer(transformer),
-  fClusterStore(0x0)
+  fClusterStore(0x0),
+  fNCluster(0)
 {
     /// Standard Constructor
     /// Note that we adopt clusterFinder
@@ -88,45 +94,42 @@ AliMUONClusterReconstructor::ClusterizeOneDE(Int_t detElemId,
     AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::kCath1)
   };
     
-  Bool_t ok = fClusterFinder->Prepare(seg,digitStore);
-  if ( !ok )
-  {
-    AliWarning(Form("No hit pad for DE %d ?",detElemId));
-  }
+  if (!fClusterFinder->Prepare(seg,digitStore)) AliWarning(Form("No hit pad for DE %d ?",detElemId));
   
   AliMUONCluster* cluster;
+  AliMUONVCluster *rawCluster;
+  Int_t nPad;
+  
+  // Converts cluster objects into ones suitable for output
+  while ( ( cluster = fClusterFinder->NextCluster() ) ) {
     
-  while ( ( cluster = fClusterFinder->NextCluster() ) )
-  {
-    // Converts cluster objects into ones suitable for output
-    //
-    AliMUONRawCluster rawCluster;
-    
-    rawCluster.SetDetElemId(detElemId);
+    // add new cluster to the store with information to build its ID
+    // increment the number of clusters into the store
+    rawCluster = fClusterStore->Add(AliMpDEManager::GetChamberId(detElemId), detElemId, fNCluster++);
     
-    for ( Int_t cathode = 0; cathode < 2; ++cathode )
-    {
-      rawCluster.SetMultiplicity(cathode,cluster->Multiplicity(cathode));
-      rawCluster.SetCharge(cathode,cluster->Charge()); // both cathode get the total cluster charge
-      Double_t xg, yg, zg;
-      
-      fTransformer->Local2Global(detElemId, 
-                                 cluster->Position().X(), cluster->Position().Y(), 
-                                 0, xg, yg, zg);
-      
-      if ( cathode == 0 )
-      {
-        AliDebug(1,Form("Adding RawCluster detElemId %4d mult %2d charge %e (xl,yl,zl)=(%e,%e,%e) (xg,yg,zg)=(%e,%e,%e)",
-                        detElemId,cluster->Multiplicity(),cluster->Charge(),
-                        cluster->Position().X(),cluster->Position().Y(),0.0,
-                        xg,yg,zg));
-      }
-      rawCluster.SetX(cathode,xg);
-      rawCluster.SetY(cathode,yg);
-      rawCluster.SetZ(cathode,zg);      
+    // fill array of Id of digits attached to this cluster
+    nPad = cluster->Multiplicity();
+    if (nPad < 1) AliWarning("no pad attached to the cluster");
+    for (Int_t iPad=0; iPad<nPad; iPad++) {
+      AliMUONPad *pad = cluster->Pad(iPad);
+      rawCluster->AddDigitId(pad->GetUniqueID());
     }
-    fClusterStore->Add(rawCluster);
+    
+    // fill charge and other cluster informations
+    rawCluster->SetCharge(cluster->Charge());
+    
+    Double_t xg, yg, zg;
+    fTransformer->Local2Global(detElemId, 
+                               cluster->Position().X(), cluster->Position().Y(), 
+                               0, xg, yg, zg);
+    rawCluster->SetXYZ(xg, yg, zg);
+    
+    AliDebug(1,Form("Adding RawCluster detElemId %4d mult %2d charge %e (xl,yl,zl)=(%e,%e,%e) (xg,yg,zg)=(%e,%e,%e)",
+               detElemId,nPad,cluster->Charge(),
+               cluster->Position().X(),cluster->Position().Y(),0.0,
+               xg,yg,zg));
   }
+  
 }
 
 //____________________________________________________________________
@@ -137,6 +140,7 @@ void AliMUONClusterReconstructor::Digits2Clusters(const AliMUONVDigitStore& digi
   
   fClusterStore = &clusterStore;
   fClusterStore->Clear();
+  fNCluster = 0;
   
   AliMpDEIterator deIt;
   
index 4f8c01d..7dad6ab 100644 (file)
@@ -16,7 +16,6 @@ class AliMUONVClusterFinder;
 class AliMUONGeometryTransformer;
 class AliMUONVClusterStore;
 class AliMUONVDigitStore;
-class AliMUONRawCluster;
 
 class AliMUONClusterReconstructor : public TObject 
 {
@@ -46,6 +45,8 @@ private:
   
   AliMUONVClusterStore* fClusterStore; //!< not owner
   
+  Int_t fNCluster; //!< number of clusters in the cluster store (used to define the cluster ID)
+  
   ClassDef(AliMUONClusterReconstructor,0) // Clustering steering
 };
        
index 7adfb67..00cb479 100644 (file)
@@ -86,21 +86,51 @@ AliMUONClusterStoreV1::~AliMUONClusterStoreV1()
   delete fClusters;
 }
 
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV1::CreateCluster(Int_t /*chamberId*/, Int_t detElemId, Int_t /*clusterIndex*/) const
+{
+  /// Create a cluster
+  AliMUONVCluster* vCluster = new AliMUONRawCluster();
+  (static_cast<AliMUONRawCluster*> (vCluster))->SetDetElemId(detElemId);
+  return vCluster;
+}
+
 //_____________________________________________________________________________
 Bool_t 
-AliMUONClusterStoreV1::Add(const AliMUONRawCluster& cluster)
+AliMUONClusterStoreV1::Add(const AliMUONVCluster& vCluster)
 {
   /// Add a cluster to this store
-  Int_t iChamber = AliMpDEManager::GetChamberId(cluster.GetDetElemId());
+  const AliMUONRawCluster* cluster = dynamic_cast<const AliMUONRawCluster*>(&vCluster);
+  
+  if (!cluster)
+  {
+    AliError(Form("Cluster is not of the expected type (%s vs AliMUONRawCluster)",
+                  vCluster.ClassName()));
+    return 0x0;
+  }
+  
+  Int_t iChamber = AliMpDEManager::GetChamberId(cluster->GetDetElemId());
   TClonesArray* array = ChamberClusters(iChamber);
   if (!array) 
   {
     return kFALSE;
   }
-  new((*array)[array->GetLast()+1]) AliMUONRawCluster(cluster);
+  new((*array)[array->GetLast()+1]) AliMUONRawCluster(*cluster);
   return kTRUE;
 }
 
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV1::Add(Int_t chamberId, Int_t detElemId, Int_t /*clusterIndex*/)
+{
+  /// Add a cluster to this store
+  TClonesArray* array = ChamberClusters(chamberId);
+  if (!array) return 0x0;
+  
+  AliMUONVCluster* vCluster = static_cast<AliMUONVCluster*> (new((*array)[array->GetLast()+1]) AliMUONRawCluster());
+  (static_cast<AliMUONRawCluster*> (vCluster))->SetDetElemId(detElemId);
+  return vCluster;
+}
+
 //_____________________________________________________________________________
 TClonesArray*
 AliMUONClusterStoreV1::ChamberClusters(Int_t chamberId) const
@@ -166,8 +196,8 @@ AliMUONClusterStoreV1::Connect(TTree& tree, Bool_t alone) const
 }
 
 //_____________________________________________________________________________
-AliMUONRawCluster*
-AliMUONClusterStoreV1::Remove(AliMUONRawCluster& cluster)
+AliMUONVCluster*
+AliMUONClusterStoreV1::Remove(AliMUONVCluster& cluster)
 {
   /// Remove a cluster
   Int_t iChamber = AliMpDEManager::GetChamberId(cluster.GetDetElemId());
@@ -177,7 +207,7 @@ AliMUONClusterStoreV1::Remove(AliMUONRawCluster& cluster)
   {
     array->Compress();
   }
-  return static_cast<AliMUONRawCluster*>(o);
+  return static_cast<AliMUONVCluster*>(o);
 }
 
 //_____________________________________________________________________________
@@ -221,3 +251,4 @@ AliMUONClusterStoreV1::GetSize() const
   }
   return n;
 }
+
index 9718d25..6462416 100644 (file)
@@ -29,9 +29,12 @@ public:
   
   virtual AliMUONClusterStoreV1* Create() const { return new AliMUONClusterStoreV1; }
   
+  virtual AliMUONVCluster* CreateCluster(Int_t /*chamberId*/, Int_t detElemId, Int_t /*clusterIndex*/) const;
+  
   using AliMUONVClusterStore::Add;
   
-  virtual Bool_t Add(const AliMUONRawCluster& Cluster);
+  virtual Bool_t Add(const AliMUONVCluster& Cluster);
+  virtual AliMUONVCluster* Add(Int_t chamberId, Int_t detElemId, Int_t /*clusterIndex*/);
 
   /// Whether the Connect(TTree&) method is implemented
   virtual Bool_t CanConnect() const { return kTRUE; }
@@ -48,18 +51,19 @@ public:
   
   virtual Int_t GetSize() const;
 
-  virtual AliMUONRawCluster* Remove(AliMUONRawCluster& cluster);
+  virtual AliMUONVCluster* Remove(AliMUONVCluster& cluster);
 
 private:
 
   TClonesArray* ChamberClusters(Int_t chamberId) const;
   TObject** ChamberClustersPtr(Int_t chamberId) const;
-  //AliMUONRawCluster* Find(Int_t clusterId, Int_t& index) const;
+  //AliMUONVCluster* Find(Int_t clusterId, Int_t& index) const;
   
 private:
-  TObjArray* fClusters; //!< Array of TClonesArray of RawClusters
+  TObjArray* fClusters; //!< Array of TClonesArray of VClusters
   
   ClassDef(AliMUONClusterStoreV1,1) // Implementation of VClusterStore
 };
 
 #endif
+
diff --git a/MUON/AliMUONClusterStoreV2.cxx b/MUON/AliMUONClusterStoreV2.cxx
new file mode 100644 (file)
index 0000000..39ac6b2
--- /dev/null
@@ -0,0 +1,261 @@
+/**************************************************************************
+* 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$
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONClusterStoreV2
+///
+/// Implementation of VClusterStore.
+///
+/// Note that clusters are identified by their UniqueID, so it MUST be correctly set
+///
+/// \author Philippe Pillot, Subatech
+///
+//-----------------------------------------------------------------------------
+
+#include "AliMUONClusterStoreV2.h"
+
+#include "AliMUONRawClusterV2.h"
+#include "AliMUONClusterStoreV2Iterator.h"
+#include "AliMUONTreeManager.h"
+#include "AliMpConstants.h"
+#include "AliMpExMap.h"
+
+#include "AliLog.h"
+
+#include <TTree.h>
+
+#include <Riostream.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONClusterStoreV2)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2::AliMUONClusterStoreV2() 
+: AliMUONVClusterStore(), 
+  fClusters(new TClonesArray("AliMUONRawClusterV2",100)),
+  fMap(0x0),
+  fMapped(kFALSE)
+{
+  /// Constructor
+}
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2::AliMUONClusterStoreV2(const AliMUONClusterStoreV2& store)
+: AliMUONVClusterStore(), 
+  fClusters(new TClonesArray(*(store.fClusters))),
+  fMap(0x0),
+  fMapped(kFALSE)
+{
+  /// Copy constructor
+  if (store.fMapped) ReMap();
+}
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2& AliMUONClusterStoreV2::operator=(const AliMUONClusterStoreV2& store)
+{
+  /// Assignment operator
+  fClusters = new TClonesArray(*(store.fClusters));
+  fMap = 0x0;
+  fMapped = kFALSE;
+  if (store.fMapped) ReMap();
+  return *this;
+}
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2::~AliMUONClusterStoreV2()
+{
+  /// Destructor
+  delete fClusters;
+  delete fMap;
+}
+
+//_____________________________________________________________________________
+void AliMUONClusterStoreV2::Clear(Option_t*)
+{
+  /// Clear the internal cluster array AND the index
+  fClusters->Clear("C");
+  if (fMap) {
+    fMap->Clear("C");
+    fMapped = kFALSE;
+  }
+}
+
+//_____________________________________________________________________________
+Bool_t AliMUONClusterStoreV2::Connect(TTree& tree, Bool_t alone) const
+{
+  /// Connect this to the tree, i.e. make the branches or set their addresses.
+  
+  AliMUONTreeManager tman;
+  
+  if (tree.GetBranch("MUONRawClusters")) {
+    
+    if (alone) tman.UpdateBranchStatuses(tree,"MUONRawClusters");
+    
+    return tman.SetAddress(tree,"MUONRawClusters", 
+                        const_cast<TClonesArray**>(&fClusters));
+  } else {
+    
+    return tman.MakeBranch(tree,ClassName(),"TClonesArray", "MUONRawClusters",
+                        const_cast<TClonesArray**>(&fClusters));
+  }
+    
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV2::CreateCluster(Int_t chamberId, Int_t detElemId, Int_t clusterIndex) const
+{
+  /// Create a cluster
+  return new AliMUONRawClusterV2(chamberId, detElemId, clusterIndex);
+}
+
+//_____________________________________________________________________________
+Bool_t AliMUONClusterStoreV2::Add(const AliMUONVCluster& vCluster)
+{
+  /// Add a cluster to this store
+  const AliMUONRawClusterV2* cluster = dynamic_cast<const AliMUONRawClusterV2*>(&vCluster);
+  
+  if (!cluster) {
+    AliError(Form("Cluster is not of the expected type (%s vs AliMUONRawClusterV2)",
+                  vCluster.ClassName()));
+    return kFALSE;
+  }
+  
+  // check that there is no cluster with the same Id
+  if (FindObject(cluster->GetUniqueID())) {
+    AliError("cluster store already contains a cluster with the same ID --> add() aborted");
+    return kFALSE;
+  }
+  
+  // add new cluster
+  AliMUONVCluster *c = new((*fClusters)[fClusters->GetLast()+1]) AliMUONRawClusterV2(*cluster);
+  
+  if (c) UpdateMap(*c);
+  
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV2::Add(Int_t chamberId, Int_t detElemId, Int_t clusterIndex)
+{
+  /// Add an empty cluster with an unique ID to this store
+  
+  // check that there is no cluster with the same Id
+  AliMUONVCluster *c = FindObject(AliMUONVCluster::BuildUniqueID(chamberId, detElemId, clusterIndex));
+  if (c) {
+    AliError("cluster store already contains a cluster with the same ID --> add() aborted:");
+    c->Print("FULL");
+    return 0x0;
+  }
+  
+  // add new cluster
+  c = new((*fClusters)[fClusters->GetLast()+1]) AliMUONRawClusterV2(chamberId, detElemId, clusterIndex);
+  
+  if (c) UpdateMap(*c);
+  
+  return c;
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV2::Remove(AliMUONVCluster& cluster)
+{
+  /// Remove a cluster
+  AliMUONVCluster* c = static_cast<AliMUONVCluster*>(fClusters->Remove(&cluster));
+  
+  if (c) {
+    fClusters->Compress();
+    fMapped = kFALSE;
+  }
+  
+  return c;
+}
+
+//_____________________________________________________________________________
+void AliMUONClusterStoreV2::ReMap()
+{
+  /// Recompute the fMap, which map (ch) to an index within the fClusters array
+  fMapped = kTRUE;
+  
+  // Create (or clear) the TClonesArray of map
+  Int_t nChamber = AliMpConstants::NofTrackingChambers();
+  if (!fMap) fMap = new TClonesArray("AliMpExMap",nChamber);
+  else fMap->Clear("C");
+  
+  // Create one map per chamber
+  AliMpExMap *map;
+  for (Int_t chamber=0; chamber<nChamber; chamber++) {
+    map = new((*fMap)[chamber]) AliMpExMap(kTRUE);
+    map->SetOwner(kFALSE);
+  }
+  
+  // Fill the maps
+  TIter next(fClusters);
+  AliMUONVCluster* cluster;
+  while ( (cluster = static_cast<AliMUONVCluster*>(next())) ) UpdateMap(*cluster);
+}
+
+//_____________________________________________________________________________
+void AliMUONClusterStoreV2::UpdateMap(AliMUONVCluster& cluster)
+{
+  /// Update the internal index given this new cluster
+  if (fMapped) static_cast<AliMpExMap*>(fMap->UncheckedAt(cluster.GetChamberId()))->Add(cluster.GetUniqueID(),&cluster);
+  else ReMap();
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV2::FindObject(const TObject* object) const
+{
+  /// Find an object, if of AliMUONVCluster type.
+  const AliMUONVCluster* cluster = dynamic_cast<const AliMUONVCluster*>(object);
+  if (cluster) return FindObject(cluster->GetUniqueID());
+  return 0x0;
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONClusterStoreV2::FindObject(UInt_t uniqueID) const
+{
+  /// Find a cluster by its UniqueID
+  if (!fMapped) (const_cast<AliMUONClusterStoreV2*>(this))->ReMap();
+  AliMpExMap* map = static_cast<AliMpExMap*>(fMap->UncheckedAt(AliMUONVCluster::GetChamberId(uniqueID)));
+  return static_cast<AliMUONVCluster*>(map->GetValue(uniqueID));
+}
+
+//_____________________________________________________________________________
+TIterator* AliMUONClusterStoreV2::CreateIterator() const
+{
+  /// Return an iterator to loop over all clusters
+  return fClusters->MakeIterator();
+}
+
+//_____________________________________________________________________________
+TIterator* AliMUONClusterStoreV2::CreateChamberIterator(Int_t firstChamber, Int_t lastChamber) const
+{
+  /// Return an iterator to loop over clusters in the chambers within the given range
+  
+  // check validity of given chamber IDs
+  if (firstChamber < 0 || firstChamber >= AliMpConstants::NofTrackingChambers()) {
+    AliError(Form("First chamber out of boundaries [0,%d[", AliMpConstants::NofTrackingChambers()));
+    return 0x0;
+  }
+  if (lastChamber < 0 || lastChamber >= AliMpConstants::NofTrackingChambers()) {
+    AliError(Form("Last chamber out of boundaries [0,%d[", AliMpConstants::NofTrackingChambers()));
+    return 0x0;
+  }
+  
+  if (!fMapped) (const_cast<AliMUONClusterStoreV2*>(this))->ReMap();
+  return new AliMUONClusterStoreV2Iterator(this,firstChamber,lastChamber);
+}
diff --git a/MUON/AliMUONClusterStoreV2.h b/MUON/AliMUONClusterStoreV2.h
new file mode 100644 (file)
index 0000000..471e42e
--- /dev/null
@@ -0,0 +1,75 @@
+#ifndef AliMUONCLUSTERSTOREV2_H
+#define AliMUONCLUSTERSTOREV2_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup rec
+/// \class AliMUONClusterStoreV2
+/// \brief Implementation of VClusterStore
+/// 
+// Author Philippe Pillot, Subatech
+
+#ifndef ALIMUONVCLUSTERSTORE_H
+#  include "AliMUONVClusterStore.h"
+#endif
+
+#include "AliMUONVCluster.h"
+#include <TClonesArray.h>
+
+class AliMUONClusterStoreV2 : public AliMUONVClusterStore
+{
+  friend class AliMUONClusterStoreV2Iterator;
+  
+public:
+  AliMUONClusterStoreV2();
+  AliMUONClusterStoreV2(const AliMUONClusterStoreV2& store);
+  AliMUONClusterStoreV2& operator=(const AliMUONClusterStoreV2& store);  
+  virtual ~AliMUONClusterStoreV2();
+  
+  virtual void Clear(Option_t* opt="");
+  
+  /// Whether the Connect(TTree&) method is implemented
+  virtual Bool_t CanConnect() const { return kTRUE; }
+  virtual Bool_t Connect(TTree& tree, Bool_t alone=kTRUE) const;
+  
+  /// Create an empty copy of this
+  virtual AliMUONClusterStoreV2* Create() const { return new AliMUONClusterStoreV2; }
+  
+  virtual AliMUONVCluster* CreateCluster(Int_t chamberId, Int_t detElemId, Int_t clusterIndex) const;
+  
+  using AliMUONVClusterStore::Add;
+  
+  virtual Bool_t Add(const AliMUONVCluster& Cluster);
+  virtual AliMUONVCluster* Add(Int_t chamberId, Int_t detElemId, Int_t clusterIndex);
+
+  virtual AliMUONVCluster* Remove(AliMUONVCluster& cluster);
+
+  using AliMUONVClusterStore::GetSize;
+  
+  /// Return the number of clusters we hold
+  virtual Int_t GetSize() const {return fClusters->GetLast()+1;}
+  
+  using AliMUONVStore::FindObject;
+  
+  AliMUONVCluster* FindObject(const TObject* object) const;
+  AliMUONVCluster* FindObject(UInt_t uniqueID) const;
+  
+  virtual TIterator* CreateIterator() const;
+  virtual TIterator* CreateChamberIterator(Int_t firstChamberId, Int_t lastChamberId) const;
+  
+private:
+  void ReMap();
+  void UpdateMap(AliMUONVCluster& cluster);
+  
+private:
+  TClonesArray* fClusters; ///< collection of clusters
+  TClonesArray* fMap;      //!< index map for fast cluster retrieval
+  Bool_t        fMapped;   //!< whether our internal indices are uptodate
+  
+  ClassDef(AliMUONClusterStoreV2,1) // Implementation of VClusterStore
+};
+
+#endif
diff --git a/MUON/AliMUONClusterStoreV2Iterator.cxx b/MUON/AliMUONClusterStoreV2Iterator.cxx
new file mode 100644 (file)
index 0000000..c6c2f8a
--- /dev/null
@@ -0,0 +1,138 @@
+/**************************************************************************
+* 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$
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONClusterStoreV2Iterator
+///
+/// Implementation of TIterator for AliMUONClusterStoreV2
+///
+/// \author Philippe Pillot, Subatech
+///
+//-----------------------------------------------------------------------------
+
+#include "AliMUONClusterStoreV2Iterator.h"
+
+#include "AliMUONClusterStoreV2.h"
+
+#include "AliMpExMap.h"
+
+#include <TExMap.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONClusterStoreV2Iterator)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2Iterator::AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2* store,
+                                                             Int_t firstChamberId, Int_t lastChamberId)
+: TIterator(),
+  fStore(store),
+  fFirstChamberId(firstChamberId),
+  fLastChamberId(lastChamberId),
+  fCurrentChamberId(-1),
+  fChamberIterator(0x0)
+{
+  /// Constructor for partial iteration
+  if (fFirstChamberId > fLastChamberId) {
+    fLastChamberId = fFirstChamberId;
+    fFirstChamberId = lastChamberId;
+  }
+  Reset();
+}
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2Iterator::AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2Iterator& iter)
+: TIterator(iter),
+  fStore(iter.fStore),
+  fFirstChamberId(iter.fFirstChamberId),
+  fLastChamberId(iter.fLastChamberId),
+  fCurrentChamberId(iter.fCurrentChamberId),
+  fChamberIterator(0x0)
+{
+  /// Copy constructor
+  if (iter.fChamberIterator) fChamberIterator = new TExMapIter(*(iter.fChamberIterator));
+}
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2Iterator& AliMUONClusterStoreV2Iterator::operator=(const AliMUONClusterStoreV2Iterator& iter)
+{
+  /// Assignment operator
+  if ( this != &iter ) {
+    fFirstChamberId = iter.fFirstChamberId;
+    fLastChamberId = iter.fLastChamberId;
+    fCurrentChamberId = iter.fCurrentChamberId;
+    delete fChamberIterator;
+    fChamberIterator = 0x0;
+    if (iter.fChamberIterator) fChamberIterator = new TExMapIter(*(iter.fChamberIterator));
+  }
+  return *this;
+}
+
+//_____________________________________________________________________________
+TIterator& AliMUONClusterStoreV2Iterator::operator=(const TIterator& iter)
+{
+  /// Overriden operator= (imposed by Root's definition of TIterator::operator= ?)
+  if ( this != &iter && iter.IsA() == AliMUONClusterStoreV2Iterator::Class() ) {
+    (*this) = static_cast<const AliMUONClusterStoreV2Iterator&>(iter);
+  }
+  return *this;
+}
+
+//_____________________________________________________________________________
+AliMUONClusterStoreV2Iterator::~AliMUONClusterStoreV2Iterator()
+{
+  /// Destructor
+  delete fChamberIterator;
+}
+
+//_____________________________________________________________________________
+TObject* AliMUONClusterStoreV2Iterator::NextInCurrentChamber() const
+{
+  /// Return the value corresponding to theKey in iterator iter
+  Long_t key, value;
+  if (fChamberIterator->Next(key,value)) return reinterpret_cast<TObject*>(value);
+  else return 0x0;
+}
+
+//_____________________________________________________________________________
+TObject* AliMUONClusterStoreV2Iterator::Next()
+{
+  /// Return next cluster in store
+  TObject* o = NextInCurrentChamber();
+  
+  while (!o) {
+    // fChamberIterator exhausted, try to get the next ones
+    if (fCurrentChamberId == fLastChamberId) return 0x0; // we reached the end
+    
+    fCurrentChamberId++;
+    delete fChamberIterator;
+    fChamberIterator = new TExMapIter(static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->GetIterator());
+    
+    o = NextInCurrentChamber();
+  }
+  
+  return o;
+}
+
+//_____________________________________________________________________________
+void AliMUONClusterStoreV2Iterator::Reset()
+{
+  /// Reset the iterator
+  fCurrentChamberId = fFirstChamberId;
+  delete fChamberIterator;
+  fChamberIterator = new TExMapIter(static_cast<AliMpExMap*>(fStore->fMap->UncheckedAt(fCurrentChamberId))->GetIterator());
+}
diff --git a/MUON/AliMUONClusterStoreV2Iterator.h b/MUON/AliMUONClusterStoreV2Iterator.h
new file mode 100644 (file)
index 0000000..821fa4e
--- /dev/null
@@ -0,0 +1,53 @@
+#ifndef ALIMUONCLUSTERSTOREV2ITERATOR_H
+#define ALIMUONCLUSTERSTOREV2ITERATOR_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONClusterStoreV2Iterator
+/// \brief Base implementation of TIterator for AliMUONClusterStoreV2
+/// 
+//  Author Philippe Pillot, Subatech
+
+#ifndef ROOT_TIterator
+#  include "TIterator.h"
+#endif
+
+class AliMUONClusterStoreV2;
+class TExMapIter;
+
+class AliMUONClusterStoreV2Iterator : public TIterator
+{
+public:
+  AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2* store,
+                                Int_t firstChamberId, Int_t lastChamberId);
+  AliMUONClusterStoreV2Iterator(const AliMUONClusterStoreV2Iterator& rhs);
+  AliMUONClusterStoreV2Iterator& operator=(const AliMUONClusterStoreV2Iterator& rhs);
+  TIterator& operator=(const TIterator& rhs);
+  
+  virtual ~AliMUONClusterStoreV2Iterator();
+  
+  TObject* Next();
+  
+  void Reset();
+  
+  /// Return 0 as we're not dealing with TCollection objects really
+  virtual const TCollection* GetCollection() const { return 0x0; }
+  
+private:
+  TObject* NextInCurrentChamber() const;
+  
+private:
+  const AliMUONClusterStoreV2* fStore; ///< store to iterate upon
+  Int_t fFirstChamberId; ///< first chamber
+  Int_t fLastChamberId; ///< last chamber
+  Int_t fCurrentChamberId; ///< current chamber
+  TExMapIter* fChamberIterator; ///< helper iterator
+  
+  ClassDef(AliMUONClusterStoreV2Iterator,0) // Implementation of TIterator
+};
+
+#endif
index 31ff500..bd935ef 100644 (file)
@@ -18,7 +18,7 @@
 #include "AliMUONDataInterface.h"
 #include "AliMUONGeometryTransformer.h"
 #include "AliMUONVDigit.h"
-#include "AliMUONRawCluster.h"
+#include "AliMUONVCluster.h"
 #include "AliMUONTrack.h"
 #include "AliMUONLocalTrigger.h"
 #include "AliMUONRegionalTrigger.h"
@@ -718,7 +718,7 @@ Int_t AliMUONDataInterface::NumberOfRawClusters(Int_t chamber)
 }
 
 //_____________________________________________________________________________
-AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t index)
+AliMUONVCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t index)
 {
 /// Returns a pointer to the index'th raw cluster on the specified chamber.
 /// @param chamber  The chamber number in the range [0 .. 13].
@@ -726,7 +726,7 @@ AliMUONRawCluster* AliMUONDataInterface::RawCluster(Int_t chamber, Int_t index)
 ///   where N = NumberOfRawClusters(chamber)
 
   TIterator* iter = GetIterator(kRawClusterIterator, chamber);
-  return static_cast<AliMUONRawCluster*>( FetchObject(iter, index) );
+  return static_cast<AliMUONVCluster*>( FetchObject(iter, index) );
 }
 
 //_____________________________________________________________________________
index 15e70d3..52a085f 100644 (file)
@@ -27,7 +27,7 @@ class AliMUONVTrackStore;
 class AliMUONVTriggerStore;
 class AliMUONVTriggerTrackStore;
 class AliMUONVDigit;
-class AliMUONRawCluster;
+class AliMUONVCluster;
 class AliMUONTrack;
 class AliMUONLocalTrigger;
 class AliMUONRegionalTrigger;
@@ -78,7 +78,7 @@ public:
   Int_t NumberOfDigits(Int_t chamber, Int_t cathode);
   AliMUONVDigit* Digit(Int_t chamber, Int_t cathode, Int_t index);
   Int_t NumberOfRawClusters(Int_t chamber);
-  AliMUONRawCluster* RawCluster(Int_t chamber, Int_t index);
+  AliMUONVCluster* RawCluster(Int_t chamber, Int_t index);
   Int_t NumberOfTracks();
   AliMUONTrack* Track(Int_t index);
   Int_t NumberOfLocalTriggers();
index f47d948..1634538 100644 (file)
 // Author: J. Gosset
 //-----------------------------------------------------------------------------
 
-#include "AliTrackReference.h" 
 #include "AliMUONHitForRec.h" 
-#include "AliMUONRawCluster.h"
+#include "AliMUONVCluster.h"
 #include "AliMUONConstants.h"
 #include "AliLog.h"
+#include "TMath.h"
 #include "Riostream.h"
 
 /// \cond CLASSIMP
@@ -53,56 +53,10 @@ AliMUONHitForRec::AliMUONHitForRec()
 }
 
   //__________________________________________________________________________
-AliMUONHitForRec::AliMUONHitForRec(AliTrackReference* theGhit)
+AliMUONHitForRec::AliMUONHitForRec(AliMUONVCluster* theRawCluster)
   : TObject(),
-    fBendingCoor(theGhit->Y()),
-    fNonBendingCoor(theGhit->X()),
-    fZ(theGhit->Z()),
-    fBendingReso2(0.),
-    fNonBendingReso2(0.),
-    fChamberNumber(0),
-    fDetElemId(0),
-    fHitNumber(0),
-    fTTRTrack(0),
-    fTrackRefSignal(0),
-    fNTrackHits(0)
-{
-/// Constructor for AliMUONHitForRec from a track ref. hit.
-/// Fills the bending, non bending, and Z coordinates,
-/// which are taken from the coordinates of the track ref. hit,
-/// the track number (track ref. and not TH),
-/// and the chamber number (0...).
-
-  // fTrack = theGhit->fTrack; ?????????
-  fDetElemId = theGhit->UserId();
-  if (fDetElemId) fChamberNumber = fDetElemId / 100 - 1;
-  else fChamberNumber = AliMUONConstants::ChamberNumber(fZ);
-  // other fields will be updated in
-  // AliMUONEventReconstructor::NewHitForRecFromTrackRef
-  return;
-}
-
-//   //__________________________________________________________________________
-// AliMUONHitForRec::AliMUONHitForRec(AliMUONReconstHit* CathCorrel)
-// {
-//   // Constructor for AliMUONHitForRec from a (cathode correlated) raw cluster.
-//   // Fills the bending and non bending coordinates.
-//   // Only the first correlation is taken into account.
-//   // The bending coordinate is taken from the first cathode.
-//   // The non bending coordinate is taken 
-//   // from the second cathode if it exists,
-//   // from the first one otherwise.
-//   fBendingCoor = CathCorrel->fY[3];
-//   if (CathCorrel->fCorrelIndex[0] >= 0) fNonBendingCoor = CathCorrel->fX[0];
-//   else fNonBendingCoor = CathCorrel->fX[3];
-//   return;
-// }
-
-  //__________________________________________________________________________
-AliMUONHitForRec::AliMUONHitForRec(AliMUONRawCluster* theRawCluster)
-  : TObject(),
-    fBendingCoor(theRawCluster->GetY(0)),
-    fNonBendingCoor(theRawCluster->GetX(0)),
+    fBendingCoor(theRawCluster->GetY()),
+    fNonBendingCoor(theRawCluster->GetX()),
     fZ(0.),
     fBendingReso2(0.),
     fNonBendingReso2(0.),
index 7f92fc3..66db382 100644 (file)
@@ -14,8 +14,7 @@
 
 #include <TObject.h>
 
-class AliTrackReference;
-class AliMUONRawCluster;
+class AliMUONVCluster;
 class AliMUONTrackHit;
 class AliMUONTrackParam;
 
@@ -25,8 +24,7 @@ class AliMUONHitForRec : public TObject {
   virtual ~AliMUONHitForRec(); // Destructor
   AliMUONHitForRec (const AliMUONHitForRec& AliMUONHitForRec); // copy constructor
   AliMUONHitForRec& operator=(const AliMUONHitForRec& AliMUONHitForRec); // assignment operator
-  AliMUONHitForRec(AliTrackReference* mHit); // Constructor from track ref. hit
-  AliMUONHitForRec(AliMUONRawCluster* theRawCluster); // Constructor from raw cluster
+  AliMUONHitForRec(AliMUONVCluster* theRawCluster); // Constructor from raw cluster
 
   // Inline functions for Get and Set
            /// Return coordinate (cm) in bending plane
index 805829d..ba2620a 100644 (file)
@@ -72,7 +72,6 @@ fIsReal(kFALSE),
 fClusterId(-1),
 fCathode(-1),
 fDetElemId(-1),
-fDigitIndex(-1),
 fIx(-1),
 fIy(-1),
 fStatus(0),
@@ -96,7 +95,6 @@ fIsReal(kFALSE),
 fClusterId(-1),
 fCathode(-1),
 fDetElemId(-1),
-fDigitIndex(-1),
 fIx(-1),
 fIy(-1),
 fStatus(0),
@@ -119,7 +117,6 @@ fIsReal(kFALSE),
 fClusterId(-1),
 fCathode(-1),
 fDetElemId(-1),
-fDigitIndex(-1),
 fIx(-1),
 fIy(-1),
 fStatus(0),
@@ -141,7 +138,6 @@ fIsReal(kFALSE),
 fClusterId(-1),
 fCathode(-1),
 fDetElemId(-1),
-fDigitIndex(-1),
 fIx(-1),
 fIy(-1),
 fStatus(0),
@@ -387,7 +383,6 @@ AliMUONPad::Init(Int_t detElemId, Int_t cathode,
   fChargeBackup = fCharge;
   
   fClusterId = -1;
-  fDigitIndex = -1;
 
   fStatus = 0;
 }
index 7b72f38..2ecc7da 100644 (file)
@@ -52,10 +52,6 @@ public:
   /// Return detection element id
   Int_t DetElemId() const { return fDetElemId; }
   
-  /// \brief Return corresponding digit index 
-  /// To get back the digit from which this pad was constructed, if needed
-  Int_t DigitIndex() const { return fDigitIndex; }
-
   /// Return half dimensions in x and y (cm)
   TVector2 Dimensions() const { return fDimensions; }
   
@@ -104,10 +100,6 @@ public:
 
   void SetCoord(Int_t ixy, Double_t Coord);
 
-  /// \brief Set corresponding digit index
-  /// To get back the digit from which this pad was constructed, if needed
-  void SetDigitIndex(Int_t digitIndex) { fDigitIndex = digitIndex; }
-
   /// Set status word
   void SetStatus(Int_t status) { fStatus = status; }
     
@@ -160,7 +152,6 @@ private:
   Int_t fClusterId; ///< cluster id this pad belongs to (-1 if not attached to a cluster)
   Int_t fCathode; ///< cathode number
   Int_t fDetElemId; ///< detection element id
-  Int_t fDigitIndex; ///< corresponding digit index (to get back the digit from which this pad was constructed, if needed)
   Int_t fIx; ///< x-index
   Int_t fIy; ///< y-index
   Int_t fStatus; ///< status word
@@ -169,7 +160,7 @@ private:
   Double_t fCharge; ///< pad charge
   Double_t fChargeBackup; ///< backup charge (usefull if clustering somehow plays with the charge, this one is the "original" one)
   
-  ClassDef(AliMUONPad,1) // A full grown pad 
+  ClassDef(AliMUONPad,2) // A full grown pad 
 };
 
 #endif
index a211240..7be9d56 100644 (file)
@@ -130,7 +130,8 @@ AliMUONPreClusterFinder::Prepare(const AliMpVSegmentation* segmentations[2],
                     ix,iy,pad.Position().X(),pad.Position().Y(),
                     pad.Dimensions().X(),pad.Dimensions().Y(),
                     d->Charge());
-    if ( d->IsSaturated() ) mpad.SetSaturated(kTRUE); 
+    if ( d->IsSaturated() ) mpad.SetSaturated(kTRUE);
+    mpad.SetUniqueID(d->GetUniqueID());
     new (padArray[padArray.GetLast()+1]) AliMUONPad(mpad);      
   }
   if ( fPads[0]->GetLast() < 0 && fPads[1]->GetLast() < 0 )
@@ -203,8 +204,7 @@ AliMUONCluster*
 AliMUONPreClusterFinder::NextCluster()
 {
   /// Builds the next cluster, and returns it.
-  
-//  AliCodeTimerAuto("")
+//  AliCodeTimerAuto("pre-clustering")
   
   // Start a new cluster
   Int_t id = fClusters->GetLast()+1;
index f1cbef8..21f5e44 100644 (file)
@@ -129,6 +129,7 @@ AliMUONPreClusterFinderV2::Prepare(const AliMpVSegmentation* segmentations[2],
                     pad.Dimensions().X(),pad.Dimensions().Y(),
                     d->Charge());
     if ( d->IsSaturated() ) mpad.SetSaturated(kTRUE); 
+    mpad.SetUniqueID(d->GetUniqueID());
     new (padArray[padArray.GetLast()+1]) AliMUONPad(mpad);      
   }
   if ( fPads[0]->GetLast() < 0 && fPads[1]->GetLast() < 0 )
index eead6bc..400c6fa 100644 (file)
@@ -170,6 +170,7 @@ AliMUONPreClusterFinderV3::Prepare(const AliMpVSegmentation* segmentations[2],
                     pad.Dimensions().X(),pad.Dimensions().Y(),
                     d->Charge());
     if ( d->IsSaturated() ) mpad.SetSaturated(kTRUE); 
+    mpad.SetUniqueID(d->GetUniqueID());
     new (padArray[padArray.GetLast()+1]) AliMUONPad(mpad);      
   }
   if ( fPads[0]->GetLast() < 0 && fPads[1]->GetLast() < 0 )
index f5d3a23..5284860 100644 (file)
 ClassImp(AliMUONRawCluster)
 /// \endcond
 
+
 //____________________________________________________
 AliMUONRawCluster::AliMUONRawCluster() 
-  : TObject(),
+  : AliMUONVCluster(),
     fClusterType(0),
     fGhost(0),
     fDetElemId(0)   
@@ -60,8 +61,8 @@ AliMUONRawCluster::AliMUONRawCluster()
        }
     }
     fNcluster[0]=fNcluster[1]=-1;
-    fErrXY[0] = 0.144;
-    fErrXY[1] = 0.01;
+    fErrXY[0] = fgkDefaultNonBendingReso;
+    fErrXY[1] = fgkDefaultBendingReso;
 }
 
 //____________________________________________________
@@ -70,6 +71,21 @@ AliMUONRawCluster::~AliMUONRawCluster()
 /// Destructor
 }
 
+//____________________________________________________
+void AliMUONRawCluster::SetDigitsId(Int_t nDigits, const UInt_t *digitsId)
+{
+  /// Set the array of digit Id
+  /// if digitsId is not given the array is filled with id=0
+  
+  fMultiplicity[0] = (nDigits < 50) ? nDigits : 50;
+  
+  if (fMultiplicity[0] == 0) return;
+  if (digitsId == 0)
+    for (Int_t i=0; i<fMultiplicity[0]; i++) fIndexMap[i][0] = 0;
+  else
+    for (Int_t i=0; i<fMultiplicity[0]; i++) fIndexMap[i][0] = (Int_t) digitsId[i];
+}
+
 //____________________________________________________
 Int_t AliMUONRawCluster::Compare(const TObject *obj) const
 {
@@ -93,11 +109,11 @@ Int_t AliMUONRawCluster::Compare(const TObject *obj) const
    */
   
   const AliMUONRawCluster* raw = static_cast<const AliMUONRawCluster*>(obj);
-  if ( GetCharge(0) > raw->GetCharge(0) ) 
+  if ( GetCharge() > raw->GetCharge() ) 
   {
     return 1;
   }
-  else if ( GetCharge(0) < raw->GetCharge(0) ) 
+  else if ( GetCharge() < raw->GetCharge() ) 
   {
     return -1;
   }
@@ -455,3 +471,4 @@ Int_t AliMUONRawCluster::SetChi2(Int_t i, Float_t chi2)
   else return 0;
 }
 
+
index 4ded373..b3670ee 100644 (file)
 /// RawCluster contains also the information from the both cathode of the chambers.
 
 
-#include <TObject.h>
+#include "AliMUONVCluster.h"
 #include <TMath.h> // because of inline funtion GetRadius
 #include <TArrayF.h>
-class AliMUONRawCluster : public TObject {
+
+class AliMUONRawCluster : public AliMUONVCluster {
 
 public:
    AliMUONRawCluster();
    virtual ~AliMUONRawCluster();
    
+           /// Clear method (used by TClonesArray)
+   virtual void Clear(Option_t* = "") {}
+   
+          /// Set coordinates (cm)
+  virtual void     SetXYZ(Double_t x, Double_t y, Double_t z) {fX[0] = x; fY[0] = y; fZ[0] = z;}
+           /// Return coordinate X (cm)
+  virtual Double_t GetX() const {return fX[0];}
+           /// Return coordinate Y (cm)
+  virtual Double_t GetY() const {return fY[0];}
+           /// Return coordinate Z (cm)
+  virtual Double_t GetZ() const {return fZ[0];}
+  
+          /// Set resolution (cm) on coordinates (X,Y)
+  virtual void     SetErrXY(Double_t errX, Double_t errY) {fErrXY[0] = errX; fErrXY[1] = errY;}
+           /// Return resolution (cm) on coordinate X
+  virtual Double_t GetErrX() const {return fErrXY[0];}
+           /// Return resolution**2 (cm**2) on coordinate X
+  virtual Double_t GetErrX2() const {return fErrXY[0] * fErrXY[0];}
+           /// Return resolution (cm) on coordinate Y
+  virtual Double_t GetErrY() const {return fErrXY[1];}
+           /// Return resolution**2 (cm**2) on coordinate Y
+  virtual Double_t GetErrY2() const {return fErrXY[1] * fErrXY[1];}
+  
+           /// Set the cluster charge
+  virtual void     SetCharge(Double_t q) {fQ[0] = q;}
+           /// Set the cluster charge
+  virtual Double_t GetCharge() const {return fQ[0];}
+  
+           /// Return chamber Id
+  virtual Int_t    GetChamberId() const {return fDetElemId/100 - 1;}
+           /// Set detection element Id
+          void     SetDetElemId(Int_t id) {fDetElemId = id;}
+           /// Return detection element Id
+  virtual Int_t    GetDetElemId() const {return fDetElemId;}
+  
+  virtual void     SetDigitsId(Int_t nDigits, const UInt_t *digitsId);
+           /// Add a digit Id to the array of associated digits
+  virtual void     AddDigitId(UInt_t id) {fIndexMap[fMultiplicity[0]++][0] = id;}
+
+           /// Return number of associated digits
+  virtual Int_t    GetNDigits() const {return fMultiplicity[0];}
+           /// Return Id of digits i
+  virtual UInt_t   GetDigitId(Int_t i) const {return (i < fMultiplicity[0] && i < 50) ? (UInt_t)fIndexMap[i][0] : 0;}
+  
+           /// Set chi2 of cluster
+  virtual void     SetChi2( Double_t chi2) {fChi2[0] = chi2;}
+           /// Return chi2 of cluster
+  virtual Double_t GetChi2() const {return fChi2[0];}
+   
    /// Return radius
    Float_t      GetRadius(Int_t i) {return TMath::Sqrt(fX[i]*fX[i]+fY[i]*fY[i]);}
    /// Return true as the function Compare() is implemented
@@ -41,34 +91,26 @@ public:
    Int_t        AddY(Int_t i, Float_t Y);
    Int_t        AddZ(Int_t i, Float_t Z);
 
-   /// Return the ID number of the detection element (slat) on which the cluster is found
-   Int_t DetElemId() const { return fDetElemId; }
-   
-   Float_t        GetCharge(Int_t i=0) const;
-   Float_t      GetX(Int_t i=0) const;
-   Float_t      GetY(Int_t i=0) const;
-   Float_t      GetZ(Int_t i=0) const;
+   Float_t      GetCharge(Int_t i) const;
+   Float_t      GetX(Int_t i) const;
+   Float_t      GetY(Int_t i) const;
+   Float_t      GetZ(Int_t i) const;
    Int_t        GetTrack(Int_t i=0) const;
-   Float_t        GetPeakSignal(Int_t i=0) const;
+   Float_t      GetPeakSignal(Int_t i=0) const;
    Int_t        GetMultiplicity(Int_t i=0) const;
    Int_t        GetClusterType() const;
    Int_t        GetGhost() const;
    Int_t        GetNcluster(Int_t i=0) const;
-   Float_t      GetChi2(Int_t i=0) const;
+   Float_t      GetChi2(Int_t i) const;
    Int_t        GetIndex(Int_t i, Int_t j) const;
    Int_t        GetOffset(Int_t i, Int_t j) const;
    Float_t      GetContrib(Int_t i, Int_t j) const;
    Int_t        GetPhysics(Int_t i) const;
-   Int_t        GetDetElemId() const ; 
-   Float_t      GetError(Int_t iXY) const;
-   Float_t      GetErrX() const;
-   Float_t      GetErrY() const;
 
    Int_t        SetCharge(Int_t i, Float_t Q);
    Int_t        SetX(Int_t i, Float_t X);
    Int_t        SetY(Int_t i, Float_t Y);
    Int_t        SetZ(Int_t i, Float_t Z);
-   void         SetDetElemId(Int_t Id); 
    Int_t        SetTrack(Int_t i, Int_t track);
    Int_t        SetPeakSignal(Int_t i, Float_t peaksignal);
    Int_t        SetMultiplicity(Int_t i, Int_t mul);
@@ -80,15 +122,12 @@ public:
    void         SetOffset(Int_t i, Int_t j, Int_t offset);
    void         SetContrib(Int_t i, Int_t j, Float_t contrib);
    void         SetPhysics(Int_t i, Int_t physics);
-   void         SetError(Int_t iXY, Float_t err);
-   void         SetErrX(Float_t err);
-   void         SetErrY(Float_t err);
 
 private:
    Int_t       fIndexMap[50][2];  ///< Indices of digits
    Int_t       fOffsetMap[50][2]; ///< Emmanuel special
    Float_t     fContMap[50][2];   ///< Contribution from digit
-   Int_t     fPhysicsMap[50];   ///< Distinguish signal and background contr.
+   Int_t       fPhysicsMap[50];   ///< Distinguish signal and background contr.
   
    Float_t     fQ[2]  ;           ///< Q of cluster (in ADC counts)     
    Float_t     fX[2]  ;           ///< X of cluster
@@ -108,7 +147,8 @@ private:
    Float_t     fChi2[2];          ///< Chi**2 of fit
    Int_t       fDetElemId;        ///< ID number of the detection element (slat) on which the cluster is found. 
    Float_t     fErrXY[2];         ///< coordinate errors
-   ClassDef(AliMUONRawCluster,2)  //Cluster class for MUON
+   
+   ClassDef(AliMUONRawCluster,3)  //Cluster class for MUON
 };
 
 // inline functions
@@ -145,42 +185,6 @@ inline  void  AliMUONRawCluster::SetContrib(Int_t i, Int_t j, Float_t contrib)
 inline  void  AliMUONRawCluster::SetPhysics(Int_t i, Int_t physics)
 { fPhysicsMap[i] = physics; }
 
-/// Set ID number of the detection element (slat) on which the cluster is found.
-inline void AliMUONRawCluster::SetDetElemId(Int_t Id)
-{ fDetElemId = Id; }
-
-/// Return ID number of the detection element (slat) on which the cluster is found.
-inline Int_t AliMUONRawCluster::GetDetElemId() const
-{ return fDetElemId;}
-
-/// Set coordinate errors
-inline void AliMUONRawCluster::SetError(Int_t iXY, Float_t err)
-{ fErrXY[iXY] = err; }
-
-/// Set x coordinate error
-inline void AliMUONRawCluster::SetErrX(Float_t err)
-{ SetError(0, err); }
-
-/// Set y coordinate error
-inline void AliMUONRawCluster::SetErrY(Float_t err)
-{ SetError(1, err); }
-
-/// Return coordinate errors
-inline Float_t AliMUONRawCluster::GetError(Int_t iXY) const
-{ return fErrXY[iXY]; }
-
-/// Return x coordinate error
-inline Float_t AliMUONRawCluster::GetErrX() const
-{ return GetError(0); }
-
-/// Return y coordinate error
-inline Float_t AliMUONRawCluster::GetErrY() const
-{ return GetError(1); }
 
 #endif
 
-
-
-
-
-
diff --git a/MUON/AliMUONRawClusterV2.cxx b/MUON/AliMUONRawClusterV2.cxx
new file mode 100644 (file)
index 0000000..ccb0f05
--- /dev/null
@@ -0,0 +1,186 @@
+/**************************************************************************
+ * 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$ */
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONRawClusterV2
+///
+/// Class for the MUON RecPoint
+///
+/// \author Philippe Pillot, Subatech
+//-----------------------------------------------------------------------------
+
+
+#include "AliMUONRawClusterV2.h"
+
+#include "AliLog.h"
+
+#include "Riostream.h"
+
+/// \cond CLASSIMP
+ClassImp(AliMUONRawClusterV2)
+/// \endcond
+
+
+//____________________________________________________
+AliMUONRawClusterV2::AliMUONRawClusterV2() 
+  : AliMUONVCluster(),
+    fX(FLT_MAX),
+    fY(FLT_MAX),
+    fZ(FLT_MAX),
+    fErrX2(fgkDefaultNonBendingReso * fgkDefaultNonBendingReso),
+    fErrY2(fgkDefaultBendingReso * fgkDefaultBendingReso),
+    fQ(0.),
+    fChi2(0.),
+    fNDigits(0),
+    fDigitsId(0x0)
+{
+  /// Default Constructor
+}
+
+//_____________________________________________________________________________
+AliMUONRawClusterV2::AliMUONRawClusterV2(Int_t chamberId, Int_t detElemId, Int_t clusterIndex)
+  : AliMUONVCluster(chamberId, detElemId, clusterIndex),
+    fX(FLT_MAX),
+    fY(FLT_MAX),
+    fZ(FLT_MAX),
+    fErrX2(fgkDefaultNonBendingReso * fgkDefaultNonBendingReso),
+    fErrY2(fgkDefaultBendingReso * fgkDefaultBendingReso),
+    fQ(0.),
+    fChi2(0.),
+    fNDigits(0),
+    fDigitsId(0x0)
+{
+  /// Constructor
+}
+
+//____________________________________________________
+AliMUONRawClusterV2::~AliMUONRawClusterV2() 
+{
+  /// Destructor
+  delete [] fDigitsId;
+}
+
+//____________________________________________________
+AliMUONRawClusterV2::AliMUONRawClusterV2(const AliMUONRawClusterV2& cluster)
+  : AliMUONVCluster(cluster),
+    fX(cluster.fX),
+    fY(cluster.fY),
+    fZ(cluster.fZ),
+    fErrX2(cluster.fErrX2),
+    fErrY2(cluster.fErrY2),
+    fQ(cluster.fQ),
+    fChi2(cluster.fChi2),
+    fNDigits(cluster.fNDigits),
+    fDigitsId(0x0)
+
+{
+  /// Copy constructor
+  
+  if (cluster.fDigitsId) {
+    fDigitsId = new UInt_t[fNDigits];
+    memcpy(fDigitsId,cluster.fDigitsId, fNDigits*sizeof(UInt_t));
+  }
+}
+
+  //__________________________________________________________________________
+AliMUONRawClusterV2 & AliMUONRawClusterV2::operator=(const AliMUONRawClusterV2& cluster)
+{
+  /// Asignment operator
+  
+  // check assignement to self
+  if (this == &cluster)
+    return *this;
+
+  // base class assignement
+  AliMUONVCluster::operator=(cluster);
+  
+  fX = cluster.fX;
+  fY = cluster.fY;
+  fZ = cluster.fZ;
+  fErrX2 = cluster.fErrX2;
+  fErrY2 = cluster.fErrY2;
+  fQ = cluster.fQ;
+  fChi2 = cluster.fChi2;
+  SetDigitsId(cluster.fNDigits,cluster.fDigitsId);
+
+  return *this;
+}
+
+//____________________________________________________
+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 = fgkDefaultNonBendingReso * fgkDefaultNonBendingReso;
+  fErrY2 = fgkDefaultBendingReso * fgkDefaultBendingReso;
+  fQ = 0.;
+  fChi2 = 0.;
+  fNDigits = 0;
+  delete [] fDigitsId;
+  fDigitsId = 0x0;
+}
+
+//____________________________________________________
+void AliMUONRawClusterV2::SetDigitsId(Int_t nDigits, const UInt_t *digitsId)
+{
+  /// Set size of array of digits Id to n ints and set the content
+  /// if digitsId is not given the array is filled with id=0
+  
+  if (fDigitsId && fNDigits != nDigits) {
+    delete [] fDigitsId;
+    fDigitsId = 0;
+  }
+  fNDigits = nDigits;
+  if (fNDigits == 0) return;
+  if (!fDigitsId) fDigitsId = new UInt_t[fNDigits];
+  if (digitsId == 0)
+    for (Int_t i=0; i<fNDigits; i++) fDigitsId[i] = 0;
+  else
+    memcpy(fDigitsId,digitsId, fNDigits*sizeof(UInt_t));
+}
+
+//____________________________________________________
+void AliMUONRawClusterV2::AddDigitId(UInt_t id)
+{
+  /// Reset size of array of digits Id and add the new id to its content
+  
+  UInt_t *digitsIdNew = new UInt_t[fNDigits+1];
+  memcpy(digitsIdNew,fDigitsId, fNDigits*sizeof(UInt_t));
+  digitsIdNew[fNDigits++] = id;
+  delete fDigitsId;
+  fDigitsId = digitsIdNew;
+}
+
+//____________________________________________________
+Int_t AliMUONRawClusterV2::Compare(const TObject *obj) const
+{
+/// Compare
+
+  const AliMUONRawClusterV2* raw = static_cast<const AliMUONRawClusterV2*>(obj);
+  if ( GetCharge() > raw->GetCharge() ) 
+  {
+    return 1;
+  }
+  else if ( GetCharge() < raw->GetCharge() ) 
+  {
+    return -1;
+  }
+  return 0;
+}
diff --git a/MUON/AliMUONRawClusterV2.h b/MUON/AliMUONRawClusterV2.h
new file mode 100644 (file)
index 0000000..04e99e8
--- /dev/null
@@ -0,0 +1,99 @@
+#ifndef ALIMUONRAWCLUSTERV2_H
+#define ALIMUONRAWCLUSTERV2_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+// Revision of includes 07/05/2004
+
+/// \ingroup base
+/// \class AliMUONRawClusterV2
+/// \brief MUON raw cluster
+///
+//  Author Philippe Pillot, Subatech
+
+#include "AliMUONVCluster.h"
+#include <TMath.h>
+
+class AliMUONRawClusterV2 : public AliMUONVCluster {
+
+ public:
+  AliMUONRawClusterV2();
+  AliMUONRawClusterV2(Int_t chamberId, Int_t detElemId, Int_t clusterIndex);
+  virtual ~AliMUONRawClusterV2();
+  AliMUONRawClusterV2(const AliMUONRawClusterV2& cluster);
+  AliMUONRawClusterV2 & operator=(const AliMUONRawClusterV2& cluster);
+  
+  virtual void Clear(Option_t* = "");
+  
+          /// Set coordinates (cm)
+  virtual void     SetXYZ(Double_t x, Double_t y, Double_t z) {fX = x; fY = y; fZ = z;}
+          /// Return coordinate X (cm)
+  virtual Double_t GetX() const {return fX;}
+          /// Return coordinate Y (cm)
+  virtual Double_t GetY() const {return fY;}
+          /// Return coordinate Z (cm)
+  virtual Double_t GetZ() const {return fZ;}
+  
+          /// Set resolution (cm) on coordinates (X,Y)
+  virtual void     SetErrXY(Double_t errX, Double_t errY) {fErrX2 = errX * errX; fErrY2 = errY * errY;}
+           /// Return resolution (cm) on coordinate X
+  virtual Double_t GetErrX() const {return TMath::Sqrt(fErrX2);}
+           /// Return resolution**2 (cm**2) on coordinate X
+  virtual Double_t GetErrX2() const {return fErrX2;}
+           /// Return resolution (cm) on coordinate Y
+  virtual Double_t GetErrY() const {return TMath::Sqrt(fErrY2);}
+           /// Return resolution**2 (cm**2) on coordinate Y
+  virtual Double_t GetErrY2() const {return fErrY2;}
+  
+           /// Set the cluster charge
+  virtual void     SetCharge(Double_t q) {fQ = q;}
+           /// Set the cluster charge
+  virtual Double_t GetCharge() const {return fQ;}
+  
+           /// Return chamber Id
+  virtual Int_t    GetChamberId() const {return AliMUONVCluster::GetChamberId(GetUniqueID());}
+           /// Return detection element id
+  virtual Int_t    GetDetElemId() const {return AliMUONVCluster::GetDetElemId(GetUniqueID());}
+  
+  virtual void     SetDigitsId(Int_t nDigits, const UInt_t *digitsId);
+           /// Add a digit Id to the array of associated digits
+  virtual void     AddDigitId(UInt_t id);
+           /// Return number of associated digits
+  virtual Int_t    GetNDigits() const {return fNDigits;}
+           /// Return Id of digits i
+  virtual UInt_t   GetDigitId(Int_t i) const {return (i < fNDigits && fDigitsId) ? fDigitsId[i] : 0;}
+  
+           /// Set chi2 of cluster
+  virtual void     SetChi2( Double_t chi2) {fChi2 = chi2;}
+           /// Return chi2 of cluster
+  virtual Double_t GetChi2() const {return fChi2;}
+  
+  /// Return true as the function Compare() is implemented
+  Bool_t       IsSortable() const {return kTRUE;}
+  Int_t        Compare(const TObject *obj) const;
+  
+  
+private:
+  
+  Double32_t fX;       ///< X of cluster
+  Double32_t fY;       ///< Y of cluster
+  Double32_t fZ;       ///< Z of cluster
+  
+  Double32_t fErrX2;   ///< X coordinate error square
+  Double32_t fErrY2;   ///< Y coordinate error square
+  
+  Double32_t fQ;       ///< Q of cluster (in ADC counts)
+  
+  Double32_t fChi2;    ///< Chi2 of cluster
+  
+  Int_t    fNDigits;   ///< Number of digits attached to the cluster
+  /// Indices of digits attached to the cluster
+  UInt_t   *fDigitsId; //[fNDigits] Indices of digits attached to the cluster
+  
+  
+  ClassDef(AliMUONRawClusterV2,1)  //Cluster class for MUON
+};
+
+#endif
index 421ebcf..2507049 100644 (file)
@@ -31,9 +31,7 @@
 ///
 /// SIMPLEFIT : use the AliMUONClusterFinderSimpleFit clusterizer
 ///
-/// AZ : use the AliMUONClusterFinderAZ clusterizer (default)
-///
-/// MLEM : another implementation of AZ, where preclustering is external
+/// MLEM : another implementation of AZ, where preclustering is external (default)
 /// MLEMV3 : MLEM with preclustering=PRECLUSTERV2
 /// MLEMV3 : MLEM with preclustering=PRECLUSTERV3
 ///
@@ -71,9 +69,8 @@
 #include "AliMUONClusterFinderCOG.h"
 #include "AliMUONClusterFinderMLEM.h"
 #include "AliMUONClusterFinderSimpleFit.h"
-#include "AliMUONClusterFinderAZ.h"
 #include "AliMUONClusterReconstructor.h"
-#include "AliMUONClusterStoreV1.h"
+#include "AliMUONClusterStoreV2.h"
 #include "AliMUONConstants.h"
 #include "AliMUONDigitCalibrator.h"
 #include "AliMUONDigitMaker.h"
@@ -97,7 +94,7 @@
 #include <TClonesArray.h>
 #include <TString.h>
 #include <TTree.h>
-//#include "AliCodeTimer.h"
+
 /// \cond CLASSIMP
 ClassImp(AliMUONReconstructor)
 /// \endcond 
@@ -190,7 +187,7 @@ AliMUONReconstructor::ClusterStore() const
   /// Return (and create if necessary) the cluster container
   if (!fClusterStore) 
   {
-    fClusterStore = new AliMUONClusterStoreV1;
+    fClusterStore = new AliMUONClusterStoreV2;
   }
   return fClusterStore;
 }
@@ -217,6 +214,7 @@ void
 AliMUONReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree) const
 {
    /// convert raw data into a digit tree
+  AliCodeTimerAuto("")
 
   Bool_t alone = ( TriggerStore() == 0 );
   
@@ -233,7 +231,9 @@ AliMUONReconstructor::ConvertDigits(AliRawReader* rawReader, TTree* digitsTree)
   else
   {
     ConvertDigits(rawReader,DigitStore(),TriggerStore());
+    AliCodeTimerStart("Fill digits")
     digitsTree->Fill();
+    AliCodeTimerStop("Fill digits")
     DigitStore()->Clear();
   }
 }
@@ -359,14 +359,10 @@ AliMUONReconstructor::CreateClusterReconstructor() const
   {
     clusterFinder = new AliMUONClusterFinderMLEM(kFALSE,new AliMUONPreClusterFinder);
   } 
-  else if ( strstr(opt,"AZ") )
-  {
-    clusterFinder = new AliMUONClusterFinderAZ;
-  }
   else
   {
-    // default is currently AZ
-    clusterFinder = new AliMUONClusterFinderAZ;
+    // default is currently MLEM
+    clusterFinder = new AliMUONClusterFinderMLEM(kFALSE,new AliMUONPreClusterFinder);
   }
   
   if ( clusterFinder ) 
@@ -534,7 +530,7 @@ AliMUONReconstructor::Reconstruct(TTree* digitsTree, TTree* clustersTree) const
   /// This method is called by AliReconstruction if HasLocalReconstruction()==kTRUE
   /// AND HasDigitConversion()==kTRUE
   
-//  AliCodeTimerAuto("(TTree*,TTree*)")
+  AliCodeTimerAuto("")
   
   AliDebug(1,"");
   
index 3c38ab3..08930b7 100644 (file)
@@ -798,7 +798,7 @@ void AliMUONTrackExtrap::ExtrapOneStepHelix(Double_t charge, Double_t step, Doub
 ///    *   output                                                       *
 ///    *     VOUT = same as VECT after completion of the step           *
 ///    *                                                                *
-///    *    ==>Called by : <USER>, GUSWIM                               *
+///    *    ==>Called by : USER, GUSWIM                               *
 ///    *       Author    m.hansroul  *********                          *
 ///    *       modified  s.egli, s.v.levonian                           *
 ///    *       modified  v.perevoztchikov
@@ -911,7 +911,7 @@ void AliMUONTrackExtrap::ExtrapOneStepHelix3(Double_t field, Double_t step, Doub
 ///    *       Tracking is performed with a conventional                *
 ///    *       helix step method                                        *
 ///    *                                                                *
-///    *    ==>Called by : <USER>, GUSWIM                               *
+///    *    ==>Called by : USER, GUSWIM                                 *
 ///    *       Authors    R.Brun, M.Hansroul  *********                 *
 ///    *       Rewritten  V.Perevoztchikov
 ///    *                                                                *
@@ -997,7 +997,7 @@ void AliMUONTrackExtrap::ExtrapOneStepRungekutta(Double_t charge, Double_t step,
 ///    *  User routine called                                           *
 ///    *       CALL GUFLD(X,F)                                          *
 ///    *                                                                *
-///    *    ==>Called by : <USER>, GUSWIM                               *
+///    *    ==>Called by : USER, GUSWIM                                 *
 ///    *       Authors    R.Brun, M.Hansroul  *********                 *
 ///    *                  V.Perevoztchikov (CUT STEP implementation)    *
 ///    *                                                                *
index caf0493..8b7a695 100644 (file)
@@ -45,6 +45,7 @@
 #include "AliESDMuonTrack.h"
 #include "AliESDVertex.h"
 #include "AliLog.h"
+#include "AliCodeTimer.h"
 
 #include <Riostream.h>
 #include <TTree.h>
@@ -148,8 +149,8 @@ AliMUONTracker::Clusters2Tracks(AliESDEvent* esd)
 Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESDEvent* esd)
 {
   /// Performs the tracking
-  
   AliDebug(1,"");
+  AliCodeTimerAuto("")
   
   AliMUONVTrackStore* trackStore(0x0);
   AliMUONVTriggerTrackStore* triggerTrackStore(0x0);
@@ -178,10 +179,12 @@ Int_t AliMUONTracker::Clusters2Tracks(TTree& tracksTree, AliESDEvent* esd)
   }
   
   // Fills output TreeT 
-  tracksTree.Fill();
+  //tracksTree.Fill();
 
   if( trackStore && triggerTrackStore && fTriggerStore && fTrigChamberEff){
+      AliCodeTimerStart("EventChamberEff");
       fTrigChamberEff->EventChamberEff(*fTriggerStore,*triggerTrackStore,*trackStore);
+      AliCodeTimerStop("EventChamberEff");
   }
 
   FillESD(*trackStore,esd);
@@ -198,8 +201,8 @@ void
 AliMUONTracker::FillESD(AliMUONVTrackStore& trackStore, AliESDEvent* esd) const
 {
   /// Fill the ESD from the trackStore
-  
   AliDebug(1,"");
+  AliCodeTimerAuto("")
   
   // Get vertex 
   Double_t vertex[3] = {0};
diff --git a/MUON/AliMUONVCluster.cxx b/MUON/AliMUONVCluster.cxx
new file mode 100644 (file)
index 0000000..3a049d2
--- /dev/null
@@ -0,0 +1,79 @@
+/**************************************************************************
+* 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$
+
+//-----------------------------------------------------------------------------
+/// \class AliMUONVCluster
+///
+/// An abstract base class for clusters
+///
+/// \author Philippe Pillot, Subatech
+//-----------------------------------------------------------------------------
+
+#include "AliMUONVCluster.h"
+
+#include "AliLog.h"
+
+#include <Riostream.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONVCluster)
+/// \endcond
+
+const Double_t AliMUONVCluster::fgkDefaultNonBendingReso = 0.144;
+const Double_t AliMUONVCluster::fgkDefaultBendingReso = 0.01;
+
+//_____________________________________________________________________________
+AliMUONVCluster::AliMUONVCluster()
+{
+  /// default constructor
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster::AliMUONVCluster(Int_t chamberId, Int_t detElemId, Int_t clusterIndex)
+  : TObject() 
+{
+  /// constructor
+  SetUniqueID(BuildUniqueID(chamberId, detElemId, clusterIndex));
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster::~AliMUONVCluster()
+{
+  /// destructor
+}
+
+//_____________________________________________________________________________
+void AliMUONVCluster::Print(Option_t *option) const
+{
+  /// print cluster content
+  /// if option=FULL print also all Digit ID
+  UInt_t cId = GetUniqueID();
+  Int_t nDigits = GetNDigits();
+  
+  cout<<Form("clusterID=%u (ch=%d, det=%d, index=%d)",
+            cId,GetChamberId(),GetDetElemId(),GetClusterIndex(cId))<<endl;
+  
+  cout<<Form("position=(%5.2f, %5.2f, %5.2f), sigma=(%5.2f, %5.2f, 0.0), charge=%5.2f, chi2=%5.2f",
+            GetX(),GetY(),GetZ(),GetErrX(),GetErrY(),GetCharge(),GetChi2())<<endl;
+  
+  if (strcmp(option,"FULL") == 0) {
+    cout<<"nDigits="<<nDigits<<" digitID=(";
+    for (Int_t i=0; i<nDigits; i++) cout<<GetDigitId(i)<<", ";
+    cout<<")"<<endl;
+  }
+  
+}
diff --git a/MUON/AliMUONVCluster.h b/MUON/AliMUONVCluster.h
new file mode 100644 (file)
index 0000000..1bf1581
--- /dev/null
@@ -0,0 +1,89 @@
+#ifndef ALIMUONVCLUSTER_H
+#define ALIMUONVCLUSTER_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONVCluster
+/// \brief abstract base class for clusters
+/// 
+//  Author Philippe Pillot, Subatech
+
+
+#include <TObject.h>
+
+class AliMUONVCluster : public TObject {
+ public:
+  AliMUONVCluster(); // Constructor
+  AliMUONVCluster(Int_t chamberId, Int_t detElemId, Int_t clusterIndex);
+  virtual ~AliMUONVCluster(); // Destructor
+  
+           /// Clear method (used by TClonesArray)
+  virtual void Clear(Option_t*) = 0;
+  
+           /// Set coordinates (cm)
+  virtual void     SetXYZ(Double_t x, Double_t y, Double_t z) = 0;
+           /// Return coordinate X (cm)
+  virtual Double_t GetX() const = 0;
+           /// Return coordinate Y (cm)
+  virtual Double_t GetY() const = 0;
+           /// Return coordinate Z (cm)
+  virtual Double_t GetZ() const = 0;
+  
+           /// Set resolution (cm) on coordinates (X,Y)
+  virtual void     SetErrXY(Double_t errX, Double_t errY) = 0;
+           /// Return resolution (cm) on coordinate X
+  virtual Double_t GetErrX() const = 0;
+           /// Return resolution**2 (cm**2) on coordinate X
+  virtual Double_t GetErrX2() const = 0;
+           /// Return resolution (cm) on coordinate Y
+  virtual Double_t GetErrY() const = 0;
+           /// Return resolution**2 (cm**2) on coordinate Y
+  virtual Double_t GetErrY2() const = 0;
+  
+           /// Set the cluster charge
+  virtual void     SetCharge(Double_t charge) = 0;
+           /// Set the cluster charge
+  virtual Double_t GetCharge() const = 0;
+  
+           /// Build a single integer with id information
+  static  UInt_t   BuildUniqueID(Int_t chamberId, Int_t detElemId, Int_t clusterIndex)
+                       {return ((chamberId << 28) | (detElemId << 17) | (clusterIndex));}
+           /// Return chamber id (0..), part of the uniqueID
+  static  Int_t    GetChamberId(UInt_t uniqueID)    {return (uniqueID & 0xF0000000) >> 28;}
+           /// Return detection element id, part of the uniqueID
+  static  Int_t    GetDetElemId(UInt_t uniqueID)    {return (uniqueID & 0x0FFE0000) >> 17;}
+           /// The index of this cluster (0..), part of the uniqueID
+  static  Int_t    GetClusterIndex(UInt_t uniqueID) {return (uniqueID & 0x0001FFFF);}
+           /// Return chamber Id
+  virtual Int_t    GetChamberId() const = 0;
+           /// Return detection element Id
+  virtual Int_t    GetDetElemId() const = 0;
+  
+           /// Set Id of associated digits
+  virtual void     SetDigitsId(Int_t nDigits, const UInt_t *digitsId) = 0;
+           /// Add a digit Id to the array of associated digits
+  virtual void     AddDigitId(UInt_t id) = 0;
+           /// Return number of associated digits
+  virtual Int_t    GetNDigits() const = 0;
+           /// Return Id of digits i
+  virtual UInt_t   GetDigitId(Int_t i) const = 0;
+  
+           /// Set chi2 of cluster
+  virtual void     SetChi2(Double_t chi2) = 0;
+           /// Return chi2 of cluster
+  virtual Double_t GetChi2() const = 0;
+  
+  virtual void     Print(Option_t *option = "") const;
+  
+ protected:
+  static const Double_t fgkDefaultNonBendingReso; ///< default chamber resolution in the non-bending direction
+  static const Double_t fgkDefaultBendingReso; ///< default chamber resolution in the bending direction
+  
+  ClassDef(AliMUONVCluster, 1) // abstract base class for cluster
+};
+       
+#endif
index 9c4b7f0..e8320ac 100644 (file)
 ///
 /// An interface of a cluster container
 ///
-/// Please note that the the object stored are currently supposed to 
-/// be concrete class AliMUONRawCluster.
-/// This is likely to change to something like AliMUONVCluster...
+/// The object stored are inherited from AliMUONVCluster
 ///
 /// \author Laurent Aphecetche, Subatech
 //-----------------------------------------------------------------------------
 
 #include "AliMUONVClusterStore.h"
-#include "AliMUONRawCluster.h"
+#include "AliMUONVCluster.h"
 
 /// \cond CLASSIMP
 ClassImp(AliMUONVClusterStore)
@@ -51,7 +49,7 @@ Bool_t
 AliMUONVClusterStore::Add(TObject* object)
 {
   /// Add an object, if it is of the right class
-  AliMUONRawCluster* cluster = dynamic_cast<AliMUONRawCluster*>(object);
+  AliMUONVCluster* cluster = dynamic_cast<AliMUONVCluster*>(object);
   if (cluster)
   {
     Add(*cluster);
@@ -67,3 +65,21 @@ AliMUONVClusterStore::Create(TTree& tree)
   /// Create a VClusterStore from the tree
   return static_cast<AliMUONVClusterStore*>(AliMUONVStore::Create(tree,"Cluster"));
 }
+
+//______________________________________________________________________________
+AliMUONVCluster* AliMUONVClusterStore::FindObject(const TObject *obj) const
+{
+  /// Find an object, if of AliMUONVCluster type
+  const AliMUONVCluster* cluster = dynamic_cast<const AliMUONVCluster*>(obj);
+  if (cluster)
+    return static_cast<AliMUONVCluster*>(AliMUONVStore::FindObject(obj));
+  return 0x0;
+}
+
+//_____________________________________________________________________________
+AliMUONVCluster* AliMUONVClusterStore::FindObject(UInt_t uniqueID) const
+{
+  /// Find an object by its uniqueID (default is the same as in AliMUONVStore)
+  return static_cast<AliMUONVCluster*>(AliMUONVStore::FindObject(uniqueID));
+}
+
index d151fb4..1e37d17 100644 (file)
 #  include "AliMUONVStore.h"
 #endif
 
-class AliMUONRawCluster;
+#ifndef ALIMUONVCLUSTER_H
+#  include "AliMUONVCluster.h" // must be there for covariant return type of FindObjet methods
+#endif
+
+class AliMUONVCluster;
 
 class AliMUONVClusterStore : public AliMUONVStore
 {
@@ -27,24 +31,39 @@ public:
   virtual Bool_t Add(TObject* object);
 
   /// Add a cluster object to the store
-  virtual Bool_t Add(const AliMUONRawCluster& Cluster) = 0;
+  virtual Bool_t Add(const AliMUONVCluster& Cluster) = 0;
+  /// Create a new cluster with an unique ID and add it to the store
+  virtual AliMUONVCluster* Add(Int_t chamberId, Int_t detElemId, Int_t clusterIndex) = 0;
 
   using AliMUONVStore::Create;
   
   static AliMUONVClusterStore* Create(TTree& tree);
   
+  /// Create a cluster
+  virtual AliMUONVCluster* CreateCluster(Int_t chamberId, Int_t detElemId, Int_t clusterIndex) const = 0;
+  
   /// Return an iterator to loop over the whole store
   virtual TIterator* CreateIterator() const = 0;
 
   /// Return an iterator to loop over the store in the given chamber range
   virtual TIterator* CreateChamberIterator(Int_t firstChamberId, Int_t lastChamberId) const = 0;
-
+  
+  /// Clear container
+  virtual void Clear(Option_t* opt="") = 0;
+  
   /// Remove a cluster object to the store
-  virtual AliMUONRawCluster* Remove(AliMUONRawCluster& cluster) = 0;
+  virtual AliMUONVCluster* Remove(AliMUONVCluster& cluster) = 0;
     
-  using AliMUONVStore::GetSize;
+  using AliMUONVStore::FindObject;
+
+  // Find an object (default is the same as in AliMUONVStore)
+  virtual AliMUONVCluster* FindObject(const TObject* object) const;
+  
+  // Find an object by its uniqueID (default is the same as in AliMUONVStore)
+  virtual AliMUONVCluster* FindObject(UInt_t uniqueID) const;
   
   ClassDef(AliMUONVClusterStore,1) // Cluster container interface
 };
 
 #endif
+
index 1d46d30..63a2365 100644 (file)
@@ -52,7 +52,6 @@
 #include "AliMUONVTrackReconstructor.h"
 
 #include "AliMUONConstants.h"
-#include "AliMUONRawCluster.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONObjectPair.h"
 #include "AliMUONTriggerTrack.h"
@@ -65,7 +64,7 @@
 #include "AliMUONTrackHitPattern.h"
 #include "AliMUONVTrackStore.h"
 #include "AliMUONVClusterStore.h"
-#include "AliMUONRawCluster.h"
+#include "AliMUONVCluster.h"
 #include "AliMUONVTriggerStore.h"
 #include "AliMUONVTriggerTrackStore.h"
 #include "AliMpDEManager.h"
@@ -188,19 +187,20 @@ void AliMUONVTrackReconstructor::AddHitsForRecFromRawClusters(const AliMUONVClus
 {
   /// Build internal array of hit for rec from clusterStore
   
-  TIter next(clusterStore.CreateIterator());
-  AliMUONRawCluster* clus(0x0);
+  AliMUONVCluster* clus(0x0);
   Int_t iclus(0);
   
-  while ( ( clus = static_cast<AliMUONRawCluster*>(next()) ) )
+  TIter next(clusterStore.CreateIterator());
+  
+  while ( ( clus = static_cast<AliMUONVCluster*>(next()) ) )
   {
     // new AliMUONHitForRec from raw cluster
     // and increment number of AliMUONHitForRec's (total and in chamber)
     AliMUONHitForRec* hitForRec = new ((*fHitsForRecPtr)[fNHitsForRec]) AliMUONHitForRec(clus);
     fNHitsForRec++;
     // more information into HitForRec
-    hitForRec->SetBendingReso2(clus->GetErrY() * clus->GetErrY());
-    hitForRec->SetNonBendingReso2(clus->GetErrX() * clus->GetErrX());
+    hitForRec->SetNonBendingReso2(clus->GetErrX2());
+    hitForRec->SetBendingReso2(clus->GetErrY2());
     //  original raw cluster
     Int_t ch = AliMpDEManager::GetChamberId(clus->GetDetElemId());
     hitForRec->SetChamberNumber(ch);
index b5ad1fe..eef1a29 100644 (file)
@@ -30,7 +30,7 @@
 #include <TIterator.h>
 #include "AliMUONHit.h"
 #include "AliMUONVDigit.h"
-#include "AliMUONRawCluster.h"
+#include "AliMUONVCluster.h"
 #include "AliMUONTrack.h"
 #include "AliMUONLocalTrigger.h"
 #include "AliMUONRegionalTrigger.h"
@@ -357,8 +357,8 @@ bool RawClustersOk()
                clustersFromStore.SetOwner(kTRUE);
                AliMUONVClusterStore* store = data.ClusterStore(event);
                TIter next(store->CreateIterator());
-               AliMUONRawCluster* cluster;
-               while ( (cluster = static_cast<AliMUONRawCluster*>( next() )) != NULL )
+               AliMUONVCluster* cluster;
+               while ( (cluster = static_cast<AliMUONVCluster*>( next() )) != NULL )
                {
                        clustersFromStore.Add(cluster->Clone());
                }
@@ -372,7 +372,7 @@ bool RawClustersOk()
                        Int_t nclusters = data.NumberOfRawClusters(chamber);
                        for (Int_t i = 0; i < nclusters; i++)
                        {
-                               AliMUONRawCluster* cluster = data.RawCluster(chamber, i);
+                               AliMUONVCluster* cluster = data.RawCluster(chamber, i);
                                clustersByChamber.Add(cluster->Clone());
                        }
                }
index b514fcd..de23626 100644 (file)
@@ -64,7 +64,6 @@
 
 #include "AliMUONHit.h"
 #include "AliMUONHitForRec.h"
-#include "AliMUONRawCluster.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONTrackExtrap.h"
index 5eb407e..a8ab4b1 100644 (file)
@@ -44,7 +44,6 @@
 #include "AliMUONHit.h"
 #include "AliMUONConstants.h"
 #include "AliMUONDigit.h"
-#include "AliMUONRawCluster.h"
 #include "AliMUONGlobalTrigger.h"
 #include "AliMUONTrack.h"