Adding AliHLTMUONTrack object to store ROOTified internal dHLT track data in new...
[u/mrichter/AliRoot.git] / HLT / MUON / OfflineInterface / AliHLTMUONRootifierComponent.h
1 #ifndef ALIHLTMUONROOTIFIERCOMPONENT_H
2 #define ALIHLTMUONROOTIFIERCOMPONENT_H
3 /* This file is property of and copyright by the ALICE HLT Project        *
4  * ALICE Experiment at CERN, All rights reserved.                         *
5  * See cxx source for full Copyright notice                               */
6
7 // $Id$
8
9 ///
10 /// @file   AliHLTMUONRootifierComponent.h
11 /// @author Artur Szostak <artursz@iafrica.com>
12 /// @date   29 Sep 2007
13 /// @brief  Component for converting dHLT raw data into ROOT objects.
14 ///
15
16 #include "AliHLTMUONProcessor.h"
17
18 class AliHLTMUONEvent;
19 class AliHLTMUONMansoTrack;
20 class AliHLTMUONTrack;
21 extern "C" struct AliHLTMUONMansoTrackStruct;
22
23 /**
24  * \class AliHLTMUONRootifierComponent
25  * \brief Converts dHLT raw data blocks into ROOT objects.
26  *
27  * This component class is used to convert all internal raw dHLT data blocks into
28  * ROOT object that can be stored in '.root' files in a platform independant manner.
29  * This can also make some of the analysis easier because the dHLT internal data
30  * will be available in TObjects.
31  *
32  * <h2>General properties:</h2>
33  *
34  * Component ID: \b MUONRootifier <br>
35  * Library: \b libAliHLTMUON.so <br>
36  * Input Data Types:  kAliHLTAnyDataType = "*******:***" <br>
37  * Output Data Types: AliHLTMUONConstants::RootifiedEventDataType() = "ROOTEVNT:MUON" <br>
38  *
39  * <h2>Mandatory arguments:</h2>
40  * None.
41  *
42  * <h2>Optional arguments:</h2>
43  * \li -warn_on_unexpected_block <br>
44  *      This will cause the component to generate warnings when it receives data block
45  *      types it does not know how to handle. Without this option the component only
46  *      generates debug messages when they are compiled in. <br>
47  * \li -dumponerror <br>
48  *      This flag will cause the component to dump the data blocks it received if
49  *      an error occurs during the processing of an event. <br>
50  * \li -dumppath <i>path</i> <br>
51  *      Allows one to specify the path in which to dump the received data blocks
52  *      if an error occurs. <br>
53  *
54  * <h2>Standard configuration:</h2>
55  * There is no special configuration for this component.
56  *
57  * <h2>Default CDB entries:</h2>
58  * None.
59  *
60  * <h2>Performance:</h2>
61  * A few milliseconds per event.
62  *
63  * <h2>Memory consumption:</h2>
64  * A few MBytes.
65  *
66  * <h2>Output size:</h2>
67  * A few kBytes.
68  *
69  * @ingroup alihlt_dimuon_component
70  */
71 class AliHLTMUONRootifierComponent : public AliHLTMUONProcessor
72 {
73 public:
74
75         AliHLTMUONRootifierComponent();
76         virtual ~AliHLTMUONRootifierComponent();
77         
78         virtual const char* GetComponentID();
79
80         virtual void GetInputDataTypes(AliHLTComponentDataTypeList& list);
81         virtual AliHLTComponentDataType GetOutputDataType();
82         virtual int GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList);
83         virtual void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier);
84
85         virtual AliHLTComponent* Spawn();
86
87 protected:
88
89         virtual int DoInit(int argc, const char** argv);
90         virtual int DoDeinit();
91         virtual int DoEvent(const AliHLTComponentEventData& evtData, AliHLTComponentTriggerData& trigData);
92         virtual bool IgnoreArgument(const char* arg) const;
93         using AliHLTProcessor::DoEvent;
94         
95 private:
96
97         // Prevent copying of these objects.
98         AliHLTMUONRootifierComponent(const AliHLTMUONRootifierComponent& /*object*/);
99         AliHLTMUONRootifierComponent& operator = (const AliHLTMUONRootifierComponent& /*object*/);
100         
101         /**
102          * This method creates a AliHLTMUONMansoTrack object from the track structure
103          * and adds it to the dHLT event object.
104          * \param event  The dHLT event object.
105          * \param track  The track structure to convert and add to the event.
106          */
107         AliHLTMUONMansoTrack* AddTrack(AliHLTMUONEvent& event, const AliHLTMUONMansoTrackStruct& track);
108         
109         /**
110          * This method creates a AliHLTMUONTrack object from the given track structure
111          * and adds it to the dHLT event object.
112          * \param event  The dHLT event object.
113          * \param track  The track structure to convert and add to the event.
114          */
115         AliHLTMUONTrack* AddTrack(AliHLTMUONEvent& event, const AliHLTMUONTrackStruct& track);
116         
117         bool fWarnForUnexpecedBlock;  /// Flag indicating if we should log a warning if we got a block of an unexpected type.
118
119         ClassDef(AliHLTMUONRootifierComponent, 0); // Converter component of dHLT raw data.
120 };
121
122 #endif // ALIHLTMUONROOTIFIERCOMPONENT_H