adjusting interface to the offline ITS CF in accordance to recent changes in the...
[u/mrichter/AliRoot.git] / HLT / ITS / AliHLTITSClusterFinderComponent.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: Gaute Øvrebekk <st05886@alf.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   AliHLTITSClusterFinderComponent.cxx
19     @author Gaute Øvrebekk <st05886@alf.uib.no>
20     @date   
21     @brief  Component to run offline clusterfinders
22 */
23
24 #if __GNUC__>= 3
25 using namespace std;
26 #endif
27
28 #include "AliHLTITSClusterFinderComponent.h" 
29
30 #include "AliCDBEntry.h"
31 #include "AliCDBManager.h"
32 #include "AliCDBStorage.h"
33 #include "AliITSgeomTGeo.h"
34 #include "AliITSRecPoint.h"
35 #include "AliHLTITSSpacePointData.h"
36 #include "AliHLTITSClusterDataFormat.h"
37 #include <AliHLTDAQ.h>
38 #include "AliGeomManager.h"
39 #include "AliITSRecoParam.h"
40 #include "AliITSReconstructor.h"
41 #include "AliHLTITSClusterFinderSPD.h"
42 #include "AliHLTITSClusterFinderSSD.h"
43 #include "TMap.h"
44
45 #include <cstdlib>
46 #include <cerrno>
47 #include "TFile.h"
48 #include "TString.h"
49 #include "TObjString.h"
50 #include <sys/time.h>
51
52 /** ROOT macro for the implementation of ROOT specific class methods */
53 ClassImp(AliHLTITSClusterFinderComponent);
54
55 AliHLTITSClusterFinderComponent::AliHLTITSClusterFinderComponent(int mode)
56   :
57   fModeSwitch(mode),
58   fInputDataType(kAliHLTVoidDataType),
59   fOutputDataType(kAliHLTVoidDataType),
60   fUseOfflineFinder(0),
61   fNModules(0),
62   fId(0),
63   fNddl(0),
64   fClusters(NULL),
65   fRawReader(NULL),
66   fDettype(NULL),
67   fgeom(NULL),
68   fgeomInit(NULL),
69   fSPD(NULL),
70   fSSD(NULL),
71   tD(NULL),
72   tR(NULL),
73   fclusters(),
74   fBenchmark(GetComponentID())
75
76   // see header file for class documentation
77   // or
78   // refer to README to build package
79   // or
80   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
81
82   switch(fModeSwitch){
83   case kClusterFinderSPD:
84     fInputDataType  = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginITSSPD;
85     fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD;
86     break;
87   case kClusterFinderSDD:        
88     fInputDataType  = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginITSSDD;
89     fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD;
90     break;
91   case kClusterFinderSSD:
92     fInputDataType  = kAliHLTDataTypeDDLRaw | kAliHLTDataOriginITSSSD;
93     fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD;
94     break;
95   case kClusterFinderDigits:
96     fInputDataType  = kAliHLTDataTypeAliTreeD|kAliHLTDataOriginITS;
97     fOutputDataType = kAliHLTDataTypeClusters|kAliHLTDataOriginITS;
98     break;
99   default:
100     HLTFatal("unknown cluster finder");
101   }
102 }
103
104 AliHLTITSClusterFinderComponent::~AliHLTITSClusterFinderComponent() 
105 {
106   // see header file for class documentation
107   delete fRawReader;
108   delete fDettype;
109   delete fgeomInit;  
110   delete fSPD;
111   delete fSSD;
112 }
113
114 // Public functions to implement AliHLTComponent's interface.
115 // These functions are required for the registration process
116
117 const char* AliHLTITSClusterFinderComponent::GetComponentID()
118 {
119   // see header file for class documentation
120   switch(fModeSwitch){
121   case kClusterFinderSPD:
122     return "ITSClusterFinderSPD";
123     break;
124   case kClusterFinderSDD:        
125     return "ITSClusterFinderSDD";
126     break;
127   case kClusterFinderSSD:
128     return "ITSClusterFinderSSD";
129     break;
130   case kClusterFinderDigits:
131     return "ITSClusterFinderDigits";
132     break;
133   }
134   return "";
135 }
136
137 void AliHLTITSClusterFinderComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list) 
138 {
139   // see header file for class documentation
140   list.clear(); 
141   list.push_back( fInputDataType );
142 }
143
144 AliHLTComponentDataType AliHLTITSClusterFinderComponent::GetOutputDataType() 
145 {
146   // see header file for class documentation
147   return fOutputDataType;
148 }
149
150 void AliHLTITSClusterFinderComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) {
151   // see header file for class documentation
152   constBase = 0;
153   inputMultiplier = 100;
154 }
155
156 AliHLTComponent* AliHLTITSClusterFinderComponent::Spawn() {
157   // see header file for class documentation
158   return new AliHLTITSClusterFinderComponent(fModeSwitch);
159 }
160         
161 Int_t AliHLTITSClusterFinderComponent::DoInit( int argc, const char** argv ) {
162   // see header file for class documentation
163   fBenchmark.Reset();
164   fBenchmark.SetTimer(0,"total");
165   fBenchmark.SetTimer(1,"reco");
166
167   /*
168   fStatTime = 0;
169   fStatTimeAll = 0;
170   fStatTimeC = 0;
171   fStatTimeAllC = 0;
172   fStatNEv = 0;
173   */
174   
175   Int_t runNo = GetRunNo();
176   AliCDBStorage* store = AliCDBManager::Instance()->GetDefaultStorage();
177   if (!store) {
178     return NULL;
179   }
180
181   bool cdbOK = true;
182   //OCDB for SPD
183   if(store->GetLatestVersion("ITS/Calib/SPDNoisy", runNo)<0){
184     HLTError("SPDNoisy is not found in SPD/Calib");
185     cdbOK = false;
186   }
187   if(store->GetLatestVersion("ITS/Calib/SPDDead", runNo)<0){
188     HLTError("SPDDead is not found in SPD/Calib");
189     cdbOK = false;
190   }
191   if(store->GetLatestVersion("TRIGGER/SPD/PITConditions", runNo)<0){
192     HLTError("PITConditions is not found in TRIGGER/SPD");
193     cdbOK = false;
194   }
195   
196   //OCDB for SDD
197   if(store->GetLatestVersion("ITS/Calib/CalibSDD", runNo)<0){
198     HLTError("CalibSDD is not found in ITS/Calib");
199     cdbOK = false;
200   }
201   if(store->GetLatestVersion("ITS/Calib/RespSDD", runNo)<0){
202     HLTError("RespSDD is not found in ITS/Calib");
203     cdbOK = false;
204   }
205   if(store->GetLatestVersion("ITS/Calib/DriftSpeedSDD", runNo)<0){
206     HLTError("DriftSpeedSDD is not found in ITS/Calib");
207     cdbOK = false;
208   }
209   if(store->GetLatestVersion("ITS/Calib/DDLMapSDD", runNo)<0){
210     HLTError("DDLMapSDD is not found in ITS/Calib");
211     cdbOK = false;
212   }
213   if(store->GetLatestVersion("ITS/Calib/MapsTimeSDD", runNo)<0){
214     HLTError("MapsTimeSDD is not found in ITS/Calib");
215     cdbOK = false;
216   }
217
218   //OCDB for SSD
219   if(store->GetLatestVersion("ITS/Calib/NoiseSSD", runNo)<0){
220     HLTError("NoiseSSD is not found in ITS/Calib");
221     cdbOK = false;
222   }
223   if(store->GetLatestVersion("ITS/Calib/GainSSD", runNo)<0){
224     HLTError("GainSSD is not found in ITS/Calib");
225     cdbOK = false;
226   }
227   if(store->GetLatestVersion("ITS/Calib/BadChannelsSSD", runNo)<0){
228     HLTError("BadChannelsSSD is not found in ITS/Calib");
229     cdbOK = false;
230   }
231   
232   //General reconstruction
233   if(store->GetLatestVersion("GRP/CTP/Scalers", runNo)<0){
234     HLTError("Scalers is not found in GRP/CTP/");
235     cdbOK = false;
236   }
237   if(!cdbOK){return NULL;}
238
239   if(fModeSwitch==kClusterFinderSPD) {
240     HLTDebug("using ClusterFinder for SPD");
241     //fNModules=AliITSgeomTGeo::GetNDetectors(1)*AliITSgeomTGeo::GetNLadders(1) + AliITSgeomTGeo::GetNDetectors(2)*AliITSgeomTGeo::GetNLadders(2);
242     fId=AliHLTDAQ::DdlIDOffset("ITSSPD");
243     fNddl=AliHLTDAQ::NumberOfDdls("ITSSPD");
244   }
245   else if(fModeSwitch==kClusterFinderSDD) {
246     HLTDebug("using ClusterFinder for SDD");
247     //fNModules=AliITSgeomTGeo::GetNDetectors(3)*AliITSgeomTGeo::GetNLadders(3) + AliITSgeomTGeo::GetNDetectors(4)*AliITSgeomTGeo::GetNLadders(4);
248     fId=AliHLTDAQ::DdlIDOffset("ITSSDD");
249     fNddl=AliHLTDAQ::NumberOfDdls("ITSSDD");
250   }
251   else if(fModeSwitch==kClusterFinderSSD) {
252     HLTDebug("using ClusterFinder for SSD");
253     //fNModules=AliITSgeomTGeo::GetNDetectors(5)*AliITSgeomTGeo::GetNLadders(5) + AliITSgeomTGeo::GetNDetectors(6)*AliITSgeomTGeo::GetNLadders(6);
254     fId=AliHLTDAQ::DdlIDOffset("ITSSSD");
255     fNddl=AliHLTDAQ::NumberOfDdls("ITSSSD");
256   }
257   else if(fModeSwitch==kClusterFinderDigits) {
258     //tR = new TTree();
259   }
260   else{
261      HLTFatal("No mode set for clusterfindercomponent");
262   }
263
264   //Removed the warning for loading default RecoParam in HLT
265   AliITSRecoParam *par = AliITSRecoParam::GetLowFluxParam();
266   AliITSReconstructor *rec = new AliITSReconstructor();
267   rec->SetRecoParam(par);
268   
269   AliCDBManager* man = AliCDBManager::Instance();
270   if (!man->IsDefaultStorageSet()){
271     HLTError("Default CDB storage has not been set !");
272     return -ENOENT;
273   }
274
275   if(AliGeomManager::GetGeometry()==NULL){
276     AliGeomManager::LoadGeometry();
277   }
278
279   fgeomInit = new AliITSInitGeometry();
280   //fgeomInit = new AliITSInitGeometry(kvPPRasymmFMD,2);
281   //fgeomInit->InitAliITSgeom(fgeom);
282   fgeom = fgeomInit->CreateAliITSgeom();
283  
284   fNModules = fgeom->GetIndexMax();
285
286   fClusters = new TClonesArray*[fNModules]; 
287   for (Int_t iModule = 0; iModule < fNModules; iModule++) {
288     fClusters[iModule] = NULL;
289   } 
290
291   //set dettype
292   fDettype = new AliITSDetTypeRec();
293   fDettype->SetITSgeom(fgeom); 
294   fDettype->SetDefaults();
295   fDettype->SetDefaultClusterFindersV2(kTRUE); 
296
297   if ( fRawReader )
298     return -EINPROGRESS;
299
300   fRawReader = new AliRawReaderMemory();
301   fSPD = new AliHLTITSClusterFinderSPD( fDettype );
302   fSSD = new AliHLTITSClusterFinderSSD( fDettype, fRawReader );
303
304   TString arguments = "";
305   for ( int i = 0; i < argc; i++ ) {
306     if ( !arguments.IsNull() ) arguments += " ";
307     arguments += argv[i];
308   }
309
310   tD = NULL;
311   tR = NULL;
312
313   return Configure( arguments.Data() );
314 }
315
316 Int_t AliHLTITSClusterFinderComponent::DoDeinit() {
317   // see header file for class documentation
318
319   if ( fRawReader )
320     delete fRawReader;
321   fRawReader = NULL;
322
323   if ( fDettype )
324     delete fDettype;
325   fDettype = NULL;
326
327   if ( fgeomInit )
328     delete fgeomInit;
329   fgeomInit = NULL;
330   
331   delete fSPD;
332   fSPD = 0;
333
334   delete fSSD;
335   fSSD = 0;
336
337   for (Int_t iModule = 0; iModule < fNModules; iModule++) {
338     if(fClusters[iModule] != NULL){
339       fClusters[iModule]->Delete();
340       delete fClusters[iModule];
341     }
342     fClusters[iModule] = NULL;
343   } 
344   
345   fUseOfflineFinder = 0;
346
347   return 0;
348 }
349
350 int AliHLTITSClusterFinderComponent::DoEvent
351 (
352  const AliHLTComponentEventData& evtData,
353  const AliHLTComponentBlockData* /*blocks*/,
354  AliHLTComponentTriggerData& /*trigData*/,
355  AliHLTUInt8_t* outputPtr,
356  AliHLTUInt32_t& size,
357   vector<AliHLTComponentBlockData>& outputBlocks )
358 {
359  // see header file for class documentation
360   
361   AliHLTUInt32_t maxBufferSize = size;
362   size = 0; // output size
363
364   if (!IsDataEvent()) return 0;
365   
366   if ( evtData.fBlockCnt<=0 )
367     {
368       HLTDebug("no blocks in event" );
369       return 0;
370     }
371
372   fBenchmark.StartNewEvent();
373   fBenchmark.Start(0);
374   for( const AliHLTComponentBlockData *i= GetFirstInputBlock(fInputDataType); i!=NULL; i=GetNextInputBlock() ){
375     fBenchmark.AddInput(i->fSize);
376   }
377
378   Int_t ret = 0;
379
380   if(fModeSwitch==kClusterFinderDigits) {
381
382     for ( const TObject *iter = GetFirstInputObject(fInputDataType); iter != NULL; iter = GetNextInputObject() ) {  
383       tD = dynamic_cast<TTree*>(const_cast<TObject*>( iter ) );
384       if(!tD){
385         HLTFatal("No Digit Tree found");
386         return -1;
387       }
388       // 2010-04-17 very crude workaround: TTree objects are difficult to send
389       // The actual case: Running ITS and TPC reconstruction fails at the second event
390       // to read the ITS digits from the TreeD
391       //
392       // Reason: reading fails in TBranch::GetBasket, there a new basket is opened from
393       // a TFile object. The function TBranch::GetFile returns the file object from
394       // an internal fDirectory (TDirectory) object. This file is at the second event
395       // set to the TPC.Digits.root. The internal mismatch creates a seg fault
396       //
397       // Investigation: TBranch::Streamer uses a crude assignment after creating the
398       // TBranch object
399       //    fDirectory = gDirectory;
400       // gDirectory is obviously not set correctly. Setting the directory to a TFile
401       // object for the ITS digits helps to fix the internal mess. Tried also to set
402       // the Directory for the TreeD to NULL (This has only effect if ones sets it 
403       // to something not NULL first, and then to NULL). But then no content, i.e.
404       // ITS clusters could be retrieved.
405       //
406       // Conclusion: TTree objects are hardly to be sent via TMessage, there are direct
407       // links to the file required anyhow.
408       TFile* dummy=new TFile("ITS.Digits.root");
409       tD->SetDirectory(dummy);
410       tR = new TTree();
411       tR->SetDirectory(0);
412       fDettype->SetTreeAddressD(tD);
413       fDettype->MakeBranch(tR,"R");
414       fDettype->SetTreeAddressR(tR);
415       Option_t *opt="All";
416       fBenchmark.Start(1);
417       fDettype->DigitsToRecPoints(tD,tR,0,opt,0);
418       fBenchmark.Stop(1);
419       TClonesArray * fRecPoints = NULL;
420       tR->SetBranchAddress("ITSRecPoints",&fRecPoints);
421       for(Int_t treeEntry=0;treeEntry<tR->GetEntries();treeEntry++){
422         tR->GetEntry(treeEntry);
423         for(Int_t tCloneEntry=0;tCloneEntry<fRecPoints->GetEntries();tCloneEntry++){
424           AliITSRecPoint *recpoint=(AliITSRecPoint*)fRecPoints->At(tCloneEntry);
425           fclusters.push_back(*recpoint);
426         }
427       }
428       
429       if(tR){
430         tR->Delete();
431       }
432
433       tD->SetDirectory(0);
434       delete dummy;
435       UInt_t nClusters=fclusters.size();
436       
437       UInt_t bufferSize = nClusters * sizeof(AliHLTITSSpacePointData) + sizeof(AliHLTITSClusterData);
438       if( size + bufferSize > maxBufferSize ){
439         HLTWarning( "Output buffer size exceed (buffer size %d, current size %d)", maxBufferSize, size+bufferSize);
440         ret = -ENOSPC;      
441         break;          
442       }
443       if( nClusters>0 ){
444         fBenchmark.Start(1);
445         RecPointToSpacePoint(outputPtr,size);
446         fBenchmark.Stop(1);
447         AliHLTComponentBlockData bd;
448         FillBlockData( bd );
449         bd.fOffset = size;
450         bd.fSize = bufferSize;
451         bd.fSpecification = 0x00000000;
452         bd.fDataType = GetOutputDataType();
453         outputBlocks.push_back( bd );
454         size += bufferSize;
455         fBenchmark.AddOutput(bd.fSize);
456         fclusters.clear();      
457       }
458     }
459   }
460   else{
461       
462     // -- Loop over blocks
463     for( const AliHLTComponentBlockData* iter = GetFirstInputBlock(fInputDataType); iter != NULL; iter = GetNextInputBlock() ) {
464       
465       // -- Debug output of datatype --
466       HLTDebug("Event 0x%08LX (%Lu) received datatype: %s - required datatype: %s",
467                evtData.fEventID, evtData.fEventID, 
468                DataType2Text(iter->fDataType).c_str(), 
469                DataType2Text(fInputDataType).c_str());
470       
471       // -- Check for the correct data type
472       if ( iter->fDataType != (fInputDataType) )  
473         continue;
474       
475       // -- Get equipment ID out of specification
476       AliHLTUInt32_t spec = iter->fSpecification;
477       
478       Int_t id = fId;
479       for ( Int_t ii = 0; ii < fNddl ; ii++ ) {   //number of ddl's
480         if ( spec & 0x00000001 ) {
481           id += ii;
482           break;
483         }
484         spec = spec >> 1 ;
485       }
486       
487       // -- Set equipment ID to the raw reader
488       
489       if(!fRawReader){
490         HLTWarning("The fRawReader pointer is NULL");
491         continue;
492       }
493
494       if(!fRawReader->AddBuffer((UChar_t*) iter->fPtr, iter->fSize, id)){
495         HLTWarning("Could not add buffer");
496       }
497
498       fBenchmark.Start(1);
499
500       if(fModeSwitch==kClusterFinderSPD && !fUseOfflineFinder){ fSPD->RawdataToClusters( fRawReader, fclusters ); }
501       else if(fModeSwitch==kClusterFinderSSD && !fUseOfflineFinder){ fSSD->RawdataToClusters( fclusters ); }
502       else{
503         if(fModeSwitch==kClusterFinderSPD && fUseOfflineFinder) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SPD");}
504         if(fModeSwitch==kClusterFinderSSD && fUseOfflineFinder) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SSD");}
505         if(fModeSwitch==kClusterFinderSDD) {fDettype->DigitsToRecPoints(fRawReader,fClusters,"SDD");}
506         for(int i=0;i<fNModules;i++){
507           if(fClusters[i] != NULL){
508             for(int j=0;j<fClusters[i]->GetEntriesFast();j++){
509               AliITSRecPoint *recpoint = (AliITSRecPoint*) (fClusters[i]->At(j));
510               fclusters.push_back(*recpoint);
511             }
512             fClusters[i]->Delete();
513             delete fClusters[i];
514           }
515           fClusters[i] = NULL;
516         }     
517       }
518       fBenchmark.Stop(1);
519       
520       fRawReader->ClearBuffers();    
521          
522       UInt_t nClusters=fclusters.size();
523       
524       UInt_t bufferSize = nClusters * sizeof(AliHLTITSSpacePointData) + sizeof(AliHLTITSClusterData);
525       if( size + bufferSize > maxBufferSize ){
526         HLTWarning( "Output buffer size exceed (buffer size %d, current size %d)", maxBufferSize, size+bufferSize);
527         ret = -ENOSPC;      
528         break;          
529       }
530       if( nClusters>0 ){
531
532         RecPointToSpacePoint(outputPtr,size);
533
534         AliHLTComponentBlockData bd;
535         FillBlockData( bd );
536         bd.fOffset = size;
537         bd.fSize = bufferSize;
538         bd.fSpecification = iter->fSpecification;
539         bd.fDataType = GetOutputDataType();
540         outputBlocks.push_back( bd );
541         size += bufferSize;
542         fBenchmark.AddOutput(bd.fSize);
543         fclusters.clear();      
544       }
545       
546     } // input blocks
547   }
548
549   fBenchmark.Stop(0);
550   HLTInfo(fBenchmark.GetStatistics());
551   return ret;
552 }
553
554 int AliHLTITSClusterFinderComponent::Configure(const char* arguments)
555 {
556   
557   int iResult=0;
558   
559   if (!arguments) return iResult;
560   
561   TString allArgs=arguments;
562   TString argument;
563   
564   TObjArray* pTokens=allArgs.Tokenize(" ");
565   
566   if (pTokens) {
567     for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) {
568       argument=((TObjString*)pTokens->At(i))->GetString();
569       if (argument.IsNull()) continue;      
570       if (argument.CompareTo("-use-offline-finder")==0) {
571         fUseOfflineFinder = 1;
572         HLTInfo("Off-line ClusterFinder will be used");
573         continue;
574       }
575       /*
576       else if (argument.CompareTo("")==0) {
577         HLTInfo("");
578         continue;
579       }
580       */
581       else {
582         HLTError("unknown argument %s", argument.Data());
583         iResult=-EINVAL;
584         break;
585       }
586     }
587     delete pTokens;
588   }
589   
590   return iResult;
591 }
592
593 int AliHLTITSClusterFinderComponent::Reconfigure(const char* cdbEntry, const char* chainId)
594 {
595   // see header file for class documentation
596   int iResult=0;
597   
598   const char* path="HLT/ConfigITS/ClusterFinderComponent";
599   const char* defaultNotify="";
600   if (cdbEntry) {
601     path=cdbEntry;
602     defaultNotify=" (default)";
603   }
604   if (path) {
605     HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
606     AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path);
607     if (pEntry) {
608       TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject());
609       if (pString) {
610         HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
611         iResult=Configure(pString->GetString().Data());
612       } else {
613         HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
614       }
615     } else {
616       HLTError("can not fetch object \"%s\" from CDB", path);
617     }
618   }
619   
620   return iResult;
621 }
622 void AliHLTITSClusterFinderComponent::GetOCDBObjectDescription( TMap* const targetMap)
623 {
624   // Get a list of OCDB object description.
625   if (!targetMap) return;
626   //SPD
627   targetMap->Add(new TObjString("ITS/Calib/SPDNoisy"),new TObjString("Calibration object for SPD" ));
628   targetMap->Add(new TObjString("ITS/Calib/SPDDead"),new TObjString("Calibration object for SPD" ));
629   targetMap->Add(new TObjString("TRIGGER/SPD/PITConditions"),new TObjString("Calibration object for SPD" ));
630   //SDD
631   targetMap->Add(new TObjString("ITS/Calib/CalibSDD"),new TObjString("Calibration object for SDD" ));
632   targetMap->Add(new TObjString("ITS/Calib/RespSDD"),new TObjString("Calibration object for SDD" ));
633   targetMap->Add(new TObjString("ITS/Calib/DriftSpeedSDD"),new TObjString("Calibration object for SDD" ));
634   targetMap->Add(new TObjString("ITS/Calib/DDLMapSDD"),new TObjString("Calibration object for SDD" ));
635   targetMap->Add(new TObjString("ITS/Calib/MapsTimeSDD"),new TObjString("Calibration object for SDD" ));
636   //SSD
637   targetMap->Add(new TObjString("ITS/Calib/NoiseSSD"),new TObjString("Calibration object for SSD" ));
638   targetMap->Add(new TObjString("ITS/Calib/GainSSD"),new TObjString("Calibration object for SSD" ));
639   targetMap->Add(new TObjString("ITS/Calib/BadChannelsSSD"),new TObjString("Calibration object for SSD" ));
640   //General reconstruction
641   targetMap->Add(new TObjString("GRP/CTP/Scalers"),new TObjString("General reconstruction object" ));
642 }
643
644
645 void AliHLTITSClusterFinderComponent::RecPointToSpacePoint(AliHLTUInt8_t* outputPtr,AliHLTUInt32_t& size){
646   AliHLTITSClusterData *outputClusters = reinterpret_cast<AliHLTITSClusterData*>(outputPtr + size);
647   outputClusters->fSpacePointCnt=fclusters.size();    
648   int clustIdx=0;
649   for(UInt_t i=0;i<fclusters.size();i++){
650     AliITSRecPoint *recpoint = (AliITSRecPoint*) &(fclusters[i]);
651     outputClusters->fSpacePoints[clustIdx].fY=recpoint->GetY();
652     outputClusters->fSpacePoints[clustIdx].fZ=recpoint->GetZ();
653     outputClusters->fSpacePoints[clustIdx].fSigmaY2=recpoint->GetSigmaY2();
654     outputClusters->fSpacePoints[clustIdx].fSigmaZ2=recpoint->GetSigmaZ2();
655     outputClusters->fSpacePoints[clustIdx].fSigmaYZ=recpoint->GetSigmaYZ();
656     outputClusters->fSpacePoints[clustIdx].fQ=recpoint->GetQ();
657     outputClusters->fSpacePoints[clustIdx].fNy=recpoint->GetNy();
658     outputClusters->fSpacePoints[clustIdx].fNz=recpoint->GetNz();
659     outputClusters->fSpacePoints[clustIdx].fLayer=recpoint->GetLayer();
660     outputClusters->fSpacePoints[clustIdx].fIndex=recpoint->GetDetectorIndex() | recpoint->GetPindex() | recpoint->GetNindex();
661     outputClusters->fSpacePoints[clustIdx].fTracks[0]=recpoint->GetLabel(0);
662     outputClusters->fSpacePoints[clustIdx].fTracks[1]=recpoint->GetLabel(1);
663     outputClusters->fSpacePoints[clustIdx].fTracks[2]=recpoint->GetLabel(2);      
664     clustIdx++;
665   }
666 }