Bugfix for https://savannah.cern.ch/bugs/?97755
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCClusterAccessHLTOUT.h
1 //-*- Mode: C++ -*-
2 // $Id$
3 #ifndef ALIHLTTPCCLUSTERACCESSHLTOUT_H
4 #define ALIHLTTPCCLUSTERACCESSHLTOUT_H
5 //* This file is property of and copyright by the ALICE Project            * 
6 //* ALICE Experiment at CERN, All rights reserved.                         *
7 //* See cxx source for full Copyright notice                               *
8
9 /// @file   AliHLTTPCClusterAccessHLTOUT.h
10 /// @author Matthias Richter
11 /// @date   2011-06-06
12 /// @brief  Interface to HLT TPC clusters
13 ///
14
15 #include "TObject.h"
16 #include "AliHLTDataTypes.h"
17 #include "AliHLTTPCClusterMCData.h"
18 #include "AliHLTTPCRawCluster.h"
19 #include <map>
20
21 class AliTPCParam;
22 class AliTPCClustersRow;
23 class AliTPCclusterMI;
24 class AliHLTOUT;
25 class TClonesArray;
26 class AliHLTTPCDataCompressionDecoder;
27
28 /**
29  * @class AliHLTTPCClusterAccessHLTOUT
30  * Generator for TPC cluster array from HLT TPC clusters in the HLTOUT
31  * data stream. It uses the TObject method interface. Combined with dynamic
32  * loading, any cross dependency between the TPC code and HLT libraries
33  * can be avoided.
34  *
35  * Creating the instance: 
36  * The class is implemented in libAliHLTTPC.so and can be loaded
37  * through the TClass interface (you might want to add
38  * further error messages on the various error conditions).
39  * <pre>
40  *     TObject* pClusterAccess=NULL;
41  *     TClass* pCl=NULL;
42  *     ROOT::NewFunc_t pNewFunc=NULL;
43  *     do {
44  *       pCl=TClass::GetClass("AliHLTTPCClusterAccessHLTOUT");
45  *     } while (!pCl && gSystem->Load("libAliHLTTPC.so")==0);
46  *     if (pCl && (pNewFunc=pCl->GetNew())!=NULL) {
47  *       void* p=(*pNewFunc)(NULL);
48  *       if (p) {
49  *         pClusterAccess=reinterpret_cast<TObject*>(p);
50  *       }
51  *     }
52  * </pre>
53  * 
54  * Usage:
55  * TObject::Execute can be used to execute commands. Command 'read'
56  * will get hold on the HLTOUT data and read the clusters. The const char*
57  * parameter 'param' is used to select the region.
58  * - param="sector=sectorno"
59  * 'sectorno' specifies sector number in the offline code, range 0 and 71,
60  * enumerating first the 36 inner (partitions 0+1)  and then 36 outer sectors
61  * (partitions 2-5).<br>
62  * If the error pointer parameter is provided the result code is returned
63  * - >=0 success, number of clusters
64  * - -ENODATA  no data in HLTOUT
65  * - -EINVAL   invalid parameter/argument
66  * - -ENOMEM   memory allocation failed
67  * - -EACCESS  no access to HLTOUT
68  * - -NODEV    internal error, can not get AliHLTSystem
69  * - -ENOBUFS  internal error, can not get cluster array
70  * 
71  * Command 'verbosity=level' sets the verbositylevel which is default 0
72  * (no info output).
73  *
74  * <pre>
75  *     pClusterAccess->Execute("read", param);
76  *     TObject* pClusterAccess->FindObject("clusterarray");
77  * </pre>
78  *
79  * After processing the loop of sectors, the instance should be cleaned.
80  * <pre>
81  *     pClusterAccess->Clear("event");
82  * </pre>
83  * 
84  * @ingroup alihlt_tpc
85  */
86 class AliHLTTPCClusterAccessHLTOUT : public TObject
87 {
88  public:
89   /** standard constructor */
90   AliHLTTPCClusterAccessHLTOUT();
91   /** destructor */
92   ~AliHLTTPCClusterAccessHLTOUT();
93
94   /// inherited from TObject: abstract command interface
95   virtual void        Execute(const char *method,  const char *params, Int_t *error=0);
96
97   /// inherited from TObject: return the cluster array if name id "clusterarray"
98   virtual TObject    *FindObject(const char *name) const;
99
100   /// inherited from TObject: supports writing of data to AliTPCClustersRow
101   virtual void Copy(TObject &object) const;
102
103   /// inherited from TObject: cleanup
104   virtual void        Clear(Option_t * option ="");
105
106   /// inherited from TObject
107   virtual void        Print(Option_t *option="") const;
108
109   /// process the cluster data block of various formats from HLTOUT
110   int ProcessClusters(const char* params);
111
112   /// helper struct to store cluster in a map together with MC info
113   struct AliRawClusterEntry {
114     AliRawClusterEntry() : fCluster(), fMC() {}
115     AliRawClusterEntry(const AliRawClusterEntry& other) : fCluster(other.fCluster), fMC(other.fMC) {}
116     AliRawClusterEntry& operator=(const AliRawClusterEntry& other) {
117       if (&other==this) return *this;
118       fCluster=other.fCluster; fMC=other.fMC;
119       return *this;
120     }
121     AliHLTTPCRawCluster fCluster; //! cluster
122     AliHLTTPCClusterMCLabel fMC; //! MC labels 
123   };
124   
125   typedef vector<AliRawClusterEntry> AliRawClusterEntryVector;
126
127   /**
128    * @class AliRawClusterContainer
129    * Cluster read interface for offline.
130    * The class implements the interface to be used in the decoding
131    * of compressed TPC data.
132    */
133   class AliRawClusterContainer {
134   public:
135     AliRawClusterContainer();
136     virtual ~AliRawClusterContainer();
137
138     struct AliClusterIdBlock {
139       AliClusterIdBlock() : fIds(NULL), fSize(0) {}
140       AliHLTUInt32_t* fIds; //!
141       AliHLTUInt32_t  fSize; //!
142     };
143
144     class iterator {
145     public:
146       iterator() : fClusterNo(-1), fData(NULL), fEntry(NULL), fRowOffset(0) {}
147       iterator(AliRawClusterContainer* pData) : fClusterNo(-1), fData(pData), fEntry(NULL), fRowOffset(0) {}
148       iterator(const iterator& other) : fClusterNo(other.fClusterNo), fData(other.fData), fEntry(other.fEntry), fRowOffset(other.fRowOffset) {}
149       iterator& operator=(const iterator& other) {
150         if (this==&other) return *this;
151         fClusterNo=other.fClusterNo; fData=other.fData; fEntry=other.fEntry; fRowOffset=other.fRowOffset; return *this;
152       }
153       ~iterator() {}
154
155       void SetPadRow(int row)          {if (fEntry ) fEntry->fCluster.SetPadRow(row-fRowOffset);}
156       void SetPad(float pad)           {if (fEntry ) fEntry->fCluster.SetPad(pad);}
157       void SetTime(float time)         {if (fEntry ) fEntry->fCluster.SetTime(time);}
158       void SetSigmaY2(float sigmaY2)   {if (fEntry ) fEntry->fCluster.SetSigmaY2(sigmaY2);}
159       void SetSigmaZ2(float sigmaZ2)   {if (fEntry ) fEntry->fCluster.SetSigmaZ2(sigmaZ2);}
160       void SetCharge(unsigned charge)  {if (fEntry ) fEntry->fCluster.SetCharge(charge);}
161       void SetQMax(unsigned qmax)      {if (fEntry ) fEntry->fCluster.SetQMax(qmax);}
162       void SetMC(const AliHLTTPCClusterMCLabel* pMC) {
163         if (fEntry && pMC ) fEntry->fMC=*pMC;
164       }
165
166       // switch to next cluster
167       iterator& Next(int slice, int partition);
168
169     private:
170
171       static const Int_t fkRowOffsetOuterSector; //! transient
172
173       int fClusterNo; //! cluster no in the current block
174       AliRawClusterContainer* fData; //! pointer to actual data
175       AliRawClusterEntry* fEntry; //! pointer to current cluster
176       int fRowOffset;  //! row offset for current partition      
177     };
178
179     /// iterator of remaining clusters block of specification
180     iterator& BeginRemainingClusterBlock(int count, AliHLTUInt32_t specification);
181     /// iterator of track model clusters
182     iterator& BeginTrackModelClusterBlock(int count);
183
184     /// internal cleanup
185     virtual void  Clear(Option_t * option="");
186     /// get the cluster array for a sector
187     TObjArray* GetSectorArray(unsigned sector) const;
188     /// fill the cluster array for a sector and specific row if specified
189     int FillSectorArray(TClonesArray* pSectorArray, unsigned sector, int row=-1) const;
190     /// print info
191     virtual void Print(Option_t *option=NULL) const;
192
193   protected:
194     /// load next cluster from array of the sepcific sector
195     AliRawClusterEntry* NextCluster(int slice, int partition);
196
197   private:
198     /// copy constructor prohibited
199     AliRawClusterContainer(const AliRawClusterContainer&);
200     /// assignment operator prohibited
201     AliRawClusterContainer& operator=(const AliRawClusterContainer&);
202
203     vector<AliRawClusterEntryVector*> fClusterMaps; //! cluster pointer vectors per sector (offline notation 0-71)
204     TClonesArray* fSectorArray; //! current sector array of clusters provided to caller
205     iterator fIterator; //!
206   };
207
208  private:
209   /// copy constructor prohibited
210   AliHLTTPCClusterAccessHLTOUT(const AliHLTTPCClusterAccessHLTOUT&);
211   /// assignment operator prohibited
212   AliHLTTPCClusterAccessHLTOUT& operator=(const AliHLTTPCClusterAccessHLTOUT&);
213
214   enum EOptions {
215     // skip the track clusters
216     kSkipTrackClusters = BIT(15),
217     // skip the partition (remaining) clusters
218     kSkipPartitionClusters = BIT(16)
219   };
220
221   int fVerbosity; //! verbosity level
222   AliRawClusterContainer* fClusters; //! cluster container
223   int fCurrentSector; //! current sector
224   AliHLTTPCDataCompressionDecoder* fpDecoder; //! decoder instance
225   AliTPCParam* fTPCParam; //! pointer to TPC param
226
227   ClassDef(AliHLTTPCClusterAccessHLTOUT, 0)
228 };
229 #endif