implementing association of cluster MC labels and cluster ids to the unpacked cluster...
[u/mrichter/AliRoot.git] / HLT / TPCLib / comp / AliHLTTPCDataCompressionDecoder.cxx
1 // $Id$
2 //**************************************************************************
3 //* This file is property of and copyright by the ALICE HLT Project        * 
4 //* ALICE Experiment at CERN, All rights reserved.                         *
5 //*                                                                        *
6 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
7 //*                  for The ALICE HLT Project.                            *
8 //*                                                                        *
9 //* Permission to use, copy, modify and distribute this software and its   *
10 //* documentation strictly for non-commercial purposes is hereby granted   *
11 //* without fee, provided that the above copyright notice appears in all   *
12 //* copies and that both the copyright notice and this permission notice   *
13 //* appear in the supporting documentation. The authors make no claims     *
14 //* about the suitability of this software for any purpose. It is          *
15 //* provided "as is" without express or implied warranty.                  *
16 //**************************************************************************
17
18 /// @file   AliHLTTPCDataCompressionDecoder.cxx
19 /// @author Matthias Richter
20 /// @date   2011-10-04
21 /// @brief  Generic decoder class for compressed TPC data, works on a container
22 ///         class implementation which fills the actual target data struct
23
24 #include "AliHLTTPCDataCompressionDecoder.h"
25 #include "AliHLTDataInflaterSimple.h"
26 #include "AliHLTDataInflaterHuffman.h"
27 #include "TList.h"
28 #include <memory>
29
30 ClassImp(AliHLTTPCDataCompressionDecoder)
31
32 AliHLTTPCDataCompressionDecoder::AliHLTTPCDataCompressionDecoder()
33   : fPadShift(0.)
34   , fVerbosity(0)
35   , fpDataInflaterPartition(NULL)
36   , fpDataInflaterTrack(NULL)
37   , fpClusterMerger(NULL)
38   , fRemainingClusterIds()
39   , fTrackModelClusterIds()
40   , fCurrentClusterIds(NULL)
41   , fClusterMCData()
42 {
43   /// constructor
44 }
45
46 AliHLTTPCDataCompressionDecoder::~AliHLTTPCDataCompressionDecoder()
47 {
48   ///destructor
49   if (fpDataInflaterPartition) delete fpDataInflaterPartition;
50   fpDataInflaterPartition=NULL;
51   if (fpDataInflaterTrack) delete fpDataInflaterTrack;
52   fpDataInflaterTrack=NULL;
53   if (fpClusterMerger) delete fpClusterMerger;
54   fpClusterMerger=NULL;
55 }
56
57 AliHLTDataInflater* AliHLTTPCDataCompressionDecoder::CreateInflater(int deflater, int mode) const
58 {
59   // create the inflater for the specified mode
60   vector<AliHLTTPCDefinitions::AliClusterParameterId_t> parameterids;
61   switch (mode) {
62   case 1:
63     parameterids.push_back(AliHLTTPCDefinitions::kPadRow );
64     parameterids.push_back(AliHLTTPCDefinitions::kPad    );
65     parameterids.push_back(AliHLTTPCDefinitions::kTime   );
66     parameterids.push_back(AliHLTTPCDefinitions::kSigmaY2);
67     parameterids.push_back(AliHLTTPCDefinitions::kSigmaZ2);
68     parameterids.push_back(AliHLTTPCDefinitions::kCharge );
69     parameterids.push_back(AliHLTTPCDefinitions::kQMax   );
70     break;
71   case 2:
72     parameterids.push_back(AliHLTTPCDefinitions::kResidualPad );
73     parameterids.push_back(AliHLTTPCDefinitions::kResidualTime);
74     parameterids.push_back(AliHLTTPCDefinitions::kSigmaY2);
75     parameterids.push_back(AliHLTTPCDefinitions::kSigmaZ2);
76     parameterids.push_back(AliHLTTPCDefinitions::kCharge );
77     parameterids.push_back(AliHLTTPCDefinitions::kQMax   );
78     break;
79   default:
80     HLTError("invalid mode %d for inflater initialization", mode);
81   }
82
83   switch (deflater) {
84   case 1:
85     {
86       std::auto_ptr<AliHLTDataInflaterSimple> inflatersimple(new AliHLTDataInflaterSimple);
87       if (!inflatersimple.get()) return NULL;
88       for (vector<AliHLTTPCDefinitions::AliClusterParameterId_t>::const_iterator id=parameterids.begin();
89            id!=parameterids.end(); id++) {
90         const AliHLTTPCDefinitions::AliClusterParameter& parameter=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[*id];
91         if (inflatersimple->AddParameterDefinition(parameter.fName,
92                                                    parameter.fBitLength,
93                                                    parameter.fOptional)<0) {
94           HLTError("error adding parameter definition %s to inflater", parameter.fName);
95           return NULL;
96         }
97       }
98       return inflatersimple.release();
99     }
100     break;
101   case 2:
102     {
103       std::auto_ptr<AliHLTDataInflaterHuffman> inflaterhuffman(new AliHLTDataInflaterHuffman);
104       if (!inflaterhuffman.get()) return NULL;
105       TString cdbPath("HLT/ConfigTPC/TPCDataCompressorHuffmanTables");
106       TObject* pConf=AliHLTMisc::Instance().ExtractObject(AliHLTMisc::Instance().LoadOCDBEntry(cdbPath));
107       if (!pConf) {
108         HLTError("can not load configuration object %s", cdbPath.Data());
109         return NULL;
110       }
111       if (dynamic_cast<TList*>(pConf)==NULL) {
112         HLTError("huffman table configuration object of inconsistent type");
113         return NULL;
114       }
115       inflaterhuffman->InitDecoders(dynamic_cast<TList*>(pConf));
116       for (vector<AliHLTTPCDefinitions::AliClusterParameterId_t>::const_iterator id=parameterids.begin();
117            id!=parameterids.end(); id++) {
118         const AliHLTTPCDefinitions::AliClusterParameter& parameter=AliHLTTPCDefinitions::fgkClusterParameterDefinitions[*id];
119         if (inflaterhuffman->AddParameterDefinition(parameter.fName,
120                                                     parameter.fBitLength)<0) {
121           HLTError("error adding parameter definition %s to inflater", parameter.fName);
122           return NULL;
123         }
124       }
125       return inflaterhuffman.release();
126     }
127     break;
128   default:
129     HLTError("unknown inflater requested %d", deflater);
130   }
131   return NULL;
132 }
133
134 int AliHLTTPCDataCompressionDecoder::InitPartitionClusterDecoding(AliHLTUInt32_t specification)
135 {
136   /// init the decoding of partition cluster block
137   AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(specification);
138   AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(specification);
139   unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
140   if (index<fRemainingClusterIds.size())
141     fCurrentClusterIds=&fRemainingClusterIds[index];
142   else
143     fCurrentClusterIds=NULL;
144   return 0;
145 }
146
147 int AliHLTTPCDataCompressionDecoder::InitTrackModelClusterClusterDecoding()
148 {
149   /// init the decoding of track model cluster block
150   if (fTrackModelClusterIds.fIds && fTrackModelClusterIds.fSize>0)
151     fCurrentClusterIds=&fTrackModelClusterIds;
152   else
153     fCurrentClusterIds=NULL;
154   return 0;
155 }
156
157 int AliHLTTPCDataCompressionDecoder::AddClusterMCData(const AliHLTComponentBlockData* pDesc)
158 {
159   /// add cluster mc data block
160   if (!pDesc) return -EINVAL;
161   if (pDesc->fDataType==AliHLTTPCDefinitions::AliHLTDataTypeClusterMCInfo()) {
162     AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(pDesc->fSpecification);
163     AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(pDesc->fSpecification);
164     unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
165     if (fClusterMCData.size()<=index) {
166       if ((int)fClusterMCData.size()<AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches()) {
167         fClusterMCData.resize(AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches(), NULL);
168       } else {
169         fClusterMCData.resize(index+1, NULL);
170       }
171     }
172     if (pDesc->fSize<sizeof(AliHLTTPCClusterMCData)) return -EINVAL;
173     const AliHLTTPCClusterMCData* pData=reinterpret_cast<const AliHLTTPCClusterMCData*>(pDesc->fPtr);
174     unsigned nLabels = pData->fCount;
175     if (nLabels*sizeof(AliHLTTPCClusterMCLabel) + sizeof(AliHLTTPCClusterMCData) != pDesc->fSize) {
176       return -EINVAL;
177     }
178     fClusterMCData[index]=pData;
179     return 0;
180   }
181   return -ENODATA;
182 }
183
184 int AliHLTTPCDataCompressionDecoder::AddClusterIds(const AliHLTComponentBlockData* pDesc)
185 {
186   /// add cluster id block for remaining or track model clusters
187   if (!pDesc) return -EINVAL;
188   if (pDesc->fDataType==AliHLTTPCDefinitions::ClusterIdTracksDataType()) {
189     fTrackModelClusterIds.fIds=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
190     fTrackModelClusterIds.fSize=pDesc->fSize/sizeof(AliHLTUInt32_t);
191     return 0;
192   }
193   if (pDesc->fDataType==AliHLTTPCDefinitions::RemainingClusterIdsDataType()) {
194     AliHLTUInt8_t slice=AliHLTTPCDefinitions::GetMinSliceNr(pDesc->fSpecification);
195     AliHLTUInt8_t partition=AliHLTTPCDefinitions::GetMinPatchNr(pDesc->fSpecification);
196     unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
197     if (fRemainingClusterIds.size()<=index) {
198       if ((int)fRemainingClusterIds.size()<AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches()) {
199         fRemainingClusterIds.resize(AliHLTTPCTransform::GetNSlice()*AliHLTTPCTransform::GetNumberOfPatches());
200       } else {
201         fRemainingClusterIds.resize(index+1);
202       }
203     }
204     fRemainingClusterIds[index].fIds=reinterpret_cast<AliHLTUInt32_t*>(pDesc->fPtr);
205     fRemainingClusterIds[index].fSize=pDesc->fSize/sizeof(AliHLTUInt32_t);
206     return 0;
207   }
208   return -ENODATA;
209 }
210
211 AliHLTUInt32_t AliHLTTPCDataCompressionDecoder::GetClusterId(int clusterNo) const
212 {
213   /// get the cluster id from the current cluster id block
214   if (!fCurrentClusterIds ||
215       (int)fCurrentClusterIds->fSize<=clusterNo ||
216       clusterNo<0)
217     return kAliHLTVoidDataSpec;
218   return fCurrentClusterIds->fIds[clusterNo];
219 }
220
221 const AliHLTTPCClusterMCLabel* AliHLTTPCDataCompressionDecoder::GetMCLabel(AliHLTUInt32_t clusterId) const
222 {
223   /// get MC data for a cluster Id
224   if (clusterId==kAliHLTVoidDataSpec) return NULL;
225
226   unsigned slice=AliHLTTPCSpacePointData::GetSlice(clusterId);
227   unsigned partition=AliHLTTPCSpacePointData::GetPatch(clusterId);
228   unsigned number=AliHLTTPCSpacePointData::GetNumber(clusterId);
229   if ((int)slice>=AliHLTTPCTransform::GetNSlice() ||
230       (int)partition>=AliHLTTPCTransform::GetNumberOfPatches()) return NULL;
231   unsigned index=slice*AliHLTTPCTransform::GetNumberOfPatches()+partition;
232   if (fClusterMCData.size()<=index ||
233       fClusterMCData[index]==NULL ||
234       fClusterMCData[index]->fCount<=number) return NULL;
235
236   return &(fClusterMCData[index]->fLabels[number]);
237 }
238
239 void AliHLTTPCDataCompressionDecoder::Clear(const char* /*option*/)
240 {
241   // cleanup
242 }