New MUON data container AliMUONData implementation
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Sep 2003 22:27:42 +0000 (22:27 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Sep 2003 22:27:42 +0000 (22:27 +0000)
22 files changed:
MUON/AliMUON.cxx
MUON/AliMUON.h
MUON/AliMUONClusterFinderAZ.cxx
MUON/AliMUONClusterFinderVS.cxx
MUON/AliMUONData.cxx
MUON/AliMUONData.h
MUON/AliMUONDigitizer.cxx
MUON/AliMUONDigitizer.h
MUON/AliMUONDigitizerv1.cxx
MUON/AliMUONDigitizerv1.h
MUON/AliMUONDisplay.cxx
MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONMerger.cxx
MUON/AliMUONPoints.cxx
MUON/AliMUONSegmentationSlatModuleN.cxx
MUON/AliMUONTrackK.cxx
MUON/AliMUONTriggerDecision.cxx
MUON/AliMUONv1.cxx
MUON/MUONCheck.C
MUON/MUONLinkDef.h
MUON/MUONrawclusters.C
MUON/libMUON.pkg

index a0cb78fb1046fbea4598d39855aba852e5042bdc..0a7ad8477d0c24342e7fd0aba7f69c36892182c9 100644 (file)
@@ -84,7 +84,7 @@
 //          for the first and second chambers in the station, respectively
 
 ClassImp(AliMUON)
-//___________________________________________
+//__________________________________________________________________
 AliMUON::AliMUON()
 {
 // Default Constructor
@@ -92,267 +92,95 @@ AliMUON::AliMUON()
     fNCh             = 0;
     fNTrackingCh     = 0;
     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;
+    fTriggerCircuits = 0;
     fAccMin          = 0.;
     fAccMax          = 0.;   
     fAccCut          = kFALSE;
     fMerger          = 0;
     fFileName        = 0;
 }
-//___________________________________________
+//__________________________________________________________________
 AliMUON::AliMUON(const char *name, const char *title)
-       : AliDetector(name,title)
+  : AliDetector(name,title)
 {
 //Begin_Html
 /*
 <img src="gif/alimuon.gif">
 */
 //End_Html
+  fMUONData  = 0x0;
+  fIshunt     =  0;
 
-   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());
+  fNCh             = AliMUONConstants::NCh(); 
+  fNTrackingCh     = 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);
-//
+  SetMarkerColor(kRed);//
 //
-//
-//
-
+// Creating List of Chambers
     Int_t ch;
-
     fChambers = new TObjArray(AliMUONConstants::NCh());
-
     // 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),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 
     }     // 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;
+    
+    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):AliDetector(rMUON)
 {
 // Dummy copy constructor
     ;
     
 }
-
+//____________________________________________________________________
 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::AddHit(Int_t fIshunt, Int_t track, Int_t iChamber, 
-             Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
-             Float_t tof, Float_t momentum, Float_t theta, 
-             Float_t phi, Float_t length, Float_t destep)
-{
-  TClonesArray &lhits = *fHits;
-  new(lhits[fNhits++]) AliMUONHit(fIshunt, track, iChamber, 
-              idpart, X, Y, Z, 
-              tof, momentum, theta, 
-              phi, length, destep);
-}
-//___________________________________________
-void AliMUON::AddPadHit(Int_t *clhits)  // To be removed
-{
-   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
-    //
-
-  //PH    TClonesArray &ldigits = * ((TClonesArray*)(*fDchambers)[id]);
-    TClonesArray &ldigits = * ( (TClonesArray*) fDchambers->At(id) );
-    new(ldigits[fNdch[id]++]) AliMUONDigit(tracks,charges,digits);
-}
-
-//_____________________________________________________________________________
-void AliMUON::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
-{
-    //
-    // Add a MUON digit to the list
-    //
-
-  //PH    TClonesArray &lrawcl = *((TClonesArray*)(*fRawClusters)[id]);
-    TClonesArray &lrawcl = *((TClonesArray*)fRawClusters->At(id));
-    new(lrawcl[fNrawch[id]++]) AliMUONRawCluster(c);
+  if(fDebug) printf("%s: Calling AliMUON destructor !!!\n",ClassName());
+  fIshunt  = 0;
+  if (fMerger) delete fMerger;
 }
-
-//___________________________________________
-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
@@ -363,233 +191,23 @@ void AliMUON::BuildGeometry()
     }
   }
 }
-
-//___________________________________________
+//___________________________________________________________________
 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
 {
-   return 9999;
-}
-
-//___________________________________________
-void AliMUON::MakeBranch(Option_t* option)
-{
-    //
-    // Create Tree branches for the MUON.
-    //
-    const Int_t kBufferSize = 4000;
-    char branchname[30];
-    sprintf(branchname,"%sCluster",GetName());
-    
-    
-    const char *cD = strstr(option,"D");
-    const char *cR = strstr(option,"R");
-    const char *cH = strstr(option,"H");
-
-    if (TreeH() && cH) 
-     {
-      if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
-      MakeBranchInTree(TreeH(), branchname, &fPadHits, kBufferSize, 0);
-      if (fHits == 0x0) fHits     = new TClonesArray("AliMUONHit",1000);
-     }
-    //it must be under fHits creation
-    AliDetector::MakeBranch(option);
-    
-    if (cD  && fLoader->TreeD()) {
-      //
-      // one branch for digits per chamber
-      // 
-      Int_t i;
-      if (fDchambers  == 0x0) 
-        {
-          fDchambers = new TObjArray(AliMUONConstants::NCh());
-          for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
-              fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
-          }
-        }
-    
-      for (i=0; i<AliMUONConstants::NCh() ;i++) 
-       {
-        sprintf(branchname,"%sDigits%d",GetName(),i+1);        
-        MakeBranchInTree(fLoader->TreeD(), branchname, &((*fDchambers)[i]), kBufferSize, 0);
-        printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
-       }
-    }
-    
-    if (cR  && fLoader->TreeR()) {
-      //     
-      // one branch for raw clusters per chamber
-      //  
-      printf("Make Branch - TreeR address %p\n",fLoader->TreeR());
-      
-      Int_t i;
-      if (fRawClusters == 0x0)
-      {
-        fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
-        for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
-            fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
-        }
-      }
-
-      for (i=0; i<AliMUONConstants::NTrackingCh() ;i++) 
-       {
-         sprintf(branchname,"%sRawClusters%d",GetName(),i+1);  
-         MakeBranchInTree(fLoader->TreeR(), branchname, &((*fRawClusters)[i]), kBufferSize, 0);
-         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 == 0x0) {
-        fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
-      }
-      MakeBranchInTree(fLoader->TreeR(), branchname, &fGlobalTrigger, kBufferSize, 0);
-      printf("Making Branch %s for Global Trigger\n",branchname);
-      //
-      // one branch for local trigger
-      //  
-      sprintf(branchname,"%sLocalTrigger",GetName());
-      
-      if (fLocalTrigger == 0x0) {
-        fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
-      }
-      
-      MakeBranchInTree(fLoader->TreeR(), branchname, &fLocalTrigger, kBufferSize, 0);
-      printf("Making Branch %s for Local Trigger\n",branchname);
-   }
-}
-
-//___________________________________________
-void AliMUON::SetTreeAddress()
-{
-  // Set branch address for the Hits and Digits Tree.
-  char branchname[30];
-
-  TBranch *branch;
-  TTree *treeH = fLoader->TreeH();
-  TTree *treeD = fLoader->TreeD();
-  TTree *treeR = fLoader->TreeR();
-
-  if (treeH) {
-    if (fPadHits == 0x0) fPadHits = new TClonesArray("AliMUONPadHit",10000);
-    if (fPadHits) {
-      branch = treeH->GetBranch("MUONCluster");
-      if (branch) branch->SetAddress(&fPadHits);
-    }
-    if (fHits == 0x0) fHits     = new TClonesArray("AliMUONHit",1000);
-  }
-  //it must be under fHits creation
-  AliDetector::SetTreeAddress();
-
-  if (treeD) {
-      if (fDchambers == 0x0) 
-        {
-          fDchambers = new TObjArray(AliMUONConstants::NCh());
-          for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
-              fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
-          }
-        }
-      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]));
-         }
-      }
-  }
-
-  // printf("SetTreeAddress --- treeR address  %p \n",treeR);
-
-  if (treeR) {
-      if (fRawClusters == 0x0)
-      {
-        fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
-        for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
-            fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
-        }
-      }
-      
-      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 == 0x0) {
-        fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
-      }
-
-      if (fLocalTrigger) {
-       branch = treeR->GetBranch("MUONLocalTrigger");
-       if (branch) branch->SetAddress(&fLocalTrigger);
-      }
-      
-      if (fGlobalTrigger == 0x0) {
-        fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
-      }
-      
-      if (fGlobalTrigger) {
-       branch = treeR->GetBranch("MUONGlobalTrigger");
-       if (branch) branch->SetAddress(&fGlobalTrigger);
-      }
-  }
-}
-//___________________________________________
-void AliMUON::ResetHits()
-{
-  // Reset number of clusters and the cluster array for this detector
-  AliDetector::ResetHits();
-  fNPadHits = 0;
-  if (fPadHits) fPadHits->Clear();
+  return 9999;
 }
-
-//____________________________________________
-void AliMUON::ResetDigits()
-{
-    //
-    // Reset number of digits and the digits array for this detector
-    //
-    if (fDchambers == 0x0) return;
-    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;
-    }
-}
-
-//____________________________________________
-void AliMUON::ResetTrigger()
+//__________________________________________________________________
+void  AliMUON::SetTreeAddress()
 {
-  //  Reset Local and Global Trigger 
-  fNGlobalTrigger = 0;
-  if (fGlobalTrigger) fGlobalTrigger->Clear();
-  fNLocalTrigger = 0;
-  if (fLocalTrigger) fLocalTrigger->Clear();
+  GetMUONData()->SetLoader(fLoader); 
+  GetMUONData()->SetTreeAddress("H,D,RC");
 }
 
-//____________________________________________
+//____________________________________________________________________
 void AliMUON::SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2)
 {
 // 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);
 }
@@ -600,12 +218,10 @@ 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;
 }
-
-//___________________________________________
+//_________________________________________________________________
 void AliMUON::SetChambersZToDefault()
 {
   // Set Z values for all chambers (tracking and trigger)
@@ -613,129 +229,110 @@ void AliMUON::SetChambersZToDefault()
   SetChambersZ(AliMUONConstants::DefaultChamberZ());
   return;
 }
-
-//___________________________________________
+//_________________________________________________________________
 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);
+    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
     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
     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)
     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;
+  fMaxStepGas=p1;
 }
-
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxStepAlu(Float_t p1)
 {
 // Set step size in Alu
     fMaxStepAlu=p1;
 }
-
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxDestepGas(Float_t p1)
 {
 // Set maximum step size in Gas
     fMaxDestepGas=p1;
 }
-
-//___________________________________________
+//__________________________________________________________________
 void AliMUON::SetMaxDestepAlu(Float_t p1)
 {
 // Set maximum step size in Alu
-    fMaxDestepAlu=p1;
+  fMaxDestepAlu=p1;
 }
-//___________________________________________
+//___________________________________________________________________
 void AliMUON::SetAcceptance(Bool_t acc, Float_t angmin, Float_t angmax)
 {
 // 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
-   }
+  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
+  }
 }
-//___________________________________________
+//____________________________________________________________________
 void   AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliSegmentation *segmentation)
 {
 // Set the segmentation for chamber id cathode isec
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetSegmentationModel(isec, segmentation);
     ((AliMUONChamber*) fChambers->At(id))->SetSegmentationModel(isec, segmentation);
 
 }
-//___________________________________________
+//____________________________________________________________________
 void   AliMUON::SetResponseModel(Int_t id, AliMUONResponse *response)
 {
 // Set the response for chamber id
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetResponseModel(response);
     ((AliMUONChamber*) fChambers->At(id))->SetResponseModel(response);
 }
-
+//____________________________________________________________________
 void   AliMUON::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
 {
 // Set ClusterFinder for chamber id
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetReconstructionModel(reconst);
     ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
 }
-
+//____________________________________________________________________
 void   AliMUON::SetNsec(Int_t id, Int_t nsec)
 {
 // Set number of segmented cathods for chamber id
-  //PH    ((AliMUONChamber*) (*fChambers)[id])->SetNsec(nsec);
     ((AliMUONChamber*) fChambers->At(id))->SetNsec(nsec);
 }
-
-//___________________________________________
+//_____________________________________________________________________
 void AliMUON::SDigits2Digits()
 {
 
@@ -756,8 +353,7 @@ void AliMUON::SDigits2Digits()
     fLoader->TreeD()->Reset();
 }
 
-
-//__________________________________________________________________________
+//_______________________________________________________________________
 AliLoader* AliMUON::MakeLoader(const char* topfoldername)
 { 
 //builds standard getter (AliLoader type)
@@ -768,62 +364,12 @@ AliLoader* AliMUON::MakeLoader(const char* topfoldername)
         "Creating standard getter for detector %s. Top folder is %s.",
          GetName(),topfoldername);
      
- fLoader = new AliMUONLoader(GetName(),topfoldername);
+ fLoader   = new AliLoader(GetName(),topfoldername);
+ fMUONData = new AliMUONData(fLoader,GetName(),GetName()); 
  return fLoader;
 }
-//__________________________________________________________________________
-// To be removed
-void AliMUON::MakePadHits(Float_t xhit,Float_t yhit, Float_t zhit,
-                         Float_t eloss, Float_t tof,  Int_t idvol)
-{
-//
-//  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
-
-    
-    clhits[0]=fNhits+1;
-//
-//
-//    if (idvol == 6) printf("\n ->Disintegration %f %f %f", xhit, yhit, eloss );
-    
-
-    //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);
-       }
-    }
-}
 
-//___________________________________________
+//_______________________________________________________________________
 void AliMUON::Trigger(Int_t nev){
 // call the Trigger Algorithm and fill TreeR
 
@@ -832,50 +378,49 @@ void AliMUON::Trigger(Int_t nev){
   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);
+  
+  // add a local trigger in the list 
+  GetMUONData()->AddGlobalTrigger(singlePlus, singleMinus, singleUndef, pairUnlike, pairLike);
   Int_t i;
   
   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
+    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));
       }
+      GetMUONData()->AddLocalTrigger(localtr);  // add a local trigger in the list
+    }
   }
-
+  
   delete decision;
-
+  
   fLoader->TreeR()->Fill();
-//  char hname[30];
-//  sprintf(hname,"TreeR%d",nev);
-//  fLoader->TreeR()->Write(hname,TObject::kOverwrite);
-//  fLoader->TreeR()->Reset();
+  //  char hname[30];
+  //  sprintf(hname,"TreeR%d",nev);
+  //  fLoader->TreeR()->Write(hname,TObject::kOverwrite);
+  //  fLoader->TreeR()->Reset();
   fLoader->WriteRecPoints("OVERWRITE");
   ResetTrigger();
   
   printf("\n End of trigger for event %d", nev);
 }
 
-
-//____________________________________________
+//____________________________________________________________________
 void AliMUON::Digits2Reco()
 {
   FindClusters();
@@ -886,10 +431,10 @@ void AliMUON::Digits2Reco()
   //fLoader->TreeR()->Write(hname);
   //fLoader->TreeR()->Reset();
   fLoader->WriteRecPoints("OVERWRITE");
-  ResetRawClusters();        
+  GetMUONData()->ResetRawClusters();        
   printf("\n End of cluster finding for event %d", nev);
 }
-
+//____________________________________________________________________
 void AliMUON::FindClusters()
 {
 //
@@ -913,7 +458,7 @@ void AliMUON::FindClusters()
        ResetDigits();
        fLoader->TreeD()->GetEvent(0);
        //TClonesArray *
-       muonDigits = (TClonesArray *) Dchambers()->At(ich);
+       muonDigits = GetMUONData()->Digits(ich,0);  // cathode plane not yet operational
        ndig=muonDigits->GetEntriesFast();
        printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
        TClonesArray &lhits1 = *dig1;
@@ -926,7 +471,7 @@ void AliMUON::FindClusters()
        ResetDigits();
        fLoader->TreeD()->GetEvent(1);
        //muonDigits  = this->DigitsAddress(ich);
-       muonDigits = (TClonesArray *) Dchambers()->At(ich);
+       muonDigits =  GetMUONData()->Digits(ich,1);  // cathode plane not yet operational
        ndig=muonDigits->GetEntriesFast();
        printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
        TClonesArray &lhits2 = *dig2;
@@ -948,9 +493,9 @@ void AliMUON::FindClusters()
     delete dig1;
     delete dig2;
 }
+//______________________________________________________________________
 #ifdef never
-void AliMUON::Streamer(TBuffer &R__b)
+void AliMUON::Streamer(TBuffer &R__b)_
 {
    // Stream an object of class AliMUON.
       AliMUONChamber        *iChamber;
@@ -1061,7 +606,7 @@ void AliMUON::Streamer(TBuffer &R__b)
       }
 }
 #endif
-
+//_______________________________________________________________________
 AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters) 
 {
 // to be removed
@@ -1077,7 +622,7 @@ AliMUONPadHit* AliMUON::FirstPad(AliMUONHit*  hit, TClonesArray *clusters)
        return 0;
     }
 }
-
+//_______________________________________________________________________
 AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters) 
 {
   // To be removed
@@ -1090,14 +635,14 @@ AliMUONPadHit* AliMUON::NextPad(TClonesArray *clusters)
        return 0;
     }
 }
-
+//_______________________________________________________________________
 
 AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t icluster)
 {
 //
 //  Return rawcluster (icluster) for chamber ichamber and cathode icathod
 //  Obsolete ??
-    TClonesArray *muonRawCluster  = RawClustAddress(ichamber);
+    TClonesArray *muonRawCluster  = GetMUONData()->RawClusters(ichamber);
     ResetRawClusters();
     TTree *treeR = fLoader->TreeR();
     Int_t nent=(Int_t)treeR->GetEntries();
@@ -1110,21 +655,19 @@ AliMUONRawCluster *AliMUON::RawCluster(Int_t ichamber, Int_t icathod, Int_t iclu
     
     return  mRaw;
 }
+//________________________________________________________________________
 void   AliMUON::SetMerger(AliMUONMerger* merger)
 {
 // Set pointer to merger 
     fMerger = merger;
 }
-
+//________________________________________________________________________
 AliMUONMerger*  AliMUON::Merger()
 {
 // Return pointer to merger
     return fMerger;
 }
-
-
-
+//________________________________________________________________________
 AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
 {
 // copy operator
@@ -1132,34 +675,3 @@ AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
     return *this;
 }
 
-////////////////////////////////////////////////////////////////////////
-void AliMUON::MakeBranchInTreeD(TTree *treeD, const char *file)
-{
-    //
-    // Create TreeD branches for the MUON.
-    //
-
-  const Int_t kBufferSize = 4000;
-  char branchname[30];
-    
-  if (fDchambers  == 0x0)   {
-    fDchambers = new TObjArray(AliMUONConstants::NCh());
-    for (Int_t i=0; i<AliMUONConstants::NCh() ;i++) {
-      fDchambers->AddAt(new TClonesArray("AliMUONDigit",10000),i); 
-    }
-  }
-  //
-  // 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);
-    }
-  }
-}
-
-//___________________________________________
-
index c2c32cf128469d9d29f466c435c37297c97c3de9..a127602c15bc7da51473071cc41968b6e4c0e9ac 100644 (file)
 //  AliDetector Class for MUON subsystem      //
 ////////////////////////////////////////////////
 #include "AliDetector.h"
+#include "AliMUONData.h"
+#include "AliMUONChamber.h"
 
 class AliLoader;
-class AliMUONChamber;
 class AliMUONLocalTrigger;
 class AliMUONGlobalTrigger;
 class AliMUONTriggerCircuit;
@@ -40,139 +41,101 @@ class AliMUON : public  AliDetector {
     AliMUON(const char *name, const char *title);
     AliMUON(const AliMUON& rMUON);
     virtual       ~AliMUON();
-    virtual void   AddHit(Int_t track , Int_t *vol, Float_t *hits);
-    virtual void   AddHit(Int_t fIshunt, Int_t track, Int_t iChamber, 
-                         Int_t idpart, Float_t X, Float_t Y, Float_t Z, 
-                         Float_t tof, Float_t momentum, Float_t theta, 
-                         Float_t phi, Float_t length, Float_t destep);
-    virtual void   AddPadHit(Int_t* clhits); // To be removed !
-    virtual void   AddDigits(Int_t id, Int_t* tracks, Int_t* charges,
-                            Int_t* digits);
-    virtual void   AddRawCluster(Int_t id, const AliMUONRawCluster& clust);
+   
     virtual void   BuildGeometry();
-    void           AddGlobalTrigger(Int_t *singlePlus, Int_t *singleMinus,
-                                   Int_t *singleUndef, Int_t *pairUnlike, 
-                                   Int_t *pairLike);
-    void           AddLocalTrigger(Int_t* ltrigger);
     Int_t          DistancetoPrimitive(Int_t px, Int_t py);
-    virtual Int_t  IsVersion() const {return 0;}
-    TClonesArray  *PadHits() {return fPadHits;}
-    TClonesArray  *LocalTrigger() {return fLocalTrigger;}
-    TClonesArray  *GlobalTrigger() {return fGlobalTrigger;}
+    AliMUONData*   GetMUONData() {return fMUONData;}
+    virtual Int_t  IsVersion()   const {return 0;}
 
+    // MUONLoader definition
     virtual AliLoader* MakeLoader(const char* topfoldername); //builds standard getter (AliLoader type)
-
-    virtual void       MakeBranch(Option_t *opt=" ");
-    virtual void       MakeBranchInTreeD(TTree *treeD, const char *file=0);
+    // Interface with AliMUONData
+    virtual void       MakeBranch(Option_t *opt=" ") {GetMUONData()->MakeBranch(opt);}
     void               SetTreeAddress();
-    virtual void       ResetHits();
-    virtual void       ResetDigits();
-    virtual void       ResetTrigger();
-    virtual void       ResetRawClusters();
+    virtual void       ResetHits()                   {GetMUONData()->ResetHits();}
+    virtual void       ResetDigits()                 {GetMUONData()->ResetDigits();}
+    virtual void       ResetTrigger()                {GetMUONData()->ResetTrigger();};
+    virtual void       ResetRawClusters()            {GetMUONData()->ResetRawClusters();};
     // Cluster Finding
     virtual void   Digits2Reco();
     virtual void   FindClusters();
     // Digitisation 
     virtual void   SDigits2Digits();      
-// Configuration Methods (per station id)
-//
-// Set Chamber Segmentation Parameters
-// id refers to the station and isec to the cathode plane
-// Set Z values for all chambers
+    // Configuration Methods (per station id)
+    //
+    // Set Chamber Segmentation Parameters
+    // id refers to the station and isec to the cathode plane
+    // Set Z values for all chambers
     virtual void SetChambersZ(const Float_t *Z);
     virtual void SetChambersZToDefault(void);
     virtual void SetPadSize(Int_t id, Int_t isec, Float_t p1, Float_t p2);
-// Set Signal Generation Parameters
+    // 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 Segmentation and Response Model
+    // Set Segmentation and Response Model
     virtual void   SetSegmentationModel(Int_t id, Int_t isec,
                                        AliSegmentation *segmentation);
     virtual void   SetResponseModel(Int_t id, AliMUONResponse *response);
     virtual void   SetNsec(Int_t id, Int_t nsec);
-// Set Reconstruction Model
+    // Set Reconstruction Model
     virtual void   SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconstruction);
-// Set Merger/Digitizer
+    // Set Merger/Digitizer
     virtual void   SetMerger(AliMUONMerger* merger);
     virtual AliMUONMerger* Merger();
     
-// Set Stepping Parameters
+    // 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);
     virtual void   SetAcceptance(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 zhit,
-                              Float_t eloss, Float_t tof, Int_t id);
-// get Trigger answer
+   
+    // get Trigger answer
     void   Trigger(Int_t nev);
-// Return reference to Chamber #id
+    // Return reference to Chamber #id
     virtual AliMUONChamber& Chamber(Int_t id)
-       {return *((AliMUONChamber *) (*fChambers)[id]);}
-// Return reference to Circuit #id
+      {return *((AliMUONChamber *) (*fChambers)[id]);}
+    // Return reference to Circuit #id
     virtual AliMUONTriggerCircuit& TriggerCircuit(Int_t id)
       {return *((AliMUONTriggerCircuit *) (*fTriggerCircuits)[id]);}
-// Retrieve pad hits for a given Hit
+    // Retrieve pad hits for a given Hit
     virtual AliMUONPadHit* FirstPad(AliMUONHit *hit, TClonesArray *padHits);
     virtual AliMUONPadHit* NextPad(TClonesArray *padHits);
-// 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
-    TObjArray            *RawClusters() {return fRawClusters;}
-    Int_t                *Nrawch() {return fNrawch;} 
-    virtual TClonesArray *RawClustAddress(Int_t id) 
-       {return ((TClonesArray *) (*fRawClusters)[id]);}
-
+    // Return pointers to digits
     AliMUONRawCluster    *RawCluster(Int_t ichamber, Int_t icathod,
                                     Int_t icluster);
-// Copy Operator
+    // Copy Operator
     AliMUON& operator = (const AliMUON& rhs);
     
-           
+    
  protected:
     Int_t                 fNCh;                // Number of chambers   
-    Int_t                 fNTrackingCh;        // Number of tracking chambers
-    TObjArray            *fChambers;           // List of Tracking Chambers
-    TObjArray            *fTriggerCircuits;    // List of Trigger Circuits
-    Int_t                 fNPadHits;           // Number of pad hits
-    TClonesArray         *fPadHits;            //! List of pad hits
-    TObjArray            *fDchambers;          //! List of digits
-    Int_t                *fNdch;               // [fNCh] Number of digits per chamber
-    TObjArray            *fRawClusters;        //! List of raw clusters
-    Int_t                *fNrawch;             // [fNTrackingCh] Number of raw clusters  per chamber
-    Int_t                 fNLocalTrigger;      // Number of Local Trigger 
-    TClonesArray         *fLocalTrigger;       //! List of Local Trigger      
-    Int_t                 fNGlobalTrigger;     // Number of Global Trigger
-    TClonesArray         *fGlobalTrigger;      //! List of Global Trigger  
-    
-//
+    Int_t                 fNTrackingCh;        // Number of tracking chambers*
+    AliMUONData*          fMUONData;           // Data container for MUON subsystem  
+    TObjArray*            fChambers;           // List of Tracking Chambers
+    TObjArray*            fTriggerCircuits;    // List of Trigger Circuits
+   
+    //
     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
-// Background eent for event mixing
-   Text_t *fFileName;           // ! File with background hits
-   AliMUONMerger *fMerger;   // ! pointer to merger
-
-   ClassDef(AliMUON,3)  // MUON Detector base class
+    //  
+    //  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
+    // Background eent for event mixing
+    Text_t *fFileName;           // ! File with background hits
+    AliMUONMerger *fMerger;   // ! pointer to merger
+    
+    ClassDef(AliMUON,3)  // MUON Detector base class
 };
 #endif
 
index 75eed513230a0870a989102273f68cbceb9c455d..fe5f5d6882a74e2dd53e9ef4dfbb9fbb43b77e33 100644 (file)
@@ -147,7 +147,7 @@ newev:
 newchamber:
   if (ch > 9) {if (fReco) return; nev++; ch = 0; goto newev;}
   //gAlice->ResetDigits();
-  fMuonDigits  = MUON->DigitsAddress(ch);
+  fMuonDigits  = MUON->GetMUONData()->Digits(ch,0);
   if (fMuonDigits == 0) return;
   iChamber = &(MUON->Chamber(ch));
   fSegmentation[0] = iChamber->SegmentationModel(1);
@@ -185,7 +185,7 @@ next:
     Int_t cath = TMath::Odd(iii);
     gAlice->ResetDigits();
     TD->GetEvent(cath);
-    fMuonDigits  = MUON->DigitsAddress(ch);
+    fMuonDigits  = MUON->GetMUONData()->Digits(ch,0);
 
     ndigits[cath] = fMuonDigits->GetEntriesFast();
     if (!ndigits[0] && !ndigits[1]) {if (fReco) return; ch++; goto newchamber;}
@@ -432,7 +432,7 @@ next:
   } // for (Int_t i=0; i<ntracks;
 
   // Draw reconstructed coordinates
-  MUONrawclust = MUON->RawClustAddress(ch);
+  MUONrawclust = MUON->GetMUONData()->RawClusters(ch);
   TR->GetEvent(ch);
   //cout << MUONrawclust << " " << MUONrawclust->GetEntries() << endl;
   AliMUONRawCluster *mRaw;
@@ -2315,7 +2315,7 @@ void AliMUONClusterFinderAZ::AddRawCluster(Double_t x, Double_t y, Double_t fmin
     */
   } 
   //cnew.fClusterType=cnew.PhysicsContribution();
-  pMUON->AddRawCluster(AliMUONClusterInput::Instance()->Chamber(),cnew); 
+  pMUON->GetMUONData()->AddRawCluster(AliMUONClusterInput::Instance()->Chamber(),cnew); 
   //fNPeaks++;
 }
 
index 55c6c3f52effc72e5d66ba662dac50ed905e1b11..0c5f92825628fb0f69e09da260413b8dce934e50 100644 (file)
@@ -2062,7 +2062,7 @@ void AliMUONClusterFinderVS::AddRawCluster(const AliMUONRawCluster c)
   // Add a raw cluster copy to the list
   //
     AliMUON *pMUON=(AliMUON*)gAlice->GetModule("MUON");
-    pMUON->AddRawCluster(fInput->Chamber(),c); 
+    pMUON->GetMUONData()->AddRawCluster(fInput->Chamber(),c); 
     fNRawClusters++;
 //    if (fDebugLevel)
        fprintf(stderr,"\nfNRawClusters %d\n",fNRawClusters);
index 16ca8aa4e18da773cfb7c7ebe4c85c316b7aff5d..3636309f432112fcd885d046f369b678054d9071 100644 (file)
@@ -18,6 +18,7 @@ AliMUONData::AliMUONData():TNamed()
   fLoader        = 0x0;
   fHits          = 0x0;    // One event in treeH per primary track
   fDigits        = 0x0;  // One event in treeH per detection plane
+  fNdigits       = 0x0;
   fRawClusters   = 0x0; //One event in TreeR/RawclusterBranch per tracking detection plane
   fGlobalTrigger = 0x0; //! List of Global Trigger 1st event in TreeR/GlobalTriggerBranch
   fLocalTrigger  = 0x0;  //! List of Local Trigger, 1st event in TreeR/LocalTriggerBranch       
@@ -85,7 +86,7 @@ void AliMUONData::AddDigit(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digit
   //
   // Add a MUON digit to the list of Digits of the detection plane id
   //
-  TClonesArray &ldigits = * ( (TClonesArray*) fDigits->At(id) )
+  TClonesArray &ldigits = * Digits(id,0) 
   new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
 }
 //_____________________________________________________________________________
@@ -126,9 +127,7 @@ void AliMUONData::AddRawCluster(Int_t id, const AliMUONRawCluster& c)
   TClonesArray &lrawcl = *((TClonesArray*) fRawClusters->At(id));
   new(lrawcl[fNrawclusters[id]++]) AliMUONRawCluster(c);
 }
-//_____________________________________________________________________________
-
-//___________________________________________
+//____________________________________________________________________________
 void AliMUONData::MakeBranch(Option_t* option)
 {
   //
@@ -164,10 +163,14 @@ void AliMUONData::MakeBranch(Option_t* option)
   if (TreeD() && cD ) {
     // one branch for digits per chamber
     if (fDigits  == 0x0) {
-      fDigits = new TObjArray(AliMUONConstants::NCh());
-      fNdigits = new Int_t[AliMUONConstants::NCh()];
+      fDigits  = new TObjArray(AliMUONConstants::NCh());
       for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
        fDigits->AddAt(new TClonesArray("AliMUONDigit",10000),iDetectionPlane); 
+      }
+    }
+    if (fNdigits == 0x0) {
+      fNdigits = new Int_t[AliMUONConstants::NCh()];
+      for (Int_t iDetectionPlane=0; iDetectionPlane<AliMUONConstants::NCh() ;iDetectionPlane++) {
        fNdigits[iDetectionPlane]=0;
       }
     }
@@ -179,7 +182,8 @@ void AliMUONData::MakeBranch(Option_t* option)
        Info("MakeBranch","Branch %s is already in tree.",GetName());
        return;
       }
-      branch = TreeD()->Branch(branchname, &((*fDigits)[iDetectionPlane]),kBufferSize);
+      TClonesArray * digits = Digits(iDetectionPlane,0); 
+      branch = TreeD()->Branch(branchname, &digits, kBufferSize);
       Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
       }
   }
@@ -190,9 +194,14 @@ void AliMUONData::MakeBranch(Option_t* option)
     Int_t i;
     if (fRawClusters == 0x0) {
       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
-      fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
        fRawClusters->AddAt(new TClonesArray("AliMUONRawCluster",10000),i); 
+      }
+    }
+
+    if (fNrawclusters == 0x0) {
+      fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
+      for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
        fNrawclusters[i]=0;
       }
     }
@@ -295,19 +304,26 @@ void AliMUONData::ResetTrigger()
   if (fLocalTrigger) fLocalTrigger->Clear();
 }
 //_____________________________________________________________________________
-void AliMUONData::SetTreeAddress()
+void AliMUONData::SetTreeAddress(Option_t* option)
 {
+  const char *cH   = strstr(option,"H");
+  const char *cD   = strstr(option,"D");   // Digits branches in TreeD
+  const char *cRC  = strstr(option,"RC");  // RawCluster branches in TreeR
+  const char *cGLT = strstr(option,"GLT"); // Global and Local Trigger branches in TreeR
+  // const char *cRT  = strstr(option,"RT");  // Reconstructed Track in TreeT
+  //const char *cRP  = strstr(option,"RP");  // Reconstructed Particle in TreeP
+  
   // Set branch address for the Hits, Digits, RawClusters, GlobalTrigger and LocalTrigger Tree.
   char branchname[30];
   TBranch * branch = 0x0;
 
   //
   // Branch address for hit tree
-  if ( TreeH() ) {
+  if ( TreeH() && cH ) {
     if (fHits == 0x0) fHits     = new TClonesArray("AliMUONHit",1000);
     fNhits =0;
   } 
-  if (TreeH() && fHits) {
+  if (TreeH() && fHits && cH) {
     sprintf(branchname,"%sHits",GetName());  
     branch = TreeH()->GetBranch(branchname);
     if (branch) {
@@ -321,7 +337,7 @@ void AliMUONData::SetTreeAddress()
   
   //
   // Branch address for digit tree
-  if ( TreeD() ) {
+  if ( TreeD() && cD) {
     if (fDigits == 0x0) { 
       fDigits = new TObjArray(AliMUONConstants::NCh());
       fNdigits= new Int_t[AliMUONConstants::NCh()];
@@ -332,11 +348,12 @@ void AliMUONData::SetTreeAddress()
     }
   }
 
-  if (TreeD() && fDigits) {
+  if (TreeD() && fDigits && cD) {
     for (int i=0; i<AliMUONConstants::NCh(); i++) {
       sprintf(branchname,"%sDigits%d",GetName(),i+1);
       branch = TreeD()->GetBranch(branchname);
-      if (branch) branch->SetAddress(&((*fDigits)[i]));
+      TClonesArray * digits = Digits(i,0);
+      if (branch) branch->SetAddress( &digits );
       else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
     }
   }
@@ -344,7 +361,7 @@ void AliMUONData::SetTreeAddress()
   //
   // Branch address for rawclusters, globaltrigger and local trigger tree
   if (TreeR() ) {
-    if (fRawClusters == 0x0) {
+    if (fRawClusters == 0x0 && cRC) {
       fRawClusters = new TObjArray(AliMUONConstants::NTrackingCh());
       fNrawclusters= new Int_t[AliMUONConstants::NTrackingCh()];
       for (Int_t i=0; i<AliMUONConstants::NTrackingCh();i++) {
@@ -352,15 +369,15 @@ void AliMUONData::SetTreeAddress()
        fNrawclusters[i]=0;
       }
     }
-    if (fLocalTrigger == 0x0) {
+    if (fLocalTrigger == 0x0 && cGLT) {
       fLocalTrigger  = new TClonesArray("AliMUONLocalTrigger",234);
     }
-    if (fGlobalTrigger== 0x0) {
+    if (fGlobalTrigger== 0x0 && cGLT) {
         fGlobalTrigger = new TClonesArray("AliMUONGlobalTrigger",1); 
     }
 
   }
-  if ( TreeR()  && fRawClusters ) {
+  if ( TreeR()  && fRawClusters && cRC) {
     for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
       sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
       if (fRawClusters) {
@@ -370,13 +387,13 @@ void AliMUONData::SetTreeAddress()
       }
     }
   }
-  if ( TreeR()  && fLocalTrigger ) {
+  if ( TreeR()  && fLocalTrigger && cGLT) {
     sprintf(branchname,"%sLocalTrigger",GetName());
     branch = TreeR()->GetBranch(branchname);
     if (branch) branch->SetAddress(&fLocalTrigger);
     else Warning("SetTreeAddress","(%s) Failed for LocalTrigger. Can not find branch in tree.",GetName());
   }
-  if ( TreeR() && fGlobalTrigger) {
+  if ( TreeR() && fGlobalTrigger && cGLT) {
     sprintf(branchname,"%sGlobalTrigger",GetName());
     branch = TreeR()->GetBranch(branchname);
     if (branch) branch->SetAddress(&fGlobalTrigger);
@@ -384,5 +401,3 @@ void AliMUONData::SetTreeAddress()
   }
 }
 //_____________________________________________________________________________
-
-
index 368e11faab09d76d2b1cb34d57fbb37d414d7e46..3ed04b55edeb874684dcc864ebc6ec939d5d212e 100644 (file)
@@ -48,9 +48,12 @@ class AliMUONData : public TNamed {
     TClonesArray*  GlobalTrigger() {return fGlobalTrigger;}
     TClonesArray*  RawClusters(Int_t DetectionPlane)
       {return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );}
-    
+
+    virtual AliLoader* GetLoader() {return fLoader;}
+    virtual void       SetLoader(AliLoader * loader) {fLoader=loader;}    
+
     virtual void   MakeBranch(Option_t *opt=" ");
-    virtual void   SetTreeAddress();
+    virtual void   SetTreeAddress(Option_t *opt=" ");
 
     virtual void   ResetHits();
     virtual void   ResetDigits();
index 673c0351bbe4a2f3e3a2c44e01c9cd8a5d042f63..ad9ac4cfa53d104335bfc63c04d5078aeb8ec0bc 100644 (file)
@@ -131,8 +131,7 @@ void AliMUONDigitizer::CreateNew(AliMUONPadHit *padhit)
 //------------------------------------------------------------------------
 Bool_t AliMUONDigitizer::Init()
 {
-// Initialization 
-    
+// Initialization
   fHits     = new TClonesArray("AliMUONHit",1000);
   fPadHits  = new TClonesArray("AliMUONPadHit",1000);
   return kTRUE;
@@ -141,242 +140,276 @@ Bool_t AliMUONDigitizer::Init()
 
 //------------------------------------------------------------------------
 //void AliMUONDigitizer::Digitize()
-void AliMUONDigitizer::Exec(Option_t* option)
+void AliMUONDigitizer::Exec(Option_t* /*option*/)
 {
-
-  TString optionString = option;
-  if (optionString.Data() == "deb") {
-    cout<<"AliMUONDigitizer::Exec: called with option deb "<<endl;
-    fDebug = 3;
-  }
-  AliMUONChamber*   iChamber;
-  AliSegmentation*  segmentation;
-  
-  if (GetDebug()>2) cerr<<"   AliMUONDigitizer::Digitize() starts"<<endl;
-  fTDList = new TObjArray;
-
-  AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
-  if (!pMUON) {
-    cerr<<"AliMUONDigitizer::Digitize Error:"
-       <<" module MUON not found in the input file"<<endl;
-    return;
-  }
+  // Obsolet sep 2003 Gines MARTINEZ
+
+//    TString optionString = option;
+//    if (optionString.Data() == "deb") {
+//      cout<<"AliMUONDigitizer::Exec: called with option deb "<<endl;
+//      fDebug = 3;
+//    }
+//    AliMUONChamber*   iChamber;
+//    AliSegmentation*  segmentation;
   
-  AliRunLoader *rl, *orl;
-  AliLoader *gime, *ogime;
-  orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
-  ogime = orl->GetLoader("MUONLoader");
-
-  pMUON->MakeBranchInTreeD(ogime->TreeD());
+//    if (GetDebug()>2) cerr<<"   AliMUONDigitizer::Digitize() starts"<<endl;
+//    fTDList = new TObjArray;
+
+//    //Loaders (We assume input0 to be the output too)
+//    AliRunLoader *rl, *orl;
+//    AliLoader *gime, *ogime;
+//    orl = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+//    ogime = orl->GetLoader("MUONLoader");
+
+//   runloader    = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
+//    if (runloader == 0x0) {
+//      cerr<<"AliMUONDigitizerv1::Digitize() opening file "<<fManager->GetInputFileName(0,0)<<endl;
+//      return;  // RunDigitizer is not working.  
+//    }
+//    gime         = runloader->GetLoader("MUONLoader");
+//    if (gime->TreeH()==0x0) {
+//       Info("Digitize","TreeH is not loaded yet. Loading...");
+//       gime->LoadHits("READ");
+//       Info("Digitize","Now treeH is %#x. MUONLoader is %#x",gime->TreeH(),gime);
+//    }
+
+//    if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() loaders"<<endl;
+
+//     if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+//    gAlice = runloader->GetAliRun();
+
+//    // Getting Module MUON  
+//    AliMUON *pMUON  = (AliMUON *) gAlice->GetDetector("MUON");
+//    if (!pMUON) {
+//      cerr<<"AliMUONDigitizerv1::Digitize Error:"
+//     <<" module MUON not found in the input file"<<endl;
+//      return;
+//    } 
+//    // Loading Event
+//    Int_t currentevent = fManager->GetOutputEventNr();
   
-  fHitMap= new AliMUONHitMapA1* [AliMUONConstants::NCh()];
-
-  //
-  // loop over cathodes
-  //
-
-  for (int icat = 0; icat < 2; icat++) { 
-    fCounter = 0;
-    for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
-      iChamber = &(pMUON->Chamber(i));
-//      if (!(iChamber->Nsec() == 1 && icat == 1)) {
-       segmentation = iChamber->SegmentationModel(icat+1);
-       fHitMap[i] = new AliMUONHitMapA1(segmentation, fTDList);
+//    if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() Event Number is "<<currentevent <<endl;
+//    if ( (currentevent<10)                                                 || 
+//         (Int_t(TMath::Log10(currentevent)) == TMath::Log10(currentevent) ) )
+//      cout <<"ALiMUONDigitizerv1::Digitize() Event Number is "<< currentevent <<endl;
+
+//    // Output file for digits 
+//    AliRunLoader *  runloaderout  = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+//    AliLoader * gimeout         = runloaderout->GetLoader("MUONLoader"); 
+//    // New branch per chamber for MUON digit in the tree of digits
+//    if (gimeout->TreeD() == 0x0) gimeout->MakeDigitsContainer();
+//    TTree* treeD = gimeout->TreeD();
+//    pMUON->GetMUONData()->SetLoader(gimeout);
+//    pMUON->MakeBranch("D");
+
+//    fHitMap= new AliMUONHitMapA1* [AliMUONConstants::NCh()];
+
+//    //
+//    // loop over cathodes
+//    //
+
+//    for (int icat = 0; icat < 2; icat++) { 
+//      fCounter = 0;
+//      for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
+//        iChamber = &(pMUON->Chamber(i));
+//  //      if (!(iChamber->Nsec() == 1 && icat == 1)) {
+//         segmentation = iChamber->SegmentationModel(icat+1);
+//         fHitMap[i] = new AliMUONHitMapA1(segmentation, fTDList);
+//  //      }
 //      }
-    }
 
 
-// Loop over files to digitize
-    fSignal = kTRUE;
-    for (Int_t inputFile=0; inputFile<fManager->GetNinputs();
-        inputFile++) {
-// Connect MUON branches
+//  // Loop over files to digitize
+//      fSignal = kTRUE;
+//      for (Int_t inputFile=0; inputFile<fManager->GetNinputs();
+//          inputFile++) {
+//  // Connect MUON branches
 
-      if (inputFile > 0 ) fSignal = kFALSE;
-      TBranch *branchHits = 0;
-      TBranch *branchPadHits = 0;
+//        if (inputFile > 0 ) fSignal = kFALSE;
+//        TBranch *branchHits = 0;
+//        TBranch *branchPadHits = 0;
       
-      rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
-      gime = rl->GetLoader("MUONLoader");
+//        rl = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(inputFile));
+//        gime = rl->GetLoader("MUONLoader");
     
       
-      TTree *treeH = gime->TreeH();
-      if (GetDebug()>2) {
-       cerr<<"   inputFile , cathode = "<<inputFile<<" "
-           <<icat<<endl;
-       cerr<<"   treeH, fHits "<<treeH<<" "<<fHits<<endl;
-      }
-      if (treeH && fHits) {
-       branchHits = treeH->GetBranch("MUON");
-       if (branchHits) {
-         fHits->Clear();
-         branchHits->SetAddress(&fHits);
-       }
-       else
-         Error("Exec","branch MUON was not found");
-      }
-      if (GetDebug()>2) cerr<<"   branchHits = "<<branchHits<<endl;
-
-      if (treeH && fPadHits) {
-       branchPadHits = treeH->GetBranch("MUONCluster");
-       if (branchPadHits) 
-         branchPadHits->SetAddress(&fPadHits);
-       else
-         Error("Exec","branch MUONCluster was not found");
-      }
-      if (GetDebug()>2) cerr<<"   branchPadHits = "<<branchPadHits<<endl;
-
-//
-//   Loop over tracks
-//
-
-      Int_t ntracks = (Int_t) treeH->GetEntries();
-
-      for (fTrack = 0; fTrack < ntracks; fTrack++) {
-       if (GetDebug()>2) cerr<<"   fTrack = "<<fTrack<<endl;
-       fHits->Clear();
-       fPadHits->Clear();
-       branchHits->GetEntry(fTrack);
-       branchPadHits->GetEntry(fTrack);
+//        TTree *treeH = gime->TreeH();
+//        if (GetDebug()>2) {
+//         cerr<<"   inputFile , cathode = "<<inputFile<<" "
+//             <<icat<<endl;
+//         cerr<<"   treeH, fHits "<<treeH<<" "<<fHits<<endl;
+//        }
+//        if (treeH && fHits) {
+//         branchHits = treeH->GetBranch("MUON");
+//         if (branchHits) {
+//           fHits->Clear();
+//           branchHits->SetAddress(&fHits);
+//         }
+//         else
+//           Error("Exec","branch MUON was not found");
+//        }
+//        if (GetDebug()>2) cerr<<"   branchHits = "<<branchHits<<endl;
+
+//        if (treeH && fPadHits) {
+//         branchPadHits = treeH->GetBranch("MUONCluster");
+//         if (branchPadHits) 
+//           branchPadHits->SetAddress(&fPadHits);
+//         else
+//           Error("Exec","branch MUONCluster was not found");
+//        }
+//        if (GetDebug()>2) cerr<<"   branchPadHits = "<<branchPadHits<<endl;
+
+//  //
+//  //   Loop over tracks
+//  //
+
+//        Int_t ntracks = (Int_t) treeH->GetEntries();
+
+//        for (fTrack = 0; fTrack < ntracks; fTrack++) {
+//         if (GetDebug()>2) cerr<<"   fTrack = "<<fTrack<<endl;
+//         fHits->Clear();
+//         fPadHits->Clear();
+//         branchHits->GetEntry(fTrack);
+//         branchPadHits->GetEntry(fTrack);
        
-//
-//   Loop over hits
-
-       AliMUONHit* mHit;
-       for(Int_t i = 0; i < fHits->GetEntriesFast(); ++i) {
-         mHit = static_cast<AliMUONHit*>(fHits->At(i));
-         fNch = mHit->Chamber()-1;  // chamber number
-         if (fNch > AliMUONConstants::NCh()-1) {
-           cerr<<"AliMUONDigitizer: ERROR: "
-              <<"fNch > AliMUONConstants::NCh()-1, fNch, NCh(): "
-              <<fNch<<", "<< AliMUONConstants::NCh()<<endl;
-           return;
-         }
-         iChamber = &(pMUON->Chamber(fNch));
-//
-// Loop over pad hits
-         for (AliMUONPadHit* mPad =
-               (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHits);
-              mPad;
-              mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHits))
-         {
-           Int_t cathode  = mPad->Cathode();      // cathode number
-           Int_t ipx      = mPad->PadX();         // pad number on X
-           Int_t ipy      = mPad->PadY();         // pad number on Y
-           Int_t iqpad    = Int_t(mPad->QPad());  // charge per pad
-           if (cathode != (icat+1)) continue;
-
-           fMask = fManager->GetMask(inputFile);
-           fDigits[0] = ipx;
-           fDigits[1] = ipy;
-           fDigits[2] = icat;
-           fDigits[3] = iqpad;
-           if (inputFile == 0) {
-             fDigits[4] = iqpad;
-           } else {
-             fDigits[4] = 0;
-           }
-           if (mHit->Particle() == kMuonPlus ||
-              mHit->Particle() == kMuonMinus) {
-             fDigits[5] = (mPad->HitNumber()) + fMask; 
-           } else fDigits[5] = -1;
-
-           // build the list of fired pads and update the info, 
-           // fDigits is input for Update(mPad)
-
-           if (!Exists(mPad)) {
-             CreateNew(mPad);
-           } else {
-             Update(mPad);
-           } //  end if Exists(mPad)
-         } //end loop over clusters
-       } // hit loop
-      } // track loop
-    } // end file loop
-    if (GetDebug()>2) cerr<<"END OF FILE LOOP"<<endl;
-
-    Int_t tracks[kMAXTRACKS];
-    Int_t charges[kMAXTRACKS];
-    Int_t nentries = fTDList->GetEntriesFast();
+//  //
+//  //   Loop over hits
+
+//         AliMUONHit* mHit;
+//         for(Int_t i = 0; i < fHits->GetEntriesFast(); ++i) {
+//           mHit = static_cast<AliMUONHit*>(fHits->At(i));
+//           fNch = mHit->Chamber()-1;  // chamber number
+//           if (fNch > AliMUONConstants::NCh()-1) {
+//             cerr<<"AliMUONDigitizer: ERROR: "
+//                <<"fNch > AliMUONConstants::NCh()-1, fNch, NCh(): "
+//                <<fNch<<", "<< AliMUONConstants::NCh()<<endl;
+//             return;
+//           }
+//           iChamber = &(pMUON->Chamber(fNch));
+//  //
+//  // Loop over pad hits
+//           for (AliMUONPadHit* mPad =
+//                 (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHits);
+//                mPad;
+//                mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHits))
+//           {
+//             Int_t cathode  = mPad->Cathode();      // cathode number
+//             Int_t ipx      = mPad->PadX();         // pad number on X
+//             Int_t ipy      = mPad->PadY();         // pad number on Y
+//             Int_t iqpad    = Int_t(mPad->QPad());  // charge per pad
+//             if (cathode != (icat+1)) continue;
+
+//             fMask = fManager->GetMask(inputFile);
+//             fDigits[0] = ipx;
+//             fDigits[1] = ipy;
+//             fDigits[2] = icat;
+//             fDigits[3] = iqpad;
+//             if (inputFile == 0) {
+//               fDigits[4] = iqpad;
+//             } else {
+//               fDigits[4] = 0;
+//             }
+//             if (mHit->Particle() == kMuonPlus ||
+//                mHit->Particle() == kMuonMinus) {
+//               fDigits[5] = (mPad->HitNumber()) + fMask; 
+//             } else fDigits[5] = -1;
+
+//             // build the list of fired pads and update the info, 
+//             // fDigits is input for Update(mPad)
+
+//             if (!Exists(mPad)) {
+//               CreateNew(mPad);
+//             } else {
+//               Update(mPad);
+//             } //  end if Exists(mPad)
+//           } //end loop over clusters
+//         } // hit loop
+//        } // track loop
+//      } // end file loop
+//      if (GetDebug()>2) cerr<<"END OF FILE LOOP"<<endl;
+
+//      Int_t tracks[kMAXTRACKS];
+//      Int_t charges[kMAXTRACKS];
+//      Int_t nentries = fTDList->GetEntriesFast();
        
-    for (Int_t nent = 0; nent < nentries; nent++) {
-      AliMUONTransientDigit *address = (AliMUONTransientDigit*)fTDList->At(nent);
-      if (address == 0) continue; 
-      Int_t ich = address->Chamber();
-      Int_t   q = address->Signal(); 
-      iChamber = &(pMUON->Chamber(ich));
-//
-//  Digit Response (noise, threshold, saturation, ...)
-      AliMUONResponse * response = iChamber->ResponseModel();
-      q = response->DigitResponse(q,address);
+//      for (Int_t nent = 0; nent < nentries; nent++) {
+//        AliMUONTransientDigit *address = (AliMUONTransientDigit*)fTDList->At(nent);
+//        if (address == 0) continue; 
+//        Int_t ich = address->Chamber();
+//        Int_t   q = address->Signal(); 
+//        iChamber = &(pMUON->Chamber(ich));
+//  //
+//  //  Digit Response (noise, threshold, saturation, ...)
+//        AliMUONResponse * response = iChamber->ResponseModel();
+//        q = response->DigitResponse(q,address);
            
-      if (!q) continue;
+//        if (!q) continue;
            
-      fDigits[0] = address->PadX();
-      fDigits[1] = address->PadY();
-      fDigits[2] = address->Cathode();
-      fDigits[3] = q;
-      fDigits[4] = address->Physics();
-      fDigits[5] = address->Hit();
+//        fDigits[0] = address->PadX();
+//        fDigits[1] = address->PadY();
+//        fDigits[2] = address->Cathode();
+//        fDigits[3] = q;
+//        fDigits[4] = address->Physics();
+//        fDigits[5] = address->Hit();
            
-      Int_t nptracks = address->GetNTracks();
-
-      if (nptracks > kMAXTRACKS) {
-       if (GetDebug() >0) {
-         cerr<<"AliMUONDigitizer: nptracks > 10 "<<nptracks;
-         cerr<<"reset to max value "<<kMAXTRACKS<<endl;
-       }
-       nptracks = kMAXTRACKS;
-      }
-      if (nptracks > 2 && GetDebug() >2) {
-       cerr<<"AliMUONDigitizer: nptracks > 2 "<<nptracks<<endl;
-       printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
-      }
-      for (Int_t tr = 0; tr < nptracks; tr++) {
-       tracks[tr]   = address->GetTrack(tr);
-       charges[tr]  = address->GetCharge(tr);
-      }      //end loop over list of tracks for one pad
-      // Sort list of tracks according to charge
-      if (nptracks > 1) {
-       SortTracks(tracks,charges,nptracks);
-      }
-      if (nptracks < kMAXTRACKS ) {
-       for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
-         tracks[i]  = 0;
-         charges[i] = 0;
-       }
-      }
+//        Int_t nptracks = address->GetNTracks();
+
+//        if (nptracks > kMAXTRACKS) {
+//         if (GetDebug() >0) {
+//           cerr<<"AliMUONDigitizer: nptracks > 10 "<<nptracks;
+//           cerr<<"reset to max value "<<kMAXTRACKS<<endl;
+//         }
+//         nptracks = kMAXTRACKS;
+//        }
+//        if (nptracks > 2 && GetDebug() >2) {
+//         cerr<<"AliMUONDigitizer: nptracks > 2 "<<nptracks<<endl;
+//         printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
+//        }
+//        for (Int_t tr = 0; tr < nptracks; tr++) {
+//         tracks[tr]   = address->GetTrack(tr);
+//         charges[tr]  = address->GetCharge(tr);
+//        }      //end loop over list of tracks for one pad
+//        // Sort list of tracks according to charge
+//        if (nptracks > 1) {
+//         SortTracks(tracks,charges,nptracks);
+//        }
+//        if (nptracks < kMAXTRACKS ) {
+//         for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
+//           tracks[i]  = 0;
+//           charges[i] = 0;
+//         }
+//        }
            
-      // fill digits
-      pMUON->AddDigits(ich,tracks,charges,fDigits);
-    }
+//        // fill digits
+//        pMUON->AddDigits(ich,tracks,charges,fDigits);
+//      }
     
-//    fManager->GetTreeD()->Fill();
-    ogime->TreeD()->Fill();
+//  //    fManager->GetTreeD()->Fill();
+//      ogime->TreeD()->Fill();
 
 
-    pMUON->ResetDigits();  //
-    fTDList->Clear();
+//      pMUON->ResetDigits();  //
+//      fTDList->Clear();
 
        
-    for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
-      if (fHitMap[ii]) {
-       delete fHitMap[ii];
-       fHitMap[ii] = 0;
-      }
-    }
-  } //end loop over cathodes
-  if (GetDebug()>2) 
-    cerr<<"AliMUONDigitizer::Exec: writing the TreeD: "
-       << ogime->TreeD()->GetName()<<endl;
+//      for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
+//        if (fHitMap[ii]) {
+//         delete fHitMap[ii];
+//         fHitMap[ii] = 0;
+//        }
+//      }
+//    } //end loop over cathodes
+//    if (GetDebug()>2) 
+//      cerr<<"AliMUONDigitizer::Exec: writing the TreeD: "
+//         << ogime->TreeD()->GetName()<<endl;
   
-   ogime->WriteDigits("OVERWRITE");
+//     ogime->WriteDigits("OVERWRITE");
   
-  delete [] fHitMap;
-  delete fTDList;
+//    delete [] fHitMap;
+//    delete fTDList;
     
-  if (fHits)    fHits->Delete();
-  if (fPadHits) fPadHits->Delete();
+//    if (fHits)    fHits->Delete();
+//    if (fPadHits) fPadHits->Delete();
 }
 
 
index 905cb2c5ace41d8e5bfad960a7e1a23c14245562..e10f7b0413d79001d62b4cc6e12abd8f6178faa4 100644 (file)
@@ -38,8 +38,8 @@ class AliMUONDigitizer : public AliDigitizer {
     void SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr);
     
  private:
-    TClonesArray *fHits;            //! List of hits for one track only
-    TClonesArray *fPadHits;         //! List of clusters for one track only
+    TClonesArray* fHits;
+    TClonesArray* fPadHits;
     AliMUONHitMapA1 **fHitMap;      //! pointer to array of pointers to hitmaps
     Int_t fNch;                     //! chamber nr (loop variable)
     Int_t fTrack;                   //! track nr (loop variable)
index 95427b9dd31dd4afb164a43471ca78f75495c2a9..7ae356619c38ebbf688253c70b80ea4600415d98 100644 (file)
@@ -43,7 +43,7 @@ AliMUONDigitizerv1::AliMUONDigitizerv1(AliRunDigitizer* manager)
   fHitMap  = 0;
   fTDList  = 0;
   fDebug   = 0; 
-  fHits = new TClonesArray("AliMUONHit",1000);
+  //  fHits = new TClonesArray("AliMUONHit",1000);
   if (GetDebug()>2) 
     cerr<<"AliMUONDigitizerv1::AliMUONDigitizerv1"
        <<"(AliRunDigitizer* manager) was processed"<<endl;
@@ -53,7 +53,7 @@ AliMUONDigitizerv1::AliMUONDigitizerv1(AliRunDigitizer* manager)
 AliMUONDigitizerv1::~AliMUONDigitizerv1()
 {
 // Destructor
-  delete fHits;
+  //delete fHits;
 }
 
 //------------------------------------------------------------------------
@@ -171,44 +171,50 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
 {
   TString optionString = option;
   if (optionString.Data() == "deb") {
-    cout<<"AliMUONDigitizerv1::Exec: called with option deb "<<endl;
+    Info("Digitize","Called with option deb ");
     fDebug = 3;
   }
+
   AliMUONChamber*   chamber;
   AliSegmentation*  c1Segmentation; //Cathode plane c1 of the chamber
   AliSegmentation*  c2Segmentation; //Cathode place c2 of the chamber
 
-  if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() starts"<<endl;
+  if (GetDebug()>2) Info("Digitize","AliMUONDigitizerv1::Digitize() starts");
   fTDList = new TObjArray;
 
   //Loaders (We assume input0 to be the output too)
   AliRunLoader * runloader;    // Input   loader
   AliLoader    * gime; 
  
+  // Getting runloader
   runloader    = AliRunLoader::GetRunLoader(fManager->GetInputFolderName(0));
   if (runloader == 0x0) {
-    cerr<<"AliMUONDigitizerv1::Digitize() opening file "<<fManager->GetInputFileName(0,0)<<endl;
+    Error("Digitize","RunLoader is not in input file 0");
     return;  // RunDigitizer is not working.  
   }
-  gime         = runloader->GetLoader("MUONLoader");
+  // Getting MUONloader
+  gime        = runloader->GetLoader("MUONLoader");
   if (gime->TreeH()==0x0) {
-     Info("Digitize","TreeH is not loaded yet. Loading...");
+      if (GetDebug()>2) Info("Digitize","TreeH is not loaded yet. Loading...");
      gime->LoadHits("READ");
-     Info("Digitize","Now treeH is %#x. MUONLoader is %#x",gime->TreeH(),gime);
+       if (GetDebug()>2) Info("Digitize","Now treeH is %#x. MUONLoader is %#x",gime->TreeH(),gime);
   }
 
-  if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() loaders"<<endl;
+  if (GetDebug()>2) Info("Digitize","Loaders ready");
 
-   if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
   gAlice = runloader->GetAliRun();
 
   // Getting Module MUON  
   AliMUON *pMUON  = (AliMUON *) gAlice->GetDetector("MUON");
   if (!pMUON) {
-    cerr<<"AliMUONDigitizerv1::Digitize Error:"
-       <<" module MUON not found in the input file"<<endl;
+    Error("Digitize","Module MUON not found in the input file");
     return;
-  } 
+  }
+  // Getting Muon data
+  AliMUONData * muondata = pMUON->GetMUONData(); 
+  muondata->SetLoader(gime);
+  muondata->SetTreeAddress("H");
 
   // Loading Event
   Int_t currentevent = fManager->GetOutputEventNr();
@@ -218,13 +224,14 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
        (Int_t(TMath::Log10(currentevent)) == TMath::Log10(currentevent) ) )
     cout <<"ALiMUONDigitizerv1::Digitize() Event Number is "<< currentevent <<endl;
 
-  // Output file for digits 
-  AliRunLoader *  runloaderout  = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
-  AliLoader * gimeout         = runloaderout->GetLoader("MUONLoader"); 
+  // Output file for digits same as hits
+  //  AliRunLoader *  runloaderout  = AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
+  //AliLoader * gimeout         = runloaderout->GetLoader("MUONLoader"); 
   // New branch per chamber for MUON digit in the tree of digits
-  if (gime->TreeD() == 0x0) gimeout->MakeDigitsContainer();
-  TTree* treeD = gimeout->TreeD();
-  pMUON->MakeBranchInTreeD(treeD);
+  if (gime->TreeD() == 0x0) gime->MakeDigitsContainer();
+  TTree* treeD = gime->TreeD();
+  muondata->MakeBranch("D");
+  muondata->SetTreeAddress("D");
 
   // Array of pointer of the AliMUONHitMapA1:
   //  two HitMaps per chamber, or one HitMap per cahtode plane
@@ -244,8 +251,6 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
     for (Int_t inputFile=0; inputFile<fManager->GetNinputs(); inputFile++) {
       if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Digitize() Input File is "<<inputFile<<endl;
 
-      // Hits Branch
-      TBranch *branchHits = 0;
 
       // Connect MUON Hit branch
       if (inputFile > 0 ) {
@@ -256,9 +261,11 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
          }
          gime  = runloader->GetLoader("MUONLoader");
          if (gime->TreeH() == 0x0) gime->LoadHits("READ");     
+        muondata->SetLoader(gime);
+        muondata->SetTreeAddress("H");
       }
 
-      // Setting the address of fHits list
+      // Setting the address 
       TTree *treeH = gime->TreeH();
       if (treeH == 0x0) {
        Error("Digitize","Can not get TreeH from input %d",inputFile);
@@ -267,19 +274,10 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
       }
       if (GetDebug()>2) {
        cerr<<"AliMUONDigitizerv1::Exec inputFile is "<<inputFile<<" "<<endl;
-       cerr<<"AliMUONDigitizerv1::Exec treeH, fHits "<<treeH<<" "<<fHits<<endl;
+       cerr<<"AliMUONDigitizerv1::Exec treeH" << treeH <<endl;
       }
-      if (treeH && fHits) {
-       branchHits = treeH->GetBranch("MUON");
-       if (branchHits) {
-         fHits->Clear();
-         branchHits->SetAddress(&fHits);
-       }
-       else
-         Error("Exec","branch MUON was not found");
-      }
-      if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Exec branchHits = "<<branchHits<<endl;
-
+       
+      if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Exec Setting tree addresses"<<endl;
 
       fMask = fManager->GetMask(inputFile);
       //
@@ -288,14 +286,15 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
       Int_t ntracks = (Int_t) treeH->GetEntries();
       for (itrack = 0; itrack < ntracks; itrack++) {
        if (GetDebug()>2) cerr<<"AliMUONDigitizerv1::Exec itrack = "<<itrack<<endl;
-       fHits->Clear();
+       muondata->ResetHits();
        treeH->GetEvent(itrack);
        //
        //  Loop over hits
        Int_t ihit, ichamber;
        AliMUONHit* mHit;
-       for(ihit = 0; ihit < fHits->GetEntriesFast(); ihit++) {
-         mHit = static_cast<AliMUONHit*>(fHits->At(ihit));
+       TClonesArray* hits = muondata->Hits();
+       for(ihit = 0; ihit < hits->GetEntriesFast(); ihit++) {
+         mHit = static_cast<AliMUONHit*>(hits->At(ihit));
          ichamber = mHit->Chamber()-1;  // chamber number
          if (ichamber > AliMUONConstants::NCh()-1) {
            cerr<<"AliMUONDigitizer: ERROR: "
@@ -388,13 +387,13 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
          }
        }
        
-       // fill digits
+       // Add digits
        if (GetDebug()>3) cerr<<"AliMUONDigitzerv1::Exex TransientDigit to Digit"<<endl;
-       if ( digits[2] == icat ) pMUON->AddDigits(ich,tracks,charges,digits);
+       if ( digits[2] == icat ) muondata->AddDigit(ich,tracks,charges,digits);
       }
       // Filling list of digits per chamber for a given cathode.
       treeD->Fill();
-      pMUON->ResetDigits();    
+      muondata->ResetDigits();    
     } // end loop cathode
     fTDList->Delete();  
     
@@ -409,11 +408,11 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
       cerr<<"AliMUONDigitizer::Exec: writing the TreeD: "
          <<treeD->GetName()<<endl;
 
-    gimeout->WriteDigits("OVERWRITE");
+    gime->WriteDigits("OVERWRITE");
     delete [] fHitMap;
     delete fTDList;
     
-    if (fHits)    fHits->Clear();
+    muondata->ResetHits();
 }
 
 //------------------------------------------------------------------------
index a9624503c79233951d40a12c8674e8abb1f3ebea..18dc6ee6022bbe2cb4997edbeaefc7cbd7cab461 100644 (file)
@@ -45,7 +45,6 @@ class AliMUONDigitizerv1 : public AliDigitizer {
     void           SortTracks(Int_t *tracks,Int_t *charges,Int_t ntr);
     
     private:
-    TClonesArray * fHits;           // List of Hits
     AliMUONHitMapA1 **fHitMap;      //! pointer to array of pointers to hitmaps
     TObjArray *fTDList;             //! list of AliMUONTransientDigits
     Int_t fTDCounter;                 //! nr. of AliMUONTransientDigits
index 3895adcc04b475dac1af6c2c0c5f5d499b524c7c..eb7f0cf6c5a31d8e7ade498d7497e3de4b322455 100644 (file)
@@ -778,7 +778,7 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     AliSegmentation*      segmentation;
     AliMUONResponse*      response;
 
-    TClonesArray *muonDigits  = pMUON->DigitsAddress(chamber-1);
+    TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1,0);
     if (muonDigits == 0) return;
 
 //     gAlice->ResetDigits();
@@ -889,7 +889,7 @@ void AliMUONDisplay::LoadCoG(Int_t chamber, Int_t /*cathode*/)
     AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
     AliMUONChamber*  iChamber;
     
-    TClonesArray *muonRawClusters  = pMUON->RawClustAddress(chamber-1);
+    TClonesArray *muonRawClusters  = pMUON->GetMUONData()->RawClusters(chamber-1);
     if (muonRawClusters == 0) return;
 
 //     pMUON->ResetRawClusters();
index 7b213e8e0f1043d33b031a72e978a46d9351bfc3..19650b19162a9f040e7e3e295c3e70e771d9a86f 100644 (file)
@@ -733,7 +733,7 @@ void AliMUONEventReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
     // index of first HitForRec for the chamber
     if (ch == 0) fIndexOfFirstHitForRecPerChamber[ch] = 0;
     else fIndexOfFirstHitForRecPerChamber[ch] = fNHitsForRec;
-    rawclusters = pMUON->RawClustAddress(ch);
+    rawclusters = pMUON->GetMUONData()->RawClusters(ch);
 //     pMUON->ResetRawClusters();
 //     TR->GetEvent((Int_t) (TR->GetEntries()) - 1); // to be checked ????
     nclus = (Int_t) (rawclusters->GetEntries());
index 799dfd01f1923949549db8e0269e09c6afcbf539..ea8c15719ae30e51f7aac72ac40662be13413da2 100644 (file)
@@ -152,253 +152,253 @@ void AliMUONMerger::Digitise()
 
     // keep galice.root for signal and name differently the file for 
     // background when add! otherwise the track info for signal will be lost !
-  
-    AliMUONChamber*   iChamber;
-    AliSegmentation*  segmentation;
-
-    fList = new TObjArray;
-
-    AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
-    fHitMap= new AliHitMap* [AliMUONConstants::NCh()];
-    if (fMerge ) {
-       fBgrFile->cd();
-        //
-       // Get Hits Tree header from file
-       //if(fHitsBgr) fHitsBgr->Clear();     // Useless because line 327
-       //if(fPadHitsBgr) fPadHitsBgr->Clear(); // Useless because line 328
-       if(fTrH1) delete fTrH1;
-       fTrH1 = 0;
+  // Obsolete sep 2003 Gines MARTINEZ 
+  //    AliMUONChamber*   iChamber;
+//      AliSegmentation*  segmentation;
+
+//      fList = new TObjArray;
+
+//      AliMUON *pMUON  = (AliMUON *) gAlice->GetModule("MUON");
+//      fHitMap= new AliHitMap* [AliMUONConstants::NCh()];
+//      if (fMerge ) {
+//     fBgrFile->cd();
+//          //
+//     // Get Hits Tree header from file
+//     //if(fHitsBgr) fHitsBgr->Clear();     // Useless because line 327
+//     //if(fPadHitsBgr) fPadHitsBgr->Clear(); // Useless because line 328
+//     if(fTrH1) delete fTrH1;
+//     fTrH1 = 0;
        
-       char treeName[20];
-       sprintf(treeName,"TreeH%d",fEvNrBgr);
-       fTrH1 = (TTree*)gDirectory->Get(treeName);
-       if (!fTrH1) {
-           printf("ERROR: cannot find Hits Tree for event:%d\n",fEvNrBgr);
-       }
-        //
-       // Set branch addresses
-       TBranch *branch;
-       char branchname[20];
-       sprintf(branchname,"%s",pMUON->GetName());
-       if (fTrH1 && fHitsBgr) {
-           branch = fTrH1->GetBranch(branchname);
-           if (branch) branch->SetAddress(&fHitsBgr);
-       }
-       if (fTrH1 && fPadHitsBgr) {
-           branch = fTrH1->GetBranch("MUONCluster");
-           if (branch) branch->SetAddress(&fPadHitsBgr);
-       }
-    }
-    //
-    // loop over cathodes
-    //
-    fSignal = kTRUE;
-    for (int icat = 0; icat < 2; icat++) { 
-       fCounter = 0;
-       for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
-           iChamber = &(pMUON->Chamber(i));
-           if (iChamber->Nsec() == 1 && icat == 1) {
-               continue;
-           } else {
-               segmentation = iChamber->SegmentationModel(icat+1);
-           }
-           fHitMap[i] = new AliMUONHitMapA1(segmentation, fList);
-       }
-
-//
-//   Loop over tracks
-//
-
-/******************************************************************/
-      TTree* treeH = pMUON->TreeH();
-      if (treeH == 0x0)
-       {
-         cerr<<"AliMUONMerger::Exec: Can not get TreeH"<<endl;
-         return;
-       }
-/******************************************************************/     
+//     char treeName[20];
+//     sprintf(treeName,"TreeH%d",fEvNrBgr);
+//     fTrH1 = (TTree*)gDirectory->Get(treeName);
+//     if (!fTrH1) {
+//         printf("ERROR: cannot find Hits Tree for event:%d\n",fEvNrBgr);
+//     }
+//          //
+//     // Set branch addresses
+//     TBranch *branch;
+//     char branchname[20];
+//     sprintf(branchname,"%s",pMUON->GetName());
+//     if (fTrH1 && fHitsBgr) {
+//         branch = fTrH1->GetBranch(branchname);
+//         if (branch) branch->SetAddress(&fHitsBgr);
+//     }
+//     if (fTrH1 && fPadHitsBgr) {
+//         branch = fTrH1->GetBranch("MUONCluster");
+//         if (branch) branch->SetAddress(&fPadHitsBgr);
+//     }
+//      }
+//      //
+//      // loop over cathodes
+//      //
+//      fSignal = kTRUE;
+//      for (int icat = 0; icat < 2; icat++) { 
+//     fCounter = 0;
+//     for (Int_t i = 0; i < AliMUONConstants::NCh(); i++) {
+//         iChamber = &(pMUON->Chamber(i));
+//         if (iChamber->Nsec() == 1 && icat == 1) {
+//             continue;
+//         } else {
+//             segmentation = iChamber->SegmentationModel(icat+1);
+//         }
+//         fHitMap[i] = new AliMUONHitMapA1(segmentation, fList);
+//     }
+
+//  //
+//  //   Loop over tracks
+//  //
+
+//  /******************************************************************/
+//        TTree* treeH = pMUON->TreeH();
+//        if (treeH == 0x0)
+//         {
+//           cerr<<"AliMUONMerger::Exec: Can not get TreeH"<<endl;
+//           return;
+//         }
+//  /******************************************************************/     
 
        
        
-       Int_t ntracks = (Int_t) treeH->GetEntries();
-       treeH->SetBranchStatus("*",0); // switch off all branches
-        treeH->SetBranchStatus("MUON*",1); // switch on only MUON
-
-       for (fTrack = 0; fTrack < ntracks; fTrack++) {
-           gAlice->ResetHits();
-           treeH->GetEntry(fTrack,0);
-//
-//   Loop over hits
-           for(AliMUONHit* mHit = (AliMUONHit*)pMUON->FirstHit(-1); 
-               mHit;
-               mHit = (AliMUONHit*)pMUON->NextHit()) 
-           {
-               fNch = mHit->Chamber()-1;  // chamber number
-               if (fNch > AliMUONConstants::NCh()-1) continue;
-               iChamber = &(pMUON->Chamber(fNch));
+//     Int_t ntracks = (Int_t) treeH->GetEntries();
+//     treeH->SetBranchStatus("*",0); // switch off all branches
+//          treeH->SetBranchStatus("MUON*",1); // switch on only MUON
+
+//     for (fTrack = 0; fTrack < ntracks; fTrack++) {
+//         gAlice->ResetHits();
+//         treeH->GetEntry(fTrack,0);
+//  //
+//  //   Loop over hits
+//         for(AliMUONHit* mHit = (AliMUONHit*)pMUON->FirstHit(-1); 
+//             mHit;
+//             mHit = (AliMUONHit*)pMUON->NextHit()) 
+//         {
+//             fNch = mHit->Chamber()-1;  // chamber number
+//             if (fNch > AliMUONConstants::NCh()-1) continue;
+//             iChamber = &(pMUON->Chamber(fNch));
                
-//
-// Loop over pad hits
-               for (AliMUONPadHit* mPad =
-                        (AliMUONPadHit*)pMUON->FirstPad(mHit,pMUON->PadHits());
-                    mPad;
-                    mPad = (AliMUONPadHit*)pMUON->NextPad(pMUON->PadHits()))
-               {
-                   Int_t cathode  = mPad->Cathode();      // cathode number
-                   if (cathode != (icat+1)) continue;
-                   Int_t iqpad    = Int_t(mPad->QPad());  // charge per pad
-//                 segmentation = iChamber->SegmentationModel(cathode);
-                   fDigits[0] = mPad->PadX();  
-                   fDigits[1] = mPad->PadY();
-                   if (!(fHitMap[fNch]->ValidateHit(fDigits[0], fDigits[1]))) continue;
-                   fDigits[2] = icat;
-                   fDigits[3] = iqpad;
-                   fDigits[4] = iqpad;
-                   if (mHit->Particle() == kMuonPlus ||
-                       mHit->Particle() == kMuonMinus) {
-                       fDigits[5] = mPad->HitNumber();
-                   } else fDigits[5] = -1;
-
-                   // build the list of fired pads and update the info
-
-                   if (!Exists(mPad)) {
-                       CreateNew(mPad);
-                   } else {
-                       Update(mPad);
-                   } //  end if pdigit
-               } //end loop over clusters
-           } // hit loop
-       } // track loop
-
-       // open the file with background
+//  //
+//  // Loop over pad hits
+//             for (AliMUONPadHit* mPad =
+//                      (AliMUONPadHit*)pMUON->FirstPad(mHit,pMUON->PadHits());
+//                  mPad;
+//                  mPad = (AliMUONPadHit*)pMUON->NextPad(pMUON->PadHits()))
+//             {
+//                 Int_t cathode  = mPad->Cathode();      // cathode number
+//                 if (cathode != (icat+1)) continue;
+//                 Int_t iqpad    = Int_t(mPad->QPad());  // charge per pad
+//  //             segmentation = iChamber->SegmentationModel(cathode);
+//                 fDigits[0] = mPad->PadX();  
+//                 fDigits[1] = mPad->PadY();
+//                 if (!(fHitMap[fNch]->ValidateHit(fDigits[0], fDigits[1]))) continue;
+//                 fDigits[2] = icat;
+//                 fDigits[3] = iqpad;
+//                 fDigits[4] = iqpad;
+//                 if (mHit->Particle() == kMuonPlus ||
+//                     mHit->Particle() == kMuonMinus) {
+//                     fDigits[5] = mPad->HitNumber();
+//                 } else fDigits[5] = -1;
+
+//                 // build the list of fired pads and update the info
+
+//                 if (!Exists(mPad)) {
+//                     CreateNew(mPad);
+//                 } else {
+//                     Update(mPad);
+//                 } //  end if pdigit
+//             } //end loop over clusters
+//         } // hit loop
+//     } // track loop
+
+//     // open the file with background
        
-       if (fMerge) {
-            fSignal = kFALSE;
-           ntracks = (Int_t)fTrH1->GetEntries();
-//
-//   Loop over tracks
-//
-           for (fTrack = 0; fTrack < ntracks; fTrack++) {
-
-               if (fHitsBgr)       fHitsBgr->Clear();
-               if (fPadHitsBgr)    fPadHitsBgr->Clear();
-
-               fTrH1->GetEvent(fTrack);
-//
-//   Loop over hits
-               AliMUONHit* mHit;
-               for(Int_t i = 0; i < fHitsBgr->GetEntriesFast(); ++i) 
-               {       
-                   mHit   = (AliMUONHit*) (*fHitsBgr)[i];
-                   fNch   = mHit->Chamber()-1;  // chamber number
-                   iChamber = &(pMUON->Chamber(fNch));
-//
-// Loop over pad hits
-                   for (AliMUONPadHit* mPad =
-                            (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHitsBgr);
-                        mPad;
-                        mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHitsBgr))
-                   {
-                       Int_t cathode  = mPad->Cathode();     // cathode number
-                       Int_t ipx      = mPad->PadX();        // pad number on X
-                       Int_t ipy      = mPad->PadY();        // pad number on Y
-                       Int_t iqpad    = Int_t(mPad->QPad()); // charge per pad
-                       if (!(fHitMap[fNch]->ValidateHit(ipx, ipy))) continue;
-
-                       if (cathode != (icat+1)) continue;
-                       fDigits[0] = ipx;
-                       fDigits[1] = ipy;
-                       fDigits[2] = icat;
-                       fDigits[3] = iqpad;
-                       fDigits[4] = 0;
-                       fDigits[5] = -1;
+//     if (fMerge) {
+//              fSignal = kFALSE;
+//         ntracks = (Int_t)fTrH1->GetEntries();
+//  //
+//  //   Loop over tracks
+//  //
+//         for (fTrack = 0; fTrack < ntracks; fTrack++) {
+
+//             if (fHitsBgr)       fHitsBgr->Clear();
+//             if (fPadHitsBgr)    fPadHitsBgr->Clear();
+
+//             fTrH1->GetEvent(fTrack);
+//  //
+//  //   Loop over hits
+//             AliMUONHit* mHit;
+//             for(Int_t i = 0; i < fHitsBgr->GetEntriesFast(); ++i) 
+//             {       
+//                 mHit   = (AliMUONHit*) (*fHitsBgr)[i];
+//                 fNch   = mHit->Chamber()-1;  // chamber number
+//                 iChamber = &(pMUON->Chamber(fNch));
+//  //
+//  // Loop over pad hits
+//                 for (AliMUONPadHit* mPad =
+//                          (AliMUONPadHit*)pMUON->FirstPad(mHit,fPadHitsBgr);
+//                      mPad;
+//                      mPad = (AliMUONPadHit*)pMUON->NextPad(fPadHitsBgr))
+//                 {
+//                     Int_t cathode  = mPad->Cathode();     // cathode number
+//                     Int_t ipx      = mPad->PadX();        // pad number on X
+//                     Int_t ipy      = mPad->PadY();        // pad number on Y
+//                     Int_t iqpad    = Int_t(mPad->QPad()); // charge per pad
+//                     if (!(fHitMap[fNch]->ValidateHit(ipx, ipy))) continue;
+
+//                     if (cathode != (icat+1)) continue;
+//                     fDigits[0] = ipx;
+//                     fDigits[1] = ipy;
+//                     fDigits[2] = icat;
+//                     fDigits[3] = iqpad;
+//                     fDigits[4] = 0;
+//                     fDigits[5] = -1;
                        
-                       // build the list of fired pads and update the info
-                       if (!Exists(mPad)) {
-                           CreateNew(mPad);
-                       } else {
-                           Update(mPad);
-                       } //  end if !Exists
-                   } //end loop over clusters
-               } // hit loop
-           } // track loop
-
-           TTree *treeK = gAlice->TreeK();
-            TFile *file = NULL;
+//                     // build the list of fired pads and update the info
+//                     if (!Exists(mPad)) {
+//                         CreateNew(mPad);
+//                     } else {
+//                         Update(mPad);
+//                     } //  end if !Exists
+//                 } //end loop over clusters
+//             } // hit loop
+//         } // track loop
+
+//         TTree *treeK = gAlice->TreeK();
+//              TFile *file = NULL;
            
-           if (treeK) file = treeK->GetCurrentFile();
-           file->cd();
-       } // if fMerge
+//         if (treeK) file = treeK->GetCurrentFile();
+//         file->cd();
+//     } // if fMerge
 
-       Int_t tracks[kMAXTRACKS];
-       Int_t charges[kMAXTRACKS];
-       Int_t nentries = fList->GetEntriesFast();
+//     Int_t tracks[kMAXTRACKS];
+//     Int_t charges[kMAXTRACKS];
+//     Int_t nentries = fList->GetEntriesFast();
        
-       for (Int_t nent = 0; nent < nentries; nent++) {
-           AliMUONTransientDigit *address = (AliMUONTransientDigit*)fList->At(nent);
-           if (address == 0) continue; 
-           Int_t ich = address->Chamber();
-           Int_t   q = address->Signal(); 
-           iChamber = &(pMUON->Chamber(ich));
-//
-//  Digit Response (noise, threshold, saturation, ...)
-           AliMUONResponse * response = iChamber->ResponseModel();
-           q = response->DigitResponse(q,address);
+//     for (Int_t nent = 0; nent < nentries; nent++) {
+//         AliMUONTransientDigit *address = (AliMUONTransientDigit*)fList->At(nent);
+//         if (address == 0) continue; 
+//         Int_t ich = address->Chamber();
+//         Int_t   q = address->Signal(); 
+//         iChamber = &(pMUON->Chamber(ich));
+//  //
+//  //  Digit Response (noise, threshold, saturation, ...)
+//         AliMUONResponse * response = iChamber->ResponseModel();
+//         q = response->DigitResponse(q,address);
            
-           if (!q) continue;
+//         if (!q) continue;
            
-           fDigits[0] = address->PadX();
-           fDigits[1] = address->PadY();
-           fDigits[2] = address->Cathode();
-           fDigits[3] = q;
-           fDigits[4] = address->Physics();
-           fDigits[5] = address->Hit();
+//         fDigits[0] = address->PadX();
+//         fDigits[1] = address->PadY();
+//         fDigits[2] = address->Cathode();
+//         fDigits[3] = q;
+//         fDigits[4] = address->Physics();
+//         fDigits[5] = address->Hit();
            
-           Int_t nptracks = address->GetNTracks();
-
-           if (nptracks > kMAXTRACKS) {
-               if (fDebug>0)
-                 printf("\n Attention - nptracks > kMAXTRACKS %d \n", nptracks);
-               nptracks = kMAXTRACKS;
-           }
-           if (nptracks > 2) {
-               if (fDebug>0) {
-                 printf("Attention - nptracks > 2  %d \n",nptracks);
-                 printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
-               }
-           }
-           for (Int_t tr = 0; tr < nptracks; tr++) {
-               tracks[tr]   = address->GetTrack(tr);
-               charges[tr]  = address->GetCharge(tr);
-           }      //end loop over list of tracks for one pad
-            // Sort list of tracks according to charge
-           if (nptracks > 1) {
-               SortTracks(tracks,charges,nptracks);
-           }
-           if (nptracks < kMAXTRACKS ) {
-               for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
-                   tracks[i]  = 0;
-                   charges[i] = 0;
-               }
-           }
+//         Int_t nptracks = address->GetNTracks();
+
+//         if (nptracks > kMAXTRACKS) {
+//             if (fDebug>0)
+//               printf("\n Attention - nptracks > kMAXTRACKS %d \n", nptracks);
+//             nptracks = kMAXTRACKS;
+//         }
+//         if (nptracks > 2) {
+//             if (fDebug>0) {
+//               printf("Attention - nptracks > 2  %d \n",nptracks);
+//               printf("cat,ich,ix,iy,q %d %d %d %d %d \n",icat,ich,fDigits[0],fDigits[1],q);
+//             }
+//         }
+//         for (Int_t tr = 0; tr < nptracks; tr++) {
+//             tracks[tr]   = address->GetTrack(tr);
+//             charges[tr]  = address->GetCharge(tr);
+//         }      //end loop over list of tracks for one pad
+//              // Sort list of tracks according to charge
+//         if (nptracks > 1) {
+//             SortTracks(tracks,charges,nptracks);
+//         }
+//         if (nptracks < kMAXTRACKS ) {
+//             for (Int_t i = nptracks; i < kMAXTRACKS; i++) {
+//                 tracks[i]  = 0;
+//                 charges[i] = 0;
+//             }
+//         }
            
-           // fill digits
-           pMUON->AddDigits(ich,tracks,charges,fDigits);
-       }
-       gAlice->TreeD()->Fill();
-       pMUON->ResetDigits();
-       fList->Delete();
+//         // fill digits
+//         pMUON->AddDigits(ich,tracks,charges,fDigits);
+//     }
+//     gAlice->TreeD()->Fill();
+//     pMUON->ResetDigits();
+//     fList->Delete();
 
        
-       for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
-           if (fHitMap[ii]) {
-               delete fHitMap[ii];
-               fHitMap[ii] = 0;
-           }
-       }
-    } //end loop over cathodes
-    delete [] fHitMap;
-    delete fList;
+//     for(Int_t ii = 0; ii < AliMUONConstants::NCh(); ++ii) {
+//         if (fHitMap[ii]) {
+//             delete fHitMap[ii];
+//             fHitMap[ii] = 0;
+//         }
+//     }
+//      } //end loop over cathodes
+//      delete [] fHitMap;
+//      delete fList;
     
 //  no need to delete ... and it makes a crash also
 //    if (fHitsBgr)    fHitsBgr->Delete();
index 79a8697f1b3ce2c09b7346d1070112bbd60ded87..0fab6b3af53d08c546d77c9bf9a2404c23f9c4c3 100644 (file)
@@ -236,7 +236,7 @@ AliMUONDigit *AliMUONPoints::GetDigit() const
   Int_t cathode=display->GetCathode();
    
   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-  TClonesArray *muonDigits  = pMUON->DigitsAddress(chamber-1);
+  TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1,0);
   Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
   gAlice->TreeD()->GetEvent(nent-2+cathode-1);
   //gAlice->TreeD()->GetEvent(cathode);
index aed21fdca79d281bd5930e7a70b2c73cc3d970b2..89f6287609c5513e8c8915bb9f0f066ef24281c9 100644 (file)
@@ -42,7 +42,7 @@ AliMUONSegmentationSlatModuleN::AliMUONSegmentationSlatModuleN(Int_t nsec)
 }
 
 
-Float_t AliMUONSegmentationSlatModuleN::Dpx(Int_t isec) const
+Float_t AliMUONSegmentationSlatModuleN::Dpx(Int_t /*isec*/) const
 {
 //
 // Returns x-pad size for given sector isec
index 55428bc02a927d2589f72dc4df7325b0dd753dfe..ad5d474d2a9bddb32c002a1f72872ac9edaf09b7 100644 (file)
@@ -184,7 +184,7 @@ AliMUONTrackK::AliMUONTrackK(AliMUONSegment *segment)
     // from raw clusters
     for (Int_t i=0; i<2; i++) {
       hit1 = (AliMUONHitForRec*) ((*fTrackHitsPtr)[i]);
-      rawclusters = fgMUON->RawClustAddress(hit1->GetChamberNumber());
+      rawclusters = fgMUON->GetMUONData()->RawClusters(hit1->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit1->GetHitNumber());
       cout << clus->fTracks[1]-1;
       if (clus->fTracks[2] != 0) cout << " " << clus->fTracks[2]-1;
@@ -1217,7 +1217,7 @@ void AliMUONTrackK::GoToVertex(void)
     // from raw clusters
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      rawclusters = fgMUON->RawClustAddress(hit->GetChamberNumber());
+      rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
       printf ("%4d", clus->fTracks[1] - 1); 
       //cout << clus->fTracks[1] - 1 << " ";
@@ -1225,7 +1225,7 @@ void AliMUONTrackK::GoToVertex(void)
     cout << endl;
     for (Int_t i1=0; i1<fNTrackHits; i1++) {
       hit =  (AliMUONHitForRec*) ((*fTrackHitsPtr)[i1]);
-      rawclusters = fgMUON->RawClustAddress(hit->GetChamberNumber());
+      rawclusters = fgMUON->GetMUONData()->RawClusters(hit->GetChamberNumber());
       clus = (AliMUONRawCluster*) rawclusters->UncheckedAt(hit->GetHitNumber());
       if (clus->fTracks[2] != 0) printf ("%4d", clus->fTracks[2] - 1);
       else printf ("%4s", "   ");
index b02773d36e75b1fa37673c074deb9272ede6c3a1..de99927a6791ebb7ce8477231fded0d3a35c1d6a 100644 (file)
@@ -203,7 +203,7 @@ void AliMUONTriggerDecision::SetBit(){
       AliMUONChamber*   iChamber = &(pMUON->Chamber(chamber-1));
       AliSegmentation*  segmentation;
       gime->TreeD()->GetEvent(cathode-1);
-      TClonesArray *muonDigits = pMUON->DigitsAddress(chamber-1);
+      TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
       Int_t ndigits = muonDigits->GetEntriesFast();
 //      printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
 //    if (ndigits == 0) return;
index 0fcfdd7af38b8a3f203c4bccfb78cd8bd7685099..0729cb69f201fca700598dfe6393fd928c6b2743 100644 (file)
@@ -1987,9 +1987,10 @@ void AliMUONv1::StepManager()
     destep = gMC->Edep();
     step   = gMC->TrackStep();
     //new hit
-    AddHit(fIshunt, gAlice->GetCurrentTrackNumber(), iChamber, ipart, 
-          pos.X(), pos.Y(), pos.Z(), tof, mom.P(), 
-          theta, phi, step, destep);
+
+    GetMUONData()->AddHit(fIshunt, gAlice->GetCurrentTrackNumber(), iChamber, ipart, 
+                         pos.X(), pos.Y(), pos.Z(), tof, mom.P(), 
+                         theta, phi, step, destep);
   }
   // Track left chamber ...
   if( gMC->IsTrackExiting() || gMC->IsTrackStop() || gMC->IsTrackDisappeared()){
@@ -2075,7 +2076,7 @@ void AliMUONv1::StepManagerOld()
       hits[3] = pos[2]+s*tz;            // Z-position for hit
       hits[4] = theta;                  // theta angle of incidence
       hits[5] = phi;                    // phi angle of incidence 
-      hits[8] = (Float_t) fNPadHits;    // first padhit
+      hits[8] = 0;//PadHits does not exist anymore  (Float_t) fNPadHits;    // first padhit
       hits[9] = -1;                     // last pad hit
       hits[10] = mom[3];                // hit momentum P
       hits[11] = mom[0];                // Px
@@ -2134,16 +2135,16 @@ void AliMUONv1::StepManagerOld()
       }
       
 
-      if (eloss >0)  MakePadHits(x0,y0,z0,eloss,tof,idvol);
+      //      if (eloss >0)  MakePadHits(x0,y0,z0,eloss,tof,idvol);
       
          
       hits[6] = tlength;   // track length
       hits[7] = eloss2;    // de/dx energy loss
 
-      if (fNPadHits > (Int_t)hits[8]) {
-         hits[8] = hits[8]+1;
-         hits[9] = (Float_t) fNPadHits;
-      }
+      //      if (fNPadHits > (Int_t)hits[8]) {
+      //         hits[8] = hits[8]+1;
+      //         hits[9] = 0: // PadHits does not exist anymore (Float_t) fNPadHits;
+      //}
 //
 //    new hit 
       
@@ -2168,8 +2169,8 @@ void AliMUONv1::StepManagerOld()
 
       eloss    += destep;
 
-      if (eloss > 0 && idvol < AliMUONConstants::NTrackingCh())
-       MakePadHits(0.5*(xhit+pos[0]),0.5*(yhit+pos[1]),pos[2],eloss,tof,idvol);
+      // if (eloss > 0 && idvol < AliMUONConstants::NTrackingCh())
+      //       MakePadHits(0.5*(xhit+pos[0]),0.5*(yhit+pos[1]),pos[2],eloss,tof,idvol);
       xhit     = pos[0];
       yhit     = pos[1]; 
       zhit     = pos[2];
index 519894c5f639433df885f9f6cbf50914fb5fc01c..195cd16694522bd1c0d68aa987a5af4aeb023133 100644 (file)
@@ -20,6 +20,7 @@
 
 // MUON includes
 #include "AliMUON.h"
+#include "AliMUONData.h"
 #include "AliMUONHit.h"
 #include "AliMUONConstants.h"
 #include "AliMUONDigit.h"
@@ -59,9 +60,6 @@ void MUONkine(char * filename="galice.root")
 
 void MUONhits(char * filename="galice.root")
 {
-  // List of Hits per event and per track
-  TClonesArray * ListOfHits = new TClonesArray("AliMUONHit",1000);
-
   // Creating Run Loader and openning file containing Hits
   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
   if (RunLoader ==0x0) {
@@ -72,6 +70,8 @@ void MUONhits(char * filename="galice.root")
   // Loading MUON subsystem
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
   MUONLoader->LoadHits("READ");
+  // Creating MUON data container
+  AliMUONData muondata(MUONLoader,"MUON","MUON");
 
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
@@ -81,8 +81,8 @@ void MUONhits(char * filename="galice.root")
 
     // Getting event ievent
     RunLoader->GetEvent(ievent); 
-    MUONLoader->TreeH()->GetBranch("MUON")->SetAddress(&ListOfHits);
-
+    muondata.SetTreeAddress("H");
+   
     Int_t itrack, ntracks;
     ntracks = (Int_t) (MUONLoader->TreeH())->GetEntries();
     for (itrack=0; itrack<ntracks; itrack++) { // Track loop
@@ -92,11 +92,11 @@ void MUONhits(char * filename="galice.root")
       (MUONLoader->TreeH())->GetEvent(itrack); 
 
       Int_t ihit, nhits;
-      nhits = (Int_t) ListOfHits->GetEntriesFast();
+      nhits = (Int_t) muondata.Hits()->GetEntriesFast();
       printf(">>> Number of hits  %d \n",nhits);
       AliMUONHit* mHit;
       for(ihit=0; ihit<nhits; ihit++) {
-       mHit = static_cast<AliMUONHit*>(ListOfHits->At(ihit));
+       mHit = static_cast<AliMUONHit*>(muondata.Hits()->At(ihit));
        Int_t Nch      = mHit->Chamber();  // chamber number
        Int_t hittrack = mHit->Track();
        Float_t x      = mHit->X();
@@ -109,7 +109,7 @@ void MUONhits(char * filename="galice.root")
        printf(">>> Hit %2d Chamber %2d Track %4d x %6.3f y %6.3f z %7.3f elos %g theta %6.3f phi %5.3f momentum %5.3f\n",
               ihit, Nch,hittrack,x,y,z,elos,theta,phi, momentum);
       }
-      ListOfHits->Clear();
+      muondata.ResetHits();
     } // end track loop
   }  // end event loop
   MUONLoader->UnloadHits();
@@ -118,24 +118,19 @@ void MUONhits(char * filename="galice.root")
 
 void MUONdigits(char * filename="galice.root")
 {
-  TClonesArray * ListOfDigits;
-
   // Creating Run Loader and openning file containing Hits
   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
   if (RunLoader ==0x0) {
     printf(">>> Error : Error Opening %s file \n",filename);
     return;
   }
-
-  // Loading AliRun master
-  RunLoader->LoadgAlice();
-  gAlice = RunLoader->GetAliRun();
- // Getting Module MUON  
-  AliMUON *pMUON  = (AliMUON *) gAlice->GetDetector("MUON");
-
+  // Loading MUON subsystem
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
   MUONLoader->LoadDigits("READ");
 
+  // Creating MUON data container
+  AliMUONData muondata(MUONLoader,"MUON","MUON");
+
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
 
@@ -149,14 +144,9 @@ void MUONdigits(char * filename="galice.root")
     // Addressing
     Int_t ichamber, nchambers;
     nchambers = AliMUONConstants::NCh(); ;
-    pMUON->SetTreeAddress(); 
+    muondata.SetTreeAddress("D"); 
     char branchname[30];    
-   //for( ichamber=0; ichamber<nchambers; ichamber++) {
-    // sprintf(branchname,"MUONDigits%d",ichamber+1);
-    //(MUONLoader->TreeD()->GetBranch(branchname))->SetAddress(&((*pMUON->Dchambers())[ichamber]));
-    //}
-   
-
     Int_t icathode, ncathodes;
     ncathodes=2;
     //Loop on cathodes 
@@ -168,14 +158,13 @@ void MUONdigits(char * filename="galice.root")
        printf(">>> Chamber %d\n",ichamber);
        //      sprintf(branchname,"MUONDigits%d",ichamber+1);
        //printf(">>>  branchname %s\n",branchname);
-       ListOfDigits = (TClonesArray *) pMUON->Dchambers()->At(ichamber);
        
        Int_t idigit, ndigits;
 
-       ndigits = (Int_t) ListOfDigits->GetEntriesFast();
+       ndigits = (Int_t) muondata.Digits(ichamber,0)->GetEntriesFast();
        
        for(idigit=0; idigit<ndigits; idigit++) {
-         mDigit = static_cast<AliMUONDigit*>(ListOfDigits->At(idigit));
+         mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber,0)->At(idigit));
          Int_t PadX   = mDigit->PadX();     // Pad X number
          Int_t PadY   = mDigit->PadY();     // Pad Y number
          Int_t Signal = mDigit->Signal();   // Physics Signal
@@ -188,6 +177,7 @@ void MUONdigits(char * filename="galice.root")
          printf(">>> Digit %4d cathode %1d hit %4d PadX %3d PadY %3d Signal %4d Track0 %4d Track1 %'d Track2 %4d \n",idigit, Cathode,Hit, PadX, PadY, Signal, Track0, Track1, Track2);
        } // end digit loop
       } // end chamber loop
+      muondata.ResetDigits();
     } // end cathode loop
   }  // end event loop
   MUONLoader->UnloadDigits();
@@ -195,30 +185,23 @@ void MUONdigits(char * filename="galice.root")
 
 void MUONrecpoints(char * filename="galice.root") {
 
-  TClonesArray * ListOfRecPoints;
-  
   // Creating Run Loader and openning file containing Hits
   AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","READ");
   if (RunLoader ==0x0) {
     printf(">>> Error : Error Opening %s file \n",filename);
     return;
   }
-
-  // Loading AliRun master
-  RunLoader->LoadgAlice();
-  gAlice = RunLoader->GetAliRun();
- // Getting Module MUON  
-  AliMUON *pMUON  = (AliMUON *) gAlice->GetDetector("MUON");
-
+  // Getting MUONloader
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
   MUONLoader->LoadRecPoints("READ");
+  // Creating MUON data container
+  AliMUONData muondata(MUONLoader,"MUON","MUON");
 
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
 
   AliMUONRawCluster * mRecPoint;
   
-
   for(ievent=0; ievent<nevents; ievent++) {
     printf(">>> Event %d \n",ievent);
     RunLoader->GetEvent(ievent);
@@ -226,23 +209,21 @@ void MUONrecpoints(char * filename="galice.root") {
     // Addressing
     Int_t ichamber, nchambers;
     nchambers = AliMUONConstants::NTrackingCh();
-    pMUON->SetTreeAddress(); 
+    muondata.SetTreeAddress("RC"); 
     char branchname[30];    
     MUONLoader->TreeR()->GetEvent(0);
     // Loop on chambers
     for( ichamber=0; ichamber<nchambers; ichamber++) {
       printf(">>> Chamber %d\n",ichamber);
       sprintf(branchname,"MUONRawClusters%d",ichamber+1);
       //printf(">>>  branchname %s\n",branchname);
-      ListOfRecPoints = (TClonesArray *) pMUON->RawClusters()->At(ichamber);
-      
+  
       Int_t irecpoint, nrecpoints;
       
-      nrecpoints = (Int_t) ListOfRecPoints->GetEntriesFast();
+      nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
       
       for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
-       mRecPoint = static_cast<AliMUONRawCluster*>(ListOfRecPoints->At(irecpoint));
+       mRecPoint = static_cast<AliMUONRawCluster*>(muondata.RawClusters(ichamber)->At(irecpoint));
 //     Int_t       fTracks[3];        //labels of overlapped tracks
 //     Int_t       fQ[2]  ;           // Q of cluster (in ADC counts)     
 //     Float_t     fX[2]  ;           // X of cluster
@@ -281,6 +262,7 @@ void MUONrecpoints(char * filename="galice.root") {
 irecpoint, x0, x1, y0, y1, z0, z1, Q0, Q1, Track0, Track1, Track2, chi2_0, chi2_1);
       } // end recpoint loop
     } // end chamber loop
+    muondata.ResetRawClusters();
   }  // end event loop
   MUONLoader->UnloadRecPoints();
 }
@@ -297,15 +279,12 @@ void MUONTestTrigger (char * filename="galice.root"){
       return;
   }
   
-  // Loading AliRun master
-  RunLoader->LoadgAlice();
-  gAlice = RunLoader->GetAliRun();
-  // Getting Module MUON  
-  AliMUON *pMUON  = (AliMUON *) gAlice->GetDetector("MUON");
-  
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
   MUONLoader->LoadRecPoints("READ");
+  // Creating MUON data container
+  AliMUONData muondata(MUONLoader,"MUON","MUON");
   
+
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
   
@@ -315,11 +294,11 @@ void MUONTestTrigger (char * filename="galice.root"){
   for (ievent=0; ievent<nevents; ievent++) {
       RunLoader->GetEvent(ievent);
       
-      pMUON->SetTreeAddress(); 
+      muondata.SetTreeAddress("GLT"); 
       MUONLoader->TreeR()->GetEvent(0);
       
-      globalTrigger = (TClonesArray *) pMUON->GlobalTrigger();
-      localTrigger = (TClonesArray *) pMUON->LocalTrigger();
+      globalTrigger = muondata.GlobalTrigger();
+      localTrigger = muondata.LocalTrigger();
       
       Int_t nglobals = (Int_t) globalTrigger->GetEntriesFast(); // should be 1
       Int_t nlocals  = (Int_t) localTrigger->GetEntriesFast(); // up to 234
@@ -373,6 +352,7 @@ void MUONTestTrigger (char * filename="galice.root"){
               << locTrg->LoApt() << "\n";
          
       } // end of loop on Local Trigger
+      muondata.ResetTrigger();
   } // end loop on event  
 } 
 
index 380b7a438c4cae8d83f2606d6c5a0be55beac635..9e1bac3f8f9e94918fdf98fe571e6f2760cc1c72 100644 (file)
@@ -5,6 +5,7 @@
 #pragma link C++ class  AliMUON+;
 #pragma link C++ class  AliMUONv0+;
 #pragma link C++ class  AliMUONv1+;
+#pragma link C++ class  AliMUONData+;
 #pragma link C++ class  AliMUONLoader+;
 #pragma link C++ class  AliMUONHit+;
 #pragma link C++ class  AliMUONPadHit+;
index cdc45b9a01cdca2586e77e1a5ba39745647c26f9..76cf4929a41ba3c24b4569b1e1201d04f6d639cd 100644 (file)
@@ -58,6 +58,7 @@ void MUONrawclusters (char* filename, Int_t evNumber1=0,Int_t evNumber2=0)
   // Loading MUON subsystem
   AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
+  AliMUONData * muondata = MUON->GetMUONData();
 
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
@@ -81,8 +82,8 @@ void MUONrawclusters (char* filename, Int_t evNumber1=0,Int_t evNumber2=0)
       RunLoader->GetEvent(ievent);
       MUONLoader->LoadDigits("read");
       if (MUONLoader->TreeR() == 0x0) MUONLoader->MakeTree("R");
-      MUON->MakeBranch("R");
-      MUON->SetTreeAddress();
+      muondata->MakeBranch("RC");
+      muondata->SetTreeAddress("D,RC");
       MUON->Digits2Reco(); 
       MUONLoader->UnloadDigits();
       MUONLoader->UnloadRecPoints();
index 47e994237991a0eb0fb7dab5e8c36c919b3a6001..bdbff46bce679f532714334eb7e9e4f2ed3a1588 100644 (file)
@@ -29,7 +29,7 @@ SRCS         = AliMUONChamber.cxx AliMUONChamberTrigger.cxx \
               AliMUONRecoEvent.cxx AliMUONRecoDisplay.cxx \
                AliMUONMerger.cxx AliMUONFactory.cxx AliMUONDigitizer.cxx AliMUONDigitizerv1.cxx \
                AliMUONTrackK.cxx AliMUONClusterFinderAZ.cxx AliMUONPixel.cxx \
-               AliMUONLoader.cxx
+               AliMUONLoader.cxx AliMUONData.cxx
 
 SRCS     += AliMUONv2.cxx AliMUONSt1Segmentation.cxx AliMUONSt1Response.cxx \
            AliMUONSt1ElectronicElement.cxx AliMUONSt1SpecialMotif.cxx \