More efficient implementation(s) of AliMUONVDigitStore (Laurent)
authorivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Jul 2007 16:38:08 +0000 (16:38 +0000)
committerivana <ivana@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 2 Jul 2007 16:38:08 +0000 (16:38 +0000)
MUON/AliMUONDigitStoreV2R.cxx [new file with mode: 0644]
MUON/AliMUONDigitStoreV2R.h [new file with mode: 0644]
MUON/AliMUONDigitStoreV2S.cxx [new file with mode: 0644]
MUON/AliMUONDigitStoreV2S.h [new file with mode: 0644]
MUON/AliMUONDigitStoreVImpl.cxx [new file with mode: 0644]
MUON/AliMUONDigitStoreVImpl.h [new file with mode: 0644]
MUON/AliMUONDigitStoreVImplIterator.cxx [new file with mode: 0644]
MUON/AliMUONDigitStoreVImplIterator.h [new file with mode: 0644]
MUON/AliMUONRealDigit.cxx [new file with mode: 0644]
MUON/AliMUONRealDigit.h [new file with mode: 0644]

diff --git a/MUON/AliMUONDigitStoreV2R.cxx b/MUON/AliMUONDigitStoreV2R.cxx
new file mode 100644 (file)
index 0000000..fabe407
--- /dev/null
@@ -0,0 +1,85 @@
+/**************************************************************************
+* 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 AliMUONDigitStoreV2R
+///
+/// Concrete implementation of AliMUONVDigitStore for real digits, using
+/// the AliMUONDigitStoreVImpl base implementation
+/// 
+/// \author Laurent Aphecetche
+
+#include "AliMUONDigitStoreV2R.h"
+
+#include "AliLog.h"
+#include "AliMUONRealDigit.h"
+#include <TClonesArray.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONDigitStoreV2R)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONDigitStoreV2R::AliMUONDigitStoreV2R()
+: AliMUONDigitStoreVImpl("AliMUONRealDigit")
+{
+  /// ctor
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreV2R::~AliMUONDigitStoreV2R()
+{
+  /// dtor
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit*
+AliMUONDigitStoreV2R::AddConcreteDigit(TClonesArray& a, 
+                                       const AliMUONVDigit& digit,
+                                       Int_t index)
+{
+  /// Add a digit to this store
+  
+  const AliMUONRealDigit* d = dynamic_cast<const AliMUONRealDigit*>(&digit);
+  
+  if ( !d ) 
+  {
+    AliError(Form("Digit (of class %s) is not of the expected type AliMUONRealDigit",
+                  digit.ClassName()));
+    return 0x0;
+  }
+  
+  return new(a[index]) AliMUONRealDigit(*d);
+}
+
+//_____________________________________________________________________________
+AliMUONVDigitStore* 
+AliMUONDigitStoreV2R::Create() const
+{
+  /// Create an empty store
+  return new AliMUONDigitStoreV2R;
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreV2R::CreateDigit(Int_t detElemId, Int_t manuId,                                 
+                                  Int_t manuChannel, Int_t cathode) const
+{
+  /// Create a digit that is compatible with this store
+  return new AliMUONRealDigit(detElemId,manuId,manuChannel,cathode);
+}
+
+
diff --git a/MUON/AliMUONDigitStoreV2R.h b/MUON/AliMUONDigitStoreV2R.h
new file mode 100644 (file)
index 0000000..3fdf89e
--- /dev/null
@@ -0,0 +1,39 @@
+#ifndef ALIMUONDIGITSTOREV2R_H
+#define ALIMUONDIGITSTOREV2R_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONDigitStoreV2R
+/// \brief Concrete implementation of AliMUONVDigitStore for real digits
+/// 
+// author Laurent Aphecetche
+
+#ifndef ALIMUONDIGITSTOREVIMPL_H
+#  include "AliMUONDigitStoreVImpl.h"
+#endif
+
+class AliMUONDigitStoreV2R : public AliMUONDigitStoreVImpl
+{
+public:
+  AliMUONDigitStoreV2R();
+  virtual ~AliMUONDigitStoreV2R();
+  
+  virtual AliMUONVDigitStore* Create() const;
+
+  virtual AliMUONVDigit* CreateDigit(Int_t detElemId, Int_t manuId,
+                                     Int_t manuChannel, Int_t cathode) const;
+
+protected:
+    
+    virtual AliMUONVDigit* AddConcreteDigit(TClonesArray& a, 
+                                            const AliMUONVDigit& digit,
+                                            Int_t index);
+
+  ClassDef(AliMUONDigitStoreV2R,1) // Implementation of AliMUONVDigitStore
+};
+
+#endif
diff --git a/MUON/AliMUONDigitStoreV2S.cxx b/MUON/AliMUONDigitStoreV2S.cxx
new file mode 100644 (file)
index 0000000..2d77dcc
--- /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$
+
+#include "AliMUONDigitStoreV2S.h"
+
+/// \class AliMUONDigitStoreV2S
+///
+/// Concrete implementation of AliMUONVDigitStore for simulated digits, using
+/// the AliMUONDigitStoreVImpl base implementation
+/// 
+/// \author Laurent Aphecetche
+
+
+#include "AliMUONDigit.h"
+#include <TClonesArray.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONDigitStoreV2S)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONDigitStoreV2S::AliMUONDigitStoreV2S()
+: AliMUONDigitStoreVImpl("AliMUONDigit")
+{
+  /// ctor
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreV2S::~AliMUONDigitStoreV2S()
+{
+  /// dtor
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit*
+AliMUONDigitStoreV2S::AddConcreteDigit(TClonesArray& a, 
+                                       const AliMUONVDigit& digit,
+                                       Int_t index)
+{
+  /// add a digit to this store
+  const AliMUONDigit* d = dynamic_cast<const AliMUONDigit*>(&digit);
+  
+  if ( !d ) return 0x0;
+  
+  return new(a[index]) AliMUONDigit(*d);
+}
+
+//_____________________________________________________________________________
+AliMUONVDigitStore* 
+AliMUONDigitStoreV2S::Create() const
+{
+  /// create an empty store
+  return new AliMUONDigitStoreV2S;
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreV2S::CreateDigit(Int_t detElemId, Int_t manuId,                                 
+                                  Int_t manuChannel, Int_t cathode) const
+{
+  /// create a digit, compatible with this store
+  return new AliMUONDigit(detElemId,manuId,manuChannel,cathode);
+}
+
+
diff --git a/MUON/AliMUONDigitStoreV2S.h b/MUON/AliMUONDigitStoreV2S.h
new file mode 100644 (file)
index 0000000..34d0a20
--- /dev/null
@@ -0,0 +1,39 @@
+#ifndef ALIMUONDIGITSTOREV2S_H
+#define ALIMUONDIGITSTOREV2S_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONDigitStoreV2S
+/// \brief Implementation of AliMUONVDigitStore
+/// 
+// author Laurent Aphecetche
+
+#ifndef ALIMUONDIGITSTOREVIMPL_H
+#  include "AliMUONDigitStoreVImpl.h"
+#endif
+
+class AliMUONDigitStoreV2S : public AliMUONDigitStoreVImpl
+{
+public:
+  AliMUONDigitStoreV2S();
+  virtual ~AliMUONDigitStoreV2S();
+  
+  virtual AliMUONVDigitStore* Create() const;
+
+  virtual AliMUONVDigit* CreateDigit(Int_t detElemId, Int_t manuId,
+                                     Int_t manuChannel, Int_t cathode) const;
+
+protected:
+    
+    virtual AliMUONVDigit* AddConcreteDigit(TClonesArray& a, 
+                                            const AliMUONVDigit& digit,
+                                            Int_t index);
+
+  ClassDef(AliMUONDigitStoreV2S,1) // Implementation of AliMUONVDigitStore
+};
+
+#endif
diff --git a/MUON/AliMUONDigitStoreVImpl.cxx b/MUON/AliMUONDigitStoreVImpl.cxx
new file mode 100644 (file)
index 0000000..4808d39
--- /dev/null
@@ -0,0 +1,388 @@
+/**************************************************************************
+* 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 AliMUONDigitStoreVImpl
+///
+/// Base implementation of VDigitStore, where digits are simply put
+/// within a single TClonesArray (to get compact output on disk) and
+/// fast search is achieved by using a separate index (a 2Dmap)
+///
+/// Note that this class is a base implementation only, because to add
+/// a digit to a TClonesArray, you need to give the concrete class
+/// name (made in subclass by overriding :
+///
+/// AliMUONVDigit* AddConcreteDigit(TClonesArray&,const AliMUONVDigit&, Int_t)
+///
+/// and
+///
+/// AliMUONVDigit* CreateDigit((Int_t detElemId, Int_t manuId,
+/// Int_t manuChannel, Int_t cathode) const
+/// 
+/// methods.
+///
+/// \author Laurent Aphecetche
+
+#include "AliMUONDigitStoreVImpl.h"
+
+#include "AliLog.h"
+#include "AliMUONDigitStoreVImplIterator.h"
+#include "AliMUON2DMap.h"
+#include "AliMUONTreeManager.h"
+#include "AliMUONCalibParamNI.h"
+#include "AliMpConstants.h"
+#include <TClonesArray.h>
+#include <TTree.h>
+#include <TString.h>
+#include <Riostream.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONDigitStoreVImpl)
+/// \endcond
+
+namespace
+{
+  TString BaseName(const TString& name)
+  {
+    /// Name of the branch, depending on the tree name
+    if ( name == "TreeS" ) return "MUONSDigit";
+    if ( name == "TreeD" ) return "MUONDigit";
+    return "";
+  }
+  
+  Int_t InternalManuId(Int_t cathode, Int_t manuId)
+  {
+    /// Very local convention to insure that trigger digits are not
+    /// mixed (as by default a same manuId can be in cath 0 or 1, which
+    /// is never the case for tracker)
+    ///
+    /// WARNING : the resulting manuId must still be contained within 16 bits !
+    ///
+    return manuId | ( cathode << 15 );
+  }
+  
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImpl::AliMUONDigitStoreVImpl(const char* concreteClassName)
+: AliMUONVDigitStore(),
+  fDigits(new TClonesArray(concreteClassName,100)),
+  fMap(0x0),
+  fIndexed(kFALSE)
+{
+    /// ctor
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImpl::AliMUONDigitStoreVImpl(const AliMUONDigitStoreVImpl&)
+: AliMUONVDigitStore(),
+fDigits(0x0),
+fMap(0x0),
+fIndexed(kFALSE)
+{
+  /// copy ctor
+  AliError("Please implement me");
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImpl& 
+AliMUONDigitStoreVImpl::operator=(const AliMUONDigitStoreVImpl&)
+{
+  /// assignement operator
+  AliError("Please implement me");
+  return *this;
+}
+
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImpl::~AliMUONDigitStoreVImpl()
+{
+  /// dtor
+  delete fDigits;
+  delete fMap;
+}
+
+//_____________________________________________________________________________
+Bool_t 
+AliMUONDigitStoreVImpl::Connect(TTree& tree, Bool_t alone) const
+{
+  /// Connect this to the tree.
+  
+  TString branchName(BaseName(tree.GetName()));
+  branchName += ".";
+  AliMUONTreeManager tman;
+  Bool_t ok;
+  
+  if (tree.GetBranch(branchName.Data()))
+  {
+    if ( alone ) tman.UpdateBranchStatuses(tree,BaseName(tree.GetName()));
+    ok = tman.SetAddress(tree,branchName.Data(),
+                         const_cast<TClonesArray**>(&fDigits));
+  }
+  else
+  {
+    ok = tman.MakeBranch(tree,ClassName(),"TClonesArray",branchName.Data(),
+                         const_cast<TClonesArray**>(&fDigits));
+  }
+  
+  return ok;
+}
+
+//_____________________________________________________________________________
+void 
+AliMUONDigitStoreVImpl::Clear(Option_t*)
+{
+  /// Clear the internal digit array AND the index
+  fDigits->Clear("C");
+  ClearIndex();
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigitStoreVImpl::ClearIndex()
+{
+  /// Clear our internal index
+  if ( fMap ) 
+  {
+    fMap->Clear();
+  }
+  else
+  {
+    fMap = new AliMUON2DMap(true);
+  }
+  fIndexed = kFALSE;
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreVImpl::Add(const AliMUONVDigit& vdigit, EReplacePolicy replace)
+{
+  /// Try to add a digit to the store. Return whether the try was successfull
+  /// or not.
+  /// 
+  /// If the digit is already there, the action taken depends on "replace"
+  /// kAllow -> replacement will occur (i.e. return kTRUE)
+  /// kDeny -> replacement will *not* occur (and returned value is kFALSE)
+  /// kMerge -> both digits will be merged into one (return kTRUE)
+  ///
+  
+  if ( replace != kIgnore )
+  {
+    AliMUONVDigit* alreadyThere = Find(vdigit);
+    if ( alreadyThere ) 
+    {
+      if ( replace == kDeny ) return 0x0;
+      if ( replace == kMerge )
+      {
+        alreadyThere->MergeWith(vdigit);
+        return alreadyThere;
+      }
+    }
+  }
+  
+  
+  Int_t n = fDigits->GetLast()+1;
+
+  AliMUONVDigit* d = AddConcreteDigit(*fDigits,vdigit,n);
+  
+  if ( d )
+  {
+    UpdateIndex(*d,n);
+  }
+  
+  return d;
+}
+
+//_____________________________________________________________________________
+TIterator* 
+AliMUONDigitStoreVImpl::CreateIterator() const
+{
+  /// Create an iterator over the full store
+  return fDigits->MakeIterator();
+}
+
+//_____________________________________________________________________________
+TIterator* 
+AliMUONDigitStoreVImpl::CreateIterator(Int_t firstDetElemId, 
+                                    Int_t lastDetElemId,
+                                    Int_t cathode) const
+{
+  /// Create an iterator on a given part of the store
+  (const_cast<AliMUONDigitStoreVImpl*>(this))->ReIndex();
+
+  return new AliMUONDigitStoreVImplIterator(this,firstDetElemId,lastDetElemId,cathode);
+}
+
+//_____________________________________________________________________________
+TIterator*
+AliMUONDigitStoreVImpl::CreateTrackerIterator() const
+{
+  /// Create an iterator to loop over tracker digits only
+  
+  (const_cast<AliMUONDigitStoreVImpl*>(this))->ReIndex();
+
+  return new AliMUONDigitStoreVImplIterator(this,100,1025);
+}
+
+//_____________________________________________________________________________
+TIterator* 
+AliMUONDigitStoreVImpl::CreateTriggerIterator() const
+{
+  /// Create an iterator to loop over trigger digits only
+  (const_cast<AliMUONDigitStoreVImpl*>(this))->ReIndex();
+
+  return new AliMUONDigitStoreVImplIterator(this,1100,1417);
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreVImpl::Find(const AliMUONVDigit& digit) const
+{
+  /// Find a given digit
+  /// Note that we only check for the id of the digit (i.e. de,manu,...)
+  /// not for the actual content (charge, ...) to decide whether
+  /// it's the same digit or not
+  
+  return FindObject(digit.DetElemId(),digit.ManuId(),digit.ManuChannel(),
+                    digit.Cathode());
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigitStoreVImpl::ReIndex()
+{
+  /// Recompute the fMap, which map (de,manu,ch) to an index within
+  /// the fDigits array
+  
+  if ( fIndexed ) return;
+  
+  ClearIndex();
+  
+  TIter next(fDigits);
+  AliMUONVDigit* d;
+  Int_t digitIndex(0);
+  
+  while ( ( d = static_cast<AliMUONVDigit*>(next()) ) )
+  {
+    UpdateIndex(*d,digitIndex++);
+  }
+  
+  fIndexed = kTRUE;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigitStoreVImpl::UpdateIndex(const AliMUONVDigit& digit, Int_t index)
+{
+  /// Update the internal index given this new digit
+  if (!fMap) fMap = new AliMUON2DMap(true);
+  
+  Int_t manuId = InternalManuId(digit.Cathode(),digit.ManuId());
+                        
+  AliMUONVCalibParam* param = 
+  static_cast<AliMUONVCalibParam*>
+  (fMap->FindObject(digit.DetElemId(),manuId));
+
+  if (!param)
+  {
+    param = new AliMUONCalibParamNI(1,64,digit.DetElemId(),manuId,-1);
+    fMap->Add(param);
+  }
+  param->SetValueAsInt(digit.ManuChannel(),0,index);
+  fIndexed = kTRUE;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDigitStoreVImpl::FindIndex(Int_t detElemId, Int_t internalManuId,
+                                  Int_t manuChannel) const
+{
+  /// Find the index of a given (de,internalManu,ch) triplet
+  
+  AliMUONVCalibParam* param = 
+  static_cast<AliMUONVCalibParam*>
+  (fMap->FindObject(detElemId,internalManuId));
+  
+  if (param)
+  {
+    return param->ValueAsInt(manuChannel);
+  }
+  
+  return -1;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONDigitStoreVImpl::FindIndex(const AliMUONVDigit& digit) const
+{
+  /// Find the index of a given digit
+  return FindIndex(digit.DetElemId(),
+                   InternalManuId(digit.Cathode(),digit.ManuId()),
+                   digit.ManuChannel());
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreVImpl::FindObject(UInt_t uniqueID) const
+{
+  /// Find digit by its uniqueID
+  
+  return FindObject(AliMUONVDigit::DetElemId(uniqueID),
+                    AliMUONVDigit::ManuId(uniqueID),
+                    AliMUONVDigit::ManuChannel(uniqueID),
+                    AliMUONVDigit::Cathode(uniqueID));
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreVImpl::FindObject(Int_t detElemId, Int_t manuId, Int_t manuChannel, 
+                                Int_t cathode) const
+{
+  /// Find a digit
+
+  (const_cast<AliMUONDigitStoreVImpl*>(this))->ReIndex();
+
+  Int_t index = FindIndex(detElemId,InternalManuId(cathode,manuId),manuChannel);
+  
+  if (index>=0 ) 
+  {
+    return static_cast<AliMUONVDigit*>(fDigits->UncheckedAt(index));
+  }
+  
+  return 0x0;
+}
+
+//_____________________________________________________________________________
+Int_t 
+AliMUONDigitStoreVImpl::GetSize() const
+{
+  /// Return the number of digits we hold
+  return fDigits->GetLast()+1;
+}
+
+//_____________________________________________________________________________
+AliMUONVDigit* 
+AliMUONDigitStoreVImpl::Remove(AliMUONVDigit& digit)
+{
+  /// Remove a digit
+  AliMUONVDigit* d = static_cast<AliMUONVDigit*>(fDigits->Remove(&digit));
+  if (d) 
+  {
+    UpdateIndex(*d,-1);
+  }
+  return d;
+}
+
diff --git a/MUON/AliMUONDigitStoreVImpl.h b/MUON/AliMUONDigitStoreVImpl.h
new file mode 100644 (file)
index 0000000..1be958e
--- /dev/null
@@ -0,0 +1,95 @@
+#ifndef ALIMUONDIGITSTOREVIMPL_H
+#define ALIMUONDIGITSTOREVIMPL_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONDigitStoreVImpl
+/// \brief Base implementation of VDigitStore
+/// 
+// author Laurent Aphecetche
+
+#ifndef ALIMUONVDIGITSTORE_H
+#  include "AliMUONVDigitStore.h"
+#endif
+
+class TClonesArray;
+class AliMUON2DMap;
+
+class AliMUONDigitStoreVImpl : public AliMUONVDigitStore
+{
+  friend class AliMUONDigitStoreVImplIterator;
+  
+public:
+  AliMUONDigitStoreVImpl(const char* concreteClassName);
+  AliMUONDigitStoreVImpl(const AliMUONDigitStoreVImpl& rhs);
+  AliMUONDigitStoreVImpl& operator=(const AliMUONDigitStoreVImpl& rhs);
+  virtual ~AliMUONDigitStoreVImpl();
+  
+  /// Whether we can be connected to a TTree
+  virtual Bool_t CanConnect() const { return kTRUE; }
+  
+  virtual Bool_t Connect(TTree& tree, Bool_t alone = kTRUE) const;
+  
+  virtual void Clear(Option_t* opt="");
+  
+  virtual AliMUONVDigit* CreateDigit(Int_t detElemId, Int_t manuId,
+                                     Int_t manuChannel, Int_t cathode) const = 0;
+  
+  using AliMUONVDigitStore::Add;
+  
+  virtual AliMUONVDigit* Add(const AliMUONVDigit& digit, EReplacePolicy replace);
+  
+  virtual TIterator* CreateIterator() const;
+  
+  virtual TIterator* CreateIterator(Int_t firstDetElemId, 
+                                    Int_t lastDetElemId,
+                                    Int_t cathode=2) const;
+  
+  virtual TIterator* CreateTrackerIterator() const;
+  
+  virtual TIterator* CreateTriggerIterator() const;
+  
+  using AliMUONVStore::FindObject;
+
+  virtual AliMUONVDigit* FindObject(UInt_t uniqueID) const;
+
+  virtual AliMUONVDigit* FindObject(Int_t detElemId, Int_t manuId, 
+                                    Int_t manuChannel, Int_t cathode) const;
+  
+  using AliMUONVDigitStore::GetSize;
+  
+  virtual Int_t GetSize() const;
+  
+  virtual AliMUONVDigit* Remove(AliMUONVDigit& digit);
+
+protected:
+  /// Add concrete digit
+  virtual AliMUONVDigit* AddConcreteDigit(TClonesArray& a, 
+                                          const AliMUONVDigit& digit,
+                                          Int_t index) = 0;
+  
+private:
+  
+  AliMUONVDigit* Find(const AliMUONVDigit& digit) const;
+  
+  void UpdateIndex(const AliMUONVDigit& digit, Int_t index);
+  
+  Int_t FindIndex(const AliMUONVDigit& digit) const;
+  Int_t FindIndex(Int_t detElemId, Int_t internalManuId, Int_t manuChannel) const;
+    
+  void ReIndex();
+  void ClearIndex();
+
+private:
+  TClonesArray* fDigits; ///< collection of digits
+  AliMUON2DMap* fMap; //!< index map for fast digit retrieval
+  Bool_t fIndexed; //!< whether our internal indices fDEs and fManus are uptodate
+  
+  ClassDef(AliMUONDigitStoreVImpl,1) // Implementation of AliMUONVDigitStore
+};
+
+#endif
diff --git a/MUON/AliMUONDigitStoreVImplIterator.cxx b/MUON/AliMUONDigitStoreVImplIterator.cxx
new file mode 100644 (file)
index 0000000..4f52508
--- /dev/null
@@ -0,0 +1,171 @@
+/**************************************************************************
+* 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 AliMUONDigitStoreVImplIterator
+///
+/// Implementation of AliMUONVDataIterator for AliMUONDigitStoreVImpl
+///
+/// \author Laurent Aphecetche, Subatech
+///
+
+#include "AliMUONDigitStoreVImplIterator.h"
+
+#include "AliMUONVDigit.h"
+#include "AliMUONDigitStoreVImpl.h"
+#include "AliMUON2DMap.h"
+#include "AliMUONVCalibParam.h"
+#include <TClonesArray.h>
+#include <TError.h>
+
+/// \cond CLASSIMP
+ClassImp(AliMUONDigitStoreVImplIterator)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImplIterator::AliMUONDigitStoreVImplIterator(const AliMUONDigitStoreVImpl* store)
+: TIterator(),
+fStore(store),
+fFirstDetElemId(100),
+fLastDetElemId(1417),
+fCathode(2),
+fStoreIterator(store->fMap->CreateIterator()),
+fCurrentCalibParam(0x0),
+fCurrentCalibParamIndex(-1)
+{
+  /// ctor for full iteration
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImplIterator::AliMUONDigitStoreVImplIterator(const AliMUONDigitStoreVImpl* store,
+                                                         Int_t firstDE,
+                                                         Int_t lastDE,
+                                                         Int_t cathode)
+: TIterator(),
+fStore(store),
+fFirstDetElemId(firstDE),
+fLastDetElemId(lastDE),
+fCathode(cathode),
+fStoreIterator(store->fMap->CreateIterator(firstDE,lastDE)),
+fCurrentCalibParam(0x0),
+fCurrentCalibParamIndex(-1)
+{
+  /// ctor for partial iteration
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImplIterator::AliMUONDigitStoreVImplIterator(const AliMUONDigitStoreVImplIterator& rhs)
+: TIterator(rhs),
+fStore(rhs.fStore),
+fFirstDetElemId(rhs.fFirstDetElemId),
+fLastDetElemId(rhs.fLastDetElemId),
+fCathode(rhs.fCathode),
+fStoreIterator(0x0),
+fCurrentCalibParam(0x0),
+fCurrentCalibParamIndex(-1)
+{
+  /// copy ctor
+  Fatal("AliMUONDigitStoreVImplIterator::copy tor","Not implementeable"); // because there's no clone in TIterator :-(
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImplIterator&
+AliMUONDigitStoreVImplIterator::operator=(const AliMUONDigitStoreVImplIterator&)
+{
+  /// assignment operator
+  Fatal("AliMUONDigitStoreVImplIterator::operator=","Not implementeable"); // because there's no clone in TIterator :-(
+  return *this;
+}
+
+//_____________________________________________________________________________
+TIterator&
+AliMUONDigitStoreVImplIterator::operator=(const TIterator&)
+{
+  /// overriden assignment operator (imposed by Root's declaration of Titerator ?)
+  Fatal("TIterator::operator=","Not implementeable"); // because there's no clone in TIterator :-(
+  return *this;
+}
+
+//_____________________________________________________________________________
+AliMUONDigitStoreVImplIterator::~AliMUONDigitStoreVImplIterator()
+{
+  /// dtor
+  delete fStoreIterator;
+}
+
+//_____________________________________________________________________________
+TObject*
+AliMUONDigitStoreVImplIterator::Next()
+{
+  /// Return next digit in store
+  if ( !fCurrentCalibParam ) 
+  {
+    fCurrentCalibParam = static_cast<AliMUONVCalibParam*>(fStoreIterator->Next());
+    fCurrentCalibParamIndex = 0;
+    if ( !fCurrentCalibParam ) return 0x0;
+  }
+
+  Int_t ix(-1);
+  AliMUONVDigit* d(0x0);
+  
+  if ( fCathode == 2 ) 
+  {
+    while ( fCurrentCalibParamIndex < 64 && ix < 0 )
+    {
+      ix = fCurrentCalibParam->ValueAsInt(fCurrentCalibParamIndex++);
+    };
+    
+    if (ix>=0)
+    {
+      d = static_cast<AliMUONVDigit*>(fStore->fDigits->UncheckedAt(ix));
+    }  
+  }
+  else
+  {
+  while ( fCurrentCalibParamIndex < 64 )
+  {
+    ix = fCurrentCalibParam->ValueAsInt(fCurrentCalibParamIndex++);
+    if (ix>=0)
+    {
+      d = static_cast<AliMUONVDigit*>(fStore->fDigits->UncheckedAt(ix));
+    
+      if (  fCathode == 2 || d->Cathode() == fCathode ) 
+      {
+        break;
+      }
+      d = 0x0;
+    }
+  }
+  }
+  
+  if (ix<0) 
+  {
+    fCurrentCalibParam = 0x0;
+    return Next();
+  }
+  
+  return d;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONDigitStoreVImplIterator::Reset()
+{
+  /// Reset the iterator
+  fCurrentCalibParam = 0x0;
+  fCurrentCalibParamIndex = 0;  
+  fStoreIterator->Reset();
+}
diff --git a/MUON/AliMUONDigitStoreVImplIterator.h b/MUON/AliMUONDigitStoreVImplIterator.h
new file mode 100644 (file)
index 0000000..9671f82
--- /dev/null
@@ -0,0 +1,55 @@
+#ifndef ALIMUONDIGITSTOREVIMPLITERATOR_H
+#define ALIMUONDIGITSTOREVIMPLITERATOR_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONDigitStoreVImplIterator
+/// \brief Base implementation of TIterator for AliMUONDigitStoreVImpl
+/// 
+// Author Laurent Aphecetche
+
+#ifndef ROOT_TIterator
+#  include "TIterator.h"
+#endif
+
+class AliMUONDigitStoreVImpl;
+class AliMUONVCalibParam;
+
+class AliMUONDigitStoreVImplIterator : public TIterator
+{
+public:
+  AliMUONDigitStoreVImplIterator(const AliMUONDigitStoreVImpl* store);
+  AliMUONDigitStoreVImplIterator(const AliMUONDigitStoreVImpl* store,
+                              Int_t firstDetElemId,
+                              Int_t lastDetElemId,
+                              Int_t cathode=2);
+  AliMUONDigitStoreVImplIterator(const AliMUONDigitStoreVImplIterator& rhs);
+  AliMUONDigitStoreVImplIterator& operator=(const AliMUONDigitStoreVImplIterator& rhs);
+  TIterator& operator=(const TIterator& rhs);
+  
+  virtual ~AliMUONDigitStoreVImplIterator();
+  
+  TObject* Next();
+  
+  void Reset();
+  
+  /// Return 0 as we're not dealing with TCollection objects really
+  virtual const TCollection* GetCollection() const { return 0x0; }
+  
+private:
+  const AliMUONDigitStoreVImpl* fStore; //!< store to iterate upon
+  Int_t fFirstDetElemId; //!< first de
+  Int_t fLastDetElemId; //!< last de
+  Int_t fCathode; //!< cathode (-1 for both)
+  TIterator* fStoreIterator; //!< helper iterator
+  AliMUONVCalibParam* fCurrentCalibParam; //!< current CalibParam
+  Int_t fCurrentCalibParamIndex; //!< current index in fCurrentCalibParam
+  
+  ClassDef(AliMUONDigitStoreVImplIterator,1) // Implementation of AliMUONVDataIterator
+};
+
+#endif
diff --git a/MUON/AliMUONRealDigit.cxx b/MUON/AliMUONRealDigit.cxx
new file mode 100644 (file)
index 0000000..2c0782d
--- /dev/null
@@ -0,0 +1,104 @@
+/**************************************************************************
+* 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 "AliMUONRealDigit.h"
+
+/// \class AliMUONRealDigit
+///
+/// Implementation of AliMUONVDigit for real digit.
+/// 
+/// This class should store the bare minimum in order to save disk space
+///
+/// \author Laurent Aphecetche
+///
+
+/// \cond CLASSIMP
+ClassImp(AliMUONRealDigit)
+/// \endcond
+
+//_____________________________________________________________________________
+AliMUONRealDigit::AliMUONRealDigit() 
+  : AliMUONVDigit(),
+  fCharge(0),
+  fPadXY(0),
+  fADC(0),
+  fStatusMap(0)
+{
+      /// default ctor
+}
+
+//_____________________________________________________________________________
+AliMUONRealDigit::AliMUONRealDigit(Int_t detElemId, Int_t manuId, 
+                                   Int_t manuChannel, Int_t cathode)
+: AliMUONVDigit(detElemId,manuId,manuChannel,cathode),
+fCharge(0),
+fPadXY(0),
+fADC(0),
+fStatusMap(0)
+{
+  /// normal ctor
+}
+
+//_____________________________________________________________________________
+AliMUONRealDigit::~AliMUONRealDigit()
+{
+  /// empty ctor
+}
+
+//_____________________________________________________________________________
+Bool_t
+AliMUONRealDigit::MergeWith(const AliMUONVDigit& src)
+{
+  /// Merge with src.
+  
+  Bool_t check = ( src.DetElemId() == DetElemId() &&
+                   src.PadX() == PadX() &&
+                   src.PadY() == PadY() &&
+                   src.Cathode() == Cathode() );
+  if (!check)
+  {
+    return kFALSE;
+  }
+  
+  AddCharge(src.Charge());
+  return kTRUE;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONRealDigit::PadX() const
+{
+  /// Return (integer) position in x (within the detection element)
+  return fPadXY & 0xFFFF;
+}
+
+//_____________________________________________________________________________
+Int_t
+AliMUONRealDigit::PadY() const
+{
+  /// Return (integer) position in y (within the detection element)
+  return ( fPadXY & 0xFFFF0000 ) >> 16;
+}
+
+//_____________________________________________________________________________
+void
+AliMUONRealDigit::SetPadXY(Int_t padx, Int_t pady)
+{
+  /// Set the pad (integer) positions
+  fPadXY = ( padx | (pady << 16) );
+}
+
diff --git a/MUON/AliMUONRealDigit.h b/MUON/AliMUONRealDigit.h
new file mode 100644 (file)
index 0000000..ecd7a77
--- /dev/null
@@ -0,0 +1,103 @@
+#ifndef ALIMUONREALDIGIT_H
+#define ALIMUONREALDIGIT_H
+
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+* See cxx source for full Copyright notice                               */
+
+// $Id$
+
+/// \ingroup base
+/// \class AliMUONRealDigit
+/// \brief Implementation of AliMUONVDigit for real (i.e. not simulated) digits
+/// 
+// author Laurent Aphecetche
+
+#ifndef ALIMUONVDIGIT_H
+#  include "AliMUONVDigit.h"
+#endif
+
+class AliMUONRealDigit : public AliMUONVDigit
+{
+public:
+  AliMUONRealDigit();
+  AliMUONRealDigit(Int_t detElemId, Int_t manuId, Int_t manuChannel, Int_t cathode);
+  virtual ~AliMUONRealDigit();
+  
+  /// Return the detection element this digit belongs to
+  virtual Int_t DetElemId() const { return AliMUONVDigit::DetElemId(GetUniqueID()); }
+  virtual Int_t PadX() const;
+  virtual Int_t PadY() const;
+  /// Return the cathode this digit belongs to
+  virtual Int_t Cathode() const { return AliMUONVDigit::Cathode(GetUniqueID()); }
+  
+  /// Charge (should be non zero if calibrated)
+  virtual Float_t Charge() const { return fCharge; }
+  
+  /// ADC value (it is the real raw adc value, not pedestal subtracted)
+  virtual Int_t ADC() const { return fADC; }
+  
+  /// Return the manu chip this digit belongs to
+  virtual Int_t ManuId() const  { return AliMUONVDigit::ManuId(GetUniqueID()); }
+  /// Return the manu channel this digits is connected to
+  virtual Int_t ManuChannel() const  { return AliMUONVDigit::ManuChannel(GetUniqueID()); }
+  
+  /// Whether this digit's charge has saturated the electronics
+  virtual Bool_t IsSaturated() const { return TestBit(kSaturated); }
+  /// Set the saturation status
+  virtual void Saturated(Bool_t saturated=kTRUE) { SetBit(kSaturated,saturated); }
+  
+  /// We have no idea whether a real digit is noise only or not ;-)
+  virtual Bool_t IsNoiseOnly() const { return kFALSE; }
+  
+  /// Again, this is for simulation only
+  virtual Bool_t IsEfficiencyApplied() const { return kFALSE; }
+  
+  /// Whether this digit is calibrated or not
+  virtual Bool_t IsCalibrated() const { return TestBit(kCalibrated); }
+  /// Set the calibration status
+  virtual void Calibrated(Bool_t value) { SetBit(kCalibrated,value); }
+  
+  /// Whether this digit is part of a cluster or something else
+  virtual Bool_t IsUsed() const { return TestBit(kUsed); }
+  /// Set the used status
+  virtual void Used(Bool_t value) { SetBit(kUsed,value); }
+  
+  /// The status map (i.e. the status of the neighbours) of this digit
+  virtual UInt_t StatusMap() const { return fStatusMap; }
+  /// Set the status map value
+  virtual void SetStatusMap(UInt_t statusMap) { fStatusMap = statusMap; }
+  
+  /// Whether this digit is real or virtual (a clustering detail...)
+  virtual Bool_t IsVirtual() const { return TestBit(kVirtual); }
+  /// Set the virtual status
+  virtual void SetVirtual(Bool_t value) { SetBit(kVirtual,value); }
+
+  /// Set the ADC value (should be between 0 and 4095)
+  virtual void SetADC(Int_t adc) { fADC = adc; }
+  virtual void SetPadXY(Int_t padx, Int_t pady);
+  /// Set the charge
+  virtual void SetCharge(Float_t q) { fCharge=q; }
+  
+  virtual Bool_t MergeWith(const AliMUONVDigit& other);
+  
+  /// No, this digit is not a Monte-Carlo one, sorry.
+  virtual Bool_t HasMCInformation() const { return kFALSE; }
+  
+private:
+  Float_t fCharge; ///< Charge on pad  
+  UInt_t fPadXY; ///< Pad number along x and Y (packed)
+  Int_t fADC; ///< Raw ADC value
+  UInt_t fStatusMap; ///< Neighbouring pad status (whether ped, gains, hv were ok or not)
+  
+  enum EStatusBit 
+  {
+    kSaturated = BIT(20),
+    kUsed = BIT(21),
+    kCalibrated = BIT(22),
+    kVirtual = BIT(23)
+  };
+  
+  ClassDef(AliMUONRealDigit,1) // Implementation of AliMUONVDigit
+};
+
+#endif