Dropping references to AliMUONLocalTrigger which are depricated. This is a temporary...
[u/mrichter/AliRoot.git] / HLT / MUON / src / AliRoot / TriggerSource.hpp
index 73123c8fbd4fe49103137d489bb5180d8205c3ca..4cb85fefc017b3a2c8df2fa892d1cfb2616507f8 100644 (file)
@@ -5,8 +5,14 @@
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef dHLT_ALIROOT_TRIGGER_SOURCE_HPP
-#define dHLT_ALIROOT_TRIGGER_SOURCE_HPP
+/* AliHLTMUONTriggerSource is used to extract L0 trigger information for
+   the muon spectrometer from a simulated event stored in .root files by AliRoot.
+   It is used by the AliHLTMUONMicrodHLT class as a input data set for the
+   dHLT algorithm.
+ */
+
+#ifndef ALIHLTMUONTRIGGERSOURCE_H
+#define ALIHLTMUONTRIGGERSOURCE_H
 
 #include "TROOT.h"
 #include "TObject.h"
 #include "AliRoot/TriggerRecord.hpp"
 
 class AliMUON;
-class AliMUONLocalTrigger;
+//class AliMUONLocalTrigger;
 class AliMUONDataInterface;
 
 
-namespace AliMUONHLT
+class AliHLTMUONTriggerSource : public TObject
 {
+public:  // Unfortunately ROOT requires the following to be public.
+
+       class AliEventData : public TObject
+       {
+       public:
+               AliEventData();
+               AliEventData(Int_t eventnumber);
+               virtual ~AliEventData();
+               
+               Int_t& EventNumber() { return fEventNumber; }
+               TClonesArray& Blocks() { return fBlocks; }
+
+       private:
+       
+               Int_t fEventNumber;  // Event number in AliMUONDataInterface from which the triggers were taken.
+               TClonesArray fBlocks; // The list of blocks of trigger records.
+               
+               ClassDef(AliEventData, 1)  // Data per event.
+       };
 
 
-class TriggerSource : public TObject
-{
 public:
 
        enum AreaType
        {
-               FromWholePlane,
-               FromLeftHalfPlane,
-               FromRightHalfPlane
+               kFromWholePlane,
+               kFromLeftHalfPlane,
+               kFromRightHalfPlane
        };
        
        enum SourceType
        {
-               FromHits,
-               FromLocalTriggers
+               kFromHits,
+               kFromLocalTriggers
        };
 
 
-       TriggerSource();
+       AliHLTMUONTriggerSource();
        
        /* Creates a new trigger source object by filling data from the data interface.
         */
-       TriggerSource(AliMUONDataInterface* data);
+       AliHLTMUONTriggerSource(AliMUONDataInterface* data);
        
-       virtual ~TriggerSource();
+       virtual ~AliHLTMUONTriggerSource();
        
        /* Get and set methods to specify how the FillFrom methods should fill the
           internal data structures.
         */
-       void AreaToUse(const AreaType value) { fAreaToUse = value; };
+       void AreaToUse(AreaType value) { fAreaToUse = value; };
        AreaType AreaToUse() const { return fAreaToUse; };
-       void DataToUse(const SourceType value) { fDataToUse = value; };
+       void DataToUse(SourceType value) { fDataToUse = value; };
        SourceType DataToUse() const { return fDataToUse; };
-       void MaxBlockSize(const UInt_t value) { fMaxBlockSize = value; };
+       void MaxBlockSize(UInt_t value) { fMaxBlockSize = value; };
        UInt_t MaxBlockSize() const { return fMaxBlockSize; };
-       void UseLookupTable(const Bool_t value) { fUseLookupTable = value; };
+       void UseLookupTable(Bool_t value) { fUseLookupTable = value; };
        Bool_t UseLookupTable() const { return fUseLookupTable; };
        
        /* Fills the internal data structures from the specified data interface
@@ -69,7 +92,7 @@ public:
        /* Fills the internal data structures from the specified data interface
           for the given event.
         */
-       void FillFrom(AliMUONDataInterface* data, const Int_t event);
+       void FillFrom(AliMUONDataInterface* data, Int_t event);
        
        /* Fills the internal data structures from the specified data interface
           for the given event and trigger number.
@@ -83,12 +106,12 @@ public:
         */
        void FillFrom(
                        AliMUONDataInterface* data, 
-                       const Int_t event, const Int_t trigger, const Bool_t newblock = kFALSE
+                       Int_t event, Int_t trigger, Bool_t newblock = kFALSE
                );
 
        /* Clears all the internal arrays.
         */
-       void Clear();
+       virtual void Clear(Option_t* option = "");
        
        // Get methods.
        TString FileName()   const { return fFilename; };
@@ -98,14 +121,14 @@ public:
         */
        Int_t NumberOfEvents() const { return fEventList.GetEntriesFast(); };
        
-       /* Fetches the specified event number stored in this TriggerSource.
+       /* Fetches the specified event number stored in this AliHLTMUONTriggerSource.
           Sets the current block and trigger to the first block and trigger record in
           the event. If there are no blocks or trigger records then these pointers are
           set to NULL. kTRUE is returned if the event was found, kFALSE otherwise.
         */
-       Bool_t GetEvent(const Int_t eventnumber) const;
+       Bool_t GetEvent(Int_t eventnumber) const;
        
-       /* Fetches the first event stored in this TriggerSource.
+       /* Fetches the first event stored in this AliHLTMUONTriggerSource.
           Sets the current block and trigger record to the first block and trigger
           in the event. If there are no blocks or trigger records then these pointers
           are set to NULL. kTRUE is returned if the event was found, kFALSE otherwise.
@@ -137,7 +160,7 @@ public:
           If there are no trigger records then this pointer is set to NULL.
           kTRUE is returned if the block was found, kFALSE otherwise.
         */
-       Bool_t GetBlock(const Int_t index) const;
+       Bool_t GetBlock(Int_t index) const;
        
        /* Fetches the first block in the current event.
           Sets the current trigger record to the first trigger in the block.
@@ -169,12 +192,12 @@ public:
           the current block.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetTrigger(const Int_t triggernumber) const;
+       const AliHLTMUONTriggerRecord* GetTrigger(Int_t triggernumber) const;
        
        /* Fetches the first trigger record in the current block.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetFirstTrigger() const;
+       const AliHLTMUONTriggerRecord* GetFirstTrigger() const;
        
        /* Returns kTRUE if there are more triggers to iterate over.
         */
@@ -183,12 +206,12 @@ public:
        /* Fetches the next trigger record in the current block.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetNextTrigger() const;
+       const AliHLTMUONTriggerRecord* GetNextTrigger() const;
        
        /* Returns the current trigger record.
           NULL is returned if the record was not found.
         */
-       const TriggerRecord* GetTrigger() const { return fCurrentTrigger; };
+       const AliHLTMUONTriggerRecord* GetTrigger() const { return fCurrentTrigger; };
        
        /* Returns the trigger record number for the currently selected trigger record.
           This number corresponds to the index'th AliMUONLocalTrigger object for the
@@ -200,10 +223,10 @@ public:
 
 private:
 
-       /* Adds a new EventData block to the fEventList and updates the fCurrentEvent,
+       /* Adds a new AliEventData block to the fEventList and updates the fCurrentEvent,
           fCurrentBlock and fCurrentTrigger pointers.
         */ 
-       void AddEvent(const Int_t eventnumber);
+       void AddEvent(Int_t eventnumber);
        
        /* Adds a new block to the current event and updates fCurrentBlock and fCurrentTrigger.
         */
@@ -212,9 +235,9 @@ private:
        /* Adds a new trigger record to the current event and block.
           The fCurrentTrigger is updated appropriately.
         */
-       void AddTrigger(const TriggerRecord& data);
+       void AddTrigger(const AliHLTMUONTriggerRecord& data);
        
-       /* Checks if the file and folder names correspond to this TriggerSource's 
+       /* Checks if the file and folder names correspond to this AliHLTMUONTriggerSource's 
           file and folder names. kTRUE is returned if they do.
           If the file and folder names are empty then they are assigned the names
           as found in the data interface and kTRUE is returned.
@@ -225,40 +248,43 @@ private:
           It is assumed that FileAndFolderOk(data) returns true just before calling
           this method.
         */
-       void AddEventFrom(AliMUONDataInterface* data, AliMUON* module, const Int_t event);
+       void AddEventFrom(AliMUONDataInterface* data, AliMUON* module, Int_t event);
        
        /* Adds the specified trigger record from the given data interface.
           The data interface should be initialised correctly, that is the event
           should already be selected before calling this method.
         */
-       void AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module, const Int_t trigger);
+       void AddTriggerFrom(AliMUONDataInterface* data, AliMUON* module, Int_t trigger);
        
        /* Checks to see if the specified trigger record is in the chamber region
           we want to fill from.
           kTRUE is returned if (x, y) is in the region, and kFALSE otherwise.
         */
-       Bool_t InFillRegion(const TriggerRecord& data);
+       Bool_t InFillRegion(const AliHLTMUONTriggerRecord& data) const;
        
        /* Fills the trigger data from the AliMUONLocalTrigger object.
           if the fUseLookupTable is set to true then we use the L0 lookup table to
           fill the Pt value otherwise we use the PtCal method in AliMUONTriggerCircuit.
           Note the fTriggerNumber parameter is not filled in to 'record'.
+          THIS METHOD IS DEPRICATED
         */
+/*
        void FillTriggerFromLocalTrigger(
-                       AliMUONLocalTrigger* trigger, AliMUON* module, TriggerRecord& record
+                       AliMUONLocalTrigger* trigger, AliMUON* module, AliHLTMUONTriggerRecord& record
                );
+*/
        
        /* Fills the TriggerRecord structure from AliMUONHit objects.
           The hits on the last 4 chambers are used (i.e. chambers 11 to 14).
           kTRUE is returned if the structure was filled successfully.
         */
-       Bool_t FillTriggerFromHits(AliMUONDataInterface* data, const Int_t track, TriggerRecord& record);
+       Bool_t FillTriggerFromHits(AliMUONDataInterface* data, Int_t track, AliHLTMUONTriggerRecord& record);
        
        /* Fetches the AliMUON module from the AliRun global object. AliRun will be loaded
           by the runloader if it has not yet been loaded. In such a case the AliRun object
           will also we unloaded when we are done with it.
           kTRUE is returned if no error occured and kFALSE otherwise.
-          Note that if fDataToUse is set to FromHits then gAlice is not loaded and 'module'
+          Note that if fDataToUse is set to kFromHits then gAlice is not loaded and 'module'
           will be left untouched. The method will still return kTRUE however since this is
           not an error. We do not need the AliMUON module when filling from hits.
         */
@@ -284,22 +310,21 @@ private:
        void ResetTriggerPointers() const;
 
 
-public:  // Unfortunately ROOT requires the following to be public.
+       // Do not allow copying of this object.
+       AliHLTMUONTriggerSource(const AliHLTMUONTriggerSource& /*object*/)
+               : TObject(),
+                 fAreaToUse(kFromWholePlane), fDataToUse(kFromLocalTriggers),
+                 fMaxBlockSize(0xFFFFFFFF), fUseLookupTable(kTRUE),
+                 fFilename(""), fFoldername(""),
+                 fEventIndex(-1), fCurrentEvent(NULL),
+                 fBlockIndex(-1), fCurrentBlock(NULL),
+                 fTriggerIndex(-1), fCurrentTrigger(NULL),
+                 fEventList(AliHLTMUONTriggerSource::AliEventData::Class()),
+                 fHadToLoadgAlice(kFALSE)
+       {}
 
-       class EventData : public TObject
-       {
-       public:
-               EventData();
-               EventData(const Int_t eventnumber);
-               virtual ~EventData();
+       AliHLTMUONTriggerSource& operator = (const AliHLTMUONTriggerSource& /*object*/) { return *this; }
 
-               Int_t fEventNumber;  // Event number in AliMUONDataInterface from which the triggers were taken.
-               TClonesArray fBlocks; // The list of blocks of trigger records.
-               
-               ClassDef(EventData, 1)  // Data per event.
-       };
-       
-private:
 
        AreaType fAreaToUse;    //! The part of the chamber to fill from.
        SourceType fDataToUse;  //! The type of raw AliRoot data to fill from.
@@ -310,20 +335,18 @@ private:
        TString fFoldername;  // The folder name from which trigger data was taken.
        
        mutable Int_t fEventIndex;               //! The index number of the currently selected event.
-       mutable EventData* fCurrentEvent;        //! Pointer to the currently selected event.
+       mutable AliEventData* fCurrentEvent;     //! Pointer to the currently selected event.
        mutable Int_t fBlockIndex;               //! The index number of the currently selected block.
        mutable TClonesArray* fCurrentBlock;     //! Pointer to the currently selected block.
        mutable Int_t fTriggerIndex;             //! The index number of the currently selected trigger record.
-       mutable TriggerRecord* fCurrentTrigger;  //! Pointer to the currently selected trigger record.
+       mutable AliHLTMUONTriggerRecord* fCurrentTrigger;  //! Pointer to the currently selected trigger record.
 
        TClonesArray fEventList;   // List of trigger records per event.
        
        Bool_t fHadToLoadgAlice;  //! Flag indicating if this object had to load the AliRun object.
 
-       ClassDef(TriggerSource, 1)  // The source of trigger records for dHLT.
+       ClassDef(AliHLTMUONTriggerSource, 1)  // The source of trigger records for dHLT.
 };
 
 
-} // AliMUONHLT
-
-#endif // dHLT_ALIROOT_TRIGGER_SOURCE_HPP
+#endif // ALIHLTMUONTRIGGERSOURCE_H