coding conventions and documentation
[u/mrichter/AliRoot.git] / HLT / TPCLib / AliHLTTPCGlobalMergerComponent.cxx
1 // $Id$
2
3 /**************************************************************************
4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
5  *                                                                        *
6  * Authors: Matthias Richter <Matthias.Richter@ift.uib.no>                *
7  *          Timm Steinbeck <timm@kip.uni-heidelberg.de>                   *
8  *          for The ALICE Off-line 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 /** @file   AliHLTTPCGlobalMergerComponent.cxx
20     @author Timm Steinbeck, Matthias Richter
21     @date   
22     @brief  HLT TPC global merger component.
23 */
24
25 #if __GNUC__== 3
26 using namespace std;
27 #endif
28
29 #include "AliHLTTPCGlobalMergerComponent.h"
30 #include "AliHLTTPCTransform.h"
31 #include "AliHLTTPCGlobalMerger.h"
32 #include "AliHLTTPCVertex.h"
33 #include "AliHLTTPCVertexData.h"
34 #include "AliHLTTPCTrackSegmentData.h"
35 #include "AliHLTTPCTrackArray.h"
36 #include "AliHLTTPCTrackletDataFormat.h"
37 #include "AliHLTTPCSpacePointData.h"
38 #include "AliHLTTPCClusterDataFormat.h"
39 #include "AliHLTTPCDefinitions.h"
40 #include <stdlib.h>
41 #include <errno.h>
42
43 // this is a global object used for automatic component registration, do not use this
44 AliHLTTPCGlobalMergerComponent gAliHLTTPCGlobalMergerComponent;
45
46 ClassImp(AliHLTTPCGlobalMergerComponent)
47
48 AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent()
49   :
50   fGlobalMerger(NULL),
51   fVertex(NULL)
52 {
53   // see header file for class documentation
54   // or
55   // refer to README to build package
56   // or
57   // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt
58 }
59
60 AliHLTTPCGlobalMergerComponent::AliHLTTPCGlobalMergerComponent(const AliHLTTPCGlobalMergerComponent&)
61   :
62   fGlobalMerger(NULL),
63   fVertex(NULL)
64 {
65   // see header file for class documentation
66   HLTFatal("copy constructor untested");
67 }
68
69 AliHLTTPCGlobalMergerComponent& AliHLTTPCGlobalMergerComponent::operator=(const AliHLTTPCGlobalMergerComponent&)
70
71   // see header file for class documentation
72   HLTFatal("assignment operator untested");
73   return *this;
74 }
75
76 AliHLTTPCGlobalMergerComponent::~AliHLTTPCGlobalMergerComponent()
77 {
78   // see header file for class documentation
79 }
80
81 // Public functions to implement AliHLTComponent's interface.
82 // These functions are required for the registration process
83
84 const char* AliHLTTPCGlobalMergerComponent::GetComponentID()
85     {
86   // see header file for class documentation
87     return "TPCGlobalMerger";
88     }
89
90 void AliHLTTPCGlobalMergerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list)
91     {
92   // see header file for class documentation
93     list.clear();
94     list.push_back( AliHLTTPCDefinitions::fgkTrackSegmentsDataType );
95     list.push_back( AliHLTTPCDefinitions::fgkVertexDataType );
96     }
97
98 AliHLTComponentDataType AliHLTTPCGlobalMergerComponent::GetOutputDataType()
99     {
100   // see header file for class documentation
101     return AliHLTTPCDefinitions::fgkTracksDataType;
102     }
103
104 void AliHLTTPCGlobalMergerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier )
105     {
106   // see header file for class documentation
107     // XXX TODO: Find more realistic values.
108     constBase = 0;
109     inputMultiplier = 1.0;
110     }
111
112 AliHLTComponent* AliHLTTPCGlobalMergerComponent::Spawn()
113     {
114   // see header file for class documentation
115     return new AliHLTTPCGlobalMergerComponent;
116     }
117
118 void AliHLTTPCGlobalMergerComponent::SetMergerParameters(Double_t maxy,Double_t maxz,Double_t maxkappa,Double_t maxpsi,Double_t maxtgl)
119     {
120   // see header file for class documentation
121     fGlobalMerger->SetParameter( maxy, maxz, maxkappa, maxpsi, maxtgl );
122     }
123
124 int AliHLTTPCGlobalMergerComponent::DoInit( int argc, const char** argv )
125     {
126   // see header file for class documentation
127     if ( fGlobalMerger || fVertex )
128         return EINPROGRESS;
129     fGlobalMerger = new AliHLTTPCGlobalMerger();
130     fVertex = new AliHLTTPCVertex();
131     SetMergerParameters();
132     return 0;
133     }
134
135 int AliHLTTPCGlobalMergerComponent::DoDeinit()
136     {
137   // see header file for class documentation
138     if ( fGlobalMerger )
139         delete fGlobalMerger;
140     fGlobalMerger = NULL;
141     if ( fVertex )
142         delete fVertex;
143     fVertex = NULL;
144     return 0;
145     }
146
147 int AliHLTTPCGlobalMergerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, 
148                                               AliHLTComponentTriggerData& trigData, AliHLTUInt8_t* outputPtr, 
149                                               AliHLTUInt32_t& size, vector<AliHLTComponentBlockData>& outputBlocks )
150     {
151   // see header file for class documentation
152     const AliHLTComponentBlockData* iter = NULL;
153     const AliHLTComponentBlockData* lastVertexBlock = NULL;
154     unsigned long ndx;
155
156     std::vector<SliceData> slices;
157     std::vector<SliceData>::iterator sdIter, sdEnd;
158     int minSlice = INT_MAX, maxSlice = 0;
159     bool found;
160     AliHLTTPCTrackletData* inPtr;
161     AliHLTTPCTrackletData* outPtr;
162     UInt_t tSize = 0;
163     Int_t slice=0;
164
165     // Create sorted (by slice number) list of data (tracks and vertex) for each slice present.
166     // also note the min and max slice numbers
167     for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ )
168         {
169         iter = blocks+ndx;
170         slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter );
171         found=false;
172         sdIter = slices.begin();
173         sdEnd = slices.end();
174         while ( sdIter != sdEnd )
175             {
176             if ( sdIter->fSlice > slice || sdIter->fSlice == slice )
177                 break;
178             sdIter++;
179             }
180         if ( sdIter==sdEnd || sdIter->fSlice>slice )
181             {
182             if ( sdIter == sdEnd )
183                 maxSlice = slice;
184             if ( sdIter==slices.begin() )
185                 minSlice = slice;
186             SliceData sd;
187             sd.fSlice = slice;
188             sd.fVertexBlock = NULL;
189             sd.fVertexBlockIndex = 0;
190             sd.fTrackletBlock = NULL;
191             sd.fTrackletBlockIndex = 0;
192             sdIter = slices.insert( sdIter, sd );
193             }
194         if ( sdIter->fSlice == slice )
195             {
196             if ( iter->fDataType == AliHLTTPCDefinitions::fgkTrackSegmentsDataType )
197                 {
198                 if ( !sdIter->fTrackletBlock )
199                     {
200                     sdIter->fTrackletBlock = iter;
201                     sdIter->fTrackletBlockIndex = ndx;
202                     }
203                 else
204                     {
205                     Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate track data block",
206                              "Duplicate track data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
207                              slice, evtData.fEventID, evtData.fEventID, sdIter->fTrackletBlockIndex, ndx );
208                     }
209                 }
210             if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType )
211                 {
212                 lastVertexBlock = iter;
213                 if ( !sdIter->fVertexBlock )
214                     {
215                     sdIter->fVertexBlock = iter;
216                     sdIter->fVertexBlockIndex = ndx;
217                     }
218                 else
219                     {
220                     Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "Duplicate vertex data block",
221                              "Duplicate vertex data block for slice %lu in event 0x%08lX (%lu) - previous block: %lu - new block: %lu.",
222                              slice, evtData.fEventID, evtData.fEventID, sdIter->fVertexBlockIndex, ndx );
223                     }
224                 }
225             }
226         }
227
228     //fGlobalMerger->Setup( minSlice, maxSlice );
229     fGlobalMerger->Setup( 0, 35 );
230
231     if ( !lastVertexBlock )
232         {
233         Logging( kHLTLogInfo, "HLT::GlobalMerger::DoEvent", "No vertex data block",
234                  "No vertex data block found  for event  0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
235         fVertex->SetZero();
236         }
237     else
238         fVertex->Read( (AliHLTTPCVertexData*)( lastVertexBlock->fPtr ) );
239
240     // Add all tracks into the merger
241     sdIter = slices.begin();
242     sdEnd = slices.end();
243     int lastSlice = -1;
244     while ( sdIter != sdEnd )
245         {
246         if ( sdIter->fVertexBlock )
247             {
248             fVertex->Read( (AliHLTTPCVertexData*)( sdIter->fVertexBlock->fPtr ) );
249             fGlobalMerger->SetVertex( fVertex );
250             }
251         for ( int slNr=lastSlice+1; slNr<=sdIter->fSlice; slNr++ )
252             fGlobalMerger->InitSlice( slNr );
253         if ( sdIter->fTrackletBlock )
254             {
255             inPtr = (AliHLTTPCTrackletData*)( sdIter->fTrackletBlock->fPtr );
256             if ( !inPtr )
257                   {
258                   Logging( kHLTLogError, "HLT::GlobalMerger::DoEvent", "No track data block",
259                            "No track data block found  for event  0x%08lX (%lu).", evtData.fEventID, evtData.fEventID );
260                   }
261             else
262                 {
263                 //fGlobalMerger->InitSlice( sdIter->fSlice );
264                 fGlobalMerger->FillTracks( inPtr->fTrackletCnt, inPtr->fTracklets );
265                 } 
266             }
267         lastSlice = sdIter->fSlice;
268         sdIter++;
269         }
270     for ( int slNr=lastSlice+1; slNr<=35; slNr++ )
271         fGlobalMerger->InitSlice( slNr );
272     
273
274     // Now we can really merge
275     fGlobalMerger->Merge();
276     fGlobalMerger->AddAllTracks();
277
278     UInt_t ntracks0=0;
279     outPtr = (AliHLTTPCTrackletData*)(outputPtr);
280
281     tSize = fGlobalMerger->GetOutTracks()->WriteTracks( ntracks0, outPtr->fTracklets );
282     outPtr->fTrackletCnt = ntracks0;
283
284     tSize += sizeof(AliHLTTPCTrackletData);
285
286     AliHLTComponentBlockData bd;
287     FillBlockData( bd );
288     bd.fOffset = 0;
289     bd.fSize = tSize;
290     bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( minSlice, maxSlice, 0, 5 );
291     outputBlocks.push_back( bd );
292
293     size = tSize;
294     return 0;
295     }
296
297