improving IO

diff --git a/MUON/AliMUON.cxx b/MUON/AliMUON.cxx
index bb56c982077c2b33251e669adce554fdc9243216..c98d259247a0170f995698daa1b3abcffdddf4d3 100644 (file)
--- a/MUON/AliMUON.cxx
+++ b/MUON/AliMUON.cxx
@@ -364,7 +364,7 @@ AliLoader* AliMUON::MakeLoader(const char* topfoldername)
         "Creating standard getter for detector %s. Top folder is %s.",
          GetName(),topfoldername);
      
- fLoader   = new AliLoader(GetName(),topfoldername);
+ fLoader   = new AliMUONLoader(GetName(),topfoldername);
  fMUONData = new AliMUONData(fLoader,GetName(),GetName()); 
  return fLoader;
 }
@@ -410,10 +410,7 @@ void AliMUON::Trigger(Int_t nev){
   delete decision;
 
   //  fLoader->TreeR()->Fill();
-  fLoader->TreeR()->GetBranch("MUONGlobalTrigger")->Fill();
-  fLoader->TreeR()->GetBranch("MUONLocalTrigger")->Fill();
- 
- 
+  GetMUONData()->Fill("GLT"); //Filling Global and Local Trigger GLT
   //  char hname[30];
   //  sprintf(hname,"TreeR%d",nev);
   //  fLoader->TreeR()->Write(hname,TObject::kOverwrite);
@@ -428,14 +425,10 @@ void AliMUON::Digits2Reco()
 {
   FindClusters();
   Int_t nev = gAlice->GetHeader()->GetEvent();
-  fLoader->TreeR()->Fill();
-  // char hname[30];
-  // sprintf(hname,"TreeR%d", nev);
-  //fLoader->TreeR()->Write(hname);
-  //fLoader->TreeR()->Reset();
+  GetMUONData()->Fill("RC"); //Filling Reconstructed Cluster
   fLoader->WriteRecPoints("OVERWRITE");
   GetMUONData()->ResetRawClusters();        
-  printf("\n End of cluster finding for event %d", nev);
+  Info("Digits2Reco","End of cluster finding for event %d", nev);
 }
 //____________________________________________________________________
 void AliMUON::FindClusters()
@@ -459,9 +452,9 @@ void AliMUON::FindClusters()
        AliMUONClusterFinderVS* rec = iChamber->ReconstructionModel();
     
        ResetDigits();
-       fLoader->TreeD()->GetEvent(0);
+       GetMUONData()->GetCathode(0);
        //TClonesArray *
-       muonDigits = GetMUONData()->Digits(ich,0);  // cathode plane not yet operational
+       muonDigits = GetMUONData()->Digits(ich); 
        ndig=muonDigits->GetEntriesFast();
        printf("\n 1 Found %d digits in %p chamber %d", ndig, muonDigits,ich);
        TClonesArray &lhits1 = *dig1;
@@ -471,10 +464,9 @@ void AliMUON::FindClusters()
            if (rec->TestTrack(digit->Track(0)))
                new(lhits1[n++]) AliMUONDigit(*digit);
        }
-       ResetDigits();
-       fLoader->TreeD()->GetEvent(1);
-       //muonDigits  = this->DigitsAddress(ich);
-       muonDigits =  GetMUONData()->Digits(ich,1);  // cathode plane not yet operational
+       GetMUONData()->ResetDigits();
+       GetMUONData()->GetCathode(1);
+       muonDigits =  GetMUONData()->Digits(ich);  
        ndig=muonDigits->GetEntriesFast();
        printf("\n 2 Found %d digits in %p %d", ndig, muonDigits, ich);
        TClonesArray &lhits2 = *dig2;

diff --git a/MUON/AliMUONClusterFinderAZ.cxx b/MUON/AliMUONClusterFinderAZ.cxx
index fe5f5d6882a74e2dd53e9ef4dfbb9fbb43b77e33..85c7f590aedfca61e2e3adc822b3a6764ac48266 100644 (file)
--- a/MUON/AliMUONClusterFinderAZ.cxx
+++ b/MUON/AliMUONClusterFinderAZ.cxx
@@ -147,7 +147,7 @@ newev:
 newchamber:
   if (ch > 9) {if (fReco) return; nev++; ch = 0; goto newev;}
   //gAlice->ResetDigits();
-  fMuonDigits  = MUON->GetMUONData()->Digits(ch,0);
+  fMuonDigits  = MUON->GetMUONData()->Digits(ch);
   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->GetMUONData()->Digits(ch,0);
+    fMuonDigits  = MUON->GetMUONData()->Digits(ch);
 
     ndigits[cath] = fMuonDigits->GetEntriesFast();
     if (!ndigits[0] && !ndigits[1]) {if (fReco) return; ch++; goto newchamber;}

diff --git a/MUON/AliMUONData.cxx b/MUON/AliMUONData.cxx
index c30996056870d238957737d3c293c08b06907ecf..1c023fc6df0aad416d3efba88bc12c66a877a4dd 100644 (file)
--- a/MUON/AliMUONData.cxx
+++ b/MUON/AliMUONData.cxx
@@ -1,8 +1,9 @@
 
-
 //Root includes
-
+#include "TNamed.h"
 //AliRoot includes
+#include "AliLoader.h" 
+#include "AliMUONConstants.h"
 #include "AliMUONData.h"
 #include "AliMUONDigit.h"
 #include "AliMUONHit.h"
@@ -94,7 +95,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 = * Digits(id,0) ; 
+  TClonesArray &ldigits = * Digits(id) ; 
   new(ldigits[fNdigits[id]++]) AliMUONDigit(tracks,charges,digits);
 }
 //_____________________________________________________________________________
@@ -145,6 +146,58 @@ void AliMUONData::AddRecTrack(const AliMUONTrack& track)
   new(lrectracks[fNrectracks++]) AliMUONTrack(track);
 }
 //____________________________________________________________________________
+void AliMUONData::Fill(Option_t* option)
+{
+  // Method to fill the trees
+  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
+  
+  char branchname[30];
+  TBranch * branch = 0x0;
+
+  //
+  // Filling TreeH
+  if ( TreeH() && cH ) {
+    TreeH()->Fill();
+  }  
+  //
+  // Filling TreeD
+  if ( TreeD() && cD) {
+    TreeD()->Fill();
+  }
+  //
+  // filling rawclusters
+  if ( TreeR()  && cRC) {
+    TreeR()->Fill();
+    //  for (int i=0; i<AliMUONConstants::NTrackingCh(); i++) {
+//        sprintf(branchname,"%sRawClusters%d",GetName(),i+1);
+//        branch = TreeR()->GetBranch(branchname);
+//        branch->Fill();
+//      }
+  }
+ //
+  // filling trigger 
+  if ( TreeR()  && cGLT) {
+    sprintf(branchname,"%sLocalTrigger",GetName());
+    branch = TreeR()->GetBranch(branchname); 
+    branch->Fill();
+    sprintf(branchname,"%sGlobalTrigger",GetName());
+    branch = TreeR()->GetBranch(branchname);
+    branch->Fill();
+  }
+  //
+  // filling tracks
+  if ( TreeT() && cRT ) {
+    sprintf(branchname,"%sTrack",GetName());  
+    branch = TreeT()->GetBranch(branchname);
+    branch->Fill();
+  }
+}
+//_____________________________________________________________________________
 void AliMUONData::MakeBranch(Option_t* option)
 {
   //
@@ -199,7 +252,7 @@ void AliMUONData::MakeBranch(Option_t* option)
        Info("MakeBranch","Branch %s is already in tree.",GetName());
        return;
       }
-      TClonesArray * digits = Digits(iDetectionPlane,0); 
+      TClonesArray * digits = Digits(iDetectionPlane); 
       branch = TreeD()->Branch(branchname, &digits, kBufferSize);
       Info("MakeBranch","Making Branch %s for digits in detection plane %d\n",branchname,iDetectionPlane+1);
       }
@@ -386,7 +439,7 @@ void AliMUONData::SetTreeAddress(Option_t* option)
     for (int i=0; i<AliMUONConstants::NCh(); i++) {
       sprintf(branchname,"%sDigits%d",GetName(),i+1);
       branch = TreeD()->GetBranch(branchname);
-      TClonesArray * digits = Digits(i,0);
+      TClonesArray * digits = Digits(i);
       if (branch) branch->SetAddress( &digits );
       else Warning("SetTreeAddress","(%s) Failed for Digits Detection plane %d. Can not find branch in tree.",GetName(),i);
     }

diff --git a/MUON/AliMUONData.h b/MUON/AliMUONData.h
index b0dadf730b86afe95353e5d3129d7e35db855211..2b638dfbb9904fb11c9c17ce09462c9158eda64c 100644 (file)
--- a/MUON/AliMUONData.h
+++ b/MUON/AliMUONData.h
@@ -6,15 +6,15 @@
 // Gines Martinez, Subatech,  September 2003
 //
 
-#include "TNamed.h"
-
-#include "AliLoader.h" 
-#include "AliMUONConstants.h"
+#include "AliLoader.h"
 
 class TClonesArray;
+class TNamed;
 class TObjArray;
 class TTree;
 
+
+class AliMUONConstants;
 class AliMUONRawCluster;
 class AliMUONTrack;
 
@@ -45,17 +45,24 @@ class AliMUONData : public TNamed {
     virtual void   AddRecTrack(const AliMUONTrack& track);
 
     TClonesArray*  Hits() {return fHits;}
-    TClonesArray*  Digits(Int_t DetectionPlane, Int_t /*Cathode*/) 
+    TClonesArray*  Digits(Int_t DetectionPlane) 
       {return ( (TClonesArray*) fDigits->At(DetectionPlane) );}
     TClonesArray*  LocalTrigger() {return fLocalTrigger;}
     TClonesArray*  GlobalTrigger() {return fGlobalTrigger;}
     TClonesArray*  RawClusters(Int_t DetectionPlane)
       {return ( (TClonesArray*) fRawClusters->At(DetectionPlane) );}
     TClonesArray*  RecTracks() {return fRecTracks;}
-    
+
+    void           GetTrack(Int_t it) {fLoader->TreeH()->GetEvent(it);}
+    Int_t          GetNtracks()       {return fLoader->TreeH()->GetEntries();}
+    void           GetCathode(Int_t ic) {fLoader->TreeD()->GetEvent(ic);}
+    void           GetRawClusters() {fLoader->TreeR()->GetEvent(0);}
+    void           GetTrigger() {fLoader->TreeR()->GetEvent(0);}
+
     virtual AliLoader* GetLoader() {return fLoader;}
     virtual void       SetLoader(AliLoader * loader) {fLoader=loader;}    
     
+    virtual void   Fill(Option_t* opt=" ");
     virtual void   MakeBranch(Option_t *opt=" ");
     virtual void   SetTreeAddress(Option_t *opt=" ");
     

diff --git a/MUON/AliMUONDigitizerv1.cxx b/MUON/AliMUONDigitizerv1.cxx
index 7ae356619c38ebbf688253c70b80ea4600415d98..119c4fd8d0ea7c73c6439d7e1c6efa70cf308276 100644 (file)
--- a/MUON/AliMUONDigitizerv1.cxx
+++ b/MUON/AliMUONDigitizerv1.cxx
@@ -392,7 +392,7 @@ void AliMUONDigitizerv1::Exec(Option_t* option)
        if ( digits[2] == icat ) muondata->AddDigit(ich,tracks,charges,digits);
       }
       // Filling list of digits per chamber for a given cathode.
-      treeD->Fill();
+      muondata->Fill("D");
       muondata->ResetDigits();    
     } // end loop cathode
     fTDList->Delete();  

diff --git a/MUON/AliMUONDisplay.cxx b/MUON/AliMUONDisplay.cxx
index eb7f0cf6c5a31d8e7ade498d7497e3de4b322455..620e16af9d5303a0215784ba7f02f3d0b9dcf55b 100644 (file)
--- a/MUON/AliMUONDisplay.cxx
+++ b/MUON/AliMUONDisplay.cxx
@@ -778,17 +778,17 @@ void AliMUONDisplay::LoadDigits(Int_t chamber, Int_t cathode)
     AliSegmentation*      segmentation;
     AliMUONResponse*      response;
 
-    TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1,0);
+    TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1);
     if (muonDigits == 0) return;
 
 //     gAlice->ResetDigits();
     Int_t nent = 0;
  
-   if (gAlice->TreeD()) {
-     nent = (Int_t) gAlice->TreeD()->GetEntries();
+   if (pMUON->GetLoader()->TreeD()) {
+     nent = (Int_t) pMUON->GetLoader()->TreeD()->GetEntries();
      printf(" entries %d \n", nent);
      //     gAlice->TreeD()->GetEvent(nent-2+cathode-1);
-     gAlice->TreeD()->GetEvent(cathode-1);
+     pMUON->GetMUONData()->GetCathode(cathode-1);
     }
     
     Int_t ndigits = muonDigits->GetEntriesFast();

diff --git a/MUON/AliMUONLoader.cxx b/MUON/AliMUONLoader.cxx
index af0d51690f973f9d6c831badbe62b3726201e2c2..ec313c22b9748d74e4441cfe0bf5ed95c60eee10 100644 (file)
--- a/MUON/AliMUONLoader.cxx
+++ b/MUON/AliMUONLoader.cxx
@@ -4,35 +4,26 @@
 
 //AliRoot includes
 #include "AliMUONLoader.h"
+#include "AliMUONConstants.h"
 
 ClassImp(AliMUONLoader)
 //___________________________________________________________________
-
- 
-/*****************************************************************************/ 
 AliMUONLoader::AliMUONLoader():AliLoader()
 {
 //default constructor
-
 }
-/******************************************************************/
-
+//_______________________________________________________________________________
 AliMUONLoader::AliMUONLoader(const Char_t* detname,const Char_t* eventfoldername):AliLoader(detname,eventfoldername)
 {
-    
 }
-/*****************************************************************************/ 
-
+//_______________________________________________________________________________
 AliMUONLoader::AliMUONLoader(const Char_t * detname,TFolder* eventfolder):AliLoader(detname,eventfolder)
 {
 //constructor
-  
 }
-/*****************************************************************************/ 
-
+//_______________________________________________________________________________
 AliMUONLoader::~AliMUONLoader()
 {
 //detructor 
 }
-/*****************************************************************************/ 
-
+//_______________________________________________________________________________

diff --git a/MUON/AliMUONLoader.h b/MUON/AliMUONLoader.h
index 97a47c170b87f0f4bc88699074b01d7423952d79..824a2ad5158f75703e300b89a3a26e1cbb4fcaa4 100644 (file)
--- a/MUON/AliMUONLoader.h
+++ b/MUON/AliMUONLoader.h
@@ -10,10 +10,9 @@
 //                                                                 //
 /////////////////////////////////////////////////////////////////////
 
-class TClonesArray;
-
 class AliMUONData;
 
+
 class AliMUONLoader : public AliLoader {
  public:
     AliMUONLoader();
@@ -21,6 +20,7 @@ class AliMUONLoader : public AliLoader {
     AliMUONLoader(const Char_t *detname,TFolder* eventfolder);
     virtual ~AliMUONLoader();
 
+ 
  private:
     //descendant classes should
     //use protected interface methods to access these folders

diff --git a/MUON/AliMUONPoints.cxx b/MUON/AliMUONPoints.cxx
index 0fab6b3af53d08c546d77c9bf9a2404c23f9c4c3..157bc3a3ebcc14b64898c4501e7e4b4f02eb2ab9 100644 (file)
--- a/MUON/AliMUONPoints.cxx
+++ b/MUON/AliMUONPoints.cxx
@@ -236,9 +236,9 @@ AliMUONDigit *AliMUONPoints::GetDigit() const
   Int_t cathode=display->GetCathode();
    
   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
-  TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1,0);
+  TClonesArray *muonDigits  = pMUON->GetMUONData()->Digits(chamber-1);
   Int_t nent=(Int_t)gAlice->TreeD()->GetEntries();
-  gAlice->TreeD()->GetEvent(nent-2+cathode-1);
+  pMUON->GetMUONData()->GetCathode(nent-2+cathode-1);
   //gAlice->TreeD()->GetEvent(cathode);
   Int_t ndigits = muonDigits->GetEntriesFast();
   if (fDigitIndex < 0 || fDigitIndex >= ndigits) return 0;

diff --git a/MUON/AliMUONTriggerDecision.cxx b/MUON/AliMUONTriggerDecision.cxx
index 40d98d88537038a3dbe902f458b2cfac72cc0de5..ca802177831d67254b78dd9f847a2b8870de641a 100644 (file)
--- a/MUON/AliMUONTriggerDecision.cxx
+++ b/MUON/AliMUONTriggerDecision.cxx
@@ -203,7 +203,7 @@ void AliMUONTriggerDecision::SetBit(){
       AliMUONChamber*   iChamber = &(pMUON->Chamber(chamber-1));
       AliSegmentation*  segmentation;
       gime->TreeD()->GetEvent(cathode-1);
-      TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1,0);
+      TClonesArray *muonDigits = pMUON->GetMUONData()->Digits(chamber-1);
       Int_t ndigits = muonDigits->GetEntriesFast();
       printf("\n 1 Found %d digits in %p %d \n ", ndigits, muonDigits,chamber-1);
 //    if (ndigits == 0) return;

diff --git a/MUON/MUONCheck.C b/MUON/MUONCheck.C
index 195cd16694522bd1c0d68aa987a5af4aeb023133..b889cbc878348ba0afc5352f18f1dbced8f7e09d 100644 (file)
--- a/MUON/MUONCheck.C
+++ b/MUON/MUONCheck.C
@@ -66,30 +66,25 @@ void MUONhits(char * filename="galice.root")
     printf(">>> Error : Error Opening %s file \n",filename);
     return;
   }
-
   // Loading MUON subsystem
   AliLoader * MUONLoader = RunLoader->GetLoader("MUONLoader");
-  MUONLoader->LoadHits("READ");
-  // Creating MUON data container
-  AliMUONData muondata(MUONLoader,"MUON","MUON");
-
+  MUONLoader->LoadHits("READ");  // Loading Tree of hits for MUON
+  AliMUONData muondata(MUONLoader,"MUON","MUON");  // Creating MUON data container
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
 
   for(ievent=0; ievent<nevents; ievent++) {  // Event loop
     printf(">>> Event %d \n",ievent);
-
     // Getting event ievent
     RunLoader->GetEvent(ievent); 
     muondata.SetTreeAddress("H");
-   
     Int_t itrack, ntracks;
-    ntracks = (Int_t) (MUONLoader->TreeH())->GetEntries();
+    ntracks = (Int_t) muondata.GetNtracks();
     for (itrack=0; itrack<ntracks; itrack++) { // Track loop
       printf(">>> Track %d \n",itrack);
 
       //Getting List of Hits of Track itrack
-      (MUONLoader->TreeH())->GetEvent(itrack); 
+      muondata.GetTrack(itrack); 
 
       Int_t ihit, nhits;
       nhits = (Int_t) muondata.Hits()->GetEntriesFast();
@@ -127,16 +122,13 @@ void MUONdigits(char * filename="galice.root")
   // 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();
-
   AliMUONDigit * mDigit;
   
-
   for(ievent=0; ievent<nevents; ievent++) {
     printf(">>> Event %d \n",ievent);
     RunLoader->GetEvent(ievent);
@@ -152,19 +144,16 @@ void MUONdigits(char * filename="galice.root")
     //Loop on cathodes 
     for(icathode=0; icathode<ncathodes; icathode++) {
       printf(">>> Cathode %d\n",icathode);
-      MUONLoader->TreeD()->GetEvent(icathode);
+      muondata.GetCathode(icathode);
       // Loop on chambers
       for( ichamber=0; ichamber<nchambers; ichamber++) {
        printf(">>> Chamber %d\n",ichamber);
-       //      sprintf(branchname,"MUONDigits%d",ichamber+1);
-       //printf(">>>  branchname %s\n",branchname);
        
        Int_t idigit, ndigits;
-
-       ndigits = (Int_t) muondata.Digits(ichamber,0)->GetEntriesFast();
+       ndigits = (Int_t) muondata.Digits(ichamber)->GetEntriesFast();
        
        for(idigit=0; idigit<ndigits; idigit++) {
-         mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber,0)->At(idigit));
+         mDigit = static_cast<AliMUONDigit*>(muondata.Digits(ichamber)->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
@@ -199,19 +188,17 @@ void MUONrecpoints(char * filename="galice.root") {
 
   Int_t ievent, nevents;
   nevents = RunLoader->GetNumberOfEvents();
-
   AliMUONRawCluster * mRecPoint;
   
   for(ievent=0; ievent<nevents; ievent++) {
     printf(">>> Event %d \n",ievent);
     RunLoader->GetEvent(ievent);
-  
     // Addressing
     Int_t ichamber, nchambers;
     nchambers = AliMUONConstants::NTrackingCh();
     muondata.SetTreeAddress("RC"); 
     char branchname[30];    
-    MUONLoader->TreeR()->GetEvent(0);
+    muondata.GetRawClusters();
     // Loop on chambers
     for( ichamber=0; ichamber<nchambers; ichamber++) {
       printf(">>> Chamber %d\n",ichamber);
@@ -219,7 +206,6 @@ void MUONrecpoints(char * filename="galice.root") {
       //printf(">>>  branchname %s\n",branchname);
   
       Int_t irecpoint, nrecpoints;
-      
       nrecpoints = (Int_t) muondata.RawClusters(ichamber)->GetEntriesFast();
       
       for(irecpoint=0; irecpoint<nrecpoints; irecpoint++) {
@@ -295,7 +281,7 @@ void MUONTestTrigger (char * filename="galice.root"){
       RunLoader->GetEvent(ievent);
       
       muondata.SetTreeAddress("GLT"); 
-      MUONLoader->TreeR()->GetEvent(0);
+      muondata.GetTrigger();
       
       globalTrigger = muondata.GlobalTrigger();
       localTrigger = muondata.LocalTrigger();

diff --git a/MUON/MUONTracker.C b/MUON/MUONTracker.C
index f2fb75d0340ea1f04b9560d41a17cc75e96b0c2a..4d0214230e3d3a709108cedfd5d833255ca07645 100644 (file)
--- a/MUON/MUONTracker.C
+++ b/MUON/MUONTracker.C
@@ -74,7 +74,7 @@ void MUONTracker (Text_t *FileName = "galice.root", Int_t FirstEvent = 0, Int_t
       muondata->AddRecTrack(*track);
     }
 
-    MUONLoader->TreeT()->Fill();
+    muondata->Fill("RT");
     MUONLoader->WriteTracks("OVERWRITE");
     muondata->ResetRecTracks();
   } // Event loop