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