In AliMUONTriggerQADataMakerRec:
[u/mrichter/AliRoot.git] / MUON / AliMUON.h
index c755a5b..ff28fa5 100644 (file)
-#ifndef MUON_H
-#define MUON_H
-////////////////////////////////////////////////
-//  Manager and hits classes for set:MUON     //
-////////////////////////////////////////////////
-#include "AliDetector.h"
-#include "AliHit.h"
-#include "AliMUONConst.h"
-#include "AliDigit.h" 
-#include <TVector.h>
-#include <TObjArray.h>
-
-
-static const int NCH=14;
-
-class AliMUONcluster;
-class AliMUONchamber;
-class AliMUONRecCluster;
-//----------------------------------------------
-class AliMUONgeometry 
-{
- public:
-    AliMUONgeometry(){}
-    virtual ~AliMUONgeometry(){}
-    void    InitGeo(Float_t z);
-    Float_t fdGas; // half gaz gap
-    Float_t fdAlu; // half Alu width
-    Float_t frMin; // innermost sensitive radius
-    Float_t frMax; // outermost sensitive radius
-    ClassDef(AliMUONgeometry,1)
-};
-//----------------------------------------------
-//
-// Chamber segmentation virtual base class
-//
-class AliMUONsegmentation :
-public TObject {
-    
- public:
-
-    // Set Chamber Segmentation Parameters
-    virtual void    SetPADSIZ(Float_t p1, Float_t p2)  =0;
-    virtual void    SetDAnod(Float_t D)                =0;
-    // Transform from pad (wire) to real coordinates and vice versa
-    virtual Float_t GetAnod(Float_t xhit)              =0;
-    virtual void    GetPadIxy(Float_t x ,Float_t y ,Int_t   &ix,Int_t   &iy)=0;
-    virtual void    GetPadCxy(Int_t   ix,Int_t   iy,Float_t &x ,Float_t &y )=0;
-    //
-    // Initialisation
-    virtual void Init(AliMUONchamber*)                 =0;
-    //
-    // Get member data
-    virtual Float_t Dpx()                              =0;
-    virtual Float_t Dpy()                              =0;
-    virtual Int_t Npx()                                =0;
-    virtual Int_t Npy()                                =0;
-    //
-    // Iterate over pads
-    virtual void  FirstPad(Float_t xhit, Float_t yhit, Float_t dx, Float_t dy) =0;
-    virtual void  NextPad()=0;
-    virtual Int_t MorePads()                           =0;
-    // Get next neighbours 
-    virtual void Neighbours
-       (Int_t iX, Int_t iY, Int_t* Nlist, Int_t Xlist[10], Int_t Ylist[10])     =0;
-    // Provisory RecCluster coordinates reconstructor
-    virtual void FitXY(AliMUONRecCluster* Cluster,TClonesArray* MUONdigits)    =0;
-    //
-    // Current pad cursor during disintegration 
-    virtual Int_t  Ix()                                =0;
-    virtual Int_t  Iy()                                =0;
-    virtual Int_t  ISector()                           =0;
-    //
-    // Signal Generation Condition during Stepping
-    virtual Int_t SigGenCond(Float_t x, Float_t y, Float_t z) = 0;
-    virtual void  SigGenInit(Float_t x, Float_t y, Float_t z) = 0;
-    virtual void  IntegrationLimits
-       (Float_t& x1, Float_t& x2, Float_t& y1, Float_t& y2)  = 0;
-    //
-    // Identification
-    ClassDef(AliMUONsegmentation,1)
-};
-//----------------------------------------------
-//
-// Chamber response virtual base class
-//
-class AliMUONresponse :
-public TObject {
- public:
-    //
-    // Configuration methods
-    virtual void   SetRSIGM(Float_t p1)                =0;
-    virtual void   SetMUCHSP(Float_t p1)               =0;
-    virtual void   SetMUSIGM(Float_t p1, Float_t p2)   =0;
-    virtual void   SetMAXADC(Float_t p1)               =0;
-    //
-    // Get member data
-    virtual Float_t Chslope()                          =0;
-    virtual Float_t ChwX()                             =0;
-    virtual Float_t ChwY()                             =0;
-    virtual Float_t Nsigma()                           =0;
-    virtual Float_t adc_satm()                         =0;
-    //  
-    // Chamber response methods
-    // Pulse height from scored quantity (eloss)
-    virtual Float_t IntPH(Float_t eloss)               =0;
-    // Charge disintegration
-    virtual Float_t IntXY(AliMUONsegmentation *)       =0;
-    //
-    // Identification
-    ClassDef(AliMUONresponse,1)
-};
-
-//----------------------------------------------
-class AliMUONchamber :
-public TObject,
-public AliMUONgeometry{
- public:
-    AliMUONchamber();
-    ~AliMUONchamber(){}
-//
-// Set and get GEANT id  
-  Int_t   GetGid()         {return fGid;}
-  void    SetGid(Int_t id) {fGid=id;}
-//  
-// Initialisation and z-Position
-  void    Init();
-  void    SetZPOS(Float_t p1) {fzPos=p1;}
-  Float_t ZPosition()         {return fzPos;}
-//  
-// Configure response model
-  void    ResponseModel(AliMUONresponse* thisResponse) {fResponse=thisResponse;}
-//  
-// Configure segmentation model
-  void    SegmentationModel(Int_t i, AliMUONsegmentation* thisSegmentation) {
-      (*fSegmentation)[i-1] = thisSegmentation;
-  }
-//  
-//  Get reference to response model
-  AliMUONresponse*     &GetResponseModel(){return fResponse;}
-//  
-//  Get reference to segmentation model
-  AliMUONsegmentation*  GetSegmentationModel(Int_t isec) {
-      return (AliMUONsegmentation *) (*fSegmentation)[isec-1];
-  }
-  Int_t Nsec()              {return fnsec;}
-  void  SetNsec(Int_t nsec) {fnsec=nsec;}
-//
-// Member function forwarding to the segmentation and response models
-//
-// Calculate pulse height from energy loss  
-  Float_t IntPH(Float_t eloss) {return fResponse->IntPH(eloss);}
-//  
-// Ask segmentation if signal should be generated  
-  Int_t   SigGenCond(Float_t x, Float_t y, Float_t z)
-      {
-         if (fnsec==1) {
-             return ((AliMUONsegmentation*) (*fSegmentation)[0])
-                 ->SigGenCond(x, y, z) ;
-         } else {
-             return (((AliMUONsegmentation*) (*fSegmentation)[0])
-                     ->SigGenCond(x, y, z)) ||
-                 (((AliMUONsegmentation*) (*fSegmentation)[1])
-                  ->SigGenCond(x, y, z)) ;
-         }
-  }
-//
-// Initialisation of segmentation for hit  
-  void    SigGenInit(Float_t x, Float_t y, Float_t z)
-      {
-         
-         if (fnsec==1) {
-             ((AliMUONsegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
-         } else {
-             ((AliMUONsegmentation*) (*fSegmentation)[0])->SigGenInit(x, y, z) ;
-             ((AliMUONsegmentation*) (*fSegmentation)[1])->SigGenInit(x, y, z) ;
-         }
-      }
-  
-// Configuration forwarding
-//
-  void   SetRSIGM(Float_t p1)              {fResponse->SetRSIGM(p1);}
-  void   SetMUCHSP(Float_t p1)             {fResponse->SetMUCHSP(p1);}
-  void   SetMUSIGM(Float_t p1, Float_t p2) {fResponse->SetMUSIGM(p1,p2);}
-  void   SetMAXADC(Float_t p1)             {fResponse->SetMAXADC(p1);}
-
-  void   SetPADSIZ(Int_t isec, Float_t p1, Float_t p2) {
-      ((AliMUONsegmentation*) (*fSegmentation)[isec-1])->SetPADSIZ(p1,p2);
-  }
-//  
-// Cluster formation method
-  void   DisIntegration(Float_t, Float_t, Float_t, Int_t&x, Float_t newclust[6][500]);
-    ClassDef(AliMUONchamber,1)
-
- private:
-// GEANT volume if for sensitive volume of this chamber
-  Int_t   fGid;
-// z-position of this chamber
-  Float_t fzPos;
-// The segmentation models for the cathode planes
-// fnsec=1: one plane segmented, fnsec=2: both planes are segmented.
-  Int_t   fnsec;
-  TObjArray           *fSegmentation;
-  AliMUONresponse     *fResponse;
-
-};
-
-
+#ifndef ALIMUON_H
+#define ALIMUON_H
+/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * See cxx source for full Copyright notice                               */
+
+/* $Id$ */
+// Revision of includes 12/01/2009
+
+/// \ingroup sim
+/// \class AliMUON
+/// \brief AliDetector class for MUON subsystem providing
+/// simulation data management 
  
-class AliMUONcluster : public TObject {
-public:
 
-   Int_t     fHitNumber;    // Hit number
-   Int_t     fCathode;      // Cathode number
-   Int_t     fQ  ;          // Total charge      
-   Int_t     fPadX  ;       // Pad number along X
-   Int_t     fPadY  ;       // Pad number along Y
-   Int_t     fQpad  ;       // Charge per pad
-   Int_t     fRSec  ;       // R -sector of pad
-public:
-   AliMUONcluster() {
-      fHitNumber=fQ=fPadX=fPadY=fQpad=fRSec=0;   
-}
-   AliMUONcluster(Int_t *clhits);
-   virtual ~AliMUONcluster() {;}
-   ClassDef(AliMUONcluster,1)  //Cluster object for set:MUON
-};
+#include "AliDetector.h"
+#include "AliMUONChamber.h"
+#include "AliMUONTrigger.h"
 
-class AliMUONreccluster : public TObject {
-public:
+#include <TString.h>
 
-   Int_t     fTracks[3];      //labels of overlapped tracks
+class AliMUONResponse;
+class AliMUONGeometry;
+class AliMUONGeometryTransformer;
+class AliMUONGeometryBuilder;
+class AliMUONRawWriter;
+class AliMUONVGeometryBuilder;
+class AliMUONDigitMaker;
+class AliMUONVHitStore;
+class AliMUONCalibrationData;
 
-   Int_t       fQ  ;          // Q of cluster (in ADC counts)     
-   Float_t     fX  ;          // X of cluster
-   Float_t     fY  ;          // Y of cluster
-public:
-   AliMUONreccluster() {
-       fTracks[0]=fTracks[1]=fTracks[2]=0; 
-       fQ=0; fX=fY=0;   
-   }
-   virtual ~AliMUONreccluster() {;}
-   ClassDef(AliMUONreccluster,1)  //Cluster object for set:MUON
-};
+class AliLoader;
 
-//_____________________________________________________________________________
+class TObjArray;
 
-class AliMUONdigit : public TObject {
- public:
-    Int_t     fPadX;        // Pad number along x
-    Int_t     fPadY ;       // Pad number along y
-    Int_t     fSignal;      // Signal amplitude
+class AliMUON : public  AliDetector 
+{
+  public:
+    AliMUON();
+    AliMUON(const char* name, const char* title);
+    virtual ~AliMUON();
+   
+    // Geometry
+    void AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder);
+    void ResetGeometryBuilder();
     
-
-    Int_t     fTcharges[10];  // charge per track making this digit (up to 10)
-    Int_t     fTracks[10];    // tracks making this digit (up to 10)
-
-
- public:
-    AliMUONdigit() {}
-    AliMUONdigit(Int_t *digits);
-    AliMUONdigit(Int_t *tracks, Int_t *charges, Int_t *digits);
-    virtual ~AliMUONdigit() {}
-
-    ClassDef(AliMUONdigit,1)  //Digits for set:MUON
-};
-//_____________________________________________________________________________
-
-class AliMUONlist : public AliMUONdigit {
- public:
     
-    Int_t          fRpad;       // r_pos of pad
+                   /// Return geometry builder
+    AliMUONGeometryBuilder*            GetGeometryBuilder() const {return fGeometryBuilder;}
+    const AliMUONGeometryTransformer*  GetGeometryTransformer() const;
+                   /// Return segmentation
+
+    // MUONLoader definition
+    virtual AliLoader* MakeLoader(const char* topfoldername); //builds standard getter (AliLoader type)
+
+    virtual void   SetTreeAddress();
+                  
+                   /// Set split level for making branches in outfiles
+    virtual void   SetSplitLevel(Int_t SplitLevel)     {fSplitLevel=SplitLevel;}
+
+    // Digitisation 
+    virtual AliDigitizer* CreateDigitizer(AliRunDigitizer* manager) const;
+    virtual void   SDigits2Digits();      
+    virtual void   Hits2SDigits();
+    virtual void   Digits2Raw();
+    virtual Bool_t Raw2SDigits(AliRawReader* rawReader);
+
+    // Trigger
+                   /// Create trigger
+    virtual AliTriggerDetector* CreateTriggerDetector() const
+       { return new AliMUONTrigger(); }
     
-    TObjArray     *fTrackList; 
-
- public:
-    AliMUONlist() {fTrackList=0;}
-    AliMUONlist(Int_t rpad, Int_t *digits);
-    virtual ~AliMUONlist() {}
-
-    TObjArray  *TrackList()   {return fTrackList;}
-    ClassDef(AliMUONlist,1)  //Digits for set:MUON
-};
-//___________________________________________
 
-
-//___________________________________________
-class AliMUONhit : public AliHit {
- public:
-    Int_t     fChamber;       // Chamber number
-    Int_t     fParticle;      // PDG particle type
-    Float_t   fTheta ;        // Incident theta angle in degrees      
-    Float_t   fPhi   ;        // Incident phi angle in degrees
-    Float_t   fTlength;       // Track length inside the chamber
-    Float_t   fEloss;         // ionisation energy loss in gas   
-    Int_t     fPHfirst;       // first padhit
-    Int_t     fPHlast;        // last padhit
- public:
-    AliMUONhit() {}
-    AliMUONhit(Int_t fIshunt, Int_t track, Int_t *vol, Float_t *hits);
-    virtual ~AliMUONhit() {}
+    // Configuration Methods (per station id)
+    //
+    // Set Signal Generation Parameters
+    virtual void   SetSigmaIntegration(Int_t id, Float_t p1);
+    virtual void   SetChargeSlope(Int_t id, Float_t p1);
+    virtual void   SetChargeSpread(Int_t id, Float_t p1, Float_t p2);
+    virtual void   SetMaxAdc(Int_t id, Int_t p1);
+    // Set Response Model
+    virtual void   SetResponseModel(Int_t id, const AliMUONResponse& response);
+
+    // Set Stepping Parameters
+    virtual void   SetMaxStepGas(Float_t p1);
+    virtual void   SetMaxStepAlu(Float_t p1);
+    virtual void   SetMaxDestepGas(Float_t p1);
+    virtual void   SetMaxDestepAlu(Float_t p1);
+   
+    // Get Stepping Parameters
+    virtual Float_t  GetMaxStepGas() const;
+    virtual Float_t  GetMaxStepAlu() const;
+    virtual Float_t  GetMaxDestepGas() const;
+    virtual Float_t  GetMaxDestepAlu() const;
     
-    ClassDef(AliMUONhit,1)  //Hits object for set:MUON
-};
-
-class AliMUON : public  AliDetector {
- public:
-    AliMUON();
-    AliMUON(const char *name, const char *title);
-    virtual       ~AliMUON();
-    virtual void   AddHit(Int_t, Int_t*, Float_t*);
-    virtual void   AddCluster(Int_t*);
-    virtual void   AddDigits(Int_t, Int_t*, Int_t*, Int_t*);
-    virtual void   AddRecCluster(Int_t iCh, Int_t iCat,
-                                AliMUONRecCluster* Cluster);
-    virtual void   BuildGeometry();
-    virtual void   CreateGeometry() {}
-    virtual void   CreateMaterials() {}
-    virtual void   StepManager();
-    Int_t          DistancetoPrimitive(Int_t px, Int_t py);
-    virtual Int_t  IsVersion() const =0;
-//
-    TClonesArray  *Clusters() {return fClusters;}
-    virtual void   MakeBranch(Option_t *opt=" ");
-    void           SetTreeAddress();
-    virtual void   ResetHits();
-    virtual void   ResetDigits();
-    virtual void   ResetRecClusters();
-    virtual void   ReconstructClusters();
-// 
-// Configuration Methods (per station id)
-//
-// Set Chamber Segmentation Parameters
-// id refers to the station and isec to the cathode plane   
-    virtual void   SetPADSIZ(Int_t id, Int_t isec, Float_t p1, Float_t p2);
-
-// Set Signal Generation Parameters
-    virtual void   SetRSIGM(Int_t id, Float_t p1);
-    virtual void   SetMUCHSP(Int_t id, Float_t p1);
-    virtual void   SetMUSIGM(Int_t id, Float_t p1, Float_t p2);
-    virtual void   SetMAXADC(Int_t id, Float_t p1);
-// Set Segmentation and Response Model
-    virtual void   SetSegmentationModel(Int_t id, Int_t isec, AliMUONsegmentation *segmentation);
-    virtual void   SetResponseModel(Int_t id, AliMUONresponse *response);
-    virtual void   SetNsec(Int_t id, Int_t nsec);
-// Set Stepping Parameters
-    virtual void   SetSMAXAR(Float_t p1);
-    virtual void   SetSMAXAL(Float_t p1);
-    virtual void   SetDMAXAR(Float_t p1);
-    virtual void   SetDMAXAL(Float_t p1);
-    virtual void   SetMUONACC(Bool_t acc=0, Float_t angmin=2, Float_t angmax=9);
-// Response Simulation
-    virtual void   MakePadHits(Float_t xhit,Float_t yhit,Float_t eloss,Int_t id);
-// Return reference to Chamber #id
-    virtual AliMUONchamber& Chamber(Int_t id) {return *((AliMUONchamber *) (*fChambers)[id]);}
-// Retrieve pad hits for a given Hit
-    virtual AliMUONcluster* FirstPad(AliMUONhit *);
-    virtual AliMUONcluster* NextPad();
-// Return pointers to digits 
-    TObjArray            *Dchambers() {return fDchambers;}
-    Int_t                *Ndch() {return fNdch;}
-    virtual TClonesArray *DigitsAddress(Int_t id) {return ((TClonesArray *) (*fDchambers)[id]);}
-// Return pointers to reconstructed clusters
-    virtual TObjArray *RecClusters(Int_t iCh, Int_t iCat) 
-       {return ( (TObjArray*) (*fRecClusters)[iCh+iCat*10]);}
+    // Set alignement option
+    virtual void  SetAlign(Bool_t align = true);
+    virtual void  SetAlign(const TString& fileName, Bool_t align = true);
+
+                   /// Set scaler event for trigger
+    virtual void  SetTriggerScalerEvent(Bool_t scaler = true){fTriggerScalerEvent = scaler;}
+
+                  /// Set trigger response version
+    virtual void  SetTriggerResponseV1(Bool_t trigResV1 = false)
+       { fTriggerResponseV1 = trigResV1; }
+    virtual Bool_t GetTriggerResponseV1() const;
+                  /// Set trigger coinc44
+    virtual void  SetTriggerCoinc44(Int_t trigCoinc44 = 0)
+       { fTriggerCoinc44 = trigCoinc44; }
+    virtual Int_t GetTriggerCoinc44() const;
+                 /// Set trigger chamber efficiency by cells
+    virtual void SetTriggerEffCells(Bool_t trigEffCells = false)
+       { fTriggerEffCells = trigEffCells; }
+    virtual Bool_t GetTriggerEffCells() const;
+                 /// Set off generation of noisy digits
+    virtual void SetDigitizerWithNoise(Int_t digitizerWithNoise)
+        { fDigitizerWithNoise = digitizerWithNoise; }
+    virtual Int_t GetDigitizerWithNoise() const; 
+    
+                 /// Parametrised tail effect in resolution histogram
+    virtual void SetTailEffect(Bool_t isTailEffect) { fIsTailEffect=isTailEffect; }
+    
+    // Getters
+                  /// Return reference to Chamber \a id
+    virtual AliMUONChamber& Chamber(Int_t id)
+      {return *((AliMUONChamber *) (*fChambers)[id]);}
 
+    virtual void MakeBranch(Option_t* opt=" ");
+    virtual void ResetHits();
+    
+                 /// Set digit store class name           
+    void SetDigitStoreClassName(const char* classname) { fDigitStoreConcreteClassName = classname; }
+                 /// Return digit store class name           
+    const TString DigitStoreClassName() const { return fDigitStoreConcreteClassName; }
+    
+  protected:
+    /// Not implemented
+    AliMUON(const AliMUON& rMUON);
+    /// Not implemented
+    AliMUON& operator = (const AliMUON& rhs);
+
+    const AliMUONGeometry* GetGeometry() const;
+
+    Int_t                 fNCh;                ///< Number of chambers   
+    Int_t                 fNTrackingCh;        ///< Number of tracking chambers*
+    Int_t                 fSplitLevel;         ///< Splitlevel when making branches in outfiles.
+    TObjArray*            fChambers;           ///< List of Tracking Chambers
+    AliMUONGeometryBuilder*  fGeometryBuilder; ///< Geometry builder 
    
- protected:
-    TObjArray            *fChambers;           // List of Tracking Chambers
-    Int_t                fNclusters;           // Number of clusters
-    TClonesArray         *fClusters;           // List of clusters
-    TObjArray            *fDchambers;          // List of digits
-    TObjArray            *fRecClusters;        // List of clusters
-    Int_t                *fNdch;               // Number of digits
-//
-    Bool_t   fAccCut;          //Transport acceptance cut
-    Float_t  fAccMin;          //Minimum acceptance cut used during transport
-    Float_t  fAccMax;          //Minimum acceptance cut used during transport
-//  
-
-//  Stepping Parameters
-   Float_t fMaxStepGas;      // Maximum step size inside the chamber gas
-   Float_t fMaxStepAlu;      // Maximum step size inside the chamber aluminum
-   Float_t fMaxDestepGas;    // Maximum relative energy loss in gas
-   Float_t fMaxDestepAlu;    // Maximum relative energy loss in aluminum
+    //
+    Bool_t   fAccCut;         ///< Transport acceptance cut
+    Float_t  fAccMin;         ///< Minimum acceptance cut used during transport
+    Float_t  fAccMax;         ///< Minimum acceptance cut used during transport
+    //  
+    //  Stepping Parameters
+    Float_t fMaxStepGas;      ///< Maximum step size inside the chamber gas
+    Float_t fMaxStepAlu;      ///< Maximum step size inside the chamber aluminum
+    Float_t fMaxDestepGas;    ///< Maximum relative energy loss in gas
+    Float_t fMaxDestepAlu;    ///< Maximum relative energy loss in aluminum
+    
+    // Pad Iterator
+    Int_t fMaxIterPad;        ///< Maximum pad index
+    Int_t fCurIterPad;        ///< Current pad index
    
- protected:
-
-   ClassDef(AliMUON,1)  //Hits manager for set:MUON
-};
-//___________________________________________
-class AliMUONRecCluster : public TObject {
-public:
-   AliMUONRecCluster() ;
-   AliMUONRecCluster(Int_t FirstDigit,Int_t Ichamber, Int_t Icathod) ;
-   virtual ~AliMUONRecCluster();
-   virtual void  AddDigit(Int_t Digit);
-   virtual Int_t FirstDigitIndex();
-   virtual Int_t NextDigitIndex();
-   virtual Int_t InvalidDigitIndex() {return -1;}
-
-   virtual Int_t NDigits();
-   virtual void  Finish();    // Nothing yet ...
-   virtual Int_t GetCathod()  {return fCathod;}
-   virtual Int_t GetChamber() {return fChamber;}
-
-public:
-   Float_t fX; // reconstructed x
-   Float_t fY; // reconstructed y
-
-protected:
-   TArrayI *fDigits;    // List of digits indexes for that cluster
-   Int_t fNdigit;       // Number of digits indexes stored;
-   Int_t fCathod;       // Number of the cathod to be used;
-   Int_t fChamber;      // Number of the chamber to be used;
-   Int_t fCurrentDigit; // Current Digit inside an iteration
+    // Options
+    Bool_t fTriggerScalerEvent; ///< Flag to generates scaler event
+    Bool_t fTriggerResponseV1;  ///< Flag to select TriggerResponseV1
+    Int_t  fTriggerCoinc44;     ///< Flag to select TriggerCoinc44 
+    Bool_t fTriggerEffCells;    ///< Flag to select TriggerEffCells
+    Int_t  fDigitizerWithNoise; ///< Flag to switch on/off generation of noisy digits
+    Bool_t fIsTailEffect;       ///< Switch to turn on/off the tail effect
+
+    AliMUONRawWriter* fRawWriter; //!< Raw data writer
+    
+    AliMUONDigitMaker* fDigitMaker; //!< pointer to the digit maker class
 
-   ClassDef(AliMUONRecCluster,1)  //Cluster object for set:MUON
+    AliMUONVHitStore* fHitStore; //!< container of hits
+    
+    TString fDigitStoreConcreteClassName; ///< to be able to select what the sdigitizer uses
+    
+    AliMUONCalibrationData* fCalibrationData; ///< pointer of calibration data
+    
+    ClassDef(AliMUON,17)  // MUON Detector base class
 };
-//___________________________________________
 #endif
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-