Initialisation changed
[u/mrichter/AliRoot.git] / HLT / ITS / tracking / AliHLTITSTrackerComponent.cxx
1 // @(#) $Id: AliHLTITSTrackerComponent.cxx 32659 2009-06-02 16:08:40Z sgorbuno $
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: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> *
7 //                  Ivan Kisel <kisel@kip.uni-heidelberg.de>                *
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
20
21 /////////////////////////////////////////////////////
22 //                                                 //
23 // a ITS tracker processing component for the HLT  //
24 //                                                 //
25 /////////////////////////////////////////////////////
26
27 #if __GNUC__>= 3
28 using namespace std;
29 #endif
30
31 #include "AliHLTITSTrackerComponent.h"
32 #include "AliHLTArray.h"
33 #include "AliExternalTrackParam.h"
34 #include "TStopwatch.h"
35 #include "TMath.h"
36 #include "AliCDBEntry.h"
37 #include "AliCDBManager.h"
38 #include "TObjString.h"
39 #include "TObjArray.h"
40 #include "AliITStrackerHLT.h"
41 #include "AliHLTITSSpacePointData.h"
42 #include "AliHLTITSClusterDataFormat.h"
43 #include "AliHLTDataTypes.h"
44 #include "AliHLTExternalTrackParam.h"
45 #include "AliHLTKalmanTrack.h"
46
47
48
49 /** ROOT macro for the implementation of ROOT specific class methods */
50 ClassImp( AliHLTITSTrackerComponent )
51 AliHLTITSTrackerComponent::AliHLTITSTrackerComponent()
52     :
53     fSolenoidBz( 0 ),
54     fFullTime( 0 ),
55     fRecoTime( 0 ),
56     fNEvents( 0 ),
57     fTracker(0)
58 {
59   // see header file for class documentation
60   // or
61   // refer to README to build package
62   // or
63   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
64 }
65
66 AliHLTITSTrackerComponent::AliHLTITSTrackerComponent( const AliHLTITSTrackerComponent& )
67     :
68     AliHLTProcessor(),
69     fSolenoidBz( 0 ),
70     fFullTime( 0 ),
71     fRecoTime( 0 ),
72     fNEvents( 0 ),
73     fTracker(0)
74 {
75   // see header file for class documentation
76   HLTFatal( "copy constructor untested" );
77 }
78
79 AliHLTITSTrackerComponent& AliHLTITSTrackerComponent::operator=( const AliHLTITSTrackerComponent& )
80 {
81   // see header file for class documentation
82   HLTFatal( "assignment operator untested" );
83   return *this;
84 }
85
86 AliHLTITSTrackerComponent::~AliHLTITSTrackerComponent()
87 {
88   // see header file for class documentation
89   delete fTracker;
90 }
91
92 //
93 // Public functions to implement AliHLTComponent's interface.
94 // These functions are required for the registration process
95 //
96
97 const char* AliHLTITSTrackerComponent::GetComponentID()
98 {
99   // see header file for class documentation
100   return "ITSTracker";
101 }
102
103 void AliHLTITSTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list )
104 {
105   // see header file for class documentation
106   list.clear();
107   list.push_back( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC );
108   list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD );
109   list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD );
110 }
111
112 AliHLTComponentDataType AliHLTITSTrackerComponent::GetOutputDataType()
113 {
114   // see header file for class documentation  
115   return kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
116 }
117
118 void AliHLTITSTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
119 {
120   // define guess for the output data size
121   constBase = 200;       // minimum size
122   inputMultiplier = 0.5; // size relative to input
123 }
124
125 AliHLTComponent* AliHLTITSTrackerComponent::Spawn()
126 {
127   // see header file for class documentation
128   return new AliHLTITSTrackerComponent;
129 }
130
131 void AliHLTITSTrackerComponent::SetDefaultConfiguration()
132 {
133   // Set default configuration for the CA tracker component
134   // Some parameters can be later overwritten from the OCDB
135
136   fSolenoidBz = 5.;
137   fFullTime = 0;
138   fRecoTime = 0;
139   fNEvents = 0;
140   fTracker = 0;
141 }
142
143 int AliHLTITSTrackerComponent::ReadConfigurationString(  const char* arguments )
144 {
145   // Set configuration parameters for the CA tracker component from the string
146
147   int iResult = 0;
148   if ( !arguments ) return iResult;
149
150   TString allArgs = arguments;
151   TString argument;
152   int bMissingParam = 0;
153
154   TObjArray* pTokens = allArgs.Tokenize( " " );
155
156   int nArgs =  pTokens ? pTokens->GetEntries() : 0;
157
158   for ( int i = 0; i < nArgs; i++ ) {
159     argument = ( ( TObjString* )pTokens->At( i ) )->GetString();
160     if ( argument.IsNull() ) continue;
161
162     if ( argument.CompareTo( "-solenoidBz" ) == 0 ) {
163       if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
164       fSolenoidBz = ( ( TObjString* )pTokens->At( i ) )->GetString().Atof();
165       HLTInfo( "Magnetic Field set to: %f", fSolenoidBz );
166       continue;
167     }
168
169     //if ( argument.CompareTo( "-minNClustersOnTrack" ) == 0 ) {
170     //if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break;
171     //fMinNTrackClusters = ( ( TObjString* )pTokens->At( i ) )->GetString().Atoi();
172     //HLTInfo( "minNClustersOnTrack set to: %d", fMinNTrackClusters );
173     //continue;
174     //}
175
176     HLTError( "Unknown option \"%s\"", argument.Data() );
177     iResult = -EINVAL;
178   }
179   delete pTokens;
180
181   if ( bMissingParam ) {
182     HLTError( "Specifier missed for parameter \"%s\"", argument.Data() );
183     iResult = -EINVAL;
184   }
185
186   return iResult;
187 }
188
189
190 int AliHLTITSTrackerComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId )
191 {
192   // see header file for class documentation
193
194   const char* defaultNotify = "";
195
196   if ( !cdbEntry ) {
197     cdbEntry = "HLT/ConfigITS/ITSTracker";
198     defaultNotify = " (default)";
199     chainId = 0;
200   }
201
202   HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" );
203   AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo());
204
205   if ( !pEntry ) {
206     HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry );
207     return -EINVAL;
208   }
209
210   TObjString* pString = dynamic_cast<TObjString*>( pEntry->GetObject() );
211
212   if ( !pString ) {
213     HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry );
214     return -EINVAL;
215   }
216
217   HLTInfo( "received configuration object string: \"%s\"", pString->GetString().Data() );
218
219   return  ReadConfigurationString( pString->GetString().Data() );
220 }
221
222
223 int AliHLTITSTrackerComponent::Configure( const char* cdbEntry, const char* chainId, const char *commandLine )
224 {
225   // Configure the component
226   // There are few levels of configuration,
227   // parameters which are set on one step can be overwritten on the next step
228
229   //* read hard-coded values
230
231   SetDefaultConfiguration();
232
233   //* read the default CDB entry
234
235   int iResult1 = ReadCDBEntry( NULL, chainId );
236
237   //* read magnetic field
238
239   int iResult2 = ReadCDBEntry( kAliHLTCDBSolenoidBz, chainId );
240
241   //* read the actual CDB entry if required
242
243   int iResult3 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0;
244
245   //* read extra parameters from input (if they are)
246
247   int iResult4 = 0;
248
249   if ( commandLine && commandLine[0] != '\0' ) {
250     HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine );
251     iResult4 = ReadConfigurationString( commandLine );
252   }
253
254   // Initialise the tracker here
255
256   return iResult1 ? iResult1 : ( iResult2 ? iResult2 : ( iResult3 ? iResult3 : iResult4 ) );
257 }
258
259
260
261 int AliHLTITSTrackerComponent::DoInit( int argc, const char** argv )
262 {
263   // Configure the ITS tracker component
264
265   if ( fTracker ) return EINPROGRESS;
266   fTracker = new AliITStrackerHLT(0);
267
268   TString arguments = "";
269   for ( int i = 0; i < argc; i++ ) {
270     if ( !arguments.IsNull() ) arguments += " ";
271     arguments += argv[i];
272   }
273
274   return Configure( NULL, NULL, arguments.Data() );
275 }
276
277
278 int AliHLTITSTrackerComponent::DoDeinit()
279 {
280   // see header file for class documentation
281   delete fTracker;
282   fTracker = 0;
283   return 0;
284 }
285
286
287
288 int AliHLTITSTrackerComponent::Reconfigure( const char* cdbEntry, const char* chainId )
289 {
290   // Reconfigure the component from OCDB .
291
292   return Configure( cdbEntry, chainId, NULL );
293 }
294
295
296
297 int AliHLTITSTrackerComponent::DoEvent
298 (
299   const AliHLTComponentEventData& evtData,
300   const AliHLTComponentBlockData* blocks,
301   AliHLTComponentTriggerData& /*trigData*/,
302   AliHLTUInt8_t* outputPtr,
303   AliHLTUInt32_t& size,
304   vector<AliHLTComponentBlockData>& outputBlocks )
305 {
306   //* process event
307
308   AliHLTUInt32_t maxBufferSize = size;
309   size = 0; // output size
310
311   if ( GetFirstInputBlock( kAliHLTDataTypeSOR ) || GetFirstInputBlock( kAliHLTDataTypeEOR ) ) {
312     return 0;
313   }
314
315   if ( evtData.fBlockCnt <= 0 ) {
316     HLTWarning( "no blocks in event" );
317     return 0;
318   }
319
320
321   TStopwatch timer;
322
323   // Event reconstruction in ITS
324
325   int iResult=0;
326
327   int nBlocks = evtData.fBlockCnt;
328
329   
330   vector< AliExternalTrackParam > tracksTPC;
331   vector< int > tracksTPCId;
332   std::vector<AliITSRecPoint> clusters;
333
334   int currentTrackID = 0;
335
336   for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) {
337
338     const AliHLTComponentBlockData* iter = blocks+ndx;
339  
340     // Read TPC tracks
341     
342     if( iter->fDataType == ( kAliHLTDataTypeTrack|kAliHLTDataOriginTPC ) ){       
343       AliHLTTracksData* dataPtr = ( AliHLTTracksData* ) iter->fPtr;
344       int nTracks = dataPtr->fCount;
345       AliHLTExternalTrackParam* currOutTrack = dataPtr->fTracklets;
346       for( int itr=0; itr<nTracks; itr++ ){
347         AliHLTKalmanTrack t(*currOutTrack);
348         tracksTPC.push_back( t );
349         tracksTPCId.push_back( currOutTrack->fTrackID );
350         unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + currOutTrack->fNPoints * sizeof( unsigned int );
351         currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
352       }
353     }
354
355
356     // Read ITS clusters
357
358     if ( (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD) ) || 
359          (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) 
360          ){
361
362       AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr );
363       int nClusters = inPtr->fSpacePointCnt;
364       for( int icl=0; icl<nClusters; icl++ ){
365         AliHLTITSSpacePointData &d = inPtr->fSpacePoints[icl];
366         AliITSRecPoint p;
367         p.SetY( d.fY );
368         p.SetZ( d.fZ );
369         p.SetSigmaY2( d.fSigmaY2 );
370         p.SetSigmaZ2( d.fSigmaZ2 );
371         p.SetSigmaYZ( d.fSigmaYZ );
372         p.SetQ( d.fQ );
373         p.SetNy( d.fNy );
374         p.SetNz( d.fNz );
375         p.SetLayer( d.fLayer );
376         p.SetDetectorIndex( d.fIndex );
377         p.SetLabel(0, d.fTracks[0] );
378         p.SetLabel(1, d.fTracks[1] );
379         p.SetLabel(2, d.fTracks[2] );
380         clusters.push_back( p );
381       }   
382     }
383     
384   }// end read input blocks
385   
386   // set clusters to tracker
387
388   fTracker->LoadClusters( clusters );
389
390   // Reconstruct the event
391
392   TStopwatch timerReco;
393   
394   fTracker->Reconstruct( tracksTPC );
395
396   timerReco.Stop();
397   
398   // Fill output tracks
399
400   {
401     unsigned int mySize = 0;    
402      
403     AliHLTTracksData* outPtr = ( AliHLTTracksData* )( outputPtr );
404
405     AliHLTExternalTrackParam* currOutTrack = outPtr->fTracklets;
406
407     mySize =   ( ( AliHLTUInt8_t * )currOutTrack ) -  ( ( AliHLTUInt8_t * )outputPtr );
408
409     outPtr->fCount = 0;
410     
411     int nTracks = fTracker->Tracks().size();
412
413     for ( int itr = 0; itr < nTracks; itr++ ) {
414
415       const AliExternalTrackParam &tp = fTracker->Tracks()[itr];
416       int id =  tracksTPCId[fTracker->Tracks()[itr].TPCtrackId()];
417
418       int nClusters = 0;
419
420       unsigned int dSize = sizeof( AliHLTExternalTrackParam ) + nClusters * sizeof( unsigned int );
421
422       if ( mySize + dSize > maxBufferSize ) {
423         HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", maxBufferSize, mySize, nTracks - itr + 1 );
424         iResult = -ENOSPC;
425         break;
426       }
427
428       currOutTrack->fAlpha = tp.GetAlpha();
429       currOutTrack->fX = tp.GetX();
430       currOutTrack->fY = tp.GetY();
431       currOutTrack->fZ = tp.GetZ();            
432       currOutTrack->fLastX = 0;
433       currOutTrack->fLastY = 0;
434       currOutTrack->fLastZ = 0;      
435       currOutTrack->fq1Pt = tp.GetSigned1Pt();
436       currOutTrack->fSinPsi = tp.GetSnp();
437       currOutTrack->fTgl = tp.GetTgl();
438       for( int i=0; i<15; i++ ) currOutTrack->fC[i] = tp.GetCovariance()[i];
439       currOutTrack->fTrackID = id;
440       currOutTrack->fFlags = 0;
441       currOutTrack->fNPoints = nClusters;    
442       currOutTrack = ( AliHLTExternalTrackParam* )( (( Byte_t * )currOutTrack) + dSize );
443       mySize += dSize;
444       outPtr->fCount++;
445     }
446   
447
448     AliHLTComponentBlockData resultData;
449     FillBlockData( resultData );
450     resultData.fOffset = 0;
451     resultData.fSize = mySize;
452     resultData.fDataType = kAliHLTDataTypeTrack|kAliHLTDataOriginITS;
453     outputBlocks.push_back( resultData );
454     size = resultData.fSize;  
455     
456     HLTInfo( "ITS tracker:: output %d tracks",nTracks );
457   }
458   return iResult;
459 }