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