provide OCDB URI as macro argument
[u/mrichter/AliRoot.git] / HLT / benchmark / AliHLTBenchExternalTrackComponent.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   AliHLTBenchExternalTrackComponent.cxx
20     @author Matthias Richter
21     @date   2008-10-30
22     @brief  Benchmark component for AliExternalTrackParam transportation.
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 "AliHLTBenchExternalTrackComponent.h"
33 #include "AliExternalTrackParam.h"
34 #include "AliHLTExternalTrackParam.h"
35 #include "TString.h"
36 #include "TDatime.h"
37 #include "TRandom.h"
38 #include "TMath.h"
39 #include "TObjArray.h"
40 #include "TClonesArray.h"
41 #include "TClass.h"
42 #include "TList.h"
43
44 /** global object for component registration */
45 AliHLTBenchExternalTrackComponent gAliHLTBenchExternalTrackComponent;
46
47 /** ROOT macro for the implementation of ROOT specific class methods */
48 ClassImp(AliHLTBenchExternalTrackComponent)
49
50 AliHLTBenchExternalTrackComponent::AliHLTBenchExternalTrackComponent()
51   : AliHLTProcessor()
52   , fVerbosity(0)
53   , fDisableRegistry(false)
54   , fMode(kPublishingOff)
55   , fMaxSize(10000)
56   , fMinSize(100)
57   , fEventModulo(-1)
58   , fRangeOffset(0)
59   , fRangeMultiplicator(1.0)
60   , fpTcArray(NULL)
61   , fpTObjArray(NULL)
62   , fpDice(NULL)
63 {
64   // see header file for class documentation
65   // or
66   // refer to README to build package
67   // or
68   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
69 }
70
71 AliHLTBenchExternalTrackComponent::~AliHLTBenchExternalTrackComponent()
72 {
73   // see header file for class documentation
74 }
75
76 const char* AliHLTBenchExternalTrackComponent::GetComponentID()
77 {
78   // see header file for class documentation
79   return "BenchmarkAliExternalTrackParam";
80 }
81
82 void AliHLTBenchExternalTrackComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list)
83 {
84   // see header file for class documentation
85   list.clear();
86   list.push_back(kAliHLTAnyDataType);
87 }
88
89 AliHLTComponentDataType AliHLTBenchExternalTrackComponent::GetOutputDataType()
90 {
91   // see header file for class documentation
92   return kAliHLTMultipleDataType;
93 }
94
95 int AliHLTBenchExternalTrackComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList)
96 {
97   // see header file for class documentation
98   tgtList.clear();
99   tgtList.push_back(kAliHLTDataTypeTObject);
100   return tgtList.size();
101 }
102
103 void AliHLTBenchExternalTrackComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier)
104 {
105   // see header file for class documentation
106   constBase=sizeof(AliHLTExternalTrackParam)*fMaxSize;
107   inputMultiplier=0.0;
108 }
109
110 AliHLTComponent* AliHLTBenchExternalTrackComponent::Spawn()
111 {
112   // see header file for class documentation
113   return new AliHLTBenchExternalTrackComponent;
114 }
115
116 int AliHLTBenchExternalTrackComponent::DoInit(int argc, const char** argv)
117 {
118   // see header file for class documentation
119   int iResult=0;
120   TString argument="";
121   bool bMissingParam=0;
122   char* cpErr=NULL;
123   int i=0;
124   for (; i<argc && iResult>=0; i++) {
125     cpErr=NULL;
126     argument=argv[i];
127     if (argument.IsNull()) continue;
128
129     // -tobjarray
130     if (argument.CompareTo("-tobjarray")==0) {
131       fMode=ktobjarray;
132
133     // -tclonesarray
134     } else if (argument.CompareTo("-tclonesarray")==0) {
135       fMode=ktclonesarray;
136
137     // -carray
138     } else if (argument.CompareTo("-carray")==0) {
139       fMode=kcarray;
140
141     // -maxsize
142     } else if (argument.CompareTo("-maxsize")==0) {
143       if ((bMissingParam=(++i>=argc))) break;
144       fMaxSize=strtoul( argv[i], &cpErr ,0);
145       if ( *cpErr ) break;
146
147     // -minsize
148     } else if (argument.CompareTo("-minsize")==0) {
149       if ((bMissingParam=(++i>=argc))) break;
150       fMinSize=strtoul( argv[i], &cpErr ,0);
151       if ( *cpErr ) break;
152
153     // -rangemodulo
154     } else if (argument.CompareTo("-rangemodulo")==0) {
155       if ((bMissingParam=(++i>=argc))) break;
156       fEventModulo=strtoul( argv[i], &cpErr ,0);
157       if ( *cpErr ) break;
158
159     // -rangeoffset
160     } else if (argument.CompareTo("-rangeoffset")==0) {
161       if ((bMissingParam=(++i>=argc))) break;
162       fRangeOffset=strtoul( argv[i], &cpErr ,0);
163       if ( *cpErr ) break;
164
165     // -rangefactor
166     } else if (argument.CompareTo("-rangefactor")==0) {
167       if ((bMissingParam=(++i>=argc))) break;
168       fRangeMultiplicator=strtof( argv[i], &cpErr);
169       if ( *cpErr ) break;
170
171     // -verbosity
172     } else if (argument.CompareTo("-verbosity")==0) {
173       if ((bMissingParam=(++i>=argc))) break;
174       fVerbosity=strtoul( argv[i], &cpErr ,0);
175       if ( *cpErr ) break;
176
177     // -nocheck
178     } else if (argument.CompareTo("-nocheck")==0) {
179       fDisableRegistry=true;
180
181     } else {
182       HLTError("unknown argument %s", argument.Data());
183       iResult=-EINVAL;
184     }
185   }
186
187   if (cpErr && *cpErr) {
188     HLTError("Cannot convert specifier '%s' for argument '%s'", argv[i], argument.Data());
189     iResult=-EINVAL;
190   } else if (bMissingParam) {
191     HLTError("missing parameter for argument %s", argument.Data());
192     iResult=-EINVAL;
193   }
194
195   // use a TClonesArray internally and for publishing in case of
196   // ktclonesarray. The maximum size and all members are allocated
197   fpTcArray=new TClonesArray("AliExternalTrackParam", fMaxSize);
198   if (fpTcArray) {
199     fpTcArray->ExpandCreate(fMaxSize);
200     switch (fMode) {
201     case kPublishingOff:
202       // nothing to do
203       break;
204     case ktclonesarray:
205     case kcarray:
206       // nothing to do
207       break;
208     case ktobjarray:
209       // use a TObjArray which owns the objects
210       fpTObjArray=new TObjArray;
211       if (!fpTObjArray) {
212         iResult=-ENOMEM;
213       }
214       break;
215     default:
216       HLTError("unknown publishing mode %d", fMode);
217       iResult=-EINVAL;
218     }
219   } else {
220     iResult=-ENOMEM;
221   }
222
223   if (iResult>=0) {
224     fpDice=new TRandom;
225     if (fpDice) {
226       TDatime dt;
227       fpDice->SetSeed(dt.Get());
228     } else {
229        iResult=-ENOMEM;
230     }
231   }
232
233   return iResult;
234 }
235
236 int AliHLTBenchExternalTrackComponent::DoDeinit()
237 {
238   // see header file for class documentation
239   if (fpTObjArray) delete fpTObjArray;
240   fpTObjArray=NULL;
241
242   if (fpTcArray) {
243     fpTcArray->Delete();
244     delete fpTcArray;
245     fpTcArray=NULL;
246   }
247
248   if (fpDice) delete fpDice;
249   fpDice=NULL;
250
251   return 0;
252 }
253
254 int AliHLTBenchExternalTrackComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/,
255                                                         const AliHLTComponentBlockData* /*blocks*/,
256                                                         AliHLTComponentTriggerData& /*trigData*/,
257                                                         AliHLTUInt8_t* outputPtr, 
258                                                         AliHLTUInt32_t& size,
259                                                         AliHLTComponentBlockDataList& outputBlocks)
260 {
261   // see header file for class documentation
262
263   // scan the input data blocks for types kAliHLTDataTypeTrack and
264   // kAliHLTDataTypeTObjArray with AliExternalTrackParam objects
265   // 
266   // If data is available, the array is extracted into the internal
267   // TClonesArray fpTcArray. If no input data is available, the array
268   // is filled randomly, both in size and content.
269   //
270   // The array is published according to the fMode member either as
271   // TClonesArray, TObjArray or C-structure (AliHLTExternalTrackParam)
272
273   int iResult=0;
274   AliHLTUInt32_t capacity=size;
275   size=0;
276   if (!IsDataEvent()) return 0;
277   if (!fpTcArray || !fpDice) return -ENODEV;
278
279   unsigned int arraySize=0;
280   const AliHLTComponentBlockData* pBlock=NULL;
281   const TObject* pObject=NULL;
282   const TObjArray* pObjArray=NULL;
283   AliHLTUInt32_t spec=0;
284   if ((pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack))!=NULL) {
285     if (pBlock->fSize%sizeof(AliHLTExternalTrackParam)==0) {
286       arraySize=pBlock->fSize/sizeof(AliHLTExternalTrackParam);
287       if (fpTcArray) {
288         spec=GetSpecification(pBlock);
289         fpTcArray->ExpandCreate(arraySize);
290         if ((iResult=ReadFromStruct(fpTcArray, reinterpret_cast<AliHLTExternalTrackParam*>(pBlock->fPtr), arraySize))<0) {
291           HLTError("can not convert struct to TObjArray, error %d", iResult);
292         } else {
293           pObjArray=fpTcArray;
294           HLTDebug("created TObjArray from C struct, specification 0x%08x", spec);
295         }
296       } else {
297         iResult=-ENOMEM;
298       }
299     } else {
300       HLTWarning("data block does not match the AliHLTExternalTrackParam struct size");
301     }
302   } else if ((pObject=GetFirstInputObject(kAliHLTDataTypeTObjArray))!=NULL) {
303     pObjArray=dynamic_cast<const TObjArray*>(pObject);
304     if (pObjArray) {
305       spec=GetSpecification(pObject);
306       HLTDebug("extracted TObjArray, specification 0x%08x", spec);
307     } else {
308       HLTWarning("object of data type %s is not of type TObjArray, ignoring it",
309                  DataType2Text(GetDataType()).c_str());
310     }
311   }
312   
313   if (pObjArray) {
314     // we already have the object array, if publishing mode is >0 the
315     // block is forwarded according to the mode
316     // 
317     // if specification is >0 the source object is searched in the list
318     // and compared with the extracted one.
319     if (spec>0) {
320       TObject* pSrcObject=FindObject(spec);
321       TObjArray* pSrcArray=NULL;
322       if (!pSrcObject) {
323         HLTError("can not find source object of id 0x%08x", spec);
324       } else if ((pSrcArray=dynamic_cast<TObjArray*>(pSrcObject))==NULL) {
325         HLTError("type cast failed for object");
326       } else if (!Compare(pObjArray, pSrcArray)) {
327         HLTError("extracted array differs from source array");
328         if (fVerbosity>1) {
329           for (int i=0; i<pObjArray->GetEntries(); i++) {
330             pObjArray->At(i)->Print();
331           }
332           HLTError("dump of original array");
333           for (int i=0; i<pSrcArray->GetEntries(); i++) {
334             pSrcArray->At(i)->Print();
335           }
336         }
337       } else {
338         if (fVerbosity>0) {
339           HLTInfo("extracted array of size %d", pObjArray->GetEntries());
340         }
341       }
342     }
343   } else {
344     // no array to forward, create a new one
345     arraySize=fpDice->Integer(fMaxSize-fMinSize)+fMinSize;
346     fpTcArray->ExpandCreate(arraySize);
347     for (unsigned int track=0; track<arraySize; track++) {
348       FillRandom(reinterpret_cast<AliExternalTrackParam*>(fpTcArray->At(track)));
349     }
350     pObjArray=fpTcArray;
351   }
352
353   switch (fMode) {
354   case kPublishingOff:
355     break;
356   case ktclonesarray:
357       // register the object if it is not a forwarded array
358     if (spec==0 && pObjArray==fpTcArray) spec=Register(fpTcArray);
359     if ((iResult=PushBack(const_cast<TObjArray*>(pObjArray), kAliHLTDataTypeTObjArray, spec))>=0) {
360       if (fVerbosity>0) {
361         HLTInfo("publishing TClonesarray, %d elements, specification 0x%08x", pObjArray->GetEntries(), spec);
362       }
363     }
364     break;
365   case kcarray:
366     iResult=SerializeToStruct(pObjArray, outputPtr, capacity);
367     if (iResult>=0) {
368       size=iResult;
369       AliHLTComponentBlockData bd;
370       FillBlockData(bd);
371       bd.fPtr=NULL;
372       bd.fOffset=0;
373       bd.fSize=size;
374       bd.fDataType=kAliHLTDataTypeTrack;
375       // register the object if it is not a forwarded array
376       if (spec==0 && pObjArray==fpTcArray) spec=Register(fpTcArray);
377       bd.fSpecification=spec;
378       outputBlocks.push_back(bd);
379       if (fVerbosity>0) {
380         HLTInfo("publishing C array, %d elements, specification 0x%08x", bd.fSize/sizeof(AliHLTExternalTrackParam), bd.fSpecification);
381       }
382     }
383     break;
384   case ktobjarray:
385     // use a TObjArray which owns the objects
386     if (fpTObjArray) {
387       fpTObjArray->Clear();
388       int entries=pObjArray->GetEntries();
389       for (int i=0; i<entries; i++) {
390         fpTObjArray->Add(pObjArray->At(i));
391       }
392
393       // register the object if it is not a forwarded array
394       if (spec==0 && pObjArray==fpTcArray) spec=Register(fpTObjArray);
395       if ((iResult=PushBack(fpTObjArray, kAliHLTDataTypeTObjArray, spec))>=0) {
396         if (fVerbosity>0) {
397           HLTInfo("publishing TObjArray, %d elements, specification 0x%08x", pObjArray->GetEntries(), spec);
398         }
399       }
400     } else {
401       HLTError("object array not initialized");
402       iResult=-EFAULT;
403     }
404     break;
405   default:
406     HLTError("unknown publishing mode %d", fMode);
407     iResult=-EINVAL;
408   }
409
410   if (fEventModulo>0 &&
411       ((GetEventCount()+1)%fEventModulo)==0 &&
412       (fRangeMultiplicator!=1.0 || fRangeOffset!=0)) {
413     fMaxSize+=fRangeOffset;
414     fMaxSize=(int)(fMaxSize*fRangeMultiplicator);
415     fMinSize+=fRangeOffset;
416     fMinSize=(int)(fMinSize*fRangeMultiplicator);
417     if (fMaxSize<1) fMaxSize=1;
418     if (fMinSize<1) fMinSize=1;
419   }
420   return iResult;
421 }
422
423 int AliHLTBenchExternalTrackComponent::FillRandom(AliExternalTrackParam* track, int fillCov)
424 {
425   // see header file for class documentation
426   int iResult=0;
427   if (!track) return -EINVAL;
428   Double_t param[5];
429   Double_t covar[15];
430
431   static TRandom* rand=NULL;
432   if (!rand) {
433     rand=new TRandom;
434     if (!rand) return -ENOMEM;
435     TDatime dt;
436     rand->SetSeed(dt.Get());
437   }
438
439   param[0]=(Double_t)rand->Integer(100);
440   param[1]=(Double_t)rand->Integer(100);
441   param[2]=(Double_t)rand->Integer(100)/100;
442   param[3]=(Double_t)rand->Integer(100)/100;
443   param[4]=(Double_t)rand->Integer(100);
444   for (int i=0; i<15 && i<fillCov; i++) {
445     covar[i]=(Double_t)rand->Integer(1000)/1000;
446   }
447   track->Set((Double_t)rand->Integer(1000),(Double_t)rand->Integer(100)/100, param, covar );
448   return iResult;
449 }
450
451 int AliHLTBenchExternalTrackComponent::SerializeToStruct(const TObjArray* pArray, AliHLTUInt8_t* buffer, unsigned int size)
452 {
453   // see header file for class documentation
454   int iResult=0;
455   if (!pArray || !buffer) return -EINVAL;
456   int entries=pArray->GetEntries();
457   if (entries*sizeof(AliHLTExternalTrackParam)>size) return -ENOSPC;
458
459   AliHLTLogging log;
460   AliHLTExternalTrackParam* tgtParam=reinterpret_cast<AliHLTExternalTrackParam*>(buffer);
461   for (int track=0; track<entries; track++, tgtParam++) {
462     TObject* pObj=pArray->At(track);
463     if (!pObj) {
464       log.LoggingVarargs(kHLTLogError, "AliHLTBenchExternalTrackComponent", "SerializeToStruct" , __FILE__ , __LINE__ ,
465                           "internal mismatch: can not get object %d from array. aborting", track);
466       iResult=-ENOENT;
467       break;
468     }
469     AliExternalTrackParam* srcParam=dynamic_cast<AliExternalTrackParam*>(pObj);
470     if (!srcParam) {
471       log.LoggingVarargs(kHLTLogError, "AliHLTBenchExternalTrackComponent", "SerializeToStruct" , __FILE__ , __LINE__ ,
472                           "object %d has wrong type %s, expecting %s", track, pObj->Class()->GetName(), "AliExternalTrackParam");
473       iResult=-ENOENT;
474       break;
475     }
476     
477     //= srcParam->GetAlpha();
478     tgtParam->fX = srcParam->GetX();
479     tgtParam->fY = srcParam->GetY();
480     tgtParam->fZ = srcParam->GetZ();
481     tgtParam->fLastX=0;
482     tgtParam->fLastY=0;
483     tgtParam->fLastZ=0;
484     tgtParam->fSinPsi = srcParam->GetSnp();
485     tgtParam->fTgl = srcParam->GetTgl();
486     tgtParam->fq1Pt = srcParam->GetSigned1Pt();
487     const Double_t *cov=srcParam->GetCovariance();
488
489     for (int i=0; i<15; i++) {
490       tgtParam->fC[i]=cov[i];
491     }
492     tgtParam->fNPoints=0;
493   }
494
495   if (iResult>=0) {
496     iResult=entries*sizeof(AliHLTExternalTrackParam);
497   }
498
499   return iResult;
500 }
501
502 int AliHLTBenchExternalTrackComponent::ReadFromStruct(TObjArray* pTgtArray, AliHLTExternalTrackParam* pArray, unsigned int arraySize)
503 {
504   // see header file for class documentation
505   AliHLTLogging log;
506   if ((unsigned)pTgtArray->GetEntries()<arraySize) {
507     log.LoggingVarargs(kHLTLogError, "AliHLTBenchExternalTrackComponent", "ReadFromStruct" , __FILE__ , __LINE__ ,
508                        "not enough space in target array: %d, required %d", pTgtArray->GetEntries(), arraySize);
509     return -ENOSPC;
510   }
511
512   Double_t param[5];
513   Double_t covar[15];
514
515   for (unsigned int track=0; track<arraySize; track++) {
516     AliExternalTrackParam* tp=dynamic_cast<AliExternalTrackParam*>(pTgtArray->At(track));
517     if (tp) {
518       // enable if AliExternalTrackParam allows templates
519       //tp->Set(pArray[track].fX, (Float_t)0.0, &pArray[track].fY, pArray[track].fC);
520       param[0]=pArray[track].fY;
521       param[1]=pArray[track].fZ;
522       param[2]=pArray[track].fSinPsi;
523       param[3]=pArray[track].fTgl;
524       param[4]=pArray[track].fq1Pt;
525       for (int i=0; i<15; i++) {
526         covar[i]=pArray[track].fC[i];
527       }
528       tp->Set((Double_t)pArray[track].fX, (Double_t)0.0, param, covar);
529     } else {
530       log.LoggingVarargs(kHLTLogError, "AliHLTBenchExternalTrackComponent", "ReadFromStruct" , __FILE__ , __LINE__ ,
531                          "invalid object type %s", pTgtArray->At(track)->Class()->GetName());
532       return -EFAULT;
533     }
534   }
535   return arraySize;
536 }
537
538 AliHLTUInt32_t AliHLTBenchExternalTrackComponent::CalcChecksum(const TObjArray* pArray)
539 {
540   // see header file for class documentation
541   AliHLTUInt32_t crc=0;
542   int entries=0;
543   if (pArray && (entries=pArray->GetEntries())>0) {
544     AliHLTLogging log;
545     unsigned int bufferSize=entries*sizeof(AliHLTExternalTrackParam);
546     AliHLTUInt8_t* buffer=new AliHLTUInt8_t[bufferSize];
547     if (buffer && SerializeToStruct(pArray, buffer, bufferSize)>0) {
548       crc=CalculateChecksum(buffer, bufferSize);
549     } else if (buffer) {
550       log.LoggingVarargs(kHLTLogError, "AliHLTBenchExternalTrackComponent", "SerializeToStruct" , __FILE__ , __LINE__ ,
551                          "failed to serialize TObjArray");
552     }
553   }
554   return crc;
555 }
556
557 bool AliHLTBenchExternalTrackComponent::Compare(const TObjArray* array1, const TObjArray* array2) 
558 {
559   // see header file for class documentation
560   if (!array1 || !array2) return false;
561   int entries=array1->GetEntries();
562   if (entries!=array2->GetEntries()) {
563     return false;
564   }
565
566   for (int i=0; i<entries; i++) {
567     TObject* object1=array1->At(i);
568     TObject* object2=array2->At(i);
569     if (!object1 || !object2) return false;
570
571     AliExternalTrackParam* param1=dynamic_cast<AliExternalTrackParam*>(object1);
572     AliExternalTrackParam* param2=dynamic_cast<AliExternalTrackParam*>(object2);
573     if (!param1 || !param2) return false;
574
575     if (TMath::Abs(param1->GetX()-param2->GetX())>0.0001) return false;
576     if (TMath::Abs(param1->GetY()-param2->GetY())>0.0001) return false;
577     if (TMath::Abs(param1->GetZ()-param2->GetZ())>0.0001) return false;
578     if (TMath::Abs(param1->GetSnp()-param2->GetSnp())>0.0001) return false;
579     if (TMath::Abs(param1->GetTgl()-param2->GetTgl())>0.0001) return false;
580     if (TMath::Abs(param1->GetSigned1Pt()-param2->GetSigned1Pt())>0.0001) return false;
581
582     if (TMath::Abs(param1->GetSigmaY2()-param2->GetSigmaY2())>0.0001) return false;
583     if (TMath::Abs(param1->GetSigmaZY()-param2->GetSigmaZY())>0.0001) return false;
584     if (TMath::Abs(param1->GetSigmaZ2()-param2->GetSigmaZ2())>0.0001) return false;
585     if (TMath::Abs(param1->GetSigmaSnpY()-param2->GetSigmaSnpY())>0.0001) return false;
586     if (TMath::Abs(param1->GetSigmaSnpZ()-param2->GetSigmaSnpZ())>0.0001) return false;
587     if (TMath::Abs(param1->GetSigmaSnp2()-param2->GetSigmaSnp2())>0.0001) return false;
588     if (TMath::Abs(param1->GetSigmaTglY()-param2->GetSigmaTglY())>0.0001) return false;
589     if (TMath::Abs(param1->GetSigmaTglZ()-param2->GetSigmaTglZ())>0.0001) return false;
590     if (TMath::Abs(param1->GetSigmaTglSnp()-param2->GetSigmaTglSnp())>0.0001) return false;
591     if (TMath::Abs(param1->GetSigmaTgl2()-param2->GetSigmaTgl2())>0.0001) return false;
592     if (TMath::Abs(param1->GetSigma1PtY()-param2->GetSigma1PtY())>0.0001) return false;
593     if (TMath::Abs(param1->GetSigma1PtZ()-param2->GetSigma1PtZ())>0.0001) return false;
594     if (TMath::Abs(param1->GetSigma1PtSnp()-param2->GetSigma1PtSnp())>0.0001) return false;
595     if (TMath::Abs(param1->GetSigma1PtTgl()-param2->GetSigma1PtTgl())>0.0001) return false;
596     if (TMath::Abs(param1->GetSigma1Pt2()-param2->GetSigma1Pt2())>0.0001) return false;
597   }
598
599   return true;
600 }
601
602 TList* AliHLTBenchExternalTrackComponent::fgpRegistry=NULL;
603
604 TObject* AliHLTBenchExternalTrackComponent::FindObject(AliHLTUInt32_t id)
605 {
606   // see header file for class documentation
607   if (!fgpRegistry) return NULL;
608
609   TIter iter(fgpRegistry);
610   TObject* pObj=NULL;
611   while ((pObj=iter.Next())) {
612     if (pObj->GetUniqueID()==id) break;
613   }
614   return pObj;
615 }
616
617 AliHLTUInt32_t AliHLTBenchExternalTrackComponent::Register(TObject* pObject)
618 {
619   // see header file for class documentation
620   if (fDisableRegistry) return 0;
621
622   if (!fgpRegistry) {
623     fgpRegistry=new TList;
624   }
625   if (!fgpRegistry) return 0;
626
627   TObject* pExist=fgpRegistry->FindObject(pObject);
628   if (pExist) return pExist->GetUniqueID();
629
630   AliHLTUInt32_t id=AliHLTComponent::CalculateChecksum(reinterpret_cast<AliHLTUInt8_t*>(&pObject), sizeof(TObject*));
631   pExist=FindObject(id);
632   assert(pExist==NULL);
633   pObject->SetUniqueID(id);
634   fgpRegistry->Add(pObject);
635   HLTInfo("adding object %p with id 0x%08x to registry", pObject, id);
636   return id;
637 }
638
639 int AliHLTBenchExternalTrackComponent::Unregister(TObject* pObject)
640 {
641   // see header file for class documentation
642   if (!fgpRegistry) return 0;
643
644   if (fgpRegistry->Remove(pObject)==pObject) return 0;
645
646   return -ENOENT;
647 }