AliMUONDataInterface.h

Go to the documentation of this file.

#ifndef ALIMUONDATAINTERFACE_H
#define ALIMUONDATAINTERFACE_H
/*  Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */
// Includes revised 07/05/2004
//

// Author: Artur Szostak (University of Cape Town)
//  email: artursz@iafrica.com
//
// Updated to MUON module w/o MUONData by Laurent Aphecetche, Subatech
//

#include <TObject.h>
#include <TString.h>

class TIterator;
class AliLoader;
class AliMUONVStore;
class AliMUONVDigitStore;
class AliMUONVClusterStore;
class AliMUONVTriggerStore;
class AliMUONVDigit;
class AliMUONVCluster;
class AliMUONLocalTrigger;
class AliMUONRegionalTrigger;
class AliMUONGlobalTrigger;


class AliMUONDataInterface : public TObject
{
public:
  
  AliMUONDataInterface(const char* filename="galice.root");
  virtual ~AliMUONDataInterface();
  
  Bool_t IsValid() const { return fIsValid; };

  void Open(const char* filename);

  Int_t NumberOfEvents() const;
  
  Int_t   CurrentEvent() const { return fCurrentEvent; }

  AliMUONVDigitStore* DigitStore(Int_t event);  
  AliMUONVClusterStore* ClusterStore(Int_t event);
  AliMUONVTriggerStore* TriggerStore(Int_t event, const char* treeLetter="R");

  void DumpClusters(Int_t event, Bool_t sorted=kTRUE)  { return DumpRecPoints(event,sorted); }
  void DumpRecPoints(Int_t event, Bool_t sorted=kTRUE);
  void DumpDigits(Int_t event, Bool_t sorted=kTRUE);
  void DumpTrigger(Int_t event, const char* treeLetter="R");  
  
  Bool_t GetEvent(Int_t event = 0);
  
  // Note the following methods can be extremely slow. Remember they are only
  // here for end user convenience for his/her small tests and macros.
  // If you want speed then don't use these methods. If you really want peak
  // performance then you should be talking to the AliRunLoader and Store
  // objects directly.
  Int_t NumberOfDigits(Int_t detElemId);
  AliMUONVDigit* Digit(Int_t detElemId, Int_t index);
  Int_t NumberOfDigits(Int_t chamber, Int_t cathode);
  AliMUONVDigit* Digit(Int_t chamber, Int_t cathode, Int_t index);
  Int_t NumberOfRawClusters(Int_t chamber);
  AliMUONVCluster* RawCluster(Int_t chamber, Int_t index);
  Int_t NumberOfLocalTriggers();
  AliMUONLocalTrigger* LocalTrigger(Int_t index);
  Int_t NumberOfRegionalTriggers();
  AliMUONRegionalTrigger* RegionalTrigger(Int_t index);
  AliMUONGlobalTrigger* GlobalTrigger();
  
private:

  enum IteratorType
  {
    kNoIterator,  
    kDigitIteratorByDetectorElement,  
    kDigitIteratorByChamberAndCathode,  
    kRawClusterIterator,  
    kLocalTriggerIterator,  
    kRegionalTriggerIterator  
  };
    
  void DumpSorted(const AliMUONVStore& store) const;

  Bool_t LoadEvent(Int_t event);

  void NtupleTrigger(const char* treeLetter);
  
  void ResetStores();
  
  TIterator* GetIterator(IteratorType type, Int_t x = 0, Int_t y = 0);
  void ResetIterator();
  
  Int_t CountObjects(TIterator* iter);
  TObject* FetchObject(TIterator* iter, Int_t index);
  
  AliMUONDataInterface(const AliMUONDataInterface& rhs);
  AliMUONDataInterface& operator=(const AliMUONDataInterface& rhs);
  
  
  AliLoader* fLoader; 
  AliMUONVDigitStore* fDigitStore; 
  AliMUONVTriggerStore* fTriggerStore; 
  AliMUONVClusterStore* fClusterStore; 
  Int_t fCurrentEvent; 
  TString fTreeLetter; 
  Bool_t fIsValid; 
  
  IteratorType fCurrentIteratorType;  
  Int_t fCurrentIndex;  
  Int_t fDataX; 
  Int_t fDataY; 
  TIterator* fIterator; 
  
  static Int_t fgInstanceCounter; 
  
  ClassDef(AliMUONDataInterface, 0)  // An easy to use interface to MUON reconstructed data
};
    

#endif // ALIMUONDATAINTERFACE_H