Separating run-dependent mapping data from data, which are not
[u/mrichter/AliRoot.git] / MUON / AliMUON.cxx
index 414c6eb..3cf30d3 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-/*
-$Log$
-Revision 1.58  2002/10/21 09:01:33  alibrary
-Getting rid of unused variable
 
-Revision 1.57  2002/10/14 14:57:29  hristov
-Merging the VirtualMC branch to the main development branch (HEAD)
+/* $Id$ */
 
-Revision 1.56.6.2  2002/07/24 10:07:20  alibrary
-Updating VirtualMC
+//-----------------------------------------------------------------------------
+// Class AliMUON
+// ------------------
+// AliDetector class for MUON subsystem 
+// providing simulation data management 
+//-----------------------------------------------------------------------------
 
-Revision 1.56.6.1  2002/06/10 15:10:14  hristov
-Merged with v3-08-02
-
-Revision 1.56  2001/11/22 11:26:28  jchudoba
-Proper deletion of arrays, deletion of unused variables (thanks to Rene Brun)
-
-Revision 1.55  2001/09/07 08:38:30  hristov
-Pointers initialised to 0 in the default constructors
-
-Revision 1.54  2001/08/30 09:52:12  hristov
-The operator[] is replaced by At() or AddAt() in case of TObjArray.
-
-Revision 1.53  2001/07/20 10:03:13  morsch
-Changes needed to work with Root 3.01 (substitute lhs [] operator). (Jiri Chudoba)
-
-Revision 1.52  2001/06/14 13:49:22  hristov
-Write a TreeD in SDigits2Digits method (needed to be compatible with alirun script)
-
-Revision 1.51  2001/05/31 10:19:52  morsch
-Fix for new AliRun::RunReco().
-
-Revision 1.50  2001/05/16 14:57:17  alibrary
-New files for folders and Stack
-
-Revision 1.49  2001/03/12 17:45:48  hristov
-Changes needed on Sun with CC 5.0
-
-Revision 1.48  2001/03/06 00:01:36  morsch
-Add  Digits2Reco() and FindClusters()
-Adapt call of cluster finder to new STEER.
-
-Revision 1.47  2001/03/05 08:38:36  morsch
-Digitization related methods moved to AliMUONMerger.
-
-Revision 1.46  2001/01/26 21:34:59  morsch
-Use access functions for AliMUONHit, AliMUONDigit and AliMUONPadHit data members.
-
-Revision 1.45  2001/01/26 20:00:49  hristov
-Major upgrade of AliRoot code
-
-Revision 1.44  2001/01/25 17:39:09  morsch
-Pass size of fNdch and fNrawch to CINT.
-
-Revision 1.43  2001/01/23 18:58:19  hristov
-Initialisation of some pointers
-
-Revision 1.42  2001/01/17 20:53:40  hristov
-Destructors corrected to avoid memory leaks
-
-Revision 1.41  2000/12/21 22:12:40  morsch
-Clean-up of coding rule violations,
-
-Revision 1.40  2000/11/29 20:32:26  gosset
-Digitize:
-1. correction for array index out of bounds
-2. one printout commented
-
-Revision 1.39  2000/11/12 17:17:03  pcrochet
-BuildGeometry of AliMUON for trigger chambers delegated to AliMUONSegmentationTriggerX (same strategy as for tracking chambers)
-
-Revision 1.38  2000/11/06 09:20:43  morsch
-AliMUON delegates part of BuildGeometry() to AliMUONSegmentation using the
-Draw() method. This avoids code and parameter replication.
-
-Revision 1.37  2000/10/26 09:53:37  pcrochet
-put back trigger chambers in the display (there was a problem in buildgeometry)
-
-Revision 1.36  2000/10/25 19:51:18  morsch
-Correct x-position of chambers.
-
-Revision 1.35  2000/10/24 19:46:21  morsch
-BuildGeometry updated for slats in station 3-4.
-
-Revision 1.34  2000/10/18 11:42:06  morsch
-- AliMUONRawCluster contains z-position.
-- Some clean-up of useless print statements during initialisations.
-
-Revision 1.33  2000/10/09 14:01:57  morsch
-Unused variables removed.
-
-Revision 1.32  2000/10/06 09:08:10  morsch
-Built geometry includes slat geometry for event display.
-
-Revision 1.31  2000/10/02 21:28:08  fca
-Removal of useless dependecies via forward declarations
-
-Revision 1.30  2000/10/02 16:58:29  egangler
-Cleaning of the code :
--> coding conventions
--> void Streamers
--> some useless includes removed or replaced by "class" statement
-
-Revision 1.29  2000/07/28 13:49:38  morsch
-SetAcceptance defines inner and outer chamber radii according to angular acceptance.
-Can be used for simple acceptance studies.
-
-Revision 1.28  2000/07/22 16:43:15  morsch
-Same comment as before, but now done correctly I hope (sorry it's Saturday evening)
-
-Revision 1.27  2000/07/22 16:36:50  morsch
-Change order of indices in creation (new) of xhit and yhit
-
-Revision 1.26  2000/07/03 11:54:57  morsch
-AliMUONSegmentation and AliMUONHitMap have been replaced by AliSegmentation and AliHitMap in STEER
-The methods GetPadIxy and GetPadXxy of AliMUONSegmentation have changed name to GetPadI and GetPadC.
-
-Revision 1.25  2000/06/29 12:34:09  morsch
-AliMUONSegmentation class has been made independent of AliMUONChamber. This makes
-it usable with any other geometry class. The link to the object to which it belongs is
-established via an index. This assumes that there exists a global geometry manager
-from which the pointer to the parent object can be obtained (in our case gAlice).
-
-Revision 1.24  2000/06/28 15:16:35  morsch
-(1) Client code adapted to new method signatures in AliMUONSegmentation (see comments there)
-to allow development of slat-muon chamber simulation and reconstruction code in the MUON
-framework. The changes should have no side effects (mostly dummy arguments).
-(2) Hit disintegration uses 3-dim hit coordinates to allow simulation
-of chambers with overlapping modules (MakePadHits, Disintegration).
-
-Revision 1.23  2000/06/28 12:19:17  morsch
-More consequent seperation of global input data services (AliMUONClusterInput singleton) and the
-cluster and hit reconstruction algorithms in AliMUONClusterFindRawinderVS.
-AliMUONClusterFinderVS becomes the base class for clustering and hit reconstruction.
-It requires two cathode planes. Small modifications in the code will make it usable for
-one cathode plane and, hence, more general (for test beam data).
-AliMUONClusterFinder is now obsolete.
-
-Revision 1.22  2000/06/28 08:06:10  morsch
-Avoid global variables in AliMUONClusterFinderVS by seperating the input data for the fit from the
-algorithmic part of the class. Input data resides inside the AliMUONClusterInput singleton.
-It also naturally takes care of the TMinuit instance.
-
-Revision 1.21  2000/06/27 08:54:41  morsch
-Problems with on constant array sizes (in hitMap, nmuon, xhit, yhit) corrected.
-
-Revision 1.20  2000/06/26 14:02:38  morsch
-Add class AliMUONConstants with MUON specific constants using static memeber data and access methods.
-
-Revision 1.19  2000/06/22 13:40:51  morsch
-scope problem on HP, "i" declared once
-pow changed to TMath::Power (PH, AM)
-
-Revision 1.18  2000/06/15 07:58:48  morsch
-Code from MUON-dev joined
-
-Revision 1.14.4.17  2000/06/14 14:36:46  morsch
-- add TriggerCircuit (PC)
-- add GlobalTrigger and LocalTrigger and specific methods (PC)
-
-Revision 1.14.4.16  2000/06/09 21:20:28  morsch
-Most coding rule violations corrected
-
-Revision 1.14.4.15  2000/05/02 09:54:32  morsch
-RULE RN17 violations corrected
-
-Revision 1.14.4.12  2000/04/26 12:25:02  morsch
-Code revised by P. Crochet:
-- Z position of TriggerChamber changed according to A.Tournaire Priv.Comm.
-- ToF included in the method MakePadHits
-- inner radius of flange between beam shielding and trigger corrected
-- Trigger global volume updated (according to the new geometry)
-
-Revision 1.14.4.11  2000/04/19 19:42:08  morsch
-Some changes of variable names curing viols and methods concerning
-correlated clusters removed.
-
-Revision 1.14.4.10  2000/03/22 16:44:07  gosset
-Memory leak suppressed in function Digitise:
-p_adr->Delete() instead of Clear (I.Chevrot and A.Baldisseri)
-
-Revision 1.14.4.9  2000/03/20 18:15:25  morsch
-Positions of trigger chambers corrected (P.C.)
-
-Revision 1.14.4.8  2000/02/21 15:38:01  morsch
-Call to AddHitList introduced to make this version compatible with head.
-
-Revision 1.14.4.7  2000/02/20 07:45:53  morsch
-Bugs in Trigger part of BuildGeomemetry corrected (P.C)
-
-Revision 1.14.4.6  2000/02/17 14:28:54  morsch
-Trigger included into initialization and digitization
-
-Revision 1.14.4.5  2000/02/15 10:02:58  morsch
-Log messages of previous revisions added
-
-Revision 1.14.4.2  2000/02/04 10:57:34  gosset
-Z position of the chambers:
-it was the Z position of the stations;
-it is now really the Z position of the chambers.
-   !!!! WARNING: THE CALLS TO "AliMUONChamber::SetZPOS"
-   !!!!                   AND "AliMUONChamber::ZPosition"
-   !!!! HAVE TO BE CHANGED TO "AliMUONChamber::"SetZ"
-   !!!!                   AND "AliMUONChamber::Z"
-
-Revision 1.14.4.3  2000/02/04 16:19:04  gosset
-Correction for mis-spelling of NCH 
-
-Revision 1.14.4.4  2000/02/15 09:43:38  morsch
-Log message added
-
-*/
-
-
-///////////////////////////////////////////////
-//  Manager and hits classes for set:MUON     //
-////////////////////////////////////////////////
+#include "Riostream.h"
 
-#include <TTUBE.h>
+#include <AliPDG.h>
 #include <TBRIK.h>
-#include <TRotMatrix.h>
+#include <TCanvas.h>
+#include <TDirectory.h>
+#include <TFile.h>
 #include <TGeometry.h>
+#include <TMinuit.h>
 #include <TNode.h> 
-#include <TTree.h> 
-#include <TRandom.h> 
-#include <TObject.h>
-#include <TVector.h>
+#include <TNtuple.h>
 #include <TObjArray.h>
-#include <TMinuit.h>
+#include <TObject.h>
+#include <TObjectTable.h>
+#include <TPad.h>
 #include <TParticle.h>
 #include <TROOT.h>
-#include <TFile.h>
-#include <TNtuple.h>
-#include <TCanvas.h>
-#include <TPad.h>
-#include <TDirectory.h>
-#include <TObjectTable.h>
-#include <AliPDG.h>
+#include <TRandom.h> 
+#include <TRotMatrix.h>
 #include <TTUBE.h>
+#include <TTUBE.h>
+#include <TTree.h> 
+#include <TVector.h>
+#include <TVirtualMC.h>
 
+//#include "AliHeader.h"
+#include "AliLoader.h"
+#include "AliCDBManager.h"
+#include "AliRunDigitizer.h"
+#include "AliMC.h"
+#include "AliRun.h"
+#include "AliRawDataHeaderSim.h"
 #include "AliMUON.h"
-#include "AliMUONHit.h"
-#include "AliMUONPadHit.h"
-#include "AliMUONDigit.h"
-#include "AliMUONTransientDigit.h"
-#include "AliMUONRawCluster.h"
-#include "AliMUONLocalTrigger.h"
-#include "AliMUONGlobalTrigger.h"
-#include "AliMUONTriggerCircuit.h"
-#include "AliHitMap.h"
-#include "AliMUONHitMapA1.h"
 #include "AliMUONChamberTrigger.h"
 #include "AliMUONConstants.h"
-#include "AliMUONClusterFinderVS.h"
-#include "AliMUONTriggerDecision.h"
-#include "AliRun.h"
-#include "AliHeader.h"
-#include "AliMUONClusterInput.h"
-#include "AliMUONMerger.h"     
-#include "Riostream.h"
-#include "AliConst.h" 
+#include "AliMUONHit.h"        
+#include "AliMUONGeometry.h"
+#include "AliMUONGeometryTransformer.h"
+#include "AliMUONGeometryBuilder.h"
+#include "AliMUONCommonGeometryBuilder.h"
+#include "AliMUONVGeometryBuilder.h"   
+#include "AliMUONRawWriter.h"
+#include "AliLog.h"
+
+#include "AliMUONSDigitizerV2.h"
+#include "AliMUONDigitizerV3.h"
+#include "AliMUONDigitMaker.h"
+#include "AliMUONCalibrationData.h"
+
+#include "AliMUONSt1GeometryBuilderV2.h"
+#include "AliMUONSt2GeometryBuilderV2.h"
+#include "AliMUONSlatGeometryBuilder.h"
+#include "AliMUONTriggerGeometryBuilder.h"
+
+#include "AliMUONDigitStoreV1.h"
+#include "AliMUONVTriggerStore.h"
+#include "AliMUONHitStoreV1.h"
 
 // Defaults parameters for Z positions of chambers
 // taken from values for "stations" in AliMUON::AliMUON
@@ -288,995 +94,590 @@ Log message added
 //          according to (Z1 = zch) and  (Z2 = zch + DTPLANES)
 //          for the first and second chambers in the station, respectively
 
-ClassImp(AliMUON)
-//___________________________________________
+/// \cond CLASSIMP
+ClassImp(AliMUON)  
+/// \endcond
+
+//__________________________________________________________________
 AliMUON::AliMUON()
-{
-// Default Constructor
-//
-    fNCh             = 0;
-    fNTrackingCh     = 0;
+  : AliDetector(),
+    fNCh(0),
+    fNTrackingCh(0),
+    fSplitLevel(0),
+    fChambers(0),
+    fGeometryBuilder(0),
+    fAccCut(kFALSE),
+    fAccMin(0.),
+    fAccMax(0.),   
+    fMaxStepGas(0.),
+    fMaxStepAlu(0.),
+    fMaxDestepGas(0.),
+    fMaxDestepAlu(0.),
+    fMaxIterPad(0),
+    fCurIterPad(0),
+    fTriggerScalerEvent(kFALSE),
+    fTriggerResponseV1(kFALSE),
+    fTriggerCoinc44(0),
+    fTriggerEffCells(0),
+    fDigitizerWithNoise(1),
+    fIsTailEffect(kTRUE),
+    fRawWriter(0x0),
+    fDigitMaker(0x0),
+    fHitStore(0x0),
+    fDigitStoreConcreteClassName(),
+    fCalibrationData(0x0)
+{
+/// Default Constructor
+    
+    AliDebug(1,Form("default (empty) ctor this=%p",this));
     fIshunt          = 0;
-    fPadHits         = 0;
-    fNPadHits        = 0;
-    fChambers        = 0;
-    fDchambers       = 0;
-    fTriggerCircuits = 0;  
-    fNdch            = 0;
-    fRawClusters     = 0;
-    fNrawch          = 0;
-    fGlobalTrigger   = 0;
-    fNLocalTrigger   = 0;
-    fLocalTrigger    = 0;
-    fNLocalTrigger   = 0;
-    fAccMin          = 0.;
-    fAccMax          = 0.;   
-    fAccCut          = kFALSE;
-    fMerger          = 0;
-    fFileName        = 0;
 }
-//___________________________________________
-AliMUON::AliMUON(const char *name, const char *title)
-       : AliDetector(name,title)
-{
-//Begin_Html
-/*
-<img src="gif/alimuon.gif">
-*/
-//End_Html
-
-   fHits     = new TClonesArray("AliMUONHit",1000);
-   gAlice->AddHitList(fHits);
-   fPadHits = new TClonesArray("AliMUONPadHit",10000);
-   fNPadHits  =  0;
-   fIshunt     =  0;
-
-   fNCh             = AliMUONConstants::NCh(); 
-   fNTrackingCh     = AliMUONConstants::NTrackingCh();
-   fNdch            = new Int_t[fNCh];
-
-   fDchambers = new TObjArray(AliMUONConstants::NCh());
-
-   Int_t i;
-   
-   for (i=0; i<AliMUONConstants::NCh() ;i++) {
-       fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
-       fNdch[i]=0;
-   }
-
-   fNrawch      = new Int_t[fNTrackingCh];
-
-   fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
-
-   for (i=0; i<AliMUONConstants::NTrackingCh();i++) {
-       fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
-       fNrawch[i]=0;
-   }
-
-   fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1);    
-   fNGlobalTrigger = 0;
-   fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);    
-   fNLocalTrigger = 0;
-
-   SetMarkerColor(kRed);
-//
-//
-//
-//
 
+//__________________________________________________________________
+AliMUON::AliMUON(const char *name, const char* title)
+  : AliDetector(name, title),
+    fNCh(AliMUONConstants::NCh()),
+    fNTrackingCh(AliMUONConstants::NTrackingCh()),
+    fSplitLevel(0),
+    fChambers(0),
+    fGeometryBuilder(0),
+    fAccCut(kFALSE),
+    fAccMin(0.),
+    fAccMax(0.),   
+    fMaxStepGas(0.1),
+    fMaxStepAlu(0.1),
+    fMaxDestepGas(-1), // Negatives values are ignored by geant3 CONS200 
+    fMaxDestepAlu(-1), // in the calculation of the tracking parameters
+    fMaxIterPad(0),
+    fCurIterPad(0),
+    fTriggerScalerEvent(kFALSE),
+    fTriggerResponseV1(kFALSE),
+    fTriggerCoinc44(0),
+    fTriggerEffCells(0),
+    fDigitizerWithNoise(1),
+    fIsTailEffect(kTRUE),
+    fRawWriter(0x0),
+    fDigitMaker(new AliMUONDigitMaker),
+    fHitStore(0x0),
+    fDigitStoreConcreteClassName("AliMUONDigitStoreV2S"),
+    fCalibrationData()
+
+{
+  /// Standard constructor  
+  
+  AliDebug(1,Form("ctor this=%p",this));
+  fIshunt =  0;
+  
+  //PH SetMarkerColor(kRed);//
+    
+  // Geometry builder
+  fGeometryBuilder = new AliMUONGeometryBuilder(this);
+  
+  // Common geometry definitions
+  fGeometryBuilder
+    ->AddBuilder(new AliMUONCommonGeometryBuilder(this));
+  
+  // By default, add also all the needed geometry builders.
+  // If you want to change this from outside, please use ResetGeometryBuilder
+  // method, followed by AddGeometryBuilder ones.
+  
+  AddGeometryBuilder(new AliMUONSt1GeometryBuilderV2(this));
+  AddGeometryBuilder(new AliMUONSt2GeometryBuilderV2(this));
+  AddGeometryBuilder(new AliMUONSlatGeometryBuilder(this));
+  AddGeometryBuilder(new AliMUONTriggerGeometryBuilder(this));
+  
+  //
+  // Creating List of Chambers
     Int_t ch;
-
     fChambers = new TObjArray(AliMUONConstants::NCh());
-
+    fChambers->SetOwner(kTRUE);
+    
     // Loop over stations
     for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
       // Loop over 2 chambers in the station
-       for (Int_t stCH = 0; stCH < 2; stCH++) {
-//
-//    
-//    Default Parameters for Muon Tracking Stations
-
-
-           ch = 2 * st + stCH;
-//
-           if (ch < AliMUONConstants::NTrackingCh()) {
-             fChambers->AddAt(new AliMUONChamber(ch),ch);
-           } else {
-             fChambers->AddAt(new AliMUONChamberTrigger(ch),ch);
-           }
-           
-        //PH       AliMUONChamber* chamber = (AliMUONChamber*) (*fChambers)[ch];
-           AliMUONChamber* chamber = (AliMUONChamber*) fChambers->At(ch);
-           
-           chamber->SetGid(0);
-           // Default values for Z of chambers
-           chamber->SetZ(AliMUONConstants::DefaultChamberZ(ch));
-//
-           chamber->InitGeo(AliMUONConstants::DefaultChamberZ(ch));
-//          Set chamber inner and outer radius to default
-           chamber->SetRInner(AliMUONConstants::Dmin(st)/2);
-           chamber->SetROuter(AliMUONConstants::Dmax(st)/2);
-//
-       } // Chamber stCH (0, 1) in 
+      for (Int_t stCH = 0; stCH < 2; stCH++) {
+       //
+       //    
+       //    Default Parameters for Muon Tracking Stations
+       ch = 2 * st + stCH;
+       if (ch < AliMUONConstants::NTrackingCh()) {
+         fChambers->AddAt(new AliMUONChamber(ch),ch);
+       } else {
+         fChambers->AddAt(new AliMUONChamberTrigger(ch, GetGeometryTransformer()),ch);
+       }
+      } // Chamber stCH (0, 1) in 
     }     // Station st (0...)
-//    fChambers->SetLast(AliMUONConstants::NCh());
-    fMaxStepGas=0.01; 
-    fMaxStepAlu=0.1; 
-    fMaxDestepGas=-1;
-    fMaxDestepAlu=-1;
-//
-   fMaxIterPad   = 0;
-   fCurIterPad   = 0;
-//
-   fAccMin          = 0.;
-   fAccMax          = 0.;   
-   fAccCut          = kFALSE;
-
-   // cp new design of AliMUONTriggerDecision
-   fTriggerCircuits = new TObjArray(AliMUONConstants::NTriggerCircuit());
-   for (Int_t circ=0; circ<AliMUONConstants::NTriggerCircuit(); circ++) {
-     fTriggerCircuits->AddAt(new AliMUONTriggerCircuit(),circ);     
-
-   }
-     fMerger = 0;
-}
-//___________________________________________
-AliMUON::AliMUON(const AliMUON& rMUON)
-{
-// Dummy copy constructor
-    ;
-    
+  
+  Int_t runnumber = AliCDBManager::Instance()->GetRun();
+  
+  fCalibrationData = new AliMUONCalibrationData(runnumber);
 }
 
+//____________________________________________________________________
 AliMUON::~AliMUON()
 {
-// Destructor
-    if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
-    
-    fIshunt  = 0;
-    // Delete TObjArrays
-    if (fChambers){
-      fChambers->Delete();
-      delete fChambers;
-    }
-    if (fTriggerCircuits){
-      fTriggerCircuits->Delete();
-      delete fTriggerCircuits;
-    }
-    if (fDchambers){
-      fDchambers->Delete();
-      delete fDchambers;
-    }
-    if (fRawClusters){
-      fRawClusters->Delete();
-      delete fRawClusters;
-    }
-
-    if (fNrawch) delete [] fNrawch;
-    // Delete TClonesArrays
-    if (fPadHits){
-      fPadHits->Delete();
-      delete fPadHits;
-    }
-    if (fGlobalTrigger){
-      fGlobalTrigger->Delete();
-      delete fGlobalTrigger;
-    }
-    fNGlobalTrigger = 0;
-    
-    if (fLocalTrigger){
-      fLocalTrigger->Delete();
-      delete fLocalTrigger;
-    }
-    fNLocalTrigger = 0;
-
-    if (fHits) {
-      fHits->Delete();
-      delete fHits;
-    }
-
-    if (fMerger) delete fMerger;
-    if (fNdch) delete [] fNdch;
-
-}
-//___________________________________________
-void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
-{
-  TClonesArray &lhits = *fHits;
-  new(lhits[fNhits++]) AliMUONHit(fIshunt,track,vol,hits);
-}
-//___________________________________________
-void AliMUON::AddPadHit(Int_t *clhits)
-{
-   TClonesArray &lclusters = *fPadHits;
-   new(lclusters[fNPadHits++]) AliMUONPadHit(clhits);
-}
-//_____________________________________________________________________________
-void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
-{
-    //
-    // Add a MUON digit to the list
-    //
+/// Destructor
 
-  //PH    TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
-    TClonesArray &ldigits = *((TClonesArray*)fDchambers->At(id));
-    new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
+  AliDebug(1,Form("dtor this=%p",this));
+  delete fChambers;
+  delete fGeometryBuilder;
+  delete fRawWriter;
+  delete fDigitMaker;
+  delete fHitStore;
+  delete fCalibrationData;
 }
 
 //_____________________________________________________________________________
-void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
+void AliMUON::AddGeometryBuilder(AliMUONVGeometryBuilder* geomBuilder)
 {
-    //
-    // Add a MUON digit to the list
-    //
+/// Add the geometry builder to the list
 
-  //PH    TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
-    TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
-    new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
+  fGeometryBuilder->AddBuilder(geomBuilder);
 }
 
-//___________________________________________
-void AliMUON::AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
-                              Int_t *singleUndef,
-                              Int_t *pairUnlike, Int_t *pairLike)
-{
-// add a MUON Global Trigger to the list (only one GlobalTrigger per event !)
-  TClonesArray &globalTrigger = *fGlobalTrigger;
-  new(globalTrigger[fNGlobalTrigger++]) 
-    AliMUONGlobalTrigger(singlePlus, singleMinus,  singleUndef, pairUnlike, 
-                        pairLike);
-}
-//___________________________________________
-void AliMUON::AddLocalTrigger(Int_t *localtr)
-{
-// add a MUON Local Trigger to the list
-  TClonesArray &localTrigger = *fLocalTrigger;
-  new(localTrigger[fNLocalTrigger++]) AliMUONLocalTrigger(localtr);
-}
-
-//___________________________________________
+//____________________________________________________________________
 void AliMUON::BuildGeometry()
 {
-// Geometry for event display
-  for (Int_t i=0; i<7; i++) {
-    for (Int_t j=0; j<2; j++) {
-      Int_t id=2*i+j+1;
-      this->Chamber(id-1).SegmentationModel(1)->Draw("eventdisplay");
-    }
-  }
-}
+/// Geometry for event display
 
-//___________________________________________
-Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
-{
-   return 9999;
-}
-
-//___________________________________________
-void AliMUON::MakeBranch(Option_t* option, const char *file)
-{
-    //
-    // Create Tree branches for the MUON.
-    //
-    const Int_t kBufferSize = 4000;
-    char branchname[30];
-    sprintf(branchname,"%sCluster",GetName());
-    
-    AliDetector::MakeBranch(option,file);
-    
-    const char *cD = strstr(option,"D");
-    const char *cR = strstr(option,"R");
-    const char *cH = strstr(option,"H");
 
-    if (fPadHits   && gAlice->TreeH() && cH) {
-      MakeBranchInTree(gAlice->TreeH(), 
-                       branchname, &fPadHits, kBufferSize, file);
-    }
-    
-    if (cD) {
-      //
-      // one branch for digits per chamber
-      // 
-      Int_t i;
-    
-      for (i=0; i<AliMUONConstants::NCh() ;i++) {
-           sprintf(branchname,"%sDigits%d",GetName(),i+1);     
-           if (fDchambers   && gAlice->TreeD()) {
-            MakeBranchInTree(gAlice->TreeD(), 
-                             branchname, &((*fDchambers)[i]), kBufferSize, file);
-             printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
-        }
-         }     
-    }
-    
-    if (cR) {
-      //     
-      // one branch for raw clusters per chamber
-      //  
-      printf("Make Branch - TreeR address %p\n",gAlice->TreeR());
-      
-      Int_t i;
-
-      for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) {
-           sprintf(branchname,"%sRawClusters%d",GetName(),i+1);        
-           if (fRawClusters   && gAlice->TreeR()) {
-              MakeBranchInTree(gAlice->TreeR(), 
-                               branchname, &((*fRawClusters)[i]), kBufferSize, file);
-             printf("Making Branch %s for raw clusters in chamber %d\n",branchname,i+1);
-           }   
-      }
-      //
-      // one branch for global trigger
-      //
-      sprintf(branchname,"%sGlobalTrigger",GetName());
-      if (fGlobalTrigger && gAlice->TreeR()) {  
-          MakeBranchInTree(gAlice->TreeR(), 
-                           branchname, &fGlobalTrigger, kBufferSize, file);
-           printf("Making Branch %s for Global Trigger\n",branchname);
-      }
-      //
-      // one branch for local trigger
-      //  
-      sprintf(branchname,"%sLocalTrigger",GetName());
-      if (fLocalTrigger && gAlice->TreeR()) {  
-          MakeBranchInTree(gAlice->TreeR(), 
-                           branchname, &fLocalTrigger, kBufferSize, file);
-           printf("Making Branch %s for Local Trigger\n",branchname);
-      }
-   }
+//     for (Int_t i = 0; i < AliMUONConstants::NCh(); i++)     
+//       this->Chamber(i).SegmentationModel2(1)->Draw("eventdisplay");// to be check !
+     
+  
 }
 
-//___________________________________________
-void AliMUON::SetTreeAddress()
+//____________________________________________________________________
+const AliMUONGeometry*  AliMUON::GetGeometry() const
 {
-  // Set branch address for the Hits and Digits Tree.
-  char branchname[30];
-  AliDetector::SetTreeAddress();
-
-  TBranch *branch;
-  TTree *treeH = gAlice->TreeH();
-  TTree *treeD = gAlice->TreeD();
-  TTree *treeR = gAlice->TreeR();
-
-  if (treeH) {
-    if (fPadHits) {
-      branch = treeH->GetBranch("MUONCluster");
-      if (branch) branch->SetAddress(&fPadHits);
-    }
-  }
+/// Return geometry parametrisation
 
-  if (treeD) {
-      for (int i=0; i<AliMUONConstants::NCh(); i++) {
-         sprintf(branchname,"%sDigits%d",GetName(),i+1);
-         if (fDchambers) {
-             branch = treeD->GetBranch(branchname);
-             if (branch) branch->SetAddress(&((*fDchambers)[i]));
-         }
-      }
+  if ( !fGeometryBuilder) {
+    AliWarningStream() << "GeometryBuilder not defined." << std::endl;
+    return 0;
   }
+  
+  return fGeometryBuilder->GetGeometry();
+}   
 
-  // printf("SetTreeAddress --- treeR address  %p \n",treeR);
-
-  if (treeR) {
-      for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
-         sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
-         if (fRawClusters) {
-             branch = treeR->GetBranch(branchname);
-             if (branch) branch->SetAddress(&((*fRawClusters)[i]));
-         }
-      }
-
-      if (fLocalTrigger) {
-       branch = treeR->GetBranch("MUONLocalTrigger");
-       if (branch) branch->SetAddress(&fLocalTrigger);
-      }
-      if (fGlobalTrigger) {
-       branch = treeR->GetBranch("MUONGlobalTrigger");
-       if (branch) branch->SetAddress(&fGlobalTrigger);
-      }
-  }
-}
-//___________________________________________
-void AliMUON::ResetHits()
+//____________________________________________________________________
+const AliMUONGeometryTransformer*  AliMUON::GetGeometryTransformer() const
 {
-  // Reset number of clusters and the cluster array for this detector
-  AliDetector::ResetHits();
-  fNPadHits = 0;
-  if (fPadHits) fPadHits->Clear();
-}
+/// Return geometry parametrisation
 
-//____________________________________________
-void AliMUON::ResetDigits()
-{
-    //
-    // Reset number of digits and the digits array for this detector
-    //
-    for ( int i=0;i<AliMUONConstants::NCh();i++ ) {
-      //PH     if ((*fDchambers)[i])    ((TClonesArray*)(*fDchambers)[i])->Clear();
-       if ((*fDchambers)[i])    ((TClonesArray*)fDchambers->At(i))->Clear();
-       if (fNdch)  fNdch[i]=0;
-    }
-}
-//____________________________________________
-void AliMUON::ResetRawClusters()
-{
-    //
-    // Reset number of raw clusters and the raw clust array for this detector
-    //
-    for ( int i=0;i<AliMUONConstants::NTrackingCh();i++ ) {
-      //PH     if ((*fRawClusters)[i])    ((TClonesArray*)(*fRawClusters)[i])->Clear();
-       if ((*fRawClusters)[i])    ((TClonesArray*)fRawClusters->At(i))->Clear();
-       if (fNrawch)  fNrawch[i]=0;
-    }
-}
+  const AliMUONGeometry* kGeometry = GetGeometry();
+  
+  if ( !kGeometry) return 0;
 
-//____________________________________________
-void AliMUON::ResetTrigger()
-{
-  //  Reset Local and Global Trigger 
-  fNGlobalTrigger = 0;
-  if (fGlobalTrigger) fGlobalTrigger->Clear();
-  fNLocalTrigger = 0;
-  if (fLocalTrigger) fLocalTrigger->Clear();
-}
+  return kGeometry->GetTransformer();
+}   
 
-//____________________________________________
-void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
+//__________________________________________________________________
+void 
+AliMUON::MakeBranch(Option_t* opt)
 {
-// Set the pad size for chamber id and cathode isec
-    Int_t i=2*(id-1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i])  ->SetPadSize(isec,p1,p2);
-    //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetPadSize(isec,p1,p2);
-    ((AliMUONChamber*) fChambers->At(i))  ->SetPadSize(isec,p1,p2);
-    ((AliMUONChamber*) fChambers->At(i+1))->SetPadSize(isec,p1,p2);
-}
+  /// Create branche(s) to hold MUON hits
+  AliDebug(1,"");
+  
+  TString sopt(opt);
+  if ( sopt != "H" ) return;
+    
+  if (!fHitStore)
+  {
+    fHitStore = new AliMUONHitStoreV1;
+    if ( gAlice->GetMCApp() )
+    {
+      if ( gAlice->GetMCApp()->GetHitLists() ) 
+      {
+        // AliStack::PurifyKine needs to be able to loop on our hits
+        // to remap the track numbers.
+        gAlice->GetMCApp()->AddHitList(fHitStore->Collection()); 
+      }  
+    }
+  }
 
-//___________________________________________
-void AliMUON::SetChambersZ(const Float_t *Z)
-{
-  // Set Z values for all chambers (tracking and trigger)
-  // from the array pointed to by "Z"
-    for (Int_t ch = 0; ch < AliMUONConstants::NCh(); ch++)
-      //PH     ((AliMUONChamber*) ((*fChambers)[ch]))->SetZ(Z[ch]);
-       ((AliMUONChamber*) fChambers->At(ch))->SetZ(Z[ch]);
-    return;
+  TTree* treeH = fLoader->TreeH();
+  
+  if (!treeH)
+  {
+    AliFatal("No TreeH");
+  }
+  
+  fHitStore->Connect(*treeH);
 }
 
-//___________________________________________
-void AliMUON::SetChambersZToDefault()
+//__________________________________________________________________
+void  
+AliMUON::SetTreeAddress()
 {
-  // Set Z values for all chambers (tracking and trigger)
-  // to default values
-  SetChambersZ(AliMUONConstants::DefaultChamberZ());
-  return;
+  /// Set Hits tree address  
+//  if ( gAlice->GetMCApp() && fHitStore )
+//  {
+//    TList* l = gAlice->GetMCApp()->GetHitLists();
+//    if ( l )
+//    {
+//      TObject* o = l->First();
+//      if (o!=fHitStore->HitCollection())
+//      {
+//        AliError(Form("Something is strange hitcollection=%x",fHitStore->HitCollection()));
+//        l->Print();        
+//      }
+//    }  
+//  }  
+}
+
+//_________________________________________________________________
+void
+AliMUON::ResetHits()
+{
+  /// Reset hits
+  
+  AliDebug(1,"");
+  if (fHitStore) fHitStore->Clear();
 }
 
-//___________________________________________
+//_________________________________________________________________
 void AliMUON::SetChargeSlope(Int_t id, Float_t p1)
 {
-// Set the inverse charge slope for chamber id
-    Int_t i=2*(id-1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetChargeSlope(p1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetChargeSlope(p1);
+/// Set the inverse charge slope for chamber id
+
+    Int_t i=2*(id-1);    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
+    //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
     ((AliMUONChamber*) fChambers->At(i))->SetChargeSlope(p1);
     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSlope(p1);
 }
-
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetChargeSpread(Int_t id, Float_t p1, Float_t p2)
 {
-// Set sigma of charge spread for chamber id
+/// Set sigma of charge spread for chamber id
+
     Int_t i=2*(id-1);
-    //PH    ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
-    //PH    ((AliMUONChamber*) fChambers->Ati+1])->SetChargeSpread(p1,p2);
     ((AliMUONChamber*) fChambers->At(i))->SetChargeSpread(p1,p2);
     ((AliMUONChamber*) fChambers->At(i+1))->SetChargeSpread(p1,p2);
 }
-
-//___________________________________________
+//___________________________________________________________________
 void AliMUON::SetSigmaIntegration(Int_t id, Float_t p1)
 {
-// Set integration limits for charge spread
+/// Set integration limits for charge spread
     Int_t i=2*(id-1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetSigmaIntegration(p1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetSigmaIntegration(p1);
     ((AliMUONChamber*) fChambers->At(i))->SetSigmaIntegration(p1);
     ((AliMUONChamber*) fChambers->At(i+1))->SetSigmaIntegration(p1);
 }
 
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxAdc(Int_t id, Int_t p1)
 {
-// Set maximum number for ADCcounts (saturation)
+/// Set maximum number for ADCcounts (saturation)
+
     Int_t i=2*(id-1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i])->SetMaxAdc(p1);
-    //PH    ((AliMUONChamber*) (*fChambers)[i+1])->SetMaxAdc(p1);
     ((AliMUONChamber*) fChambers->At(i))->SetMaxAdc(p1);
     ((AliMUONChamber*) fChambers->At(i+1))->SetMaxAdc(p1);
 }
 
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxStepGas(Float_t p1)
 {
-// Set stepsize in gas
-     fMaxStepGas=p1;
-}
+/// Set stepsize in gas
 
-//___________________________________________
+  fMaxStepGas=p1;
+}
+//__________________________________________________________________
 void AliMUON::SetMaxStepAlu(Float_t p1)
 {
-// Set step size in Alu
+/// Set step size in Alu
+
     fMaxStepAlu=p1;
 }
-
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxDestepGas(Float_t p1)
 {
-// Set maximum step size in Gas
+/// Set maximum step size in Gas
+
     fMaxDestepGas=p1;
 }
-
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxDestepAlu(Float_t p1)
 {
-// Set maximum step size in Alu
-    fMaxDestepAlu=p1;
+/// Set maximum step size in Alu
+
+  fMaxDestepAlu=p1;
 }
-//___________________________________________
-void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
+
+//____________________________________________________________________
+Float_t  AliMUON::GetMaxStepGas() const
+{
+/// Return stepsize in gas
+  
+  return fMaxStepGas;
+}  
+
+//____________________________________________________________________
+Float_t  AliMUON::GetMaxStepAlu() const
 {
-// Set acceptance cuts 
-   fAccCut=acc;
-   fAccMin=angmin*TMath::Pi()/180;
-   fAccMax=angmax*TMath::Pi()/180;
-   Int_t ch;
-   if (acc) {
-       for (Int_t st = 0; st < AliMUONConstants::NCh() / 2; st++) {
-          // Loop over 2 chambers in the station
-          for (Int_t stCH = 0; stCH < 2; stCH++) {
-              ch = 2 * st + stCH;
-//         Set chamber inner and outer radius according to acceptance cuts
-              Chamber(ch).SetRInner(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMin));
-              Chamber(ch).SetROuter(AliMUONConstants::DefaultChamberZ(ch)*TMath::Tan(fAccMax));
-          } // chamber loop
-       } // station loop
-   }
+/// Return step size in Alu
+  
+  return fMaxStepAlu;
 }
-//___________________________________________
-void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
+  
+//____________________________________________________________________
+Float_t  AliMUON::GetMaxDestepGas() const
 {
-// Set the segmentation for chamber id cathode isec
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
-    ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
-
+/// Return maximum step size in Gas
+  
+  return fMaxDestepGas;
 }
-//___________________________________________
-void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
+  
+//____________________________________________________________________
+Float_t  AliMUON::GetMaxDestepAlu() const
 {
-// Set the response for chamber id
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
-    ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
+/// Return maximum step size in Gas
+  
+  return fMaxDestepAlu;
 }
 
-void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
+//____________________________________________________________________
+ void  AliMUON::SetAlign(Bool_t align)
+{
+/// Set option for alignement to geometry builder
+   fGeometryBuilder->SetAlign(align);
+}   
+
+//____________________________________________________________________
+ void  AliMUON::SetAlign(const TString& fileName, Bool_t align)
 {
-// Set ClusterFinder for chamber id
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
-    ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
+/// Set option for alignement to geometry builder
+   fGeometryBuilder->SetAlign(fileName, align);
+}   
+
+//____________________________________________________________________
+void   AliMUON::SetResponseModel(Int_t id, const AliMUONResponse& response)
+{
+/// Set the response for chamber id
+    ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
 }
 
-void   AliMUON::SetNsec(Int_t id, Int_t nsec)
+//____________________________________________________________________
+AliDigitizer* AliMUON::CreateDigitizer(AliRunDigitizer* manager) const
 {
-// Set number of segmented cathods for chamber id
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
-    ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
+/// Return digitizer
+  
+  AliMUONDigitizerV3* digitizer = new AliMUONDigitizerV3(manager, fDigitizerWithNoise);
+  digitizer->SetCalibrationData(fCalibrationData);
+  return digitizer;
 }
 
-//___________________________________________
+//_____________________________________________________________________
 void AliMUON::SDigits2Digits()
 {
+/// Write TreeD here only 
 
-// write TreeD here 
-
-    if (!fMerger) {
-      if (gAlice->GetDebug()>0) {
-       cerr<<"AliMUON::SDigits2Digits: create default AliMUONMerger "<<endl;
-       cerr<<" no merging, just digitization of 1 event will be done"<<endl;
-      }
-      fMerger = new AliMUONMerger();
-    }
-    fMerger->Init();
-    fMerger->Digitise();
     char hname[30];
-    sprintf(hname,"TreeD%d",gAlice->GetHeader()->GetEvent());
-    gAlice->TreeD()->Write(hname,TObject::kOverwrite);
-    gAlice->TreeD()->Reset();
+    //    sprintf(hname,"TreeD%d",fLoader->GetHeader()->GetEvent());
+    fLoader->TreeD()->Write(hname,TObject::kOverwrite);
+    fLoader->TreeD()->Reset();
 }
 
-//___________________________________________
-void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
-                         Float_t eloss, Float_t tof,  Int_t idvol)
+//_____________________________________________________________________
+void AliMUON::Hits2SDigits()
 {
-//
-//  Calls the charge disintegration method of the current chamber and adds
-//  the simulated cluster to the root treee 
-//
-    Int_t clhits[7];
-    Float_t newclust[6][500];
-    Int_t nnew;
-    
-    
-//
-//  Integrated pulse height on chamber
+/// Perform Hits2Digits using SDigitizerV2
+  
+  AliMUONSDigitizerV2 sdigitizer;
+  sdigitizer.ExecuteTask();
+}
 
-    
-    clhits[0]=fNhits+1;
-//
-//
-//    if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
-    
+//_____________________________________________________________________
+void AliMUON::Digits2Raw()
+{
+/// Convert digits of the current event to raw data
 
-    //PH    ((AliMUONChamber*) (*fChambers)[idvol])
-    ((AliMUONChamber*) fChambers->At(idvol))
-       ->DisIntegration(eloss, tof, xhit, yhit, zhit, nnew, newclust);
-    Int_t ic=0;
-//    if (idvol == 6) printf("\n nnew  %d \n", nnew);
-//
-//  Add new clusters
-    for (Int_t i=0; i<nnew; i++) {
-       if (Int_t(newclust[3][i]) > 0) {
-           ic++;
-// Cathode plane
-           clhits[1] = Int_t(newclust[5][i]);
-//  Cluster Charge
-           clhits[2] = Int_t(newclust[0][i]);
-//  Pad: ix
-           clhits[3] = Int_t(newclust[1][i]);
-//  Pad: iy 
-           clhits[4] = Int_t(newclust[2][i]);
-//  Pad: charge
-           clhits[5] = Int_t(newclust[3][i]);
-//  Pad: chamber sector
-           clhits[6] = Int_t(newclust[4][i]);
-           
-           AddPadHit(clhits);
-       }
+  AliRawDataHeaderSim header;
+
+  if (!fRawWriter)
+  {
+    fRawWriter = new AliMUONRawWriter;
+    AliDebug(1,Form("Creating %s",fRawWriter->ClassName()));
+    if (fTriggerScalerEvent == kTRUE) 
+    {
+      fRawWriter->SetScalersNumbers();
     }
-}
+  }
+  
+  fLoader->LoadDigits("READ");
+  
+  TTree* treeD = fLoader->TreeD();
+  
+  if (!treeD)
+  {
+    AliError("Could not get TreeD");
+    return;
+  }
+  
+  AliMUONVTriggerStore*  triggerStore = AliMUONVTriggerStore::Create(*treeD);
+  AliMUONVDigitStore* digitStore = AliMUONVDigitStore::Create(*treeD);
 
-//___________________________________________
-void AliMUON::Trigger(Int_t nev){
-// call the Trigger Algorithm and fill TreeR
-
-  Int_t singlePlus[3]  = {0,0,0}; 
-  Int_t singleMinus[3] = {0,0,0}; 
-  Int_t singleUndef[3] = {0,0,0};
-  Int_t pairUnlike[3]  = {0,0,0}; 
-  Int_t pairLike[3]    = {0,0,0};
-
-  ResetTrigger();
-  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
-  decision->Trigger();   
-  decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
-                            pairUnlike, pairLike);
-// add a local trigger in the list 
-  AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
-  Int_t i;
+  triggerStore->Connect(*treeD,kFALSE);
+  digitStore->Connect(*treeD,kFALSE);
   
-  for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) { 
-      if(decision->GetITrigger(icirc)==1) {
-         Int_t localtr[7]={0,0,0,0,0,0,0};      
-         Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
-         decision->GetLutOutput(icirc, loLpt, loHpt, loApt);
-         localtr[0] = icirc;
-         localtr[1] = decision->GetStripX11(icirc);
-         localtr[2] = decision->GetDev(icirc);
-         localtr[3] = decision->GetStripY11(icirc);
-         for (i=0; i<2; i++) {    // convert the Lut output in 1 digit 
-             localtr[4] = localtr[4]+Int_t(loLpt[i]*TMath::Power(2,i));
-             localtr[5] = localtr[5]+Int_t(loHpt[i]*TMath::Power(2,i));
-             localtr[6] = localtr[6]+Int_t(loApt[i]*TMath::Power(2,i));
-         }
-         AddLocalTrigger(localtr);  // add a local trigger in the list
-      }
+  treeD->GetEvent(0);
+  
+  fRawWriter->SetHeader(header);
+  if (!fRawWriter->Digits2Raw(digitStore,triggerStore))
+  {
+    AliError("pb writting raw data");
   }
-  delete decision;
-
-  gAlice->TreeR()->Fill();
-  ResetTrigger();
-  char hname[30];
-  sprintf(hname,"TreeR%d",nev);
-  gAlice->TreeR()->Write(hname,TObject::kOverwrite);
-  gAlice->TreeR()->Reset();
-  printf("\n End of trigger for event %d", nev);
+  
+  delete triggerStore;
+  delete digitStore;
+  
+  fLoader->UnloadDigits();
 }
 
-
-//____________________________________________
-void AliMUON::Digits2Reco()
+//_____________________________________________________________________
+Bool_t AliMUON::Raw2SDigits(AliRawReader* rawReader)
 {
-  FindClusters();
-  Int_t nev = gAlice->GetHeader()->GetEvent();
-  gAlice->TreeR()->Fill();
-  char hname[30];
-  sprintf(hname,"TreeR%d", nev);
-  gAlice->TreeR()->Write(hname);
-  gAlice->TreeR()->Reset();
-  ResetRawClusters();        
-  printf("\n End of cluster finding for event %d", nev);
-}
+/// Convert  raw data to SDigit
 
-void AliMUON::FindClusters()
-{
-//
-//  Perform cluster finding
-//
-    TClonesArray *dig1, *dig2;
-    Int_t ndig, k;
-    dig1 = new TClonesArray("AliMUONDigit",1000);
-    dig2 = new TClonesArray("AliMUONDigit",1000);
-    AliMUONDigit *digit;
-//
-// Loop on chambers and on cathode planes
-//
-    ResetRawClusters();        
-    for (Int_t ich = 0; ich < 10; ich++) {
-      //PH     AliMUONChamber* iChamber = (AliMUONChamber*) (*fChambers)[ich];
-       AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
-       AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
-    
-       gAlice->ResetDigits();
-       gAlice->TreeD()->GetEvent(0);
-       TClonesArray *muonDigits = this->DigitsAddress(ich);
-       ndig=muonDigits->GetEntriesFast();
-       printf("\n 1 Found %d digits in %p %d", ndig, muonDigits,ich);
-       TClonesArray &lhits1 = *dig1;
-       Int_t n = 0;
-       for (k = 0; k < ndig; k++) {
-           digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
-           if (rec->TestTrack(digit->Track(0)))
-               new(lhits1[n++]) AliMUONDigit(*digit);
-       }
-       gAlice->ResetDigits();
-       gAlice->TreeD()->GetEvent(1);
-       muonDigits  = this->DigitsAddress(ich);
-       ndig=muonDigits->GetEntriesFast();
-       printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
-       TClonesArray &lhits2 = *dig2;
-       n=0;
-       
-       for (k=0; k<ndig; k++) {
-           digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
-           if (rec->TestTrack(digit->Track(0)))
-           new(lhits2[n++]) AliMUONDigit(*digit);
-       }
+  fLoader->LoadDigits("READ");
+  if (!fLoader->TreeS()) fLoader->MakeSDigitsContainer();
 
-       if (rec) {       
-           AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
-           rec->FindRawClusters();
-       }
-       dig1->Delete();
-       dig2->Delete();
-    } // for ich
-    delete dig1;
-    delete dig2;
+  TTree* treeS = fLoader->TreeS();
+  
+  AliMUONVDigitStore* sDigitStore = new AliMUONDigitStoreV1;
+  sDigitStore->Connect(*treeS);
+  
+  fDigitMaker->Raw2Digits(rawReader,sDigitStore,0x0);
+
+  fLoader->WriteSDigits("OVERWRITE");
+
+  fLoader->UnloadSDigits();
+
+  delete sDigitStore;
+  
+  return kTRUE;
 }
+
+//_______________________________________________________________________
+AliLoader* AliMUON::MakeLoader(const char* topfoldername)
+{ 
+/// Build standard getter (AliLoader type);
+/// if detector wants to use castomized getter, it must overload this method
  
-#ifdef never
-void AliMUON::Streamer(TBuffer &R__b)
-{
-   // Stream an object of class AliMUON.
-      AliMUONChamber        *iChamber;
-      AliMUONTriggerCircuit *iTriggerCircuit;
-      AliSegmentation       *segmentation;
-      AliMUONResponse       *response;
-      TClonesArray          *digitsaddress;
-      TClonesArray          *rawcladdress;
-      Int_t i;
-      if (R__b.IsReading()) {
-         Version_t R__v = R__b.ReadVersion(); if (R__v) { }
-         AliDetector::Streamer(R__b);
-         R__b >> fNPadHits;
-         R__b >> fPadHits; // diff
-         R__b >> fNLocalTrigger;       
-         R__b >> fLocalTrigger;       
-         R__b >> fNGlobalTrigger;       
-         R__b >> fGlobalTrigger;   
-         R__b >> fDchambers;
-         R__b >> fRawClusters;
-         R__b.ReadArray(fNdch);
-         R__b.ReadArray(fNrawch);
-         R__b >> fAccCut;
-         R__b >> fAccMin;
-         R__b >> fAccMax; 
-         R__b >> fChambers;
-         R__b >> fTriggerCircuits;
-         for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
-             iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
-             iTriggerCircuit->Streamer(R__b);
-         }
-// Stream chamber related information
-         for (i =0; i<AliMUONConstants::NCh(); i++) {
-             iChamber=(AliMUONChamber*) (*fChambers)[i];
-             iChamber->Streamer(R__b);
-             if (iChamber->Nsec()==1) {
-                 segmentation=iChamber->SegmentationModel(1);
-                 if (segmentation)
-                     segmentation->Streamer(R__b);
-             } else {
-                 segmentation=iChamber->SegmentationModel(1);
-                 if (segmentation)
-                     segmentation->Streamer(R__b);
-                 if (segmentation)
-                     segmentation=iChamber->SegmentationModel(2);
-                 segmentation->Streamer(R__b);
-             }
-             response=iChamber->ResponseModel();
-             if (response)
-                 response->Streamer(R__b);       
-             digitsaddress=(TClonesArray*) (*fDchambers)[i];
-             digitsaddress->Streamer(R__b);
-             if (i < AliMUONConstants::NTrackingCh()) {
-                 rawcladdress=(TClonesArray*) (*fRawClusters)[i];
-                 rawcladdress->Streamer(R__b);
-             }
-         }
-         
-      } else {
-         R__b.WriteVersion(AliMUON::IsA());
-         AliDetector::Streamer(R__b);
-         R__b << fNPadHits;
-         R__b << fPadHits; // diff
-         R__b << fNLocalTrigger;       
-         R__b << fLocalTrigger;       
-         R__b << fNGlobalTrigger;       
-         R__b << fGlobalTrigger; 
-         R__b << fDchambers;
-         R__b << fRawClusters;
-         R__b.WriteArray(fNdch, AliMUONConstants::NCh());
-         R__b.WriteArray(fNrawch, AliMUONConstants::NTrackingCh());
-         
-         R__b << fAccCut;
-         R__b << fAccMin;
-         R__b << fAccMax; 
-         
-         R__b << fChambers;
-         R__b << fTriggerCircuits;
-         for (i =0; i<AliMUONConstants::NTriggerCircuit(); i++) {
-             iTriggerCircuit=(AliMUONTriggerCircuit*) (*fTriggerCircuits)[i];
-             iTriggerCircuit->Streamer(R__b);
-         }
-         for (i =0; i<AliMUONConstants::NCh(); i++) {
-             iChamber=(AliMUONChamber*) (*fChambers)[i];
-             iChamber->Streamer(R__b);
-             if (iChamber->Nsec()==1) {
-                 segmentation=iChamber->SegmentationModel(1);
-                 if (segmentation)
-                     segmentation->Streamer(R__b);
-             } else {
-                 segmentation=iChamber->SegmentationModel(1);
-                 if (segmentation)
-                     segmentation->Streamer(R__b);
-                 segmentation=iChamber->SegmentationModel(2);
-                 if (segmentation)
-                     segmentation->Streamer(R__b);
-             }
-             response=iChamber->ResponseModel();
-             if (response)
-                 response->Streamer(R__b);
-             digitsaddress=(TClonesArray*) (*fDchambers)[i];
-             digitsaddress->Streamer(R__b);
-             if (i < AliMUONConstants::NTrackingCh()) {
-                 rawcladdress=(TClonesArray*) (*fRawClusters)[i];
-                 rawcladdress->Streamer(R__b);
-             }
-         }
-      }
+ AliDebug(1,Form("Creating standard getter for detector %s. Top folder is %s.",
+         GetName(),topfoldername));
+ fLoader   = new AliLoader(GetName(),topfoldername);
+
+ return fLoader;
 }
-#endif
 
-AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters) 
+//________________________________________________________________________
+void
+AliMUON::ResetGeometryBuilder()
 {
-//
-    // Initialise the pad iterator
-    // Return the address of the first padhit for hit
-    TClonesArray *theClusters = clusters;
-    Int_t nclust = theClusters->GetEntriesFast();
-    if (nclust && hit->PHlast() > 0) {
-       AliMUON::fMaxIterPad=hit->PHlast();
-       AliMUON::fCurIterPad=hit->PHfirst();
-       return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
-    } else {
-       return 0;
-    }
+/// Only to be used by "experts" wanting to change the geometry builders
+/// to be used. 
+/// As the ctor of AliMUON now defines a default geometrybuilder, this
+/// ResetGeometryBuilder() must be called prior to call the 
+/// AddGeometryBuilder()
+
+  delete fGeometryBuilder;
+  fGeometryBuilder = new AliMUONGeometryBuilder(this);
+  fGeometryBuilder
+    ->AddBuilder(new AliMUONCommonGeometryBuilder(this));
 }
 
-AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters) 
+//____________________________________________________________________
+Bool_t  AliMUON::GetTriggerResponseV1() const
 {
-// Get next pad (in iterator) 
-//
-    AliMUON::fCurIterPad++;
-    if (AliMUON::fCurIterPad <= AliMUON::fMaxIterPad) {
-       return (AliMUONPadHit*) clusters->UncheckedAt(AliMUON::fCurIterPad-1);
-    } else {
-       return 0;
-    }
+///
+/// Returns fTriggerResponseV1
+///  
+    return fTriggerResponseV1;
+    
+}  
+
+//____________________________________________________________________
+Int_t  AliMUON::GetTriggerCoinc44() const
+{
+///
+/// Returns fTriggerCoinc44
+///  
+    return fTriggerCoinc44;
+    
 }
 
+//____________________________________________________________________
+Bool_t  AliMUON::GetTriggerEffCells() const
+{
+///
+/// Returns fTriggerEffCells
+///  
+    return fTriggerEffCells;
+    
+}  
 
-AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
+//____________________________________________________________________
+Int_t  AliMUON::GetDigitizerWithNoise() const
 {
-//
-//  Return rawcluster (icluster) for chamber ichamber and cathode icathod
-//  Obsolete ??
-    TClonesArray *muonRawCluster  = RawClustAddress(ichamber);
-    ResetRawClusters();
-    TTree *treeR = gAlice->TreeR();
-    Int_t nent=(Int_t)treeR->GetEntries();
-    treeR->GetEvent(nent-2+icathod-1);
-    //treeR->GetEvent(icathod);
-    //Int_t nrawcl = (Int_t)muonRawCluster->GetEntriesFast();
-
-    AliMUONRawCluster * mRaw = (AliMUONRawCluster*)muonRawCluster->UncheckedAt(icluster);
-    //printf("RawCluster _ nent nrawcl icluster mRaw %d %d %d%p\n",nent,nrawcl,icluster,mRaw);
+///
+/// Returns fDigitizerWithNoise
+///  
+    return fDigitizerWithNoise;
     
-    return  mRaw;
-}
-void   AliMUON::SetMerger(AliMUONMerger* merger)
+}  
+
+//____________________________________________________________________
+Bool_t AliMUON::UsingFastTrackerDecoder() const
 {
-// Set pointer to merger 
-    fMerger = merger;
+/// Checks to see if we are using the fast decoder for tracker DDL streams.
+
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return kFALSE;
+  }
+  
+  return fDigitMaker->UsingFastTrackerDecoder();
 }
 
-AliMUONMerger*  AliMUON::Merger()
+//____________________________________________________________________
+Bool_t AliMUON::UsingFastTriggerDecoder() const
 {
-// Return pointer to merger
-    return fMerger;
+/// Checks to see if we are using the fast decoder for trigger DDL streams.
+
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return kFALSE;
+  }
+  
+  return fDigitMaker->UsingFastTriggerDecoder();
 }
 
+//____________________________________________________________________
+void AliMUON::SetFastTrackerDecoder(Bool_t useFastDecoder)
+{
+/// Set fast raw data decoder 
 
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return;
+  }
 
-AliMUON& AliMUON::operator = (const AliMUON& rhs)
-{
-// copy operator
-// dummy version
-    return *this;
+  fDigitMaker->SetFastTrackerDecoder(useFastDecoder);
 }
 
-////////////////////////////////////////////////////////////////////////
-void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
+//____________________________________________________________________
+void AliMUON::SetFastTriggerDecoder(Bool_t useFastDecoder)
 {
-    //
-    // Create TreeD branches for the MUON.
-    //
+/// Set fast raw data decoder 
 
-  const Int_t kBufferSize = 4000;
-  char branchname[30];
-    
-  //
-  // one branch for digits per chamber
-  // 
-  for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
-    sprintf(branchname,"%sDigits%d",GetName(),i+1);    
-    if (fDchambers && treeD) {
-      MakeBranchInTree(treeD, 
-                      branchname, &((*fDchambers)[i]), kBufferSize, file);
-//      printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
-    }
+  if ( ! fDigitMaker ) {
+    AliError("Digit maker is not instantiated.");
+    return;
   }
-}
 
-//___________________________________________
+  fDigitMaker->SetFastTriggerDecoder(useFastDecoder);
+}