88e107c9a45e7f3c1b2ea1823f33a079f6bb97e0
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCCATrackerComponent.cxx
1
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Ivan Kisel <kisel@kip.uni-heidelberg.de>                      *
7  *          Jochen Thaeder <thaeder@kip.uni-heidelberg.de>                *
8  *          Matthias Richter <Matthias.Richter@ift.uib.no>                *
9  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
10  *          for The ALICE Off-line Project.                               *
11  *                                                                        *
12  * Permission to use, copy, modify and distribute this software and its   *
13  * documentation strictly for non-commercial purposes is hereby granted   *
14  * without fee, provided that the above copyright notice appears in all   *
15  * copies and that both the copyright notice and this permission notice   *
16  * appear in the supporting documentation. The authors make no claims     *
17  * about the suitability of this software for any purpose. It is          *
18  * provided "as is" without express or implied warranty.                  *
19  **************************************************************************/
20  
21 ///////////////////////////////////////////////////////////////////////////////
22 //                                                                           //
23 // a TPC tracker processing component for the HLT based on CA by Ivan Kisel  //
24 //                                                                           //
25 ///////////////////////////////////////////////////////////////////////////////
26
27 #if __GNUC__>= 3
28 using namespace std;
29 #endif
30
31 #include "AliHLTTPCCATrackerComponent.h"
32 #include "AliHLTTPCTransform.h"
33 #include "AliHLTTPCCATracker.h"
34 #include "AliHLTTPCVertex.h"
35 #include "AliHLTTPCSpacePointData.h"
36 #include "AliHLTTPCVertexData.h"
37 #include "AliHLTTPCClusterDataFormat.h"
38 #include "AliHLTTPCTransform.h"
39 #include "AliHLTTPCTrackSegmentData.h"
40 #include "AliHLTTPCTrackArray.h"
41 #include "AliHLTTPCTrackletDataFormat.h"
42 //#include "AliHLTTPC.h"
43 #include <stdlib.h>
44 #include <iostream>
45 #include <errno.h>
46
47 //static bool ask = true;
48 static bool ask = false;
49
50 // this is a global object used for automatic component registration, do not use this
51 AliHLTTPCCATrackerComponent gAliHLTTPCCATrackerComponent;
52
53 ClassImp(AliHLTTPCCATrackerComponent)
54
55 AliHLTTPCCATrackerComponent::AliHLTTPCCATrackerComponent()
56     {
57     fTracker = NULL;
58     fVertex = NULL;
59     }
60
61 AliHLTTPCCATrackerComponent::~AliHLTTPCCATrackerComponent()
62     {
63     }
64
65 // Public functions to implement AliHLTComponent's interface.
66 // These functions are required for the registration process
67
68 const char* AliHLTTPCCATrackerComponent::GetComponentID()
69     {
70     return "TPCCATracker";
71     }
72
73 void AliHLTTPCCATrackerComponent::GetInputDataTypes( vector<AliHLTComponent_DataType>& list)
74     {
75     list.clear();
76     list.push_back( AliHLTTPCDefinitions::gkClustersDataType );
77     list.push_back( AliHLTTPCDefinitions::gkVertexDataType );
78     }
79
80 AliHLTComponent_DataType AliHLTTPCCATrackerComponent::GetOutputDataType()
81     {
82     return AliHLTTPCDefinitions::gkTrackSegmentsDataType;
83     }
84
85 void AliHLTTPCCATrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
86     {
87     // XXX TODO: Find more realistic values.
88     constBase = 0;
89     inputMultiplier = 0.2;
90     }
91
92 AliHLTComponent* AliHLTTPCCATrackerComponent::Spawn()
93     {
94     return new AliHLTTPCCATrackerComponent;
95     }
96
97 int AliHLTTPCCATrackerComponent::DoInit( int argc, const char** argv )
98     {
99     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" );
100
101     if ( fTracker || fVertex )
102         return EINPROGRESS;
103
104     fTracker = new AliHLTTPCCATracker();
105     fTracker->CACreateHistos();
106
107     fVertex = new AliHLTTPCVertex();
108
109
110 /* ---------------------------------------------------------------------------------
111  * cmdline arguments not needed so far
112
113     int i = 0;
114     char* cpErr;
115
116     while ( i < argc )
117         {
118         if ( !strcmp( argv[i], "bfield" ) )
119             {
120             if ( argc <= i+1 )
121                 {
122                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing B-field", "Missing B-field specifier." );
123                 return ENOTSUP;
124                 }
125             fBField = strtod( argv[i+1], &cpErr );
126             if ( *cpErr )
127                 {
128                 Logging( kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Missing multiplicity", "Cannot convert B-field specifier '%s'.", argv[i+1] );
129                 return EINVAL;
130                 }
131             i += 2;
132             continue;
133             }
134
135         Logging(kHLTLogError, "HLT::TPCSliceTracker::DoInit", "Unknown Option", "Unknown option '%s'", argv[i] );
136         return EINVAL;
137         }
138 --------------------------------------------------------------------------------- */
139
140     return 0;
141     }
142
143 int AliHLTTPCCATrackerComponent::DoDeinit()
144     {
145     if ( fTracker )
146         delete fTracker;
147     fTracker = NULL;
148     if ( fVertex )
149         delete fVertex;
150     fVertex = NULL;
151     return 0;
152     }
153
154 int AliHLTTPCCATrackerComponent::DoEvent( const AliHLTComponent_EventData& evtData, const AliHLTComponent_BlockData* blocks, 
155                                               AliHLTComponent_TriggerData& trigData, AliHLTUInt8_t* outputPtr, 
156                                               AliHLTUInt32_t& size, vector<AliHLTComponent_BlockData>& outputBlocks )
157     {
158     Logging( kHLTLogDebug, "HLT::TPCCATracker::DoEvent", "DoEvent", "DoEvent()" );
159     if ( evtData.fBlockCnt<=0 )
160       {
161         Logging( kHLTLogWarning, "HLT::TPCCATracker::DoEvent", "DoEvent", "no blocks in event" );
162         return 0;
163       }
164
165     const AliHLTComponent_BlockData* iter = NULL;
166     unsigned long ndx;
167     AliHLTTPCClusterData* inPtrSP;
168     AliHLTTPCVertexData* inPtrV = NULL;
169     const AliHLTComponent_BlockData* vertexIter=NULL;
170     AliHLTTPCTrackletData* outPtr;
171     AliHLTUInt8_t* outBPtr;
172
173     AliHLTUInt32_t vSize = 0;
174     UInt_t offset=0, mysize, tSize = 0;
175     outBPtr = outputPtr;
176
177     outPtr = (AliHLTTPCTrackletData*)(outBPtr);
178     fTracker->SetOutPtr( outPtr->fTracklets );
179
180     // ------------------------------------------
181
182     Int_t slice=-1, patch=-1, row[2];
183     Int_t minPatch=INT_MAX, maxPatch = 0;
184     offset = 0;
185     std::vector<Int_t> slices;
186     std::vector<Int_t>::iterator slIter, slEnd;
187     std::vector<unsigned> sliceCnts;
188     std::vector<unsigned>::iterator slCntIter;
189     Int_t vertexSlice=-1;
190
191     // Find min/max rows used in total and find and read out vertex if it is present
192     // also determine correct slice number, if multiple slice numbers are present in event
193     // (which should not happen in the first place) we use the one that occurs the most times
194     row[0] = 0;
195     row[1] = 0;
196     bool found;
197
198     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
199         {
200         iter = blocks+ndx;
201
202
203         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
204         found = false;
205         slIter = slices.begin();
206         slEnd = slices.end();
207         slCntIter = sliceCnts.begin();
208         while ( slIter != slEnd )
209             {
210             if ( *slIter == slice )
211                 {
212                 found = true;
213                 break;
214                 }
215             slIter++;
216             slCntIter++;
217             }
218         if ( !found )
219             {
220             slices.insert( slices.end(), slice );
221             sliceCnts.insert( sliceCnts.end(), 1 );
222             }
223         else
224             *slCntIter++;
225
226         if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType )
227             {
228             inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
229             vertexIter = iter;
230             vSize = iter->fSize;
231             fVertex->Read( inPtrV );
232             vertexSlice = slice;
233             }
234         if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType )
235             {
236             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
237             if ( minPatch>patch )
238                 {
239                 minPatch = patch;
240                 row[0] = AliHLTTPCTransform::GetFirstRow( patch );
241                 }
242             if ( maxPatch<patch )
243                 {
244                 maxPatch = patch;
245                 row[1] = AliHLTTPCTransform::GetLastRow( patch );
246                 }
247             }
248         }
249
250     // Determine slice number to really use.
251     if ( slices.size()>1 )
252         {
253         Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
254                  "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...",
255                  evtData.fEventID, evtData.fEventID );
256         unsigned maxCntSlice=0;
257         slIter = slices.begin();
258         slEnd = slices.end();
259         slCntIter = sliceCnts.begin();
260         while ( slIter != slEnd )
261             {
262             Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
263                      "Slice %lu found %lu times.", *slIter, *slCntIter );
264             if ( maxCntSlice<*slCntIter )
265                 {
266                 maxCntSlice = *slCntIter;
267                 slice = *slIter;
268                 }
269             slIter++;
270             slCntIter++;
271             }
272         Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event",
273                  "Using slice %lu.", slice );
274         }
275     else if ( slices.size()>0 )
276       {
277         slice = *(slices.begin());
278       }
279     else
280       {
281         slice = -1;
282       }
283     
284     if ( vertexSlice != slice )
285         {
286         // multiple vertex blocks in event and we used the wrong one...
287         found = false;
288         for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
289             {
290             iter = blocks+ndx;
291             if ( iter->fDataType == AliHLTTPCDefinitions::gkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
292                 {
293                 inPtrV = (AliHLTTPCVertexData*)(iter->fPtr);
294                 vertexIter = iter;
295                 vSize = iter->fSize;
296                 fVertex->Read( inPtrV );
297                 break;
298                 }
299             }
300         }
301
302     //    fTracker->InitSector( slice, row, fEta );
303     //    fTracker->SetVertex(fVertex);
304
305     mysize = 0;
306     // read in all hits
307     std::vector<unsigned long> patchIndices;
308     std::vector<unsigned long>::iterator pIter, pEnd;
309     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
310         {
311         iter = blocks+ndx;
312
313         if ( iter->fDataType == AliHLTTPCDefinitions::gkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) )
314             {
315             patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
316             pIter = patchIndices.begin();
317             pEnd = patchIndices.end();
318             while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch )
319                 pIter++;
320             patchIndices.insert( pIter, ndx );
321             }
322         }
323
324     fTracker->CAInitialize();
325
326     pIter = patchIndices.begin();
327     pEnd = patchIndices.end();
328     while ( pIter!=pEnd )
329         {
330         ndx = *pIter;
331         iter = blocks+ndx;
332
333         patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter );
334         inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr);
335             
336         Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits",
337                  "Reading hits for slice %d - patch %d", slice, patch );
338
339         fTracker->CAReadPatchHits( patch, inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints );
340         fTracker->CAFindPatchTracks( patch ); 
341
342         pIter++;
343         }
344
345     fTracker->CAFindSliceTracks();
346
347     //#ifdef XXX
348     char symbol;
349     if (ask){
350       do{
351         std::cin.get(symbol);
352         if (symbol == 'r')
353           ask = false;
354       } while (symbol != '\n');
355     }
356     //#endif //XXX
357
358
359     UInt_t ntracks0=0;
360
361     mysize = fTracker->GetOutputSize();
362     ntracks0 = fTracker->GetOutputNTracks();
363     outPtr->fTrackletCnt = fTracker->GetOutputNTracks();
364     
365     Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks",
366              "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.", 
367              ntracks0, slice, minPatch, maxPatch, row[0], row[1] );
368
369     tSize += mysize+sizeof(AliHLTTPCTrackletData);
370     outBPtr += mysize+sizeof(AliHLTTPCTrackletData);
371     
372     AliHLTComponent_BlockData bd;
373     FillBlockData( bd );
374     bd.fOffset = offset;
375     bd.fSize = tSize;
376     bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch );
377     outputBlocks.push_back( bd );
378
379 #ifdef FORWARD_VERTEX_BLOCK
380     if ( vertexIter )
381         {
382         // Copy the descriptor block for the vertex information.
383         bd = *vertexIter;
384         outputBlocks.push_back( bd );
385         }
386 #endif // FORWARD_VERTEX_BLOCK
387
388     size = tSize;
389
390     fTracker->CAWriteHistos();
391
392     return 0;
393     }
394
395