doing backward compatibility correctly
[u/mrichter/AliRoot.git] / HLT / rec / AliHLTEsdManager.h
1 //-*- Mode: C++ -*-
2 // $Id$
3
4 #ifndef ALIHLTESDMANAGER_H
5 #define ALIHLTESDMANAGER_H
6 //* This file is property of and copyright by the ALICE HLT Project        * 
7 //* ALICE Experiment at CERN, All rights reserved.                         *
8 //* See cxx source for full Copyright notice                               *
9
10 /** @file   AliHLTEsdManager.h
11     @author Matthias Richter
12     @date   
13     @brief  Manager for merging and writing of HLT ESDs
14 */
15
16 #include "AliHLTDataTypes.h"
17 #include "AliHLTLogging.h"
18 #include "TString.h"
19 #include <vector>
20
21 class AliESDEvent;
22 class TTree;
23 class TFile;
24
25 /**
26  * @class AliHLTEsdManager
27  * Tool to write and merge HLT ESD objects.
28  *
29  * HLT components can produce ESD output. The ESD objects are sent via
30  * a TMessage like mechanism as part of the HLTOUT data. This class retrieves
31  * streamed AliESDEvent objects from an HLT output block. An ESD object can be
32  * copied to a global ESD provided by the caller or to files. The name of the
33  * ROOT files follows the scheme AliHLTDETESDs.root where DET denotes a detector.
34  * E.g. the ESD from a data block of type {ESD_TREE,TPC} will be added to the
35  * file AliHLTTPCESDs.root.
36  *
37  * @ingroup alihlt_out
38  */
39 class AliHLTEsdManager : public AliHLTLogging {
40  public:
41   /** constructor */
42   AliHLTEsdManager();
43   /** destructor */
44   virtual ~AliHLTEsdManager();
45
46   /**
47    * Convert data buffer to ESD.
48    * The buffer is supposed to describe a streamed AliESDEvent object.
49    * If no target object is specified, the ESD is written to a file AliHLTdetESDs.root,
50    * where 'det' is derived from the data type origin. Each time the function is invoked
51    * a new event is created. Dummy events are added if the previous events did not contain
52    *
53    * @param pBuffer  [in] the data buffer
54    * @param size     [in] data buffer size
55    * @param dt       [in] data type of the block
56    * @param tgtesd   [out] optional target
57    * @param eventno  [in] optional event no
58    */
59   int WriteESD(const AliHLTUInt8_t* pBuffer, AliHLTUInt32_t size, AliHLTComponentDataType dt,
60                AliESDEvent* tgtesd=NULL, int eventno=-1);
61
62   /**
63    * Align all ESD to the same number of events.
64    * The function adds empty events to all ESD files if their event number
65    * does not match the specified one.
66    * @param eventno     the desired event no
67    * @return neg. error code if failed
68    */
69   int PadESDs(int eventno);
70
71   /**
72    * Set the target directory for the ESD files.
73    */
74   void SetDirectory(const char* directory);
75
76   /**
77    * Get the list of the internally created files.
78    * Returns a blank separated list of the file names.
79    */
80   TString GetFileNames(AliHLTComponentDataType dt=kAliHLTAnyDataType) const;
81
82   /**
83    * Embed an ESD into a TTree object.
84    * The tree object needs to be deleted by the caller.
85    */
86   static TTree* EmbedIntoTree(AliESDEvent* pESD, const char* name="esdTree", const char* title="Tree with HLT ESD objects");
87
88  protected:
89
90  private:
91   /** copy constructor prohibited */
92   AliHLTEsdManager(const AliHLTEsdManager&);
93   /** assignment operator prohibited */
94   AliHLTEsdManager& operator=(const AliHLTEsdManager&);
95
96   class AliHLTEsdListEntry : public AliHLTLogging {
97   public:
98     /** constructor */
99     AliHLTEsdListEntry(AliHLTComponentDataType dt);
100     /** destructor */
101     ~AliHLTEsdListEntry();
102
103     /**
104      * Write the ESD to the corresponding file.
105      * The tree is first synchronized with the eventno and additional empty
106      * events might be inserted if there was a gap. Since we are writing
107      * several files in parallel, we have to make sure that those files contain
108      * the same number of events.
109      * @param pESD        ESD to write
110      * @param eventno     optional event no for tree synchronization
111      */
112     int WriteESD(AliESDEvent* pESD, int eventno=-1);
113
114     /**
115      * Set the target directory for the ESD file.
116      */
117     void SetDirectory(const char* directory);
118
119     /**
120      * Delete the ESD file.
121      */
122     void Delete();
123
124     /**
125      * Get name of the ESD file.
126      */
127     const char* GetFileName() const;
128
129     bool operator==(AliHLTComponentDataType dt) const;
130
131   private:
132     /** copy constructor prohibited */
133     AliHLTEsdListEntry(const AliHLTEsdListEntry& src);
134     /** assignment operator prohibited */
135     AliHLTEsdListEntry& operator=(const AliHLTEsdListEntry& src);
136
137     /**
138      * Write ESD to temporary file.
139      * The ESD is embedded into a tree and saved to a temporary file.
140      * The file name is retrieved by TSystem::GetTempFileName and returned
141      * on success.
142      * @return file name, empty on failure
143      */
144     TString WriteTempFile(AliESDEvent* pESD) const;
145
146     /** root file name */
147     TString fName; //!transient
148     /** target directory */
149     TString fDirectory; //!transient
150     /** data type of the corresponding block */
151     AliHLTComponentDataType fDt; //!transient
152     /** the root file for this esd */
153     TFile* fpFile; //!transient
154     /** the tree for this esd */
155     TTree* fpTree; //!transient
156     /** the esd to fill into the tree */
157     AliESDEvent* fpEsd; //!transient
158   };
159
160   typedef vector<AliHLTEsdListEntry*> AliHLTEsdPList;
161
162   /**
163    * Find list entry for given data type
164    */
165   AliHLTEsdListEntry* Find(AliHLTComponentDataType dt) const;
166
167   /** the list of the ESDs */
168   AliHLTEsdPList fESDs; //!transient
169
170   /** target directory */
171   TString fDirectory; //!transient
172
173   ClassDef(AliHLTEsdManager, 1)
174 };
175
176 #endif