Adding local data container for clusterisation and tracking (Christian Finck)
authormartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Feb 2004 15:55:55 +0000 (15:55 +0000)
committermartinez <martinez@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 26 Feb 2004 15:55:55 +0000 (15:55 +0000)
MUON/AliMUON.cxx
MUON/AliMUONClusterReconstructor.cxx [new file with mode: 0644]
MUON/AliMUONDisplay.cxx
MUON/AliMUONEventReconstructor.cxx
MUON/AliMUONEventReconstructor.h
MUON/AliMUONTriggerDecision.cxx
MUON/AliMUONTriggerDecision.h
MUON/MUONTracker.C
MUON/MUONTriggerTracker.C
MUON/MUONrawclusters.C
MUON/MUONtrigger.C

index 2444779f35ed7cadf1a3741da0148e2f0e461bd2..ef58cf88616afa5c750d330f91f5f98aa6b35742 100644 (file)
 #include "AliMUON.h"
 #include "AliMUONTriggerTrack.h"
 #include "AliMUONEventReconstructor.h"
+#include "AliMUONClusterReconstructor.h"
 #include "AliMUONTrack.h"
 #include "AliMUONTrackParam.h"
 #include "AliMUONChamberTrigger.h"
-#include "AliMUONClusterFinderVS.h"
+#include "AliMUONClusterFinderAZ.h"
 #include "AliMUONClusterInput.h"
 #include "AliMUONConstants.h"
 #include "AliMUONDigit.h"
@@ -237,8 +238,9 @@ Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
 void  AliMUON::SetTreeAddress()
 {
   GetMUONData()->SetLoader(fLoader); 
-  GetMUONData()->MakeBranch("D,RC");
-  GetMUONData()->SetTreeAddress("H,D,RC");
+  //  GetMUONData()->MakeBranch("D,RC");
+  //  GetMUONData()->SetTreeAddress("H,D,RC");
+  GetMUONData()->SetTreeAddress("H");
   fHits = GetMUONData()->Hits(); // Added by Ivana to use the methods FisrtHit, NextHit of AliDetector
 }
 
@@ -440,7 +442,6 @@ AliLoader* AliMUON::MakeLoader(const char* topfoldername)
    Info("MakeLoader",
         "Creating standard getter for detector %s. Top folder is %s.",
          GetName(),topfoldername);
-     
  fLoader   = new AliLoader(GetName(),topfoldername);
  fMUONData = new AliMUONData(fLoader,GetName(),GetName()); 
  fMUONData->SetSplitLevel(fSplitLevel);
@@ -458,7 +459,7 @@ void AliMUON::Trigger(Int_t /*nev*/){
   Int_t pairLike[3]    = {0,0,0};
   
   ResetTrigger();
-  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
+  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(fLoader,1);
   decision->Trigger();   
   decision->GetGlobalTrigger(singlePlus, singleMinus, singleUndef,
                             pairUnlike, pairLike);
@@ -752,77 +753,92 @@ AliMUON& AliMUON::operator = (const AliMUON& /*rhs*/)
 //________________________________________________________________________
 void AliMUON::Reconstruct() const
 {
-// reconstruct clusters
 
 //  AliLoader* loader = GetLoader();
+
   AliRunLoader* runLoader = fLoader->GetRunLoader();
   Int_t nEvents = runLoader->GetNumberOfEvents();
 
+// used local container for each method
+// passing fLoader as argument, could be avoided ???
+  AliMUONEventReconstructor* recoEvent = new AliMUONEventReconstructor(fLoader);
+  AliMUONData* dataEvent = recoEvent->GetMUONData();
+
+  AliMUONClusterReconstructor* recoCluster = new AliMUONClusterReconstructor(fLoader);
+  AliMUONData* dataCluster = recoCluster->GetMUONData();
+
+  AliMUONTriggerDecision* trigDec = new AliMUONTriggerDecision(fLoader);
+  AliMUONData* dataTrig = trigDec->GetMUONData();
+
+
   for (Int_t i = 0; i < 10; i++) {
     AliMUONClusterFinderVS *RecModel = new AliMUONClusterFinderVS();
     RecModel->SetGhostChi2Cut(10);
-    const_cast<AliMUON*>(this)->SetReconstructionModel(i,RecModel);
+    recoCluster->SetReconstructionModel(i,RecModel);
   } 
 
-  AliMUONEventReconstructor* reco = new AliMUONEventReconstructor();
-
+  fLoader->LoadDigits("READ");
   fLoader->LoadRecPoints("RECREATE");
   fLoader->LoadTracks("RECREATE");
-  fLoader->LoadDigits("READ");
-
-
+  
   //   Loop over events              
   for(Int_t ievent = 0; ievent < nEvents; ievent++) {
     printf("Event %d\n",ievent);
     runLoader->GetEvent(ievent);
 
-    //---------------------------- digit2Reco & Trigger ---------------------
+    //----------------------- digit2cluster & Digits2Trigger -------------------
     if (!fLoader->TreeR()) fLoader->MakeRecPointsContainer();
      
     // tracking branch
-    fMUONData->MakeBranch("RC");
-    fMUONData->SetTreeAddress("D,RC");
-    const_cast<AliMUON*>(this)->Digits2Reco(); 
+    dataCluster->MakeBranch("RC");
+    dataCluster->SetTreeAddress("D,RC");
+    recoCluster->Digits2Clusters(); 
+    dataCluster->Fill("RC"); 
 
     // trigger branch
-    fMUONData->MakeBranch("GLT");
-    fMUONData->SetTreeAddress("D,GLT");
-    const_cast<AliMUON*>(this)->Trigger(ievent); 
+    dataTrig->MakeBranch("GLT");
+    dataTrig->SetTreeAddress("D,GLT");
+    trigDec->Digits2Trigger(); 
+    dataTrig->Fill("GLT");
+
+    fLoader->WriteRecPoints("OVERWRITE");
 
     //---------------------------- Track & TriggerTrack ---------------------
     if (!fLoader->TreeT()) fLoader->MakeTracksContainer();
+    // tracking branch
+    dataEvent->MakeBranch("RT"); //track
+    dataEvent->SetTreeAddress("RT");
+    recoEvent->EventReconstruct();
+    dataEvent->Fill("RT");
 
-    fMUONData->MakeBranch("RT"); //track
-    fMUONData->SetTreeAddress("RT");
-    reco->EventReconstruct();
-    for(Int_t i=0; i<reco->GetNRecTracks(); i++) {
-      AliMUONTrack * track = (AliMUONTrack*) reco->GetRecTracksPtr()->At(i);
-      fMUONData->AddRecTrack(*track);
-    }
-    fMUONData->Fill("RT");
-
-    fMUONData->MakeBranch("RL"); //trigger track
-    fMUONData->SetTreeAddress("RL");
-    reco->EventReconstructTrigger();
-    for(Int_t i=0; i<reco->GetNRecTriggerTracks(); i++) {
-      AliMUONTriggerTrack * triggertrack = (AliMUONTriggerTrack*) reco->GetRecTriggerTracksPtr()->At(i);
-      fMUONData->AddRecTriggerTrack(*triggertrack);
-    }
-    fMUONData->Fill("RL");
+    // trigger branch
+    dataEvent->MakeBranch("RL"); //trigger track
+    dataEvent->SetTreeAddress("RL");
+    recoEvent->EventReconstructTrigger();
+    dataEvent->Fill("RL");
 
     fLoader->WriteTracks("OVERWRITE");  
   
     //--------------------------- Resetting branches -----------------------
-    fMUONData->ResetDigits();
-    fMUONData->ResetRawClusters();
-    fMUONData->ResetTrigger();
-    fMUONData->ResetRecTracks();
-    fMUONData->ResetRecTriggerTracks();
+    dataCluster->ResetDigits();
+    dataCluster->ResetRawClusters();
+
+    dataTrig->ResetDigits();
+    dataTrig->ResetTrigger();
+
+    dataEvent->ResetRawClusters();
+    dataEvent->ResetTrigger();
+    dataEvent->ResetRecTracks();
+    dataEvent->ResetRecTriggerTracks();
+  
   }
   fLoader->UnloadDigits();
   fLoader->UnloadRecPoints();
   fLoader->UnloadTracks();
-  //delete reco;
+
+  delete recoCluster;
+  delete recoEvent;
+  delete trigDec;
 }
 //________________________________________________________________________
 void AliMUON::FillESD(AliESD* event) const
@@ -931,17 +947,17 @@ void AliMUON::FillESD(AliESD* event) const
        ESDTrack->SetY11(y11);
       }
       // storing ESD MUON Track into ESD Event & reset muondata
-      if (ntrectracks+ntrectracks != 0)  //YS 
+      if (ntrectracks+ntrectracks != 0)  
        event->AddMuonTrack(ESDTrack);
     } // end loop tracks
 
-    if (ntrectracks+ntrectracks != 0)  //YS 
-      event->SetTrigger(trigPat);
-
+    //    if (ntrectracks+ntrectracks != 0)  
+      //  event->SetTrigger(trigPat);
+      // Waiting for STEER update
     fMUONData->ResetRecTracks();
     fMUONData->ResetRecTriggerTracks();
 
-    //YS } // end loop on event  
-    fLoader->UnloadTracks(); //YS
+    //} // end loop on event  
+    fLoader->UnloadTracks(); 
 }
 
diff --git a/MUON/AliMUONClusterReconstructor.cxx b/MUON/AliMUONClusterReconstructor.cxx
new file mode 100644 (file)
index 0000000..20e99d1
--- /dev/null
@@ -0,0 +1,189 @@
+/**************************************************************************
+ * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ *                                                                        *
+ * Author: The ALICE Off-line Project.                                    *
+ * Contributors are mentioned in the code where appropriate.              *
+ *                                                                        *
+ * Permission to use, copy, modify and distribute this software and its   *
+ * documentation strictly for non-commercial purposes is hereby granted   *
+ * without fee, provided that the above copyright notice appears in all   *
+ * copies and that both the copyright notice and this permission notice   *
+ * appear in the supporting documentation. The authors make no claims     *
+ * about the suitability of this software for any purpose. It is          *
+ * provided "as is" without express or implied warranty.                  *
+ **************************************************************************/
+
+/* $Id$ */
+
+////////////////////////////////////
+//
+// MUON event reconstructor in ALICE
+//
+// This class contains as data:
+// * the parameters for the event reconstruction
+// * a pointer to the array of hits to be reconstructed (the event)
+// * a pointer to the array of segments made with these hits inside each station
+// * a pointer to the array of reconstructed tracks
+//
+// It contains as methods, among others:
+// * MakeEventToBeReconstructed to build the array of hits to be reconstructed
+// * MakeSegments to build the segments
+// * MakeTracks to build the tracks
+//
+////////////////////////////////////
+
+#include <Riostream.h> // for cout
+#include <stdlib.h> // for exit()
+
+#include <TTree.h>
+
+#include "AliMUON.h"
+#include "AliMUONClusterReconstructor.h"
+#include "AliMUONDigit.h"
+#include "AliMUONConstants.h"
+#include "AliMUONData.h"
+#include "AliMUONClusterFinderVS.h"
+#include "AliMUONClusterFinderAZ.h"
+#include "AliMUONClusterInput.h"
+#include "AliMUONRawCluster.h"
+#include "AliRun.h" // for gAlice
+#include "AliConfig.h"
+#include "AliRunLoader.h"
+#include "AliLoader.h"
+
+static const Int_t kDefaultPrintLevel = 0;
+
+ClassImp(AliMUONClusterReconstructor) // Class implementation in ROOT context
+
+//__________________________________________________________________________
+AliMUONClusterReconstructor::AliMUONClusterReconstructor(AliLoader* loader)
+{
+  // Default Constructor
+  fDebug           = 0;
+  fNCh             = 0;
+  fNTrackingCh     = 0;
+  fChambers        = 0;
+  fMUONData        = 0;
+  fChambers = new TObjArray(AliMUONConstants::NCh());
+
+  fPrintLevel = kDefaultPrintLevel;
+
+  // initialize loader's
+  fLoader = loader;
+
+  // initialize container
+  fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
+
+  // Loading AliRun master
+  AliRunLoader* runloader = fLoader->GetRunLoader();
+  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+  gAlice = runloader->GetAliRun();
+
+  // getting MUON
+  fMUON = (AliMUON*) gAlice->GetDetector("MUON");
+
+  return; 
+}
+//____________________________________________________________________
+void AliMUONClusterReconstructor::SetReconstructionModel(Int_t id, AliMUONClusterFinderVS *reconst)
+{
+  // take infos chambers from AliMUON
+  AliMUONChamber* pCh = 0;
+  pCh = &(fMUON->Chamber(id));
+
+  fChambers->AddAt(pCh, id);
+
+  // Set ClusterFinder for chamber id
+  ((AliMUONChamber*) fChambers->At(id))->SetReconstructionModel(reconst);
+}
+//_______________________________________________________________________
+AliMUONClusterReconstructor::AliMUONClusterReconstructor (const AliMUONClusterReconstructor& Reconstructor):TObject(Reconstructor)
+{
+  // Dummy copy constructor
+}
+
+AliMUONClusterReconstructor & AliMUONClusterReconstructor::operator=(const AliMUONClusterReconstructor& /*Reconstructor*/)
+{
+  // Dummy assignment operator
+    return *this;
+}
+
+//__________________________________________________________________________
+AliMUONClusterReconstructor::~AliMUONClusterReconstructor(void)
+{
+  if (fChambers){
+    fChambers->Delete();
+    delete fChambers;
+  } 
+  if (fMUONData)
+    delete fMUONData;
+
+  return;
+}
+//____________________________________________________________________
+void AliMUONClusterReconstructor::Digits2Clusters()
+{
+//
+//  Perform cluster finding
+//
+    TClonesArray *dig1, *dig2;
+    Int_t ndig, k;
+    dig1 = new TClonesArray("AliMUONDigit",1000);
+    dig2 = new TClonesArray("AliMUONDigit",1000);
+    AliMUONDigit *digit;
+// Loop on chambers and on cathode planes
+//
+//    fMUONData->ResetRawClusters();        
+    TClonesArray * muonDigits;
+
+    for (Int_t ich = 0; ich < 10; ich++) {
+       AliMUONChamber* iChamber = (AliMUONChamber*) fChambers->At(ich);
+       AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
+       //AliMUONClusterFinderAZ* rec = (AliMUONClusterFinderAZ*)iChamber->ReconstructionModel();
+
+       fMUONData->ResetDigits();
+       fMUONData->GetCathode(0);
+       //TClonesArray *
+       muonDigits = fMUONData->Digits(ich); 
+       ndig=muonDigits->GetEntriesFast();
+       if(fDebug)
+         printf("1 Found %d digits in %p chamber %d\n", ndig, muonDigits,ich);
+       TClonesArray &lhits1 = *dig1;
+       Int_t n = 0;
+       for (k = 0; k < ndig; k++) {
+           digit = (AliMUONDigit*) muonDigits->UncheckedAt(k);
+           if (rec->TestTrack(digit->Track(0)))
+             new(lhits1[n++]) AliMUONDigit(*digit);
+       }
+       fMUONData->ResetDigits();
+       fMUONData->GetCathode(1);
+       muonDigits =  fMUONData->Digits(ich);  
+       ndig=muonDigits->GetEntriesFast();
+       if(fDebug)
+         printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
+       TClonesArray &lhits2 = *dig2;
+       n=0;
+       
+       for (k=0; k<ndig; k++) {
+           digit= (AliMUONDigit*) muonDigits->UncheckedAt(k);
+           if (rec->TestTrack(digit->Track(0)))
+             new(lhits2[n++]) AliMUONDigit(*digit);
+       }
+
+       if (rec) {       
+           AliMUONClusterInput::Instance()->SetDigits(ich, dig1, dig2);
+           rec->FindRawClusters();
+       }
+       // copy into the container
+       TClonesArray* tmp = rec->GetRawClusters();
+       for (Int_t id = 0; id < tmp->GetEntriesFast(); id++) {
+         AliMUONRawCluster* pClus = (AliMUONRawCluster*) tmp->At(id);
+         fMUONData->AddRawCluster(ich, *pClus);
+       }
+       dig1->Delete();
+       dig2->Delete();
+    } // for ich
+    delete dig1;
+    delete dig2;
+}
index 8b8a663c03ea6bf6281256f65054cf198b82b2bb..f676ddb931deb4673aca1ceaaf45ef2076e4898d 100644 (file)
@@ -1059,7 +1059,10 @@ void AliMUONDisplay::NextCathode()
 void AliMUONDisplay::Trigger()
 {
   // returns Trigger Decision for current event
-  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
+  AliMUON *pMUON  =     (AliMUON*)gAlice->GetModule("MUON");
+  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(pMUON->GetLoader());
+
+  //  AliMUONTriggerDecision* decision= new AliMUONTriggerDecision(1);
   decision->Trigger(); 
 }
 
index 37f777493ba0bd1c6ec90aedc00ab965c920e659..915cd57c2acba1450c7d30965c065f6d7225006d 100644 (file)
 #include <TTree.h>
 
 #include "AliMUON.h"
-#include "AliMUONChamber.h"
+//#include "AliMUONChamber.h"
 #include "AliMUONEventReconstructor.h"
 #include "AliMUONHitForRec.h"
 #include "AliMUONTriggerTrack.h"
 //#include "AliMUONTriggerConstants.h"
 #include "AliMUONTriggerCircuit.h"
 #include "AliMUONRawCluster.h"
-#include "AliMUONGlobalTrigger.h"
 #include "AliMUONLocalTrigger.h"
+#include "AliMUONGlobalTrigger.h"
 #include "AliMUONRecoEvent.h"
 #include "AliMUONSegment.h"
 #include "AliMUONTrack.h"
@@ -85,7 +85,7 @@ static const Int_t kDefaultPrintLevel = -1;
 ClassImp(AliMUONEventReconstructor) // Class implementation in ROOT context
 
   //__________________________________________________________________________
-AliMUONEventReconstructor::AliMUONEventReconstructor(void)
+AliMUONEventReconstructor::AliMUONEventReconstructor(AliLoader* loader)
 {
   // Constructor for class AliMUONEventReconstructor
   SetReconstructionParametersToDefaults();
@@ -140,10 +140,21 @@ AliMUONEventReconstructor::AliMUONEventReconstructor(void)
   fRecoEvent = 0;
   fEventTree = 0;
   fTreeFile  = 0;
-  
+  // initialize loader's
+  fLoader = loader;
+
+  // initialize container
+  fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
+
+   // Loading AliRun master
+  AliRunLoader* runloader = fLoader->GetRunLoader();
+  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+  gAlice = runloader->GetAliRun();
+
   return;
 }
-
+  //__________________________________________________________________________
 AliMUONEventReconstructor::AliMUONEventReconstructor (const AliMUONEventReconstructor& Reconstructor):TObject(Reconstructor)
 {
   // Dummy copy constructor
@@ -434,46 +445,46 @@ void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
   // To make the list of hits to be reconstructed,
   // either from the GEANT hits or from the raw clusters
   // according to the parameter set for the reconstructor
-  TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+//   TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
   
-  AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
-  if (rl == 0x0)
-   {
-     Error("MakeEventToBeReconstructed",
-           "Can not find Run Loader in Event Folder named %s.",
-           evfoldname.Data());
-     return;
-   }
-  AliLoader* gime = rl->GetLoader("MUONLoader");
-  if (gime == 0x0)
-   {
-     Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
-     return;
-   }
+//   AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+//   if (rl == 0x0)
+//    {
+//      Error("MakeEventToBeReconstructed",
+//            "Can not find Run Loader in Event Folder named %s.",
+//            evfoldname.Data());
+//      return;
+//    }
+//   AliLoader* gime = rl->GetLoader("MUONLoader");
+//   if (gime == 0x0)
+//    {
+//      Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
+//      return;
+//    }
   
   if (fPrintLevel >= 1) cout << "enter MakeEventToBeReconstructed" << endl;
   ResetHitsForRec();
   if (fRecGeantHits == 1) {
     // Reconstruction from GEANT hits
     // Back to the signal file
-      TTree* treeH = gime->TreeH();
+      TTree* treeH = fLoader->TreeH();
       if (treeH == 0x0)
        {
-         Int_t retval = gime->LoadHits();
+         Int_t retval = fLoader->LoadHits();
          if ( retval)
           {
             Error("MakeEventToBeReconstructed","Error occured while loading hits.");
             return;
           }
-         treeH = gime->TreeH();
+         treeH = fLoader->TreeH();
          if (treeH == 0x0)
           {
            Error("MakeEventToBeReconstructed","Can not get TreeH");
            return;
           }
        }
-    
-    AddHitsForRecFromGEANT(treeH);
+      fMUONData->SetTreeAddress("H");
+      AddHitsForRecFromGEANT(treeH);
     
     // Background hits
     AddHitsForRecFromBkgGEANT(fBkgGeantTH, fBkgGeantHits);
@@ -486,7 +497,8 @@ void AliMUONEventReconstructor::MakeEventToBeReconstructed(void)
     // Security on MUON ????
     // TreeR assumed to be be "prepared" in calling function
     // by "MUON->GetTreeR(nev)" ????
-    TTree *treeR = gime->TreeR();
+    TTree *treeR = fLoader->TreeR();
+    fMUONData->SetTreeAddress("RC");
     AddHitsForRecFromRawClusters(treeR);
     // No sorting: it is done automatically in the previous function
   }
@@ -518,8 +530,8 @@ void AliMUONEventReconstructor::AddHitsForRecFromGEANT(TTree *TH)
   if (fPrintLevel >= 2)
     cout << "enter AddHitsForRecFromGEANT with TH: " << TH << endl;
   if (TH == NULL) return;
-  AliMUON *pMUON  = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
-  AliMUONData * muondata = pMUON->GetMUONData();
+  //  AliMUON *pMUON  = (AliMUON*) gAlice->GetModule("MUON"); // necessary ????
+  //AliMUONData * muondata = pMUON->GetMUONData();
   // Security on MUON ????
   // See whether it could be the same for signal and background ????
   // Loop over tracks in tree
@@ -528,7 +540,7 @@ void AliMUONEventReconstructor::AddHitsForRecFromGEANT(TTree *TH)
     cout << "ntracks: " << ntracks << endl;
   fMuons = 0; //AZ
   for (Int_t track = 0; track < ntracks; track++) {
-    muondata->ResetHits();
+    fMUONData->ResetHits();
     TH->GetEvent(track);
     // Loop over hits
     Int_t hit = 0;
@@ -537,11 +549,11 @@ void AliMUONEventReconstructor::AddHitsForRecFromGEANT(TTree *TH)
     Int_t itrack = track; //AZ
 
     Int_t ihit, nhits=0;
-      nhits = (Int_t) muondata->Hits()->GetEntriesFast();
+      nhits = (Int_t) fMUONData->Hits()->GetEntriesFast();
       AliMUONHit* mHit=0x0;
 
       for(ihit=0; ihit<nhits; ihit++) {
-       mHit = static_cast<AliMUONHit*>(muondata->Hits()->At(ihit));
+       mHit = static_cast<AliMUONHit*>(fMUONData->Hits()->At(ihit));
        Int_t ipart = TMath::Abs ((Int_t) mHit->Particle()); //AZ
        if (NewHitForRecFromGEANT(mHit,track, hit, 1) && ipart == 13
            //if (NewHitForRecFromGEANT(mHit,itrack-1, hit, 1) && ipart == 13 
@@ -727,27 +739,27 @@ void AliMUONEventReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
   TClonesArray *rawclusters;
   if (fPrintLevel >= 1) cout << "enter AddHitsForRecFromRawClusters" << endl;
 
-  TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
-  AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
-  if (rl == 0x0)
-   {
-     Error("MakeEventToBeReconstructed",
-           "Can not find Run Loader in Event Folder named %s.",
-           evfoldname.Data());
-     return;
-   }
-  AliLoader* gime = rl->GetLoader("MUONLoader");
-  if (gime == 0x0)
-   {
-     Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
-     return;
-   }
-   // Loading AliRun master
-  if (rl->GetAliRun() == 0x0) rl->LoadgAlice();
-  gAlice = rl->GetAliRun();
+//   TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+//   AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+//   if (rl == 0x0)
+//    {
+//      Error("MakeEventToBeReconstructed",
+//            "Can not find Run Loader in Event Folder named %s.",
+//            evfoldname.Data());
+//      return;
+//    }
+//   AliLoader* gime = rl->GetLoader("MUONLoader");
+//   if (gime == 0x0)
+//    {
+//      Error("MakeEventToBeReconstructed","Can not get MUON Loader from Run Loader.");
+//      return;
+//    }
+//    // Loading AliRun master
+//   rl->LoadgAlice();
+//   gAlice = rl->GetAliRun();
 
   // Loading MUON subsystem
-  AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
+  //  AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
 
   nTRentries = Int_t(TR->GetEntries());
   if (nTRentries != 1) {
@@ -756,7 +768,8 @@ void AliMUONEventReconstructor::AddHitsForRecFromRawClusters(TTree* TR)
     cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
     exit(0);
   }
-  gime->TreeR()->GetEvent(0); // only one entry  
+  fLoader->TreeR()->GetEvent(0); // only one entry  
+
   // Loop over tracking chambers
   for (Int_t ch = 0; ch < kMaxMuonTrackingChambers; ch++) {
     // number of HitsForRec to 0 for the chamber
@@ -764,7 +777,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->GetMUONData()->RawClusters(ch);
+    rawclusters =fMUONData->RawClusters(ch);
 //     pMUON->ResetRawClusters();
 //     TR->GetEvent((Int_t) (TR->GetEntries()) - 1); // to be checked ????
     nclus = (Int_t) (rawclusters->GetEntries());
@@ -961,6 +974,11 @@ void AliMUONEventReconstructor::MakeTracks(void)
     // Remove double tracks
     RemoveDoubleTracks();
   }
+  //  AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
+  for(Int_t i=0; i<GetNRecTracks(); i++) {
+    AliMUONTrack * track = (AliMUONTrack*) GetRecTracksPtr()->At(i);
+     fMUONData->AddRecTrack(*track);
+  }
   return;
 }
 
@@ -969,56 +987,55 @@ void AliMUONEventReconstructor::MakeTriggerTracks(void)
 {
     // To make the trigger tracks from Local Trigger
     if (fPrintLevel >= 1) cout << "enter MakeTriggerTracks" << endl;
-    ResetTriggerTracks();
+    //    ResetTriggerTracks();
     
     Int_t nTRentries;
+    Long_t gloTrigPat;
     TClonesArray *localTrigger;
     TClonesArray *globalTrigger;
     AliMUONLocalTrigger *locTrg;
     AliMUONGlobalTrigger *gloTrg;
     AliMUONTriggerCircuit *circuit;
-    AliMUONTriggerTrack *recTriggerTrack;
-    Long_t gloTrigPat;
-
-    TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
-    AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
-    if (rl == 0x0)
-    {
-       Error("MakeTriggerTracks",
-             "Can not find Run Loader in Event Folder named %s.",
-             evfoldname.Data());
-       return;
-    }
-    AliLoader* gime = rl->GetLoader("MUONLoader");
-    if (gime == 0x0)
-    {
-       Error("MakeTriggerTracks","Can not get MUON Loader from Run Loader.");
-       return;
-    }
-    TTree* TR = gime->TreeR();
+    AliMUONTriggerTrack *recTriggerTrack = 0;
+//     TString evfoldname = AliConfig::fgkDefaultEventFolderName;//to be interfaced properly
+//     AliRunLoader* rl = AliRunLoader::GetRunLoader(evfoldname);
+//     if (rl == 0x0)
+//     {
+//     Error("MakeTriggerTracks",
+//           "Can not find Run Loader in Event Folder named %s.",
+//           evfoldname.Data());
+//     return;
+//     }
+//     AliLoader* gime = rl->GetLoader("MUONLoader");
+//     if (gime == 0x0)
+//     {
+//     Error("MakeTriggerTracks","Can not get MUON Loader from Run Loader.");
+//     return;
+//     }
+    TTree* TR = fLoader->TreeR();
     
     // Loading AliRun master
-    if (rl->GetAliRun() == 0x0) rl->LoadgAlice();
-    gAlice = rl->GetAliRun();
+//     rl->LoadgAlice();
+//     gAlice = rl->GetAliRun();
     
     // Loading MUON subsystem
     AliMUON * pMUON = (AliMUON *) gAlice->GetDetector("MUON");
     
     nTRentries = Int_t(TR->GetEntries());
     if (nTRentries != 1) {
-       cout << "Error in AliMUONEventReconstructor::MakeTriggerTracks"
-            << endl;
-       cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
-       exit(0);
+      cout << "Error in AliMUONEventReconstructor::MakeTriggerTracks"
+          << endl;
+      cout << "nTRentries = " << nTRentries << " not equal to 1" << endl;
+      exit(0);
     }
-    gime->TreeR()->GetEvent(0); // only one entry  
+    fLoader->TreeR()->GetEvent(0); // only one entry  
 
-    pMUON->GetMUONData()->SetTreeAddress("GLT");
-    pMUON->GetMUONData()->GetTrigger();
+    fMUONData->SetTreeAddress("GLT");
+    fMUONData->GetTrigger();
 
-// global trigger
+    // global trigger for trigger pattern
     gloTrigPat = 0;
-    globalTrigger = pMUON->GetMUONData()->GlobalTrigger(); 
+    globalTrigger = fMUONData->GlobalTrigger(); 
     gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);     
     if (gloTrg->SinglePlusLpt())  gloTrigPat|= 0x1;
     if (gloTrg->SinglePlusHpt())  gloTrigPat|= 0x2;
@@ -1040,25 +1057,28 @@ void AliMUONEventReconstructor::MakeTriggerTracks(void)
     if (gloTrg->PairLikeHpt())    gloTrigPat|= 0x2000;
     if (gloTrg->PairLikeApt())    gloTrigPat|= 0x4000;
 
-// local trigger
-    localTrigger = pMUON->GetMUONData()->LocalTrigger();    
+
+    // local trigger for tracking 
+    localTrigger = fMUONData->LocalTrigger();    
     Int_t nlocals = (Int_t) (localTrigger->GetEntries());
     Float_t z11 = ( &(pMUON->Chamber(10)) )->Z();
     Float_t z21 = ( &(pMUON->Chamber(12)) )->Z();
 
     for (Int_t i=0; i<nlocals; i++) { // loop on Local Trigger
-        locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);   
-       circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
-       Float_t y11 = circuit->GetY11Pos(locTrg->LoStripX()); 
-       Float_t y21 = circuit->GetY21Pos(locTrg->LoStripX());
-       Float_t x11 = circuit->GetX11Pos(locTrg->LoStripY());
-       Float_t thetax = TMath::ATan2( x11 , z11 );
-       Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
-
-       recTriggerTrack = new ((*fRecTriggerTracksPtr)[fNRecTriggerTracks])
-           AliMUONTriggerTrack(x11,y11,thetax,thetay,gloTrigPat,this);
-// since static statement does not work, set gloTrigPat for each track
-       fNRecTriggerTracks++;
+      locTrg = (AliMUONLocalTrigger*)localTrigger->UncheckedAt(i);     
+      circuit = &(pMUON->TriggerCircuit(locTrg->LoCircuit()));
+      Float_t y11 = circuit->GetY11Pos(locTrg->LoStripX()); 
+      Float_t y21 = circuit->GetY21Pos(locTrg->LoStripX());
+      Float_t x11 = circuit->GetX11Pos(locTrg->LoStripY());
+      Float_t thetax = TMath::ATan2( x11 , z11 );
+      Float_t thetay = TMath::ATan2( (y21-y11) , (z21-z11) );
+
+      recTriggerTrack = new AliMUONTriggerTrack(x11,y11,thetax,thetay,gloTrigPat,this);
+      // since static statement does not work, set gloTrigPat for each track
+
+      //       fNRecTriggerTracks++;
+      fMUONData->AddRecTriggerTrack(*recTriggerTrack);
     } // end of loop on Local Trigger
     return;    
 }
@@ -1604,16 +1624,16 @@ void AliMUONEventReconstructor::EventDumpTrigger(void)
   // Dump reconstructed trigger event 
   // and the particle parameters
     
-  AliMUONTriggerTrack *triggertrack;
-  Int_t trackIndex;
+  AliMUONTriggerTrack *triggertrack ;
+  Int_t nTriggerTracks = fMUONData->RecTriggerTracks()->GetEntriesFast();
  
-  if (fPrintLevel >= 1) cout << "****** enter EventDumpTrigger ******" << endl;
   if (fPrintLevel >= 1) {
-      cout << " Number of Reconstructed tracks :" <<  fNRecTriggerTracks << endl;
+    cout << "****** enter EventDumpTrigger ******" << endl;
+    cout << " Number of Reconstructed tracks :" <<  nTriggerTracks << endl;
   }
   // Loop over reconstructed tracks
-  for (trackIndex = 0; trackIndex < fNRecTriggerTracks; trackIndex++) {
-      triggertrack = (AliMUONTriggerTrack*) ((*fRecTriggerTracksPtr)[trackIndex]);
+  for (Int_t trackIndex = 0; trackIndex < nTriggerTracks; trackIndex++) {
+    triggertrack = (AliMUONTriggerTrack*)fMUONData->RecTriggerTracks()->At(trackIndex);
       printf(" trigger track number %i x11=%f y11=%f thetax=%f thetay=%f \n",
             trackIndex,
             triggertrack->GetX11(),triggertrack->GetY11(),
index 9a3aeec5fb90830acaba2cc68b7c39ad5806c04e..5c5c89e9e041bdb761ab8203cd67ce743bfe881a 100644 (file)
@@ -18,6 +18,9 @@ class TClonesArray;
 class TFile;
 class TTree;
 class AliMUONRecoEvent;
+class AliMUONData;
+class AliRunLoader;
+class AliLoader;
 
 // Constants which should be elsewhere ????
 const Int_t kMaxMuonTrackingChambers = 10;
@@ -26,7 +29,7 @@ const Int_t kMaxMuonTrackingStations = kMaxMuonTrackingChambers / 2;
 class AliMUONEventReconstructor : public TObject {
 
  public:
-  AliMUONEventReconstructor(void); // Constructor
+  AliMUONEventReconstructor(AliLoader* ); // default Constructor
   virtual ~AliMUONEventReconstructor(void); // Destructor
   AliMUONEventReconstructor (const AliMUONEventReconstructor& Reconstructor); // copy constructor
   AliMUONEventReconstructor& operator=(const AliMUONEventReconstructor& Reconstructor); // assignment operator
@@ -73,12 +76,12 @@ class AliMUONEventReconstructor : public TObject {
   Int_t GetNRecTracks() const {return fNRecTracks;} // Number
   void SetNRecTracks(Int_t NRecTracks) {fNRecTracks = NRecTracks;}
   TClonesArray* GetRecTracksPtr(void) const {return fRecTracksPtr;} // Array
+ // Reconstructed trigger tracks
+   Int_t GetNRecTriggerTracks() const {return fNRecTriggerTracks;} // Number
+   void SetNRecTriggerTracks(Int_t NRecTriggerTracks) {fNRecTriggerTracks = NRecTriggerTracks;}
+   TClonesArray* GetRecTriggerTracksPtr(void) const {return fRecTriggerTracksPtr;} // Array
 
-  // Reconstructed trigger tracks
-  Int_t GetNRecTriggerTracks() const {return fNRecTriggerTracks;} // Number
-  void SetNRecTriggerTracks(Int_t NRecTriggerTracks) {fNRecTriggerTracks = NRecTriggerTracks;}
-  TClonesArray* GetRecTriggerTracksPtr(void) const {return fRecTriggerTracksPtr;} // Array
-  
   // Hits on reconstructed tracks
   Int_t GetNRecTrackHits() const {return fNRecTrackHits;} // Number
   void SetNRecTrackHits(Int_t NRecTrackHits) {fNRecTrackHits = NRecTrackHits;}
@@ -95,6 +98,9 @@ class AliMUONEventReconstructor : public TObject {
   void SetTrackMethod(Int_t TrackMethod) {fTrackMethod = TrackMethod;} //AZ
   Int_t GetTrackMethod(void) const {return fTrackMethod;} //AZ
   Int_t fMuons; // AZ - number of muons within acceptance - just for tests
+
+  AliMUONData*  GetMUONData() {return fMUONData;}
+
  protected:
 
  private:
@@ -159,6 +165,12 @@ class AliMUONEventReconstructor : public TObject {
   TTree            *fEventTree; // tree of reconstructed events
   TFile            *fTreeFile;  // file where the tree is outputed
 
+  // data container
+  AliMUONData* fMUONData;
+
+  // alice loader
+  AliLoader* fLoader;
+
   // Functions
   void ResetHitsForRec(void);
   void MakeEventToBeReconstructed(void);
index 2799b22c7d352e22f14af0d4f4d02ee0bc2c250c..a1e862e57df529afd3f4a962b1ee9a7e76c046cf 100644 (file)
@@ -27,6 +27,9 @@
 #include "AliMUONResponse.h"
 #include "AliMUONChamber.h"
 #include "AliMUONDigit.h"
+#include "AliMUONConstants.h"
+#include "AliMUONGlobalTrigger.h"
+#include "AliMUONLocalTrigger.h"
 
 
 #include <TF1.h>
@@ -43,7 +46,7 @@
 ClassImp(AliMUONTriggerDecision)
 
 //----------------------------------------------------------------------
-AliMUONTriggerDecision::AliMUONTriggerDecision(Int_t iprint)
+AliMUONTriggerDecision::AliMUONTriggerDecision(AliLoader* loader, Int_t iprint)
 {
 // Constructor 
   fDebug = iprint;            // print option
@@ -90,14 +93,41 @@ AliMUONTriggerDecision::AliMUONTriggerDecision(Int_t iprint)
       fXbit21[icirc][istrip]=fXbit22[icirc][istrip]=0;
     }
   }
-}
 
+  fTriggerCircuit = new TObjArray(AliMUONConstants::NTriggerCircuit());
+
+  // initialize loader's
+  fLoader = loader;
+
+  // initialize container
+  fMUONData  = new AliMUONData(fLoader,"MUON","MUON");
+
+  // Loading AliRun master
+  AliRunLoader* runloader = fLoader->GetRunLoader();
+  if (runloader->GetAliRun() == 0x0) runloader->LoadgAlice();
+  gAlice = runloader->GetAliRun();
+
+  // getting MUON
+  fMUON = (AliMUON*) gAlice->GetDetector("MUON");
+
+  // setting circuit
+  for (icirc = 0; icirc < AliMUONConstants::NTriggerCircuit(); icirc++) {
+    AliMUONTriggerCircuit* pCir = 0;
+    pCir = &(fMUON->TriggerCircuit(icirc));
+    fTriggerCircuit->AddAt(pCir, icirc);
+  }
+}
 //----------------------------------------------------------------------
 AliMUONTriggerDecision::~AliMUONTriggerDecision()
 {
 // Destructor
+  if (fTriggerCircuit){
+    fTriggerCircuit->Delete();
+    delete fTriggerCircuit;
+  } 
+  if (fMUONData)
+    delete fMUONData;
 }
-
 //----------------------------------------------------------------------
 void AliMUONTriggerDecision::Trigger(){
 // main method of the class which calls the overall Trigger procedure
@@ -108,11 +138,10 @@ void AliMUONTriggerDecision::Trigger(){
 
   Int_t coinc44=0, resetMid=0; // initialize coincidence
 
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
   AliMUONTriggerCircuit* triggerCircuit;
 
   for (Int_t icirc=0; icirc<234; icirc++) {  // loop on circuits
-    triggerCircuit = &(pMUON->TriggerCircuit(icirc));            
+    triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);         
     //    Int_t idCircuit=triggerCircuit->GetIdCircuit(); 
     
     Int_t minDevStrip[5], minDev[5], coordY[5];
@@ -192,25 +221,19 @@ void AliMUONTriggerDecision::SetBit(){
 // 4) set the bit patterns
 
 
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetDetector("MUON");  
   AliMUONTriggerCircuit* triggerCircuit;
-  AliRunLoader * rl = AliRunLoader::GetRunLoader();
-  AliLoader * gime  = rl->GetLoader("MUONLoader");
 
   for (Int_t chamber=11; chamber<15; chamber++){
     for (Int_t cathode=1; cathode<3; cathode++){
       
-      AliMUONChamber*   iChamber = &(pMUON->Chamber(chamber-1));
-      AliSegmentation*  segmentation;
-      gime->TreeD()->GetEvent(cathode-1);
-      TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1);
+      //      AliMUONChamber*   iChamber = &(pMUON->Chamber(chamber-1));
+      //       AliSegmentation*  segmentation;
+      fLoader->TreeD()->GetEvent(cathode-1);
+      TClonesArray *muonDigits = fMUONData->Digits(chamber-1);
       Int_t ndigits = muonDigits->GetEntriesFast();
       if (fDebug>3)
-      printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
-//    if (ndigits == 0) return;
-      
-//      iChamber = &(pMUON->Chamber(chamber-1));
-      segmentation=iChamber->SegmentationModel(cathode);
+       printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
+
       AliMUONDigit  *mdig;
       
       for (Int_t digit=0; digit<ndigits; digit++) {
@@ -243,7 +266,7 @@ void AliMUONTriggerDecision::SetBit(){
              {
              case 11:
                for (icirc=0; icirc<234; icirc++) {               
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);  
                  for (istrip=0; istrip<16; istrip++) {
                    if (triggerCircuit->GetXcode(0,istrip)==code) 
                      fXbit11[icirc][istrip]=1;
@@ -252,7 +275,7 @@ void AliMUONTriggerDecision::SetBit(){
                break;
              case 12:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
                  for (istrip=0; istrip<16; istrip++) {
                    if (triggerCircuit->GetXcode(1,istrip)==code) 
                      fXbit12[icirc][istrip]=1;
@@ -261,7 +284,7 @@ void AliMUONTriggerDecision::SetBit(){
                break;
              case 13:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc); 
                  for (istrip=0; istrip<32; istrip++) {
                    if (triggerCircuit->GetXcode(2,istrip)==code) 
                      fXbit21[icirc][istrip]=1;
@@ -270,7 +293,7 @@ void AliMUONTriggerDecision::SetBit(){
                break;
              case 14:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
                  for (istrip=0; istrip<32; istrip++) {
                    if (triggerCircuit->GetXcode(3,istrip)==code) 
                      fXbit22[icirc][istrip]=1;             
@@ -284,7 +307,7 @@ void AliMUONTriggerDecision::SetBit(){
              {
              case 11:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
                  nStrip=triggerCircuit->GetNstripY();
                  for (istrip=0; istrip<nStrip; istrip++) {
                    if (triggerCircuit->GetYcode(0,istrip)==code) 
@@ -294,7 +317,7 @@ void AliMUONTriggerDecision::SetBit(){
                break;
              case 12:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
                  nStrip=triggerCircuit->GetNstripY(); 
                  for (istrip=0; istrip<nStrip; istrip++) {
                    if (triggerCircuit->GetYcode(1,istrip)==code) 
@@ -304,7 +327,7 @@ void AliMUONTriggerDecision::SetBit(){
                break;
              case 13:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
                  nStrip=triggerCircuit->GetNstripY();    
                  for (istrip=0; istrip<nStrip; istrip++) {
                    if (triggerCircuit->GetYcode(2,istrip)==code) 
@@ -314,7 +337,7 @@ void AliMUONTriggerDecision::SetBit(){
                break;
              case 14:
                for (icirc=0; icirc<234; icirc++) {
-                 triggerCircuit = &(pMUON->TriggerCircuit(icirc));       
+                 triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
                  nStrip=triggerCircuit->GetNstripY();    
                  for (istrip=0; istrip<nStrip; istrip++) {
                    if (triggerCircuit->GetYcode(3,istrip)==code) 
@@ -326,7 +349,7 @@ void AliMUONTriggerDecision::SetBit(){
          } // if cathode
        }  // remove soft background
       }   // end loop on digit
-      pMUON->GetMUONData()->ResetDigits();
+      fMUONData->ResetDigits();
     }    // end loop on cathode
   }     // end loop on chamber
 }  
@@ -336,7 +359,6 @@ void AliMUONTriggerDecision::SetBitUpDownY(){
 // Set Y bit for up and down parts of circuits
   Int_t idModule, nStripX, nStripY, iPosCircuit;
 
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
   
   for (Int_t icirc=0; icirc<234; icirc++) {
 
@@ -344,7 +366,7 @@ void AliMUONTriggerDecision::SetBitUpDownY(){
     AliMUONTriggerCircuit* circuitD;  // circuit Down
     AliMUONTriggerCircuit* circuitU;  // circuit Up
 
-    circuit = &(pMUON->TriggerCircuit(icirc));  
+    circuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);  
     idModule=circuit->GetIdModule();      // corresponding module Id.
     nStripX=circuit->GetNstripX();        // number of X strips
     nStripY=circuit->GetNstripY();        // number of Y strips
@@ -354,7 +376,7 @@ void AliMUONTriggerDecision::SetBitUpDownY(){
     if (iPosCircuit==1) {               // need to scan lower module       
       if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) { 
        Int_t icircD=circuit->GetICircuitD();
-       circuitD = &(pMUON->TriggerCircuit(icircD));  
+       circuitD = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icircD);  
        Int_t nStripD=circuitD->GetNstripY();
                
        if (TMath::Abs(idModule)==42) { // shift of +8 bits
@@ -386,7 +408,7 @@ void AliMUONTriggerDecision::SetBitUpDownY(){
        (iPosCircuit==3&&nStripX==48)||(iPosCircuit==4&&nStripX==64)) {   
       if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {  
        Int_t icircU=circuit->GetICircuitU();
-       circuitU = &(pMUON->TriggerCircuit(icircU));  
+       circuitU = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icircU);  
        Int_t nStripU=circuitU->GetNstripY();           
        
        if (TMath::Abs(idModule)==62) { // shift of +8 bits
@@ -1026,9 +1048,8 @@ void AliMUONTriggerDecision::LocalTrigger(Int_t icirc,
 // returns local trigger answer for circuit icirc
   Int_t i;
 
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
   AliMUONTriggerCircuit* triggerCircuit;
-  triggerCircuit = &(pMUON->TriggerCircuit(icirc));      
+  triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);          
   Int_t idCircuit=triggerCircuit->GetIdCircuit();
   
   Int_t signDev=minDev[4];   
@@ -1196,9 +1217,8 @@ void AliMUONTriggerDecision::PrintBitPatYInput(Int_t icirc){
 
     Int_t istrip;
 
-  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");  
   AliMUONTriggerCircuit* triggerCircuit;
-  triggerCircuit = &(pMUON->TriggerCircuit(icirc));      
+  triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);          
   Int_t idCircuit=triggerCircuit->GetIdCircuit();
   Int_t nStrip=triggerCircuit->GetNstripY();
 
@@ -1295,6 +1315,7 @@ void AliMUONTriggerDecision::GetGlobalTrigger(Int_t singlePlus[3],
                                              Int_t pairUnlike[3], 
                                              Int_t pairLike[3]){
 // returns Global Trigger information (0,1,2 : Lpt,Hpt,Apt)
+// should not be used anymore.
   for (Int_t i=0; i<3; i++) { 
     singlePlus[i]  = fGlobalSinglePlus[i];
     singleMinus[i] = fGlobalSingleMinus[i];
@@ -1303,15 +1324,37 @@ void AliMUONTriggerDecision::GetGlobalTrigger(Int_t singlePlus[3],
     pairLike[i]    = fGlobalPairLike[i];    
   }
 }
-//----------------------------------------------------------------------
-//--- end of methods which return member data related info
-//----------------------------------------------------------------------
-//----------------------------------------------------------------------
-/*
-void AliMUONTriggerDecision::AddLocalTrigger(const AliMUONLocalTrigger c){
-// Add a Local Trigger copy to the list
-  AliMUON *MUON=(AliMUON*)gAlice->GetModule("MUON");
-  MUON->AddLocalTrigger(c); 
-  fNLocalTriggers++;
+//_______________________________________________________________________
+void AliMUONTriggerDecision::Digits2Trigger(){
+// call the Trigger Algorithm and fill TreeR
+
+  
+  fMUONData->ResetTrigger();
+  Trigger();   
+  AliMUONGlobalTrigger* pGloTrig = new AliMUONGlobalTrigger(fGlobalSinglePlus, fGlobalSingleMinus,
+                                                      fGlobalSingleUndef, fGlobalPairUnlike, 
+                                                      fGlobalPairLike);  
+  // add a local trigger in the list 
+  fMUONData->AddGlobalTrigger(*pGloTrig);
+
+  Int_t i;
+  
+  for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++) { 
+    if(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};
+      GetLutOutput(icirc, loLpt, loHpt, loApt);
+      localtr[0] = icirc;
+      localtr[1] = GetStripX11(icirc);
+      localtr[2] = GetDev(icirc);
+      localtr[3] = 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));
+      }
+      AliMUONLocalTrigger* pLocTrig = new AliMUONLocalTrigger(localtr);
+      fMUONData->AddLocalTrigger(*pLocTrig);  // add a local trigger in the list
+    }
+  }
 }
-*/
index fdc33fcef00f582281e70573f860b0a2987c7fad..619b2931c44313fcab57ecde19c936cbfb2de18d 100644 (file)
@@ -7,19 +7,21 @@
 //  MUON Trigger Decision Class               //
 ////////////////////////////////////////////////
 #include "TObject.h"
+#include "TObjArray.h"
 
-class AliMUONHitMapA1;
-class TF1;
+class AliLoader;
 class TClonesArray;
-class AliMUONSegmentation;
-class AliMUONResponse;
+class AliMUONData;
+class AliMUON;
+
 
 class AliMUONTriggerDecision :
 public TObject {
  public:
-  AliMUONTriggerDecision(Int_t iprint);         // constructor
+  AliMUONTriggerDecision(AliLoader*, Int_t iprint = 0);         // constructor
   ~AliMUONTriggerDecision();                  // destructor
   
+  AliMUONData*   GetMUONData() {return fMUONData;}
   void Trigger();
   void ResetBit();
   void SetBit();
@@ -38,6 +40,8 @@ public TObject {
                    Int_t &iTrigger);    
   void GlobalTrigger();
 
+  void   Digits2Trigger(); // main function
+
   // print-debug
   void PrintBitPatXInput(Int_t icirc);
   void PrintBitPatYInput(Int_t icirc);
@@ -54,6 +58,7 @@ public TObject {
                        Int_t singleUndef[3], Int_t pairUnlike[3], 
                        Int_t pairLike[3]);  
   
+
 // Add a new Local Trigger
   // virtual void AddLocalTrigger(const AliMUONLocalTrigger);
 //  Return pointer to Local Triggers
@@ -95,6 +100,12 @@ public TObject {
   Int_t fYbit21D[234][16]; // bit pattern YM21 Down
   Int_t fYbit22D[234][16]; // bit pattern YM22 Down
 
+  
+  AliLoader*     fLoader;             //! alice loader
+  TObjArray*     fTriggerCircuit;     //! List of Trigger Circuit
+  AliMUONData*   fMUONData;           //! Data container for MUON subsystem 
+  AliMUON*       fMUON;               //! pointer to MUON  
+
   // ???
   //  TClonesArray* fLocalTriggers;   // Local Triggers
   // Int_t fNLocalTriggers;          // Number of Local Triggers
index 07c449aa96d335f6eccbd2cb21fa755dc9ef3cd8..76b4acd34fbed9c6f01c13e0967ad58cc978554e 100644 (file)
 // Gines MARTINEZ, Subatech, sep 2003
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
-#include <TClonesArray.h>
-
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONData.h"
 #include "AliMUONEventReconstructor.h"
-#include "AliMUONTrack.h"
-#include "AliMUONTrackHit.h"
-#include "AliMUONTrackParam.h"
 #endif
 
 void MUONTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t LastEvent = 9999)
@@ -42,40 +37,37 @@ void MUONTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t
   cout << "FileName ``" << FileName << "''" << endl;
   
   // Creating Run Loader and openning file containing Hits, Digits and RecPoints
-  AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"Event","UPDATE");
+  AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"MUONLoader","UPDATE");
   if (RunLoader ==0x0) {
     printf(">>> Error : Error Opening %s file \n",FileName);
     return;
   }
-
   // Loading AliRun master
-  RunLoader->LoadgAlice();
+  if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
   gAlice = RunLoader->GetAliRun();
-  RunLoader->LoadKinematics("READ");
// RunLoader->LoadKinematics("READ");
   
   // Loading MUON subsystem
-  AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
-  AliMUONData * muondata = MUON->GetMUONData();
-
-  Int_t nevents;
-  nevents = RunLoader->GetNumberOfEvents();
  
   MUONLoader->LoadRecPoints("READ");
   MUONLoader->LoadTracks("UPDATE");
+  
+  Int_t nevents;
+  nevents = RunLoader->GetNumberOfEvents();
+  
+  AliMUONEventReconstructor* Reco = new AliMUONEventReconstructor(MUONLoader);
+  AliMUONData* muondata = Reco->GetMUONData();
 
-
-  // Testing if Tracking has already been done
+  // Testing if Tracker has already been done
   RunLoader->GetEvent(0);
   if (MUONLoader->TreeT()) {
     if (muondata->IsTrackBranchesInTree()) {
       MUONLoader->UnloadTracks();
       MUONLoader->LoadTracks("RECREATE");
-      printf("Recreating Tracks files\n");
+      printf("Recreating RecPoints files\n");
     }
   }
-  
-  AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor();
 
   // The right place for changing AliMUONEventReconstructor parameters
   // with respect to the default ones
@@ -84,35 +76,36 @@ void MUONTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t
   Reco->SetPrintLevel(0);
   //   Reco->SetBendingResolution(0.0);
   //   Reco->SetNonBendingResolution(0.0);
-  cout << "AliMUONEventReconstructor: actual parameters" << endl;
-//  Reco->Dump();
-  //   gObjectTable->Print();
+  //   cout << "AliMUONEventReconstructor: actual parameters" << endl;
 
   if  (LastEvent>nevents) LastEvent=nevents;
+
   // Loop over events
   for (Int_t event = FirstEvent; event < LastEvent; event++) {
+      //MUONLoader->LoadHits("READ");
       cout << "Event: " << event << endl;
       RunLoader->GetEvent(event);   
-      if (MUONLoader->TreeT() == 0x0) MUONLoader->MakeTracksContainer();
-      
+      // Test if trigger track has already been done before
+      if (MUONLoader->TreeT() == 0x0) {        
+         MUONLoader->MakeTracksContainer();
+      }      else {
+         if (muondata->IsTrackBranchesInTree()){ // Test if track has already been done before
+             if (event==FirstEvent) MUONLoader->UnloadTracks();
+             MUONLoader->MakeTracksContainer();  // Redoing Tracking
+             Info("TrackContainer","Recreating TrackContainer and deleting previous ones");
+         }
+      }
+
       muondata->MakeBranch("RT");
       muondata->SetTreeAddress("RT");
       Reco->EventReconstruct();
-      // Dump current event
-      // Reco->EventDump();
-      
-      // Duplicating rectrack data in muondata for output
-      for(Int_t i=0; i<Reco->GetNRecTracks(); i++) {
-         AliMUONTrack * track = (AliMUONTrack*) Reco->GetRecTracksPtr()->At(i);
-         muondata->AddRecTrack(*track);
-         //printf(">>> TEST TEST event %d Number of hits in the track %d is %d \n",event,i,track->GetNTrackHits());
-      }
-      
-      muondata->Fill("RT");
-      MUONLoader->WriteTracks("OVERWRITE");  
-      muondata->ResetRecTracks();
-      muondata->ResetRawClusters();
+    
+    muondata->Fill("RT");
+    MUONLoader->WriteTracks("OVERWRITE");  
+    muondata->ResetRecTracks();
+    muondata->ResetRawClusters();
   } // Event loop
+
   MUONLoader->UnloadRecPoints();
   MUONLoader->UnloadTracks();
 }
index ae93d712793d5d1fa69c38037641d7c5e9b4c993..2ff84d8d92119dd65db521a7ed95b4371f53f750 100644 (file)
 // The output is a TClonesArray of AliMUONTriggerTracks.
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
-#include <TClonesArray.h>
 
 #include "AliRun.h"
 #include "AliMUON.h"
 #include "AliMUONData.h"
 #include "AliMUONEventReconstructor.h"
-#include "AliMUONTriggerTrack.h"
 #endif
 
 void MUONTriggerTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t LastEvent = 9999)
@@ -39,28 +37,30 @@ void MUONTriggerTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0,
   cout << "FileName ``" << FileName << "''" << endl;
   
   // Creating Run Loader and openning file containing Hits, Digits and RecPoints
-  AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"Event","UPDATE");
+  AliRunLoader * RunLoader = AliRunLoader::Open(FileName,"MUONLoader","UPDATE");
   if (RunLoader ==0x0) {
     printf(">>> Error : Error Opening %s file \n",FileName);
     return;
   }
   
   // Loading AliRun master
-  RunLoader->LoadgAlice();
+  if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
   gAlice = RunLoader->GetAliRun();
-  RunLoader->LoadKinematics("READ");
+  // RunLoader->LoadKinematics("READ");
   
   // Loading MUON subsystem
-  AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
-  AliMUONData * muondata = MUON->GetMUONData();
-  
   Int_t nevents;
   nevents = RunLoader->GetNumberOfEvents();
 
   MUONLoader->LoadRecPoints("READ");
   MUONLoader->LoadTracks("UPDATE"); 
 
+
+  AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor(MUONLoader);
+  AliMUONData* muondata = Reco->GetMUONData();
+
   // Testing if Trigger Tracking has already been done
   RunLoader->GetEvent(0);
   if (MUONLoader->TreeT()) {
@@ -71,14 +71,9 @@ void MUONTriggerTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0,
     }
   }
 
-  AliMUONEventReconstructor *Reco = new AliMUONEventReconstructor();
-  
-  Reco->SetPrintLevel(0);
-  cout << "AliMUONEventReconstructor: actual parameters" << endl;  
-  //  Reco->Dump();
-  //   gObjectTable->Print();
-  
+  Reco->SetPrintLevel(0);    
   if  (LastEvent>nevents) LastEvent=nevents;
+
   // Loop over events
   for (Int_t event = FirstEvent; event < LastEvent; event++) {
       cout << "Event: " << event << endl;
@@ -88,21 +83,13 @@ void MUONTriggerTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0,
       muondata->MakeBranch("RL");
       muondata->SetTreeAddress("RL");
       Reco->EventReconstructTrigger();
-      // Dump current event
-      // Reco->EventDumpTrigger();
-      
-      // Duplicating rectriggertrack data in muondata for output
-      for(Int_t i=0; i<Reco->GetNRecTriggerTracks(); i++) {
-         AliMUONTriggerTrack * triggertrack = (AliMUONTriggerTrack*) Reco->GetRecTriggerTracksPtr()->At(i);
-         muondata->AddRecTriggerTrack(*triggertrack);
-//      printf(">>> TEST TEST event %d Number of hits in the track %d is %d \n",event,i,track->GetNTrackHits());
-      }
-      
       muondata->Fill("RL");
       MUONLoader->WriteTracks("OVERWRITE");  
       muondata->ResetRecTriggerTracks();
       muondata->ResetTrigger();
   } // Event loop
+
   MUONLoader->UnloadRecPoints();
   MUONLoader->UnloadTracks();
 }
index f2fa5676d6452443476fd03ce68928bff2dc0074..2a42f8caa3a40cf45f9718a5b2db1304d4e6d483 100644 (file)
@@ -16,7 +16,7 @@
 /* $Id$ */
 
 #if !defined(__CINT__) || defined(__MAKECINT__)
-#include "iostream.h"
+//#include "iostream.h"
 
 #include <TClassTable.h>
 #include <TClonesArray.h>
 #include "AliMUON.h"
 
 #include "AliMUONClusterFinderVS.h"
+//#include "AliMUONClusterFinderAZ.h"
+#include "AliMUONClusterReconstructor.h"
 #endif
 
 void MUONrawclusters (char* filename="galice.root", Int_t evNumber1=0,Int_t evNumber2=9999) 
 {
-  //////////////////////////////////////
-  //                                  //
-  // ROOT macro for ALICE Dimuon Arm: //
-  // Clusterization of digits         //
-  //                                  //
-  //////////////////////////////////////
-  //
-  // Adds the tree TR for raw clusters
-  // to the ROOT file "galice.root"
-  // containing the digits (tree TD).
-  //
-  // Arguments:
-  //   evNumber1 = first event number to act on in file "galice.root"
-  //   evNumber2 = last event number to act on in file "galice.root"
-  //
-  // Input/output file:
-  //   "galice.root"
-  //
-  //__________________________________________________________________________
-    
-//  // Dynamically link some shared libs
-    
-  //if (gClassTable->GetID("AliRun") < 0) {
-  //   gROOT->LoadMacro("$ALICE_ROOT/macros/loadlibs.C");
-  //   loadlibs();
-  //    }
-
  // Creating Run Loader and openning file containing Hits
-  AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","UPDATE");
+  AliRunLoader* RunLoader = AliRunLoader::Open(filename,"MUONLoader","UPDATE");
   if (RunLoader ==0x0) {
     printf(">>> Error : Error Opening %s file \n",filename);
     return;
   }
-  
-  // Loading AliRun master
-  RunLoader->UnloadgAlice();
-  RunLoader->LoadgAlice();
-  gAlice = RunLoader->GetAliRun();
+  if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
   
   // Loading MUON subsystem
-  AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
-  AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
-  AliMUONData * muondata = MUON->GetMUONData();
+  AliLoader* MUONLoader = RunLoader->GetLoader("MUONLoader");
   
+  MUONLoader->LoadDigits("READ");
+  MUONLoader->LoadRecPoints("UPDATE");
+
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
-  
+
+  AliMUONClusterReconstructor* Reco = new AliMUONClusterReconstructor(MUONLoader);
+  AliMUONData* muondata = Reco->GetMUONData();
+
   for (Int_t i=0; i<10; i++) {
-      //RecModel = new AliMUONClusterFinderVS();
-      AliMUONClusterFinderVS *RecModel = new AliMUONClusterFinderVS();
+    AliMUONClusterFinderVS* RecModel = new AliMUONClusterFinderVS();
     // RecModel->SetTracks(16,17);    
     // RecModel->SetTracks(266,267);    
     RecModel->SetGhostChi2Cut(10);
-    MUON->SetReconstructionModel(i,RecModel);
+    Reco->SetReconstructionModel(i,RecModel);
   } 
-  
-  MUONLoader->LoadDigits("READ");
-  MUONLoader->LoadRecPoints("UPDATE");
-  
+
   // Testing if RawClusterisation has already been done
   RunLoader->GetEvent(0);
   if (MUONLoader->TreeR()) {
@@ -104,16 +75,34 @@ void MUONrawclusters (char* filename="galice.root", Int_t evNumber1=0,Int_t evNu
     }
   }
 
-//   Loop over events              
-    if (evNumber2>nevents) evNumber2=nevents;
-    for(Int_t ievent=evNumber1; ievent<evNumber2; ievent++) {
-       printf("event %d\n",ievent);
-       RunLoader->GetEvent(ievent);
-       if (MUONLoader->TreeR() == 0x0) MUONLoader->MakeRecPointsContainer();
-       
-       muondata->MakeBranch("RC");
-       muondata->SetTreeAddress("D,RC");
-       MUON->Digits2Reco(); 
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+    if (evNumber2 > nevents) evNumber2 = nevents;
+
+    for(ievent = evNumber1; ievent < evNumber2; ievent++) {
+      printf("event %d\n",ievent);
+      RunLoader->GetEvent(ievent);
+
+      // Test if rawcluster has already been done before
+      if (MUONLoader->TreeR() == 0x0) 
+       MUONLoader->MakeRecPointsContainer();
+      else {
+       if (muondata->IsRawClusterBranchesInTree()){ 
+         // Test if rawcluster has already been done before
+         if (ievent == evNumber1) MUONLoader->UnloadRecPoints();
+         MUONLoader->MakeRecPointsContainer();  // Redoing clusterisation
+         Info("RecPointsContainer",
+              "Recreating RecPointsContainer and deleting previous ones");
+       }
+      }
+      muondata->MakeBranch("RC");
+      muondata->SetTreeAddress("D,RC");
+
+      Reco->Digits2Clusters();
+  
+      muondata->Fill("RC"); //Filling Reconstructed Cluster
+      MUONLoader->WriteRecPoints("OVERWRITE");
+      muondata->ResetRawClusters();  
+      muondata->ResetDigits();     
     }
     MUONLoader->UnloadDigits();
     MUONLoader->UnloadRecPoints();
index f79c2eed83bf9d677d2ccd4c7b959a1b4a55b17b..3958b10b24f6b29ba79fb5a04b0f1df90bb81a02 100644 (file)
@@ -21,6 +21,7 @@
 #include "AliLoader.h"
 #include "AliMUON.h"
 #include "AliMUONData.h"
+#include "AliMUONTriggerDecision.h"
 #endif
 
 AliRun * gAlice;
@@ -32,53 +33,69 @@ void MUONtrigger (char* filename="galice.root",
 {
 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 // Creating Run Loader and openning file containing Hits
-  AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONFolder","UPDATE");
+  AliRunLoader * RunLoader = AliRunLoader::Open(filename,"MUONLoader","UPDATE");
   if (RunLoader ==0x0) {
     printf(">>> Error : Error Opening %s file \n",filename);
     return;
   }
 
-// Loading AliRun master
-  RunLoader->UnloadgAlice();
-  RunLoader->LoadgAlice();
-  gAlice = RunLoader->GetAliRun();
+  // Loading AliRun master
+  if (RunLoader->GetAliRun() == 0x0) RunLoader->LoadgAlice();
 
-// Loading MUON subsystem
-  AliMUON * MUON = (AliMUON *) gAlice->GetDetector("MUON");
+  // Loading MUON subsystem
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
-  AliMUONData * muondata = MUON->GetMUONData();
 
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
 
+  AliMUONTriggerDecision* TrigDec = new AliMUONTriggerDecision(MUONLoader);
+  AliMUONData* muondata = TrigDec->GetMUONData();
+
   MUONLoader->LoadDigits("READ");
   MUONLoader->LoadRecPoints("UPDATE");
 
-// Testing if trigger has already been done
+  // Testing if trigger has already been done
   RunLoader->GetEvent(0);
   if (MUONLoader->TreeR()) {
-      if (muondata->IsTriggerBranchesInTree()) {
-         MUONLoader->UnloadRecPoints();
-         MUONLoader->LoadRecPoints("RECREATE");
-         printf("Recreating RecPoints files\n");
-      }
+    if (muondata->IsTriggerBranchesInTree()) {
+      MUONLoader->UnloadRecPoints();
+      MUONLoader->LoadRecPoints("RECREATE");
+      printf("Recreating RecPoints files\n");
+    }
   }
-  
-//   Loop over events
+
+//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   if (evNumber2>nevents) evNumber2=nevents;
-  for (Int_t ievent=evNumber1; ievent<evNumber2; ievent++) { // event loop
-      printf("event %d\n",ievent);
-      RunLoader->GetEvent(ievent);       
-      if (MUONLoader->TreeR() == 0x0)  MUONLoader->MakeRecPointsContainer();
-      
-      muondata->MakeBranch("GLT");
-      muondata->SetTreeAddress("D,GLT");
-      MUON->Trigger(ievent); 
-      muondata->ResetDigits();
-      muondata->ResetTrigger();
-  } 
-  MUONLoader->UnloadDigits();
-  MUONLoader->UnloadRecPoints();
+   for (ievent = evNumber1; ievent < evNumber2; ievent++) { // event loop
+
+       printf("event %d\n",ievent);
+       RunLoader->GetEvent(ievent);       
+       // Test if rawcluster has already been done before
+       if (MUONLoader->TreeR() == 0x0) 
+        MUONLoader->MakeRecPointsContainer();
+       else {
+        if (muondata->IsTriggerBranchesInTree()){ 
+          // Test if rawcluster has already been done before
+          if (ievent == evNumber1) MUONLoader->UnloadRecPoints();
+          MUONLoader->MakeRecPointsContainer();  // Redoing clusterisation
+          Info("RecPointsContainer",
+               "Recreating RecPointsContainer and deleting previous ones");
+        }
+       }
+       muondata->MakeBranch("GLT");
+       muondata->SetTreeAddress("D,GLT");
+
+       TrigDec->Digits2Trigger();
+
+       muondata->Fill("GLT"); //Filling Global Local Trigger
+       MUONLoader->WriteRecPoints("OVERWRITE");
+       muondata->ResetDigits();
+       muondata->ResetTrigger();
+
+   } // event loop 
+
+   MUONLoader->UnloadDigits();
+   MUONLoader->UnloadRecPoints();
 }