setter functions can be made constant as they do not affect the members of the object...
[u/mrichter/AliRoot.git] / HLT / global / AliHLTGlobalEsdConverterComponent.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   AliHLTGlobalEsdConverterComponent.cxx
20 //  @author Matthias Richter
21 //  @date   
22 //  @brief  Global ESD converter component.
23 // 
24
25 // see header file for class documentation
26 // or
27 // refer to README to build package
28 // or
29 // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
30
31 #include <cassert>
32 #include "AliHLTGlobalEsdConverterComponent.h"
33 #include "AliHLTGlobalBarrelTrack.h"
34 #include "AliHLTExternalTrackParam.h"
35 #include "AliHLTTrackMCLabel.h"
36 #include "AliHLTCTPData.h"
37 #include "AliESDEvent.h"
38 #include "AliESDtrack.h"
39 #include "AliESDMuonTrack.h"
40 #include "AliCDBEntry.h"
41 #include "AliCDBManager.h"
42 #include "AliPID.h"
43 #include "TTree.h"
44 #include "TList.h"
45 #include "TClonesArray.h"
46 #include "AliHLTESDCaloClusterMaker.h"
47 #include "AliHLTCaloClusterDataStruct.h"
48 #include "AliHLTCaloClusterReader.h"
49 #include "AliESDCaloCluster.h"
50 #include "AliHLTGlobalVertexerComponent.h"
51
52 /** ROOT macro for the implementation of ROOT specific class methods */
53 ClassImp(AliHLTGlobalEsdConverterComponent)
54
55 AliHLTGlobalEsdConverterComponent::AliHLTGlobalEsdConverterComponent()
56   : AliHLTProcessor()
57   , fWriteTree(0)
58   , fVerbosity(0)
59   , fESD(NULL)
60   , fSolenoidBz(-5.00668)
61   , fBenchmark("EsdConverter")
62 {
63   // see header file for class documentation
64   // or
65   // refer to README to build package
66   // or
67   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
68 }
69
70 AliHLTGlobalEsdConverterComponent::~AliHLTGlobalEsdConverterComponent()
71 {
72   // see header file for class documentation
73   if (fESD) delete fESD;
74   fESD=NULL;
75 }
76
77 int AliHLTGlobalEsdConverterComponent::Configure(const char* arguments)
78 {
79   // see header file for class documentation
80   int iResult=0;
81   if (!arguments) return iResult;
82
83   TString allArgs=arguments;
84   TString argument;
85   int bMissingParam=0;
86
87   TObjArray* pTokens=allArgs.Tokenize(" ");
88   if (pTokens) {
89     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
90       argument=((TObjString*)pTokens->At(i))->GetString();      
91       if (argument.IsNull()) continue;
92       
93       if (argument.CompareTo("-solenoidBz")==0) {
94         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
95         HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz());
96         continue;
97       } else {
98         HLTError("unknown argument %s", argument.Data());
99         iResult=-EINVAL;
100         break;
101       }
102     }
103     delete pTokens;
104   }
105   if (bMissingParam) {
106     HLTError("missing parameter for argument %s", argument.Data());
107     iResult=-EINVAL;
108   }
109
110   return iResult;
111 }
112
113 int AliHLTGlobalEsdConverterComponent::Reconfigure(const char* cdbEntry, const char* chainId)
114 {
115   // see header file for class documentation
116   int iResult=0;
117   const char* path=NULL;
118   const char* defaultNotify="";
119   if (cdbEntry) {
120     path=cdbEntry;
121     defaultNotify=" (default)";
122   }
123   if (path) {
124     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
125     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/);
126     if (pEntry) {
127       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
128       if (pString) {
129         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
130         iResult=Configure(pString->GetString().Data());
131       } else {
132         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
133       }
134     } else {
135       HLTError("can not fetch object \"%s\" from CDB", path);
136     }
137   }
138   
139   return iResult;
140 }
141
142 void AliHLTGlobalEsdConverterComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
143 {
144   // see header file for class documentation
145   list.push_back(kAliHLTDataTypeTrack);
146   list.push_back(kAliHLTDataTypeTrackMC);
147   list.push_back(kAliHLTDataTypeCaloCluster);
148   list.push_back(kAliHLTDataTypedEdx );
149   list.push_back(kAliHLTDataTypeESDVertex );
150   list.push_back(kAliHLTDataTypeESDObject);
151   list.push_back(kAliHLTDataTypeTObject);
152   list.push_back(kAliHLTDataTypeGlobalVertexer);
153 }
154
155 AliHLTComponentDataType AliHLTGlobalEsdConverterComponent::GetOutputDataType()
156 {
157   // see header file for class documentation
158   return kAliHLTDataTypeESDObject|kAliHLTDataOriginOut;
159 }
160
161 void AliHLTGlobalEsdConverterComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
162 {
163   // see header file for class documentation
164   constBase=2000000;
165   inputMultiplier=10.0;
166 }
167
168 int AliHLTGlobalEsdConverterComponent::DoInit(int argc, const char** argv)
169 {
170   // see header file for class documentation
171   int iResult=0;
172   TString argument="";
173   int bMissingParam=0;
174
175   // default list of skiped ESD objects
176   TString skipObjects=
177     // "AliESDRun,"
178     // "AliESDHeader,"
179     "AliESDZDC,"
180     "AliESDFMD,"
181     // "AliESDVZERO,"
182     // "AliESDTZERO,"
183     // "TPCVertex,"
184     // "SPDVertex,"
185     // "PrimaryVertex,"
186     // "AliMultiplicity,"
187     // "PHOSTrigger,"
188     // "EMCALTrigger,"
189     // "SPDPileupVertices,"
190     // "TrkPileupVertices,"
191     "Cascades,"
192     "Kinks,"
193     "AliRawDataErrorLogs,"
194     "AliESDACORDE";
195
196   iResult=Reconfigure(NULL, NULL);
197   TString allArgs = "";
198   for ( int i = 0; i < argc; i++ ) {
199     if ( !allArgs.IsNull() ) allArgs += " ";
200     allArgs += argv[i];
201   }
202
203   TObjArray* pTokens=allArgs.Tokenize(" ");
204   if (pTokens) {
205     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
206       argument=((TObjString*)pTokens->At(i))->GetString();      
207       if (argument.IsNull()) continue;
208
209       // -notree
210       if (argument.CompareTo("-notree")==0) {
211         fWriteTree=0;
212         
213         // -tree
214       } else if (argument.CompareTo("-tree")==0) {
215         fWriteTree=1;
216       } else if (argument.CompareTo("-solenoidBz")==0) {
217         if ((bMissingParam=(++i>=pTokens->GetEntries()))) break;
218         HLTInfo("Magnetic Field set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data());
219         HLTWarning("argument '-solenoidBz' is deprecated, solenoid field initiaized from CDB settings");
220         continue;
221       } else if (argument.Contains("-skipobject=")) {
222         argument.ReplaceAll("-skipobject=", "");
223         skipObjects=argument;
224       } else {
225         HLTError("unknown argument %s", argument.Data());
226         iResult=-EINVAL;
227         break;
228       }
229     }
230   }
231   if (bMissingParam) {
232     HLTError("missing parameter for argument %s", argument.Data());
233     iResult=-EINVAL;
234   }
235
236   fSolenoidBz=GetBz();
237
238   if (iResult>=0) {
239     fESD = new AliESDEvent;
240     if (fESD) {
241       fESD->CreateStdContent();
242
243       // remove some of the objects which are not needed
244       if (fESD->GetList() && !skipObjects.IsNull()) {
245         pTokens=skipObjects.Tokenize(",");
246         if (pTokens) {
247           const char* id=NULL;
248           TIter next(pTokens);
249           TObject* pObject=NULL;
250           while ((pObject=next())!=NULL) {
251             id=((TObjString*)pObject)->GetString().Data();
252             TObject* pObj=fESD->GetList()->FindObject(id);
253             if (pObj) {
254               HLTDebug("removing object %s", id);
255               fESD->GetList()->Remove(pObj);
256               delete pObj;
257             } else {
258               HLTWarning("failed to remove object '%s' from ESD", id);
259             }
260           }
261           fESD->GetStdContent();
262           delete pTokens;
263         }
264       }
265     } else {
266       iResult=-ENOMEM;
267     }
268
269     SetupCTPData();
270   }
271
272   fBenchmark.SetTimer(0,"total");
273
274   return iResult;
275 }
276
277 int AliHLTGlobalEsdConverterComponent::DoDeinit()
278 {
279   // see header file for class documentation
280   if (fESD) delete fESD;
281   fESD=NULL;
282
283   return 0;
284 }
285
286 int AliHLTGlobalEsdConverterComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, 
287                                                AliHLTComponentTriggerData& trigData)
288 {
289   // see header file for class documentation
290   int iResult=0;
291   if (!fESD) return -ENODEV;
292
293   if (IsDataEvent()) fBenchmark.StartNewEvent();
294   fBenchmark.Start(0);
295
296   AliESDEvent* pESD = fESD;
297
298   pESD->Reset(); 
299   pESD->SetMagneticField(fSolenoidBz);
300   pESD->SetRunNumber(GetRunNo());
301   pESD->SetPeriodNumber(GetPeriodNumber());
302   pESD->SetOrbitNumber(GetOrbitNumber());
303   pESD->SetBunchCrossNumber(GetBunchCrossNumber());
304   pESD->SetTimeStamp(GetTimeStamp());
305
306   const AliHLTCTPData* pCTPData=CTPData();
307   if (pCTPData) {
308     AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData);
309     for (int index=0; index<gkNCTPTriggerClasses; index++) {
310       if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue;
311       pESD->SetTriggerClass(pCTPData->Name(index), index);
312     }
313     pESD->SetTriggerMask(mask);
314   }
315
316   TTree* pTree = NULL;
317   if (fWriteTree)
318     pTree = new TTree("esdTree", "Tree with HLT ESD objects");
319  
320   if (pTree) {
321     pTree->SetDirectory(0);
322   }
323
324   if ((iResult=ProcessBlocks(pTree, pESD))>=0) {
325     // TODO: set the specification correctly
326     if (pTree) {
327       // the esd structure is written to the user info and is
328       // needed in te ReadFromTree method to read all objects correctly
329       pTree->GetUserInfo()->Add(pESD);
330       pESD->WriteToTree(pTree);
331       iResult=PushBack(pTree, kAliHLTDataTypeESDTree|kAliHLTDataOriginOut, 0);
332     } else {
333       iResult=PushBack(pESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginOut, 0);
334     }
335     fBenchmark.AddOutput(GetLastObjectSize());
336   }
337   if (pTree) {
338     // clear user info list to prevent objects from being deleted
339     pTree->GetUserInfo()->Clear();
340     delete pTree;
341   }
342
343   fBenchmark.Stop(0);
344   HLTInfo( fBenchmark.GetStatistics() );
345
346   return iResult;
347 }
348
349 int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent* pESD)
350 {
351   // see header file for class documentation
352
353   int iResult=0;
354   int iAddedDataBlocks=0;
355
356   // Barrel tracking
357
358   // in the first attempt this component reads the TPC tracks and updates in the
359   // second step from the ITS tracks
360
361   // first read MC information (if present)
362   std::map<int,int> mcLabels;
363
364   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC);
365        pBlock!=NULL; pBlock=GetNextInputBlock()) {
366
367     fBenchmark.AddInput(pBlock->fSize);
368
369     AliHLTTrackMCData* dataPtr = reinterpret_cast<AliHLTTrackMCData*>( pBlock->fPtr );
370     if (sizeof(AliHLTTrackMCData)+dataPtr->fCount*sizeof(AliHLTTrackMCLabel)==pBlock->fSize) {
371       for( unsigned int il=0; il<dataPtr->fCount; il++ ){
372         AliHLTTrackMCLabel &lab = dataPtr->fLabels[il];
373         mcLabels[lab.fTrackID] = lab.fMCLabel;
374       }
375     } else {
376       HLTWarning("data mismatch in block %s (0x%08x): count %d, size %d -> ignoring track MC information", 
377                  DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, 
378                  dataPtr->fCount, pBlock->fSize);
379     }
380   }
381
382   // read dEdx information (if present)
383
384   AliHLTFloat32_t *dEdxTPC = 0; 
385   Int_t ndEdxTPC = 0;
386   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypedEdx|kAliHLTDataOriginTPC);
387        pBlock!=NULL; pBlock=GetNextInputBlock()) {
388     fBenchmark.AddInput(pBlock->fSize);
389     dEdxTPC = reinterpret_cast<AliHLTFloat32_t*>( pBlock->fPtr );
390     ndEdxTPC = pBlock->fSize / sizeof(AliHLTFloat32_t);
391     break;
392   }
393
394   // convert the TPC tracks to ESD tracks
395   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC);
396        pBlock!=NULL; pBlock=GetNextInputBlock()) {
397     fBenchmark.AddInput(pBlock->fSize);
398     vector<AliHLTGlobalBarrelTrack> tracks;
399     if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>=0) {
400       for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin();
401            element!=tracks.end(); element++) {
402         Float_t points[4] = {
403           element->GetX(),
404           element->GetY(),
405           element->GetLastPointX(),
406           element->GetLastPointY()
407         };
408
409         Int_t mcLabel = -1;
410         if( mcLabels.find(element->TrackID())!=mcLabels.end() )
411           mcLabel = mcLabels[element->TrackID()];
412         element->SetLabel( mcLabel );
413
414         AliESDtrack iotrack;
415
416         // for the moment, the number of clusters are not set when processing the
417         // kTPCin update, only at kTPCout
418         // there ar emainly three parameters updated for kTPCout
419         //   number of clusters
420         //   chi2
421         //   pid signal
422         // The first one can be updated already at that stage here, while the two others
423         // eventually require to update from the ITS tracks before. The exact scheme
424         // needs to be checked 
425         iotrack.SetID( element->TrackID() );
426         iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTPCin);
427         {
428           AliHLTGlobalBarrelTrack outPar(*element);       
429           outPar.AliExternalTrackParam::PropagateTo( element->GetLastPointX(), fSolenoidBz );
430           iotrack.UpdateTrackParams(&outPar,AliESDtrack::kTPCout);
431         }
432         iotrack.SetTPCPoints(points);
433         if( element->TrackID()<ndEdxTPC ){
434           iotrack.SetTPCsignal( dEdxTPC[element->TrackID()], 0, 0 ); 
435           //AliTPCseed s;
436           //s.Set( element->GetX(), element->GetAlpha(),
437           //element->GetParameter(), element->GetCovariance() );
438           //s.SetdEdx( dEdxTPC[element->TrackID()] );
439           //s.CookPID();
440           //iotrack.SetTPCpid(s.TPCrPIDs() );
441         } else {
442           if( dEdxTPC ) HLTWarning("Wrong number of dEdx TPC labels");
443         }
444         pESD->AddTrack(&iotrack);
445         if (fVerbosity>0) element->Print();
446       }
447       HLTInfo("converted %d track(s) to AliESDtrack and added to ESD", tracks.size());
448       iAddedDataBlocks++;
449     } else if (iResult<0) {
450       HLTError("can not extract tracks from data block of type %s (specification %08x) of size %d: error %d", 
451                DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, pBlock->fSize, iResult);
452     }
453   }
454
455
456   // Get ITS SPD vertex
457   for( const AliHLTComponentBlockData *i= GetFirstInputBlock(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS); i!=NULL; i=GetNextInputBlock() ){
458     fBenchmark.AddInput(i->fSize);
459   }
460
461   for ( const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS); iter != NULL; iter = GetNextInputObject() ) {
462     AliESDVertex *vtx = dynamic_cast<AliESDVertex*>(const_cast<TObject*>( iter ) );
463     pESD->SetPrimaryVertexSPD( vtx );
464   }
465
466   // now update ESD tracks with the ITSOut info
467   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut);
468        pBlock!=NULL; pBlock=GetNextInputBlock()) {
469     fBenchmark.AddInput(pBlock->fSize);
470     vector<AliHLTGlobalBarrelTrack> tracks;
471     if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) {
472       for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin();
473            element!=tracks.end(); element++) {
474         int tpcID=element->TrackID();
475         // the ITS tracker assigns the TPC track used as seed for a certain track to
476         // the trackID
477         if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue;
478         AliESDtrack *tESD = pESD->GetTrack( tpcID );
479         if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSout );
480       }
481     }
482   }
483
484   // now update ESD tracks with the ITS info
485   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginITS);
486        pBlock!=NULL; pBlock=GetNextInputBlock()) {
487     fBenchmark.AddInput(pBlock->fSize);
488     vector<AliHLTGlobalBarrelTrack> tracks;
489     if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) {
490       for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin();
491            element!=tracks.end(); element++) {
492         int tpcID=element->TrackID();
493         // the ITS tracker assigns the TPC track used as seed for a certain track to
494         // the trackID
495         if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue;
496         AliESDtrack *tESD = pESD->GetTrack( tpcID );
497         if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSin );
498       }
499     }
500   }
501
502   // update with  vertices and vertex-fitted tracks
503
504   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeGlobalVertexer);
505        pBlock!=NULL; pBlock=GetNextInputBlock()) {
506     fBenchmark.AddInput(pBlock->fSize);   
507     AliHLTGlobalVertexerComponent::FillESD( pESD, reinterpret_cast<AliHLTGlobalVertexerComponent::AliHLTGlobalVertexerData* >(pBlock->fPtr) );
508   }
509
510
511   // convert the HLT TRD tracks to ESD tracks                        
512   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack | kAliHLTDataOriginTRD);
513        pBlock!=NULL; pBlock=GetNextInputBlock()) {
514     fBenchmark.AddInput(pBlock->fSize);
515     vector<AliHLTGlobalBarrelTrack> tracks;
516     if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) {
517       for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin();
518            element!=tracks.end(); element++) {
519         
520         Double_t TRDpid[AliPID::kSPECIES], eProb(0.2), restProb((1-eProb)/(AliPID::kSPECIES-1)); //eprob(element->GetTRDpid...);
521         for(Int_t i=0; i<AliPID::kSPECIES; i++){
522           switch(i){
523           case AliPID::kElectron: TRDpid[AliPID::kElectron]=eProb; break;
524           default: TRDpid[i]=restProb; break;
525           }
526         }
527         
528         AliESDtrack iotrack;
529         iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTRDin);
530         iotrack.SetTRDpid(TRDpid);
531         
532         pESD->AddTrack(&iotrack);
533         if (fVerbosity>0) element->Print();
534       }
535       HLTInfo("converted %d track(s) to AliESDtrack and added to ESD", tracks.size());
536       iAddedDataBlocks++;
537     } else if (iResult<0) {
538       HLTError("can not extract tracks from data block of type %s (specification %08x) of size %d: error %d", 
539                DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, pBlock->fSize, iResult);
540     }
541   }
542   for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeCaloCluster | kAliHLTDataOriginAny); pBlock!=NULL; pBlock=GetNextInputBlock()) 
543     {
544       fBenchmark.AddInput(pBlock->fSize);
545       AliHLTCaloClusterHeaderStruct *caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(pBlock->fPtr);
546
547       HLTDebug("%d HLT clusters from spec: 0x%X", caloClusterHeaderPtr->fNClusters, pBlock->fSpecification);
548
549       //AliHLTCaloClusterReader reader;
550       //reader.SetMemory(caloClusterHeaderPtr);
551
552       AliHLTESDCaloClusterMaker clusterMaker;
553
554       int nClusters = clusterMaker.FillESD(pESD, caloClusterHeaderPtr);
555      
556       HLTInfo("converted %d cluster(s) to AliESDCaloCluster and added to ESD", nClusters);
557       iAddedDataBlocks++;
558     }
559   
560   // Add tracks from MUON.
561   for( const AliHLTComponentBlockData *i= GetFirstInputBlock(kAliHLTAnyDataType | kAliHLTDataOriginMUON); i!=NULL; i=GetNextInputBlock() ){
562     fBenchmark.AddInput(i->fSize);
563   }
564
565   for (const TObject* obj = GetFirstInputObject(kAliHLTAnyDataType | kAliHLTDataOriginMUON);
566        obj != NULL;
567        obj = GetNextInputObject()
568       )
569   {
570     const TClonesArray* tracklist = NULL;
571     if (obj->IsA() == AliESDEvent::Class())
572     {
573       const AliESDEvent* event = static_cast<const AliESDEvent*>(obj);
574       HLTDebug("Received a MUON ESD with specification: 0x%X", GetSpecification(obj));
575       if (event->GetList() == NULL) continue;
576       tracklist = dynamic_cast<const TClonesArray*>(event->GetList()->FindObject("MuonTracks"));
577       if (tracklist == NULL) continue;
578     }
579     else if (obj->IsA() == TClonesArray::Class())
580     {
581       tracklist = static_cast<const TClonesArray*>(obj);
582       HLTDebug("Received a MUON TClonesArray of tracks with specification: 0x%X", GetSpecification(obj));
583     }
584     else
585     {
586       // Cannot handle this object type.
587       continue;
588     }
589     HLTDebug("Received %d MUON tracks.", tracklist->GetEntriesFast());
590     if (tracklist->GetEntriesFast() > 0)
591     {
592       const AliESDMuonTrack* track = dynamic_cast<const AliESDMuonTrack*>(tracklist->UncheckedAt(0));
593       if (track == NULL)
594       {
595         HLTError(Form("%s from MUON does not contain AliESDMuonTrack objects.", obj->ClassName()));
596         continue;
597       }
598     }
599     for (Int_t i = 0; i < tracklist->GetEntriesFast(); ++i)
600     {
601       const AliESDMuonTrack* track = static_cast<const AliESDMuonTrack*>(tracklist->UncheckedAt(i));
602       pESD->AddMuonTrack(track);
603     }
604   }
605   
606   if (iAddedDataBlocks>0 && pTree) {
607     pTree->Fill();
608   }
609   
610   if (iResult>=0) iResult=iAddedDataBlocks;
611   return iResult;
612 }