correcting arguments for the huffman training configuration to run track model compre...
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCAgent.cxx
1 // $Id$
2
3 //**************************************************************************
4 //* This file is property of and copyright by the ALICE HLT Project        * 
5 //* ALICE Experiment at CERN, All rights reserved.                         *
6 //*                                                                        *
7 //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no>        *
8 //*                  for The ALICE HLT Project.                            *
9 //*                                                                        *
10 //* Permission to use, copy, modify and distribute this software and its   *
11 //* documentation strictly for non-commercial purposes is hereby granted   *
12 //* without fee, provided that the above copyright notice appears in all   *
13 //* copies and that both the copyright notice and this permission notice   *
14 //* appear in the supporting documentation. The authors make no claims     *
15 //* about the suitability of this software for any purpose. It is          *
16 //* provided "as is" without express or implied warranty.                  *
17 //**************************************************************************
18
19 //  @file   AliHLTTPCAgent.cxx
20 //  @author Matthias Richter
21 //  @date   
22 //  @brief  Agent of the libAliHLTTPC library
23 //  @note   
24
25 #include "AliHLTTPCAgent.h"
26 #include "AliHLTTPCDefinitions.h"
27 #include "AliHLTOUT.h"
28 #include "AliHLTOUTHandlerChain.h"
29 #include "AliRunLoader.h"
30 #include "AliCDBManager.h"
31 #include "AliCDBEntry.h"
32 #include "AliTPCParam.h"
33
34 /** global instance for agent registration */
35 AliHLTTPCAgent gAliHLTTPCAgent;
36
37 // component headers
38 #include "AliHLTTPCCompModelInflaterComponent.h"
39 #include "AliHLTTPCCompModelDeflaterComponent.h"
40 #include "AliHLTTPCCompModelDeconverterComponent.h"
41 #include "AliHLTTPCCompModelConverterComponent.h"
42 #include "AliHLTTPCCompDumpComponent.h"
43 //#include "AliHLTTPCCalibCEComponent.h"
44 //#include "AliHLTTPCCalibPulserComponent.h"
45 //#include "AliHLTTPCCalibPedestalComponent.h"
46 #include "AliHLTTPCCAInputDataCompressorComponent.h"
47 #include "AliHLTTPCCATrackerComponent.h"
48 #include "AliHLTTPCCATrackerOutputConverter.h"
49 #include "AliHLTTPCTrackMCMarkerComponent.h"
50 #include "AliHLTTPCCAGlobalMergerComponent.h"
51 #include "AliHLTTPCdEdxComponent.h"
52 #include "AliHLTTPCdEdxMonitoringComponent.h"
53 #include "AliHLTTPCGlobalMergerComponent.h"
54 #include "AliHLTTPCSliceTrackerComponent.h"
55 #include "AliHLTTPCClusterFinderComponent.h"
56 #include "AliHLTTPCRawDataUnpackerComponent.h"
57 #include "AliHLTTPCDigitPublisherComponent.h"
58 #include "AliHLTTPCDigitDumpComponent.h"
59 #include "AliHLTTPCClusterDumpComponent.h"
60 #include "AliHLTTPCEsdWriterComponent.h"
61 #include "AliHLTTPCOfflineClustererComponent.h"
62 #include "AliHLTTPCOfflineTrackerComponent.h"
63 #include "AliHLTTPCOfflineTrackerCalibComponent.h"
64 #include "AliHLTTPCOfflineCalibrationComponent.h" // to be added to the calibration library agent
65 #include "AliHLTTPCClusterHistoComponent.h"
66 #include "AliHLTTPCHistogramHandlerComponent.h"
67 //#include "AliHLTTPCCalibTracksComponent.h"
68 #include "AliHLTTPCTrackHistoComponent.h"
69 #include "AliHLTTPCTrackDumpComponent.h"
70 #include "AliHLTTPCHWCFDataReverterComponent.h"
71 #include "AliHLTTPCHWClusterTransformComponent.h"
72 #include "AliHLTTPCCFComparisonComponent.h"
73 // #include "AliHLTTPCCalibSeedMakerComponent.h"
74 // #include "AliHLTTPCCalibTimeComponent.h"
75 // #include "AliHLTTPCCalibTimeGainComponent.h"
76 // #include "AliHLTTPCCalibrationComponent.h"
77 #include "AliHLTTPCDataCheckerComponent.h"
78 #include "AliHLTTPCHWCFEmulatorComponent.h"
79 #include "AliHLTTPCHWCFConsistencyControlComponent.h"
80 #include "AliHLTTPCDataCompressionComponent.h"
81 #include "AliHLTTPCDataCompressionMonitorComponent.h"
82
83 /** ROOT macro for the implementation of ROOT specific class methods */
84 ClassImp(AliHLTTPCAgent)
85
86 AliHLTTPCAgent::AliHLTTPCAgent()
87   : AliHLTModuleAgent("TPC")
88   , fRawDataHandler(NULL)
89   , fTracksegsDataHandler(NULL)
90   , fClustersDataHandler(NULL)
91 {
92   // see header file for class documentation
93   // or
94   // refer to README to build package
95   // or
96   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
97 }
98
99 AliHLTTPCAgent::~AliHLTTPCAgent()
100 {
101   // see header file for class documentation
102 }
103
104 int AliHLTTPCAgent::CreateConfigurations(AliHLTConfigurationHandler* handler,
105                                          AliRawReader* rawReader,
106                                          AliRunLoader* runloader) const
107 {
108   // see header file for class documentation
109   if (handler) {
110
111     // This the tracking configuration for the full TPC
112     // - 216 clusterfinders (1 per partition)
113     // - 36 slice trackers
114     // - one global merger
115     // - the esd converter
116     // The ESD is shipped embedded into a TTree
117     int iMinSlice=0; 
118     int iMaxSlice=35;
119     int iMinPart=0;
120     int iMaxPart=5;
121     TString arg;
122     TString mergerInput;
123     TString sinkRawData;
124     TString sinkClusterInput;
125     TString sinkHWClusterInput;
126     TString dEdXInput;
127     TString compressorInput;
128     for (int slice=iMinSlice; slice<=iMaxSlice; slice++) {
129       TString trackerInput;
130       for (int part=iMinPart; part<=iMaxPart; part++) {
131         TString publisher, cf;
132
133         // digit publisher components
134         publisher.Form("TPC-DP_%02d_%d", slice, part);
135         if (rawReader || !runloader) {
136           // AliSimulation: use the AliRawReaderPublisher if the raw reader is available
137           // Alireconstruction: indicated by runloader==NULL, run always on raw data
138           int ddlno=768;
139           if (part>1) ddlno+=72+4*slice+(part-2);
140           else ddlno+=2*slice+part;
141           arg.Form("-minid %d -datatype 'DDL_RAW ' 'TPC '  -dataspec 0x%02x%02x%02x%02x -silent", ddlno, slice, slice, part, part);
142           handler->CreateConfiguration(publisher.Data(), "AliRawReaderPublisher", NULL , arg.Data());
143         } else {
144           arg.Form("-slice %d -partition %d", slice, part);
145           handler->CreateConfiguration(publisher.Data(), "TPCDigitPublisher", NULL , arg.Data());
146         }
147
148         if (sinkRawData.Length()>0) sinkRawData+=" ";
149         sinkRawData+=publisher;
150
151         // cluster finder components
152         cf.Form("TPC-CF_%02d_%d", slice, part);
153         arg="-release-memory -publish-raw";
154         if (!rawReader && runloader) {
155           arg+=" -do-mc";
156           handler->CreateConfiguration(cf.Data(), "TPCClusterFinderUnpacked", publisher.Data(), arg.Data());
157         } else {
158           handler->CreateConfiguration(cf.Data(), "TPCClusterFinder32Bit", publisher.Data(),arg.Data());
159         }
160
161         // Hardware CF emulator
162         // soon going to replace the software clusterfinder
163         TString hwcfemu;
164         hwcfemu.Form("TPC-HWCFEmu_%02d_%d", slice, part);
165         handler->CreateConfiguration(hwcfemu.Data(), "TPCHWClusterFinderEmulator", publisher.Data(), "-do-mc 1");
166         if (compressorInput.Length()>0) compressorInput+=" ";
167         compressorInput+=hwcfemu;
168
169         TString hwcf;
170         hwcf.Form("TPC-HWCF_%02d_%d", slice, part);
171         handler->CreateConfiguration(hwcf.Data(), "TPCHWClusterTransform",hwcfemu.Data(), "-publish-raw");
172
173         if (trackerInput.Length()>0) trackerInput+=" ";
174         trackerInput+=hwcf;
175         if (dEdXInput.Length()>0) dEdXInput+=" ";
176         dEdXInput+=hwcf;
177         if (sinkClusterInput.Length()>0) sinkClusterInput+=" ";
178         sinkClusterInput+=cf;
179         if (sinkHWClusterInput.Length()>0) sinkHWClusterInput+=" ";
180         sinkHWClusterInput+=hwcf;
181       }
182       TString tracker;
183       // tracker finder components
184       tracker.Form("TPC-TR_%02d", slice);
185       handler->CreateConfiguration(tracker.Data(), "TPCCATracker", trackerInput.Data(), "");
186
187       if (mergerInput.Length()>0) mergerInput+=" ";
188       mergerInput+=tracker;
189
190     }
191
192     // GlobalMerger component
193     handler->CreateConfiguration("TPC-globalmerger","TPCCAGlobalMerger",mergerInput.Data(),"");
194
195     // dEdx component
196     if (dEdXInput.Length()>0) dEdXInput+=" ";
197     dEdXInput+="TPC-globalmerger";
198
199     handler->CreateConfiguration("TPC-dEdx","TPCdEdx",dEdXInput.Data(),"");
200
201     // compression component
202     if (compressorInput.Length()>0) compressorInput+=" ";
203     compressorInput+="TPC-globalmerger";
204     handler->CreateConfiguration("TPC-compression", "TPCDataCompressor", compressorInput.Data(),"-deflater-mode 1");
205     handler->CreateConfiguration("TPC-compression-huffman-trainer", "TPCDataCompressor", compressorInput.Data(),"-mode 2 -deflater-mode 3");
206
207     // the esd converter configuration
208     TString converterInput="TPC-globalmerger";
209     if (!rawReader && runloader) {
210       // propagate cluster info to the esd converter in order to fill the MC information
211       handler->CreateConfiguration("TPC-clustermc-info", "BlockFilter"   , sinkHWClusterInput.Data(), "-datatype 'CLMCINFO' 'TPC '");  
212       handler->CreateConfiguration("TPC-mcTrackMarker","TPCTrackMCMarker","TPC-globalmerger TPC-clustermc-info","" );
213       converterInput+=" ";
214       converterInput+="TPC-mcTrackMarker";
215     }
216     handler->CreateConfiguration("TPC-esd-converter", "TPCEsdConverter"   , converterInput.Data(), "");
217
218     // cluster dump collection
219     handler->CreateConfiguration("TPC-clusters", "BlockFilter"   , sinkClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC ' -datatype 'CLMCINFO' 'TPC '");
220     handler->CreateConfiguration("TPC-raw-clusters", "BlockFilter"   , sinkClusterInput.Data(), "-datatype 'CLUSTRAW' 'TPC ' -datatype 'CLMCINFO' 'TPC '");
221     handler->CreateConfiguration("TPC-hwclusters", "BlockFilter"   , sinkHWClusterInput.Data(), "-datatype 'CLUSTERS' 'TPC ' -datatype 'CLMCINFO' 'TPC '");
222     handler->CreateConfiguration("TPC-raw-hwclusters", "BlockFilter"   , sinkHWClusterInput.Data(), "-datatype 'CLUSTRAW' 'TPC ' -datatype 'CLMCINFO' 'TPC '");
223
224     // raw data
225     handler->CreateConfiguration("TPC-raw-data", "BlockFilter"   , sinkRawData.Data(), "");
226
227     handler->CreateConfiguration("TPC-hwcfdata", "BlockFilter"   , compressorInput.Data(), "-datatype 'HWCLUST1' 'TPC '");
228
229     /////////////////////////////////////////////////////////////////////////////////////
230     //
231     // dumps on the ALTRO digit level
232     //
233     // selected channel dump
234     arg.Form("-datafile selected-channel.dump -specfmt=_0x%%08x -subdir -blcknofmt= -idfmt=");
235     handler->CreateConfiguration("TPC-selected-altro-digits", "TPCDigitDump", "RCU-channelselect", arg.Data());
236
237     // raw channel dump
238     arg.Form("-datafile channel.dump -specfmt=_0x%%08x -subdir -blcknofmt= -idfmt=");
239     handler->CreateConfiguration("TPC-raw-altro-digits", "TPCDigitDump", "TPC-raw-data", arg.Data());
240
241     /////////////////////////////////////////////////////////////////////////////////////
242     //
243     // a kChain HLTOUT configuration for processing of {'TRAKSEGS':'TPC '} data blocks
244     // collects the data blocks, merges the tracks and produces an ESD object
245
246     // publisher component
247     handler->CreateConfiguration("TPC-hltout-tracksegs-publisher", "AliHLTOUTPublisher"   , NULL, "");
248
249     // GlobalMerger component
250     handler->CreateConfiguration("TPC-hltout-tracksegs-merger", "TPCGlobalMerger", "TPC-hltout-tracksegs-publisher", "");
251
252     // the esd converter configuration
253     handler->CreateConfiguration("TPC-hltout-tracksegs-esd-converter", "TPCEsdConverter", "TPC-hltout-tracksegs-merger", "");
254
255     /////////////////////////////////////////////////////////////////////////////////////
256     //
257     // a kChain HLTOUT configuration for processing of {'TRACKS  ':'TPC '} data blocks
258     // produces an ESD object from the track structure
259
260     // publisher component
261     handler->CreateConfiguration("TPC-hltout-tracks-publisher", "AliHLTOUTPublisher"   , NULL, "");
262
263     // the esd converter configuration
264     handler->CreateConfiguration("TPC-hltout-tracks-esd-converter", "TPCEsdConverter", "TPC-hltout-tracks-publisher", "");
265
266     /////////////////////////////////////////////////////////////////////////////////////
267     //
268     // a kChain HLTOUT configuration for processing of {'CLUSTERS':'TPC '} data blocks
269     // stores the blocks in file HLT.TPC.Clusters.root in HOMER format
270
271     // publisher component
272     handler->CreateConfiguration("TPC-hltout-cluster-publisher", "AliHLTOUTPublisher"   , NULL, "");
273
274     // the HLTOUT component collects the blocks and stores the file
275     handler->CreateConfiguration("TPC-hltout-cluster-dump", "HLTOUT", "TPC-hltout-cluster-publisher", "-digitfile HLT.TPC.Clusters.root -rawout=off -links 2");
276   }
277
278   return 0;
279 }
280
281 const char* AliHLTTPCAgent::GetReconstructionChains(AliRawReader* /*rawReader*/,
282                                                     AliRunLoader* runloader) const
283 {
284   // see header file for class documentation
285   if (runloader) {
286     // reconstruction chains for AliRoot simulation
287     // Note: run loader is only available while running embedded into
288     // AliRoot simulation
289     //if (runloader->GetLoader("TPCLoader") != NULL)
290       //return "TPC-esd-converter TPC-clusters";
291
292     // 2010-10-26 TPC clusters not written to HLTOUT in order to make the simulation
293     // closer to the real data 
294     //return "TPC-clusters";
295   }
296   return NULL;
297 }
298
299 const char* AliHLTTPCAgent::GetRequiredComponentLibraries() const
300 {
301   // see header file for class documentation
302
303   // actually, the TPC library has dependencies to Util and RCU
304   // so the two has to be loaded anyhow before we get here
305   //return "libAliHLTUtil.so libAliHLTRCU.so";
306   return "libAliHLTUtil.so";
307 }
308
309 int AliHLTTPCAgent::RegisterComponents(AliHLTComponentHandler* pHandler) const
310 {
311   // see header file for class documentation
312   if (!pHandler) return -EINVAL;
313
314 //   pHandler->AddComponent(new AliHLTTPCCalibCEComponent);
315 //   pHandler->AddComponent(new AliHLTTPCCalibPulserComponent);
316 //   pHandler->AddComponent(new AliHLTTPCCalibPedestalComponent);
317   pHandler->AddComponent(new AliHLTTPCCompModelInflaterComponent);
318   pHandler->AddComponent(new AliHLTTPCCompModelDeflaterComponent);
319   pHandler->AddComponent(new AliHLTTPCCompModelDeconverterComponent);
320   pHandler->AddComponent(new AliHLTTPCCompModelConverterComponent);
321   pHandler->AddComponent(new AliHLTTPCCompDumpComponent);
322   pHandler->AddComponent(new AliHLTTPCCAInputDataCompressorComponent);
323   pHandler->AddComponent(new AliHLTTPCCATrackerComponent);
324   pHandler->AddComponent(new AliHLTTPCCATrackerOutputConverter);
325   pHandler->AddComponent(new AliHLTTPCCAGlobalMergerComponent);
326   pHandler->AddComponent(new AliHLTTPCTrackMCMarkerComponent);
327   pHandler->AddComponent(new AliHLTTPCGlobalMergerComponent);
328   pHandler->AddComponent(new AliHLTTPCdEdxComponent);
329   pHandler->AddComponent(new AliHLTTPCdEdxMonitoringComponent);
330   pHandler->AddComponent(new AliHLTTPCSliceTrackerComponent);
331   pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderPacked));
332   pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderUnpacked));
333   pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinderDecoder));
334   pHandler->AddComponent(new AliHLTTPCClusterFinderComponent(AliHLTTPCClusterFinderComponent::kClusterFinder32Bit));
335   pHandler->AddComponent(new AliHLTTPCRawDataUnpackerComponent);
336   pHandler->AddComponent(new AliHLTTPCDigitPublisherComponent);
337   pHandler->AddComponent(new AliHLTTPCDigitDumpComponent);
338   pHandler->AddComponent(new AliHLTTPCClusterDumpComponent);
339   pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliWriter);
340   pHandler->AddComponent(new AliHLTTPCEsdWriterComponent::AliConverter);
341   pHandler->AddComponent(new AliHLTTPCOfflineClustererComponent);
342   pHandler->AddComponent(new AliHLTTPCOfflineTrackerComponent);
343   pHandler->AddComponent(new AliHLTTPCOfflineTrackerCalibComponent);
344   pHandler->AddComponent(new AliHLTTPCOfflineCalibrationComponent);
345   pHandler->AddComponent(new AliHLTTPCClusterHistoComponent);
346   pHandler->AddComponent(new AliHLTTPCHistogramHandlerComponent);
347   //pHandler->AddComponent(new AliHLTTPCCalibTracksComponent);
348   pHandler->AddComponent(new AliHLTTPCTrackHistoComponent);
349   pHandler->AddComponent(new AliHLTTPCTrackDumpComponent);
350   pHandler->AddComponent(new AliHLTTPCHWCFDataReverterComponent);
351   pHandler->AddComponent(new AliHLTTPCHWClusterTransformComponent);
352   pHandler->AddComponent(new AliHLTTPCCFComparisonComponent);
353 //   pHandler->AddComponent(new AliHLTTPCCalibSeedMakerComponent);
354 //   pHandler->AddComponent(new AliHLTTPCCalibTimeComponent);
355 //   pHandler->AddComponent(new AliHLTTPCCalibTimeGainComponent);
356 //   pHandler->AddComponent(new AliHLTTPCCalibrationComponent);
357   pHandler->AddComponent(new AliHLTTPCDataCheckerComponent);
358   pHandler->AddComponent(new AliHLTTPCHWCFEmulatorComponent);
359 //  pHandler->AddComponent(new AliHLTTPCHWCFConsistencyControlComponent);  //FIXME: Causes crash: https://savannah.cern.ch/bugs/?83677
360   pHandler->AddComponent(new AliHLTTPCDataCompressionComponent);
361   pHandler->AddComponent(new AliHLTTPCDataCompressionMonitorComponent);
362   return 0;
363 }
364
365 int AliHLTTPCAgent::GetHandlerDescription(AliHLTComponentDataType dt,
366                                           AliHLTUInt32_t spec,
367                                           AliHLTOUTHandlerDesc& desc) const
368 {
369   // see header file for class documentation
370
371   // raw data blocks to be fed into offline reconstruction
372   if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC)) {
373     int slice=AliHLTTPCDefinitions::GetMinSliceNr(spec);
374     int part=AliHLTTPCDefinitions::GetMinPatchNr(spec);
375     if (slice==AliHLTTPCDefinitions::GetMaxSliceNr(spec) &&
376         part==AliHLTTPCDefinitions::GetMaxPatchNr(spec)) {
377       desc=AliHLTOUTHandlerDesc(kRawReader, dt, GetModuleId());
378       return 1;
379     } else {
380       HLTWarning("handler can not process merged data from multiple ddls:"
381                  " min slice %d, max slice %d, min part %d, max part %d",
382                  slice, AliHLTTPCDefinitions::GetMaxSliceNr(spec),
383                  part, AliHLTTPCDefinitions::GetMaxPatchNr(spec));
384       return 0;
385     }
386   }
387
388   // dump for {'CLUSTERS':'TPC '} blocks stored in a 'digit' file
389   if (dt==AliHLTTPCDefinitions::fgkClustersDataType) {
390       desc=AliHLTOUTHandlerDesc(kChain, dt, GetModuleId());
391       return 1;
392   }
393
394   // {'CLUSTRAW':'TPC '}
395   // {'REMCLSCM':'TPC '}
396   // {'CLSTRKCM':'TPC '}
397   // {'REMCLIDS':'TPC '}
398   // {'CLIDSTRK':'TPC '}
399   if (dt==AliHLTTPCDefinitions::RawClustersDataType() ||
400       dt==AliHLTTPCDefinitions::RemainingClustersCompressedDataType() ||
401       dt==AliHLTTPCDefinitions::ClusterTracksCompressedDataType() ||
402       dt==AliHLTTPCDefinitions::RemainingClusterIdsDataType() ||
403       dt==AliHLTTPCDefinitions::ClusterIdTracksDataType()) {
404       desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId());
405       return 1;
406   }
407
408   // {'CLMCINFO':'TPC '} 
409   if (dt==AliHLTTPCDefinitions::fgkAliHLTDataTypeClusterMCInfo) {
410       desc=AliHLTOUTHandlerDesc(kProprietary, dt, GetModuleId());
411       return 1;
412   }
413
414   // afterburner for {'TRAKSEGS':'TPC '} blocks to be converted to ESD format
415   if (dt==AliHLTTPCDefinitions::fgkTrackSegmentsDataType) {
416       desc=AliHLTOUTHandlerDesc(kChain, dt, GetModuleId());
417       return 1;
418   }
419
420   // afterburner for {'TRACKS  ':'TPC '} block to be converted to ESD format
421   // there is only one data block
422   if (dt==AliHLTTPCDefinitions::fgkTracksDataType) {
423       desc=AliHLTOUTHandlerDesc(kChain, dt, GetModuleId());
424       return 1;
425   }
426   return 0;
427 }
428
429 AliHLTOUTHandler* AliHLTTPCAgent::GetOutputHandler(AliHLTComponentDataType dt,
430                                                    AliHLTUInt32_t /*spec*/)
431 {
432   // see header file for class documentation
433
434   // raw data blocks to be fed into offline reconstruction
435   if (dt==(kAliHLTDataTypeDDLRaw|kAliHLTDataOriginTPC)) {
436     if (!fRawDataHandler) {
437       fRawDataHandler=new AliHLTTPCAgent::AliHLTTPCRawDataHandler;
438     }
439     return fRawDataHandler;
440   }
441
442   // dump for {'CLUSTERS':'TPC '}, stored in a file HLT.TPC.Clusters.root in HOMER format
443   if (dt==AliHLTTPCDefinitions::fgkClustersDataType) {
444     if (fClustersDataHandler==NULL)
445       fClustersDataHandler=new AliHLTOUTHandlerChain("chains=TPC-hltout-cluster-dump libHLTsim.so libAliHLTUtil.so");
446     return fClustersDataHandler;
447   }
448
449   // afterburner for {'TRAKSEGS':'TPC '} blocks to be converted to ESD format
450   // in a kChain HLTOUT handler
451   if (dt==AliHLTTPCDefinitions::fgkTrackSegmentsDataType) {
452     if (fTracksegsDataHandler==NULL)
453       fTracksegsDataHandler=new AliHLTOUTHandlerChain("chains=TPC-hltout-tracksegs-esd-converter");
454     return fTracksegsDataHandler;
455   }
456
457   // afterburner for {'TRACKS  ':'TPC '} block to be converted to ESD format
458   // there is only one data block
459   if (dt==AliHLTTPCDefinitions::fgkTracksDataType) {
460     return new AliHLTOUTHandlerChain("chains=TPC-hltout-tracks-esd-converter");
461   }
462
463   return NULL;
464 }
465
466 int AliHLTTPCAgent::DeleteOutputHandler(AliHLTOUTHandler* pInstance)
467 {
468   // see header file for class documentation
469   if (pInstance==NULL) return -EINVAL;
470
471   if (pInstance==fRawDataHandler) {
472     delete fRawDataHandler;
473     fRawDataHandler=NULL;
474   }
475
476   if (pInstance==fTracksegsDataHandler) {
477     delete fTracksegsDataHandler;
478     fTracksegsDataHandler=NULL;
479   }
480
481   if (pInstance==fClustersDataHandler) {
482     delete fClustersDataHandler;
483     fClustersDataHandler=NULL;
484   }
485
486   return 0;
487 }
488
489 AliHLTTPCAgent::AliHLTTPCRawDataHandler::AliHLTTPCRawDataHandler()
490 {
491   // see header file for class documentation
492 }
493
494 AliHLTTPCAgent::AliHLTTPCRawDataHandler::~AliHLTTPCRawDataHandler()
495 {
496   // see header file for class documentation
497 }
498
499 int AliHLTTPCAgent::AliHLTTPCRawDataHandler::ProcessData(AliHLTOUT* pData)
500 {
501   // see header file for class documentation
502   if (!pData) return -EINVAL;
503   AliHLTComponentDataType dt=kAliHLTVoidDataType;
504   AliHLTUInt32_t spec=kAliHLTVoidDataSpec;
505   int iResult=pData->GetDataBlockDescription(dt, spec);
506   if (iResult>=0) {
507     int slice=AliHLTTPCDefinitions::GetMinSliceNr(spec);
508     int part=AliHLTTPCDefinitions::GetMinPatchNr(spec);
509     if (slice==AliHLTTPCDefinitions::GetMaxSliceNr(spec) &&
510         part==AliHLTTPCDefinitions::GetMaxPatchNr(spec)) {
511       iResult=768;
512       if (part>1) iResult+=72+4*slice+(part-2);
513       else iResult+=2*slice+part;
514     } else {
515       HLTError("handler can not process merged data from multiple ddls:"
516                " min slice %d, max slice %d, min part %d, max part %d",
517                slice, AliHLTTPCDefinitions::GetMaxSliceNr(spec),
518                part, AliHLTTPCDefinitions::GetMaxPatchNr(spec));
519       iResult=-EBADMSG;
520     }
521   }
522   return iResult;
523 }