HLT/MUON/OfflineInterface/AliHLTMUONAgent.h

   1 #ifndef ALIHLTMUONAGENT_H
   2 #define ALIHLTMUONAGENT_H
   3 /* Copyright(c) 1998-2007, ALICE Experiment at CERN, All rights reserved. *
   4  * See cxx source for full Copyright notice                               */
   5
   6 // $Id$
   7
   8 ///
   9 /// @file   AliHLTMUONAgent.h
  10 /// @author Artur Szostak <artursz@iafrica.com>
  11 /// @date   28 May 2007
  12 /// @brief  The HLT module agent for libAliHLTMUON.so which interfaces HLT components with offline.
  13 ///
  14
  15 #include "AliHLTModuleAgent.h"
  16 class AliRunLoader;
  17 class AliHLTOUTHandlerChain;
  18 class AliHLTOUTHandlerIgnore;
  19
  20 /**
  21  * This module agent handles dimuon HLT module registration and configurations
  22  * within the AliRoot framework.
  23  */
  24 class AliHLTMUONAgent : public AliHLTModuleAgent
  25 {
  26 public:
  27         AliHLTMUONAgent();
  28
  29         virtual ~AliHLTMUONAgent();
  30
  31         // The following methods are all inherited from AliHLTModuleAgent:
  32
  33         UInt_t GetDetectorMask() const;
  34
  35         /**
  36          * Register all processing configurations belonging to the dimuon HLT
  37          * library with the AliHLTConfigurationHandler.
  38          * @param handler      the configuration handler
  39          * @param runloader    AliRoot runloader
  40          * @return Zero on success and error code if failed.
  41          */
  42         virtual int CreateConfigurations(
  43                         AliHLTConfigurationHandler* handler,
  44                         AliRawReader* rawReader=NULL,
  45                         AliRunLoader* runloader = NULL
  46                 ) const;
  47
  48         /**
  49          * Returns the top processing chain configurations for local event
  50          * reconstruction.
  51          * @param [in] runloader  AliRoot runloader
  52          * @return string containing the top configurations separated by blanks.
  53          */
  54         virtual const char* GetReconstructionChains(AliRawReader* rawReader=NULL,
  55                                             AliRunLoader* runloader = NULL) const;
  56
  57         /**
  58          * Component libraries which the configurations of this agent depend on.
  59          * @return list of component libraries as a blank-separated string.
  60          */
  61         virtual const char* GetRequiredComponentLibraries() const;
  62
  63         /**
  64          * Registers all available components of this module.
  65          * @param [in] pHandler  instance of the component handler.
  66          */
  67         virtual int RegisterComponents(AliHLTComponentHandler* pHandler) const;
  68
  69         /**
  70          * Get handler decription for dHLT data in the HLTOUT data stream.
  71          * @param [in]  dt        data type of the block
  72          * @param [in]  spec      specification of the block
  73          * @param [out] desc      handler description
  74          * @return 1 if the agent can provide a handler, 0 if not.
  75          */
  76         virtual int GetHandlerDescription(
  77                         AliHLTComponentDataType dt,
  78                         AliHLTUInt32_t spec,
  79                         AliHLTOUTHandlerDesc& desc
  80                 ) const;
  81
  82         /**
  83          * Get specific handler for dHLT data in the HLTOUT data stream.
  84          * @param [in] dt        data type of the block
  85          * @param [in] spec      specification of the block
  86          * @return pointer to handler
  87          */
  88         virtual AliHLTOUTHandler* GetOutputHandler(
  89                         AliHLTComponentDataType dt, AliHLTUInt32_t spec
  90                 );
  91
  92         /**
  93          * Delete an HLTOUT handler.
  94          * @param pInstance      pointer to handler
  95          */
  96         virtual int DeleteOutputHandler(AliHLTOUTHandler* pInstance);
  97
  98         /**
  99          * \returns true if a MUON module was added to gAlice.
 100          */
 101         static bool IsMuonModuleLoaded();
 102
 103         /**
 104          * \returns the flag indicating if the dHLT-rootify-and-dump chain should
 105          *    be run as a HLTOUT handler during reconstruction. The default is not
 106          *    to run this chain. The chain is used to convert HLT raw data blocks
 107          *    into ROOT objects, typically useful for testing and debugging.
 108          */
 109         static bool RunRootifyChain() { return fgRunRootifyChain; }
 110
 111         /**
 112          * Sets the flag indicating if the dHLT-rootify-and-dump chain should be
 113          * run during reconstruction.
 114          */
 115         static void RunRootifyChain(bool value) { fgRunRootifyChain = value; }
 116
 117 private:
 118         AliHLTMUONAgent(const AliHLTMUONAgent&);
 119         AliHLTMUONAgent& operator=(const AliHLTMUONAgent&);
 120
 121         // The following instance is used for automatic agent and component registration.
 122         static AliHLTMUONAgent fgkInstance;  ///< The single global instance of the dimuon HLT agent.
 123
 124         AliHLTOUTHandlerChain*  fgkESDMakerChain;  ///< Chain handler for converting dHLT raw data to ESD format.
 125         AliHLTOUTHandlerChain*  fgkRootifyDumpChain;  ///< Chain handler for converting dHLT raw data to ROOT objects and dumping to file.
 126         static AliHLTOUTHandlerIgnore fgkDataIgnoreHandler;  ///< HLTOUT handler for ignoring data blocks.
 127
 128         static Int_t fgMuonModuleLoaded; ///< Cached flag for indicating if the MUON module was loaded for a simulation.
 129         static bool fgRunRootifyChain; // Indicates if the dHLT-rootify-and-dump chain should be run.
 130
 131         ClassDef(AliHLTMUONAgent, 0); // Dimuon HLT module agent which handles processing configurations.
 132 };
 133
 134 #endif // ALIHLTMUONAGENT_H