Line data Source code
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 0 : 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 0 : 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 6 : ClassDef(AliHLTMUONAgent, 0); // Dimuon HLT module agent which handles processing configurations.
132 : };
133 :
134 : #endif // ALIHLTMUONAGENT_H
|
