HLT/BASE/AliHLTOfflineInterface.h

   1 // -*- Mode: C++ -*-
   2 // $Id$
   3
   4 #ifndef ALIHLTOFFLINEINTERFACE_H
   5 #define ALIHLTOFFLINEINTERFACE_H
   6 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   7  * See cxx source for full Copyright notice                               */
   8
   9 /** @file   AliHLTOfflineInterface.h
  10     @author Matthias Richter
  11     @date
  12     @brief  the HLT interface to AliRoot
  13 */
  14
  15 // see below for class documentation
  16 // or
  17 // refer to README to build package
  18 // or
  19 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
  20
  21 #include <TObject.h>
  22 #include <TList.h>
  23
  24 class AliRunLoader;
  25 class AliRawReader;
  26 class AliESDEvent;
  27 class TTree;
  28
  29 /******************************************************************************/
  30
  31 /**
  32  * @class AliHLTOfflineInterface
  33  * The class implements the basic interface to the AliRoot objects during
  34  * reconstructions.
  35  * It serves as a base class for offline source and sink interface components
  36  * and provides access methods for the AliRunLoader, AliRawReader and AliESDEvent
  37  * objects. The AliRunLoader and the AliRawReader are fixed during one run,
  38  * while the AliESDEvent object will be changed from event to event.<br>
  39  * \em Note: The digits and clusters trees are not available through this
  40  * interface class as they are completetly detector (AliLoader) dependend.
  41  *
  42  * @note This class is only used for the @ref alihlt_system.
  43  *
  44  * @ingroup alihlt_system
  45  */
  46 class AliHLTOfflineInterface : public TObject {
  47  public:
  48   /** standard constructor */
  49   AliHLTOfflineInterface();
  50   /** constructor
  51    *  @param pRunLoader   pointer to AliRoot run loader
  52    *  @param pRawReader   pointer to AliRoot raw reader
  53    */
  54   AliHLTOfflineInterface(AliRunLoader* pRunLoader, AliRawReader* pRawReader);
  55   /** not a valid copy constructor, defined according to effective C++ style */
  56   AliHLTOfflineInterface(const AliHLTOfflineInterface&);
  57   /** not a valid assignment op, but defined according to effective C++ style */
  58   AliHLTOfflineInterface& operator=(const AliHLTOfflineInterface&);
  59   /** destructor */
  60   virtual ~AliHLTOfflineInterface();
  61
  62   /**
  63    * Get the AliRoot run loader.
  64    */
  65   AliRunLoader* GetRunLoader() const;
  66
  67   /**
  68    * Get the AliRoot raw reader
  69    */
  70   AliRawReader* GetRawReader() const;
  71
  72   /**
  73    * Set AliRoot ESD for the current event.
  74    */
  75   int SetESD(Int_t eventNo, AliESDEvent* pESD);
  76
  77   /**
  78    * Get the AliRoot ESD
  79    */
  80   AliESDEvent* GetESD() const;
  81
  82   /**
  83    * Set AliRoot external params.
  84    *
  85    * @param runLoader     the AliRoot runloader
  86    * @param rawReader     the AliRoot RawReader
  87    * @return neg. error code if failed
  88    */
  89   int SetParams(AliRunLoader* runLoader, AliRawReader* rawReader);
  90
  91   /**
  92    * Reset AliRoot internal params.
  93    */
  94   int Reset();
  95
  96   /**
  97    * Set AliRoot external params.
  98    * This method works on the global list.
  99    * @param runLoader     the AliRoot runloader
 100    * @param rawReader     the AliRoot RawReader
 101    * @return neg. error code if failed
 102    */
 103   static int SetParamsToComponents(AliRunLoader* runLoader, AliRawReader* rawReader);
 104
 105   /**
 106    * Fill ESD for one event.
 107    * Fill the ESD with the previously reconstructed data. It must be implmented
 108    * by the child class.
 109    * @param eventNo       event No. \em Note: this is an internal enumeration of the
 110    *                      processed events.
 111    * @param runLoader     the AliRoot runloader
 112    * @param esd           an AliESDEvent instance
 113    * @return neg. error code if failed
 114    */
 115   virtual int FillESD(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd)=0;
 116
 117   /**
 118    * Fill ESD for one event.
 119    * The FillESD method of all active AliHLTOfflineDataSink's is called in
 120    * order to fill the ESD with the previously reconstructed data. This method
 121    * works on the global list.
 122    * @param eventNo       event No. \em Note: this is an internal enumeration of the
 123    *                      processed events.
 124    * @param runLoader     the AliRoot runloader
 125    * @param esd           an AliESDEvent instance
 126    * @return neg. error code if failed
 127    */
 128   static int FillComponentESDs(int eventNo, AliRunLoader* runLoader, AliESDEvent* esd);
 129
 130   /**
 131    * Reset AliRoot internal params of all active components.
 132    * This method works on the global list.
 133    */
 134   static int ResetComponents();
 135
 136 protected:
 137   /**
 138    * Register an OfflineInterface.
 139    * @param me            instance of AliHLTOfflineInterface
 140    * @return neg. error code if failed
 141    */
 142   static int Register(AliHLTOfflineInterface* me);
 143
 144   /**
 145    * Unregister  an OfflineInterface.
 146    * @param me            instance of AliHLTOfflineInterface
 147    * @return neg. error code if failed
 148    */
 149   static int Unregister(AliHLTOfflineInterface* me);
 150
 151  private:
 152   /** global AliRoot run loader instance (for all components) */
 153   static AliRunLoader* fgpRunLoader;                              //! transient
 154   /** global AliRoot raw reader instance (for all components) */
 155   static AliRawReader* fgpRawReader;                              //! transient
 156
 157   /** private AliRoot run loader instance */
 158   AliRunLoader* fpRunLoader;                                      //! transient
 159   /** private AliRoot raw reader instance */
 160   AliRawReader* fpRawReader;                                      //! transient
 161   /** AliRoot HLT ESD instance */
 162   AliESDEvent* fpESD;                                                  //! transient
 163
 164   /** the list of active interfaces */
 165   static AliHLTOfflineInterface* fAnchor;                         //! transient
 166
 167   /** next element in the list */
 168   AliHLTOfflineInterface* fpNext;                                 //! transient
 169
 170   /** the current element */
 171   static AliHLTOfflineInterface* fCurrent;                        //! transient
 172
 173   /** number of interfaces */
 174   static int fCount;                                              //! see above
 175
 176   ClassDef(AliHLTOfflineInterface, 3);
 177 };
 178
 179 #endif