Update master to aliroot
[u/mrichter/AliRoot.git] / 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