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