]>
Commit | Line | Data |
---|---|---|
71d7c760 | 1 | // $Id$ |
2 | ||
bd34e482 | 3 | //************************************************************************** |
4 | //* This file is property of and copyright by the ALICE HLT Project * | |
5 | //* ALICE Experiment at CERN, All rights reserved. * | |
6 | //* * | |
7 | //* Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> * | |
8 | //* Timm Steinbeck <timm@kip.uni-heidelberg.de> * | |
9 | //* for The ALICE HLT Project. * | |
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 | //************************************************************************** | |
71d7c760 | 19 | |
de554e07 | 20 | /** @file AliHLTTPCSliceTrackerComponent.cxx |
21 | @author Timm Steinbeck, Matthias Richter | |
22 | @date | |
23 | @brief The TPC conformal mapping tracker component. | |
24 | */ | |
71d7c760 | 25 | |
db16520a | 26 | #if __GNUC__>= 3 |
71d7c760 | 27 | using namespace std; |
28 | #endif | |
29 | ||
b09247a2 | 30 | #include <climits> |
71d7c760 | 31 | #include "AliHLTTPCSliceTrackerComponent.h" |
a6c02c85 | 32 | #include "AliHLTTPCTransform.h" |
33 | #include "AliHLTTPCConfMapper.h" | |
34 | #include "AliHLTTPCVertex.h" | |
a6c02c85 | 35 | #include "AliHLTTPCVertexData.h" |
71d7c760 | 36 | #include "AliHLTTPCClusterDataFormat.h" |
a6c02c85 | 37 | #include "AliHLTTPCTransform.h" |
38 | #include "AliHLTTPCTrackSegmentData.h" | |
39 | #include "AliHLTTPCTrackArray.h" | |
71d7c760 | 40 | #include "AliHLTTPCTrackletDataFormat.h" |
ecefc48a | 41 | #include "AliHLTTPCInterMerger.h" |
42 | #include "AliHLTTPCMemHandler.h" | |
5df0cbb9 | 43 | #include "AliHLTTPCDefinitions.h" |
e8eee7af | 44 | #include "AliHLTCommonCDBEntries.h" |
669159ae | 45 | #include "TString.h" |
46 | #include "TObjString.h" | |
47 | #include "TObjArray.h" | |
48 | #include "AliCDBEntry.h" | |
49 | #include "AliCDBManager.h" | |
b1d702f1 | 50 | #include "AliCDBStorage.h" |
75970b8d | 51 | #include "TGeoGlobalMagField.h" |
a7c32962 | 52 | //#include "AliHLTTPC.h" |
5df0cbb9 | 53 | //#include <stdlib.h> |
54 | //#include <cerrno> | |
71d7c760 | 55 | |
5df0cbb9 | 56 | /** ROOT macro for the implementation of ROOT specific class methods */ |
71d7c760 | 57 | ClassImp(AliHLTTPCSliceTrackerComponent) |
58 | ||
59 | AliHLTTPCSliceTrackerComponent::AliHLTTPCSliceTrackerComponent() | |
6235cd38 | 60 | : |
61 | fTracker(NULL), | |
62 | fVertex(NULL), | |
63 | fDoNonVertex(false), | |
ecefc48a | 64 | fDoPP(false), |
e6421c43 | 65 | fDoPbPb(false), |
6235cd38 | 66 | fMultiplicity(4000), |
91db0db2 | 67 | fBField(0.5), |
6235cd38 | 68 | fnonvertextracking(kFALSE), |
ecefc48a | 69 | fmainvertextracking(kTRUE), |
e6421c43 | 70 | fPhisegment(50), |
71 | fEtasegment(100), | |
72 | fTrackletlength(3), | |
73 | fTracklength(60), | |
74 | fRowscopetracklet(6), | |
75 | fRowscopetrack(6), | |
76 | fMinPtFit(0), | |
77 | fMaxangle(0.1745), | |
78 | fGoodDist(5), | |
79 | fHitChi2Cut(100), | |
80 | fGoodHitChi2(5), | |
81 | fTrackChi2Cut(50), | |
82 | fMaxdist(50), | |
83 | fMaxphi(0.1), | |
b0914d2e | 84 | fMaxeta(0.1), |
85 | fpInterMerger(NULL) | |
6235cd38 | 86 | { |
87 | // see header file for class documentation | |
88 | // or | |
89 | // refer to README to build package | |
90 | // or | |
91 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
92 | fEta[0] = 0.; | |
93 | fEta[1] = 1.1; | |
94 | } | |
95 | ||
71d7c760 | 96 | AliHLTTPCSliceTrackerComponent::~AliHLTTPCSliceTrackerComponent() |
6235cd38 | 97 | { |
5df0cbb9 | 98 | // see header file for class documentation |
6235cd38 | 99 | } |
71d7c760 | 100 | |
101 | // Public functions to implement AliHLTComponent's interface. | |
102 | // These functions are required for the registration process | |
103 | ||
104 | const char* AliHLTTPCSliceTrackerComponent::GetComponentID() | |
6235cd38 | 105 | { |
5df0cbb9 | 106 | // see header file for class documentation |
6235cd38 | 107 | |
108 | return "TPCSliceTracker"; | |
109 | } | |
71d7c760 | 110 | |
7bcd6cad | 111 | void AliHLTTPCSliceTrackerComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) |
6235cd38 | 112 | { |
5df0cbb9 | 113 | // see header file for class documentation |
6235cd38 | 114 | list.clear(); |
96bda103 | 115 | list.push_back( AliHLTTPCDefinitions::fgkClustersDataType ); |
116 | list.push_back( AliHLTTPCDefinitions::fgkVertexDataType ); | |
6235cd38 | 117 | } |
71d7c760 | 118 | |
8ede8717 | 119 | AliHLTComponentDataType AliHLTTPCSliceTrackerComponent::GetOutputDataType() |
6235cd38 | 120 | { |
5df0cbb9 | 121 | // see header file for class documentation |
96bda103 | 122 | return AliHLTTPCDefinitions::fgkTrackSegmentsDataType; |
6235cd38 | 123 | } |
71d7c760 | 124 | |
125 | void AliHLTTPCSliceTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) | |
6235cd38 | 126 | { |
5df0cbb9 | 127 | // see header file for class documentation |
6235cd38 | 128 | // XXX TODO: Find more realistic values. |
129 | constBase = 0; | |
e6421c43 | 130 | inputMultiplier = 1; |
6235cd38 | 131 | } |
71d7c760 | 132 | |
133 | AliHLTComponent* AliHLTTPCSliceTrackerComponent::Spawn() | |
6235cd38 | 134 | { |
5df0cbb9 | 135 | // see header file for class documentation |
6235cd38 | 136 | return new AliHLTTPCSliceTrackerComponent; |
137 | } | |
71d7c760 | 138 | |
6235cd38 | 139 | void AliHLTTPCSliceTrackerComponent::SetTrackerParam(Int_t phiSegments, Int_t etaSegments, |
71d7c760 | 140 | Int_t trackletlength, Int_t tracklength, |
141 | Int_t rowscopetracklet, Int_t rowscopetrack, | |
6235cd38 | 142 | Double_t minPtFit, Double_t maxangle, |
71d7c760 | 143 | Double_t goodDist, Double_t hitChi2Cut, |
144 | Double_t goodHitChi2, Double_t trackChi2Cut, | |
e6421c43 | 145 | Int_t maxdist, Double_t maxphi,Double_t maxeta) |
146 | { | |
5df0cbb9 | 147 | // see header file for class documentation |
71d7c760 | 148 | //fTracker->SetClusterFinderParam( fXYClusterError, fZClusterError, kTRUE ); // ?? |
149 | //Set parameters input to the tracker | |
150 | //If no arguments are given, default parameters will be used | |
151 | ||
6235cd38 | 152 | fTracker->SetNSegments(phiSegments,etaSegments); |
153 | fTracker->SetMaxDca(minPtFit); | |
71d7c760 | 154 | // fTracker->MainVertexSettings(trackletlength,tracklength,rowscopetracklet,rowscopetrack); |
738c049f | 155 | |
db16520a | 156 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "==============================" ); |
738c049f | 157 | |
158 | if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){ | |
159 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE); | |
160 | fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE); | |
161 | ||
162 | fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta); | |
db16520a | 163 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING" ); |
738c049f | 164 | } |
165 | else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){ | |
166 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kTRUE); | |
167 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE); | |
168 | fTracker->SetTrackletCuts(maxangle,goodDist,kTRUE); | |
169 | fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE); | |
170 | ||
171 | fTracker->MainVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack, maxphi, maxeta); | |
172 | fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack); | |
db16520a | 173 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "MAINVERTEXTRACKING - NONVERTEXTRACKING" ); |
738c049f | 174 | } |
175 | else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){ | |
176 | fTracker->SetTrackCuts(hitChi2Cut,goodHitChi2,trackChi2Cut,maxdist,kFALSE); | |
177 | fTracker->SetTrackletCuts(maxangle,goodDist,kFALSE); | |
178 | ||
179 | fTracker->NonVertexSettings( trackletlength, tracklength, rowscopetracklet, rowscopetrack); | |
db16520a | 180 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::SetTrackerParam", "Tracking", "NONVERTEXTRACKING" ); |
738c049f | 181 | } |
71d7c760 | 182 | |
738c049f | 183 | //fTracker->SetParamDone(true); |
a7c32962 | 184 | /* Matthias 13.12.2006 |
185 | * the global variable AliHLTTPCS::fgDoVertexFit has never been used so far | |
186 | * and has always been kTRUE. | |
187 | * In order to remove the AliHLTTPC class (which is the old steering class for | |
188 | * HLT (TPC) tracking) from the compilation, this function can not be activated | |
189 | * again. We have to think about a more elegant way to specify the parameters | |
190 | * anyway. The following line was surely for some testing, but was never active | |
191 | * in a tested release. | |
192 | */ | |
a6c02c85 | 193 | //AliHLTTPC::SetVertexFit( kFALSE ); |
71d7c760 | 194 | |
195 | fTracker->InitVolumes(); | |
196 | } | |
197 | ||
738c049f | 198 | |
e6421c43 | 199 | void AliHLTTPCSliceTrackerComponent::SetTrackerParam( Bool_t doPP, Bool_t doPbPb, Int_t multiplicity, |
200 | Double_t bField, Int_t etasegment, Double_t hitchi2cut, | |
201 | Int_t rowscopetracklet, Int_t rowscopetrack, | |
202 | Int_t trackletlength, Int_t tracklength ) | |
203 | { | |
204 | // see header file for class documentation | |
205 | AliHLTTPCTransform::SetBField( bField ); | |
206 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f T\n", bField ); | |
207 | ||
208 | if ( doPP ) | |
209 | { | |
210 | //tracker->SetClusterFinderParam(xyerror,zerror,kTRUE); // ?? | |
211 | ||
72faff9f | 212 | SetTrackerParam( 50, 100, 3, 60, |
8fd35beb | 213 | 6, 6, |
e6421c43 | 214 | 0, 0.1745, 5, 100, |
215 | 5, 50, 50, 0.1, 0.1); | |
216 | } | |
217 | else if(doPbPb) | |
218 | { | |
219 | int mults[] = { 1000, 2000, 4000, 8000 }; | |
220 | int multCount = 4; | |
221 | int closestMult = 0; | |
222 | int i; | |
223 | int multDist, tmpMultDist; | |
224 | if ( multiplicity>mults[closestMult] ) | |
225 | multDist = multiplicity-mults[closestMult]; | |
226 | else | |
227 | multDist = mults[closestMult]-multiplicity; | |
228 | for ( i = 1; i < multCount; i++ ) | |
71d7c760 | 229 | { |
e6421c43 | 230 | if ( multiplicity>mults[i] ) |
231 | tmpMultDist = multiplicity-mults[i]; | |
232 | else | |
233 | tmpMultDist = mults[i]-multiplicity; | |
234 | if ( tmpMultDist < multDist ) | |
235 | { | |
236 | closestMult = i; | |
237 | multDist = tmpMultDist; | |
238 | } | |
71d7c760 | 239 | } |
e6421c43 | 240 | |
241 | double bfs[] = { 0.2, 0.4 }; | |
242 | int bfCount = 2; | |
243 | int closestBf = 0; | |
244 | double bfDist, tmpBFDist; | |
245 | if ( bField>bfs[closestBf] ) | |
246 | bfDist = bField-bfs[closestBf]; | |
247 | else | |
248 | bfDist = bfs[closestBf]-bField; | |
249 | for ( i = 1; i < bfCount; i++ ) | |
71d7c760 | 250 | { |
e6421c43 | 251 | if ( bField>bfs[i] ) |
252 | tmpBFDist = bField-bfs[i]; | |
253 | else | |
254 | tmpBFDist = bfs[i]-bField; | |
255 | if ( tmpBFDist < bfDist ) | |
71d7c760 | 256 | { |
e6421c43 | 257 | closestBf = i; |
258 | bfDist = tmpBFDist; | |
71d7c760 | 259 | } |
e6421c43 | 260 | } |
261 | ||
262 | switch ( closestMult ) | |
263 | { | |
264 | case 0: // 1000 | |
265 | switch ( closestBf ) | |
71d7c760 | 266 | { |
e6421c43 | 267 | case 0: // 0.2 |
268 | SetTrackerParam( 50, 100, 3, 10, | |
269 | 2, 4, | |
270 | 0, 0.1745, 5, 100, | |
271 | 5, 50, 50, 0.1, 0.1); | |
272 | break; | |
273 | case 1: // 0.4 | |
274 | SetTrackerParam( 50, 100, 3, 10, | |
275 | 2, 4, | |
276 | 0, 0.1745, 5, 100, | |
277 | 5, 50, 50, 0.1, 0.1); | |
278 | break; | |
71d7c760 | 279 | } |
e6421c43 | 280 | break; |
281 | case 1: // 2000 | |
282 | switch ( closestBf ) | |
71d7c760 | 283 | { |
e6421c43 | 284 | case 0: // 0.2 |
285 | SetTrackerParam( 50, 100, 3, 10, | |
286 | 2, 4, | |
287 | 0, 0.1745, 5, 30, | |
288 | 5, 20, 50, 0.1, 0.1); | |
289 | break; | |
290 | case 1: // 0.4 | |
291 | SetTrackerParam( 50, 100, 3, 10, | |
292 | 2, 5, | |
293 | 0, 0.1745, 5, 30, | |
294 | 5, 20, 50, 0.1, 0.1); | |
295 | break; | |
296 | } | |
297 | break; | |
298 | case 2: // 4000 | |
299 | switch ( closestBf ) | |
300 | { | |
301 | case 0: // 0.2 | |
302 | SetTrackerParam( 50, 100, 3, 10, | |
303 | 2 , 10, | |
304 | 0, 0.1745, 5, 20, | |
305 | 5, 10 , 50, 0.1, 0.1); | |
306 | break; | |
307 | case 1: // 0.4 | |
308 | SetTrackerParam( 50, 100, 3, 10, | |
309 | 2, 10, | |
310 | 0, 0.1745, 5, 20, | |
311 | 5, 10, 50, 0.1, 0.1); | |
312 | break; | |
313 | } | |
314 | break; | |
315 | case 3: // 8000 | |
316 | switch ( closestBf ) | |
317 | { | |
318 | case 0: // 0.2 | |
319 | SetTrackerParam( 50, 100, 3, 10, | |
320 | 3, 15, | |
321 | 0, 0.1745, 5, 10, | |
322 | 5, 5, 50, 0.1, 0.1); | |
323 | break; | |
324 | case 1: // 0.4 | |
325 | SetTrackerParam( 50, 100, 3, 10, | |
326 | 2, 15, | |
327 | 0, 0.1745, 5, 15, | |
328 | 5, 5, 50, 0.1, 0.1); | |
329 | break; | |
71d7c760 | 330 | } |
e6421c43 | 331 | break; |
71d7c760 | 332 | } |
e6421c43 | 333 | // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bfs[closestBf] ); |
334 | // AliHLTTPCTransform::SetBField( bfs[closestBf] ); | |
335 | // AliHLTTPCTransform::SetBField( bField ); | |
336 | // Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "BField", "Setting b field to %f\n", bField ); | |
71d7c760 | 337 | } |
e6421c43 | 338 | else |
339 | { | |
340 | SetTrackerParam( 50, etasegment, trackletlength, tracklength, | |
341 | rowscopetracklet, rowscopetrack, | |
342 | 0, 0.1745, 5, hitchi2cut, | |
343 | 5, 50, 50, 0.1, 0.1); | |
344 | } | |
345 | } | |
71d7c760 | 346 | |
347 | int AliHLTTPCSliceTrackerComponent::DoInit( int argc, const char** argv ) | |
348 | { | |
5df0cbb9 | 349 | // see header file for class documentation |
a6c02c85 | 350 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoInit", "DoInit", "DoInit()" ); |
a6c02c85 | 351 | |
71d7c760 | 352 | if ( fTracker || fVertex ) |
353 | return EINPROGRESS; | |
a6c02c85 | 354 | fTracker = new AliHLTTPCConfMapper(); |
355 | fVertex = new AliHLTTPCVertex(); | |
71d7c760 | 356 | fEta[0] = 0.; |
357 | fEta[1] = 1.1; | |
358 | fDoNonVertex = false; | |
a6c02c85 | 359 | fMultiplicity = 4000; |
e6421c43 | 360 | fBField = 0.5; |
a6c02c85 | 361 | fDoPP = false; |
e6421c43 | 362 | fDoPbPb = false; |
363 | fPhisegment=50; | |
364 | fEtasegment=100; | |
365 | fTrackletlength=3; | |
366 | fTracklength=60; | |
367 | fRowscopetracklet=6; | |
368 | fRowscopetrack=6; | |
369 | fMinPtFit=0; | |
370 | fMaxangle=0.1745; | |
371 | fGoodDist=5; | |
372 | fHitChi2Cut=100; | |
373 | fGoodHitChi2=5; | |
374 | fTrackChi2Cut=50; | |
375 | fMaxdist=50; | |
376 | fMaxphi=0.1; | |
377 | fMaxeta=0.1; | |
669159ae | 378 | int iResult=0; |
437e8e54 | 379 | |
669159ae | 380 | TString configuration=""; |
381 | TString argument=""; | |
382 | for (int i=0; i<argc && iResult>=0; i++) { | |
383 | argument=argv[i]; | |
384 | if (!configuration.IsNull()) configuration+=" "; | |
385 | configuration+=argument; | |
386 | } | |
ecefc48a | 387 | |
669159ae | 388 | if (!configuration.IsNull()) { |
389 | iResult=Configure(configuration.Data()); | |
390 | } else { | |
391 | iResult=Reconfigure(NULL, NULL); | |
392 | } | |
393 | ||
394 | return iResult; | |
71d7c760 | 395 | } |
396 | ||
397 | int AliHLTTPCSliceTrackerComponent::DoDeinit() | |
ecefc48a | 398 | { |
5df0cbb9 | 399 | // see header file for class documentation |
ecefc48a | 400 | if ( fTracker ) |
401 | delete fTracker; | |
402 | fTracker = NULL; | |
403 | if ( fVertex ) | |
404 | delete fVertex; | |
405 | fVertex = NULL; | |
406 | if (fpInterMerger) { | |
407 | delete fpInterMerger; | |
408 | } | |
409 | fpInterMerger=NULL; | |
410 | return 0; | |
411 | } | |
71d7c760 | 412 | |
8ede8717 | 413 | int AliHLTTPCSliceTrackerComponent::DoEvent( const AliHLTComponentEventData& evtData, const AliHLTComponentBlockData* blocks, |
5d2abf3b | 414 | AliHLTComponentTriggerData& /*trigData*/, AliHLTUInt8_t* outputPtr, |
7bcd6cad | 415 | AliHLTUInt32_t& size, AliHLTComponentBlockDataList& outputBlocks ) |
bd34e482 | 416 | { |
5df0cbb9 | 417 | // see header file for class documentation |
bd34e482 | 418 | int iResult=0; |
419 | AliHLTUInt32_t capacity=size; | |
420 | size=0; | |
421 | ||
b05e22cd | 422 | if (!IsDataEvent()) return 0; |
423 | ||
5235c3e9 | 424 | if ( evtData.fBlockCnt<=0 ) |
425 | { | |
426 | Logging( kHLTLogWarning, "HLT::TPCSliceTracker::DoEvent", "DoEvent", "no blocks in event" ); | |
427 | return 0; | |
428 | } | |
8ede8717 | 429 | const AliHLTComponentBlockData* iter = NULL; |
71d7c760 | 430 | unsigned long ndx; |
431 | AliHLTTPCClusterData* inPtrSP; | |
a6c02c85 | 432 | AliHLTTPCVertexData* inPtrV = NULL; |
c9602aeb | 433 | #ifdef FORWARD_VERTEX_BLOCK |
8ede8717 | 434 | const AliHLTComponentBlockData* vertexIter=NULL; |
c9602aeb | 435 | #endif |
71d7c760 | 436 | AliHLTTPCTrackletData* outPtr; |
437 | AliHLTUInt8_t* outBPtr; | |
c9602aeb | 438 | //AliHLTUInt32_t vSize = 0; |
71d7c760 | 439 | UInt_t offset=0, mysize, tSize = 0; |
440 | outBPtr = outputPtr; | |
5235c3e9 | 441 | Int_t slice=-1, patch=-1, row[2]; |
71d7c760 | 442 | Int_t minPatch=INT_MAX, maxPatch = 0; |
443 | offset = 0; | |
444 | std::vector<Int_t> slices; | |
445 | std::vector<Int_t>::iterator slIter, slEnd; | |
446 | std::vector<unsigned> sliceCnts; | |
447 | std::vector<unsigned>::iterator slCntIter; | |
5235c3e9 | 448 | Int_t vertexSlice=-1; |
71d7c760 | 449 | |
450 | // Find min/max rows used in total and find and read out vertex if it is present | |
451 | // also determine correct slice number, if multiple slice numbers are present in event | |
452 | // (which should not happen in the first place) we use the one that occurs the most times | |
453 | row[0] = 0; | |
454 | row[1] = 0; | |
455 | bool found; | |
456 | for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) | |
457 | { | |
458 | iter = blocks+ndx; | |
459 | ||
bd34e482 | 460 | bool bIsClusterDataBlock=false; |
461 | bool bIsVertexDataBlock=false; | |
462 | if(!(bIsClusterDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkClustersDataType)) && | |
463 | !(bIsVertexDataBlock=(iter->fDataType==AliHLTTPCDefinitions::fgkVertexDataType))){ | |
cb703d46 | 464 | continue; |
465 | } | |
466 | ||
71d7c760 | 467 | slice = AliHLTTPCDefinitions::GetMinSliceNr( *iter ); |
bd34e482 | 468 | if (slice<0 || slice>=AliHLTTPCTransform::GetNSlice()) { |
469 | HLTError("invalid slice number %d extracted from specification 0x%08lx, skipping block of type %s", | |
470 | slice, iter->fSpecification, DataType2Text(iter->fDataType).c_str()); | |
471 | // just remember the error, if there are other valid blocks ignore the | |
472 | // error, return code otherwise | |
473 | iResult=-EBADF; | |
474 | continue; | |
475 | } | |
476 | if (slice!=AliHLTTPCDefinitions::GetMaxSliceNr( *iter )) { | |
477 | // the code was not written for/ never used with multiple slices | |
478 | // in one data block/ specification | |
479 | HLTWarning("specification 0x%08lx indicates multiple slices in data block %s: never used before, please audit the code", | |
480 | iter->fSpecification, DataType2Text(iter->fDataType).c_str()); | |
481 | } | |
71d7c760 | 482 | found = false; |
483 | slIter = slices.begin(); | |
484 | slEnd = slices.end(); | |
485 | slCntIter = sliceCnts.begin(); | |
486 | while ( slIter != slEnd ) | |
487 | { | |
488 | if ( *slIter == slice ) | |
489 | { | |
490 | found = true; | |
491 | break; | |
492 | } | |
493 | slIter++; | |
494 | slCntIter++; | |
495 | } | |
496 | if ( !found ) | |
497 | { | |
498 | slices.insert( slices.end(), slice ); | |
499 | sliceCnts.insert( sliceCnts.end(), 1 ); | |
500 | } | |
501 | else | |
502 | *slCntIter++; | |
503 | ||
bd34e482 | 504 | if (bIsVertexDataBlock) |
71d7c760 | 505 | { |
a6c02c85 | 506 | inPtrV = (AliHLTTPCVertexData*)(iter->fPtr); |
c9602aeb | 507 | #ifdef FORWARD_VERTEX_BLOCK |
71d7c760 | 508 | vertexIter = iter; |
c9602aeb | 509 | #endif |
510 | //vSize = iter->fSize; | |
71d7c760 | 511 | fVertex->Read( inPtrV ); |
512 | vertexSlice = slice; | |
513 | } | |
bd34e482 | 514 | if (bIsClusterDataBlock) |
71d7c760 | 515 | { |
516 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
517 | if ( minPatch>patch ) | |
518 | { | |
519 | minPatch = patch; | |
a6c02c85 | 520 | row[0] = AliHLTTPCTransform::GetFirstRow( patch ); |
71d7c760 | 521 | } |
522 | if ( maxPatch<patch ) | |
523 | { | |
524 | maxPatch = patch; | |
a6c02c85 | 525 | row[1] = AliHLTTPCTransform::GetLastRow( patch ); |
71d7c760 | 526 | } |
527 | } | |
528 | } | |
529 | ||
530 | // Determine slice number to really use. | |
531 | if ( slices.size()>1 ) | |
532 | { | |
533 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event", | |
534 | "Multiple slice numbers found in event 0x%08lX (%lu). Determining maximum occuring slice number...", | |
535 | evtData.fEventID, evtData.fEventID ); | |
536 | unsigned maxCntSlice=0; | |
537 | slIter = slices.begin(); | |
538 | slEnd = slices.end(); | |
539 | slCntIter = sliceCnts.begin(); | |
540 | while ( slIter != slEnd ) | |
541 | { | |
542 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event", | |
543 | "Slice %lu found %lu times.", *slIter, *slCntIter ); | |
544 | if ( maxCntSlice<*slCntIter ) | |
545 | { | |
546 | maxCntSlice = *slCntIter; | |
547 | slice = *slIter; | |
548 | } | |
549 | slIter++; | |
550 | slCntIter++; | |
551 | } | |
552 | Logging( kHLTLogError, "HLT::TPCSliceTracker::DoEvent", "Multiple slices found in event", | |
553 | "Using slice %lu.", slice ); | |
554 | } | |
5235c3e9 | 555 | else if ( slices.size()>0 ) |
556 | { | |
71d7c760 | 557 | slice = *(slices.begin()); |
5235c3e9 | 558 | } |
559 | else | |
560 | { | |
bd34e482 | 561 | // there is no sense in running the tracker without input, do not send an |
562 | // empty output block | |
563 | return iResult; | |
5235c3e9 | 564 | } |
71d7c760 | 565 | |
bd34e482 | 566 | iResult=0; |
567 | ||
71d7c760 | 568 | if ( vertexSlice != slice ) |
569 | { | |
570 | // multiple vertex blocks in event and we used the wrong one... | |
571 | found = false; | |
572 | for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) | |
573 | { | |
574 | iter = blocks+ndx; | |
96bda103 | 575 | if ( iter->fDataType == AliHLTTPCDefinitions::fgkVertexDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) |
71d7c760 | 576 | { |
a6c02c85 | 577 | inPtrV = (AliHLTTPCVertexData*)(iter->fPtr); |
c9602aeb | 578 | #ifdef FORWARD_VERTEX_BLOCK |
71d7c760 | 579 | vertexIter = iter; |
c9602aeb | 580 | #endif |
581 | //vSize = iter->fSize; | |
71d7c760 | 582 | fVertex->Read( inPtrV ); |
583 | break; | |
584 | } | |
585 | } | |
586 | } | |
587 | ||
588 | fTracker->InitSector( slice, row, fEta ); | |
589 | fTracker->SetVertex(fVertex); | |
590 | mysize = 0; | |
591 | // read in all hits | |
a6c02c85 | 592 | std::vector<unsigned long> patchIndices; |
593 | std::vector<unsigned long>::iterator pIter, pEnd; | |
71d7c760 | 594 | for ( ndx = 0; ndx < evtData.fBlockCnt; ndx++ ) |
595 | { | |
596 | iter = blocks+ndx; | |
597 | ||
96bda103 | 598 | if ( iter->fDataType == AliHLTTPCDefinitions::fgkClustersDataType && slice==AliHLTTPCDefinitions::GetMinSliceNr( *iter ) ) |
71d7c760 | 599 | { |
600 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
a6c02c85 | 601 | pIter = patchIndices.begin(); |
602 | pEnd = patchIndices.end(); | |
603 | while ( pIter!=pEnd && AliHLTTPCDefinitions::GetMinSliceNr( blocks[*pIter] ) < patch ) | |
604 | pIter++; | |
605 | patchIndices.insert( pIter, ndx ); | |
71d7c760 | 606 | } |
607 | } | |
a6c02c85 | 608 | pIter = patchIndices.begin(); |
609 | pEnd = patchIndices.end(); | |
610 | while ( pIter!=pEnd ) | |
611 | { | |
612 | ndx = *pIter; | |
613 | iter = blocks+ndx; | |
614 | ||
615 | patch = AliHLTTPCDefinitions::GetMinPatchNr( *iter ); | |
616 | inPtrSP = (AliHLTTPCClusterData*)(iter->fPtr); | |
617 | ||
618 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Reading hits", | |
619 | "Reading hits for slice %d - patch %d", slice, patch ); | |
2a31fa2a | 620 | //fTracker->ReadHits( inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints ); |
621 | fTracker->ReadHitsChecked(inPtrSP->fSpacePointCnt, inPtrSP->fSpacePoints,iter->fSize ); | |
a6c02c85 | 622 | pIter++; |
623 | } | |
71d7c760 | 624 | |
437e8e54 | 625 | |
738c049f | 626 | if ( fmainvertextracking == kTRUE && fnonvertextracking == kFALSE){ |
437e8e54 | 627 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---"); |
628 | fTracker->MainVertexTrackingA(); | |
629 | fTracker->MainVertexTrackingB(); | |
630 | fTracker->FillTracks(); | |
738c049f | 631 | } |
632 | else if ( fmainvertextracking == kTRUE && fnonvertextracking == kTRUE){ | |
437e8e54 | 633 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---MAINVERTEXTRACKING---"); |
634 | fTracker->MainVertexTrackingA(); | |
635 | fTracker->MainVertexTrackingB(); | |
636 | fTracker->FillTracks(); | |
637 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---"); | |
638 | fTracker->NonVertexTracking(); | |
738c049f | 639 | } |
640 | else if ( fmainvertextracking == kFALSE && fnonvertextracking == kTRUE){ | |
437e8e54 | 641 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracking", " ---NONVERTEXTRACKING---"); |
642 | fTracker->NonVertexTracking(); | |
643 | fTracker->FillTracks(); | |
738c049f | 644 | } |
437e8e54 | 645 | |
ecefc48a | 646 | UInt_t ntracks0 =0; |
647 | if(fpInterMerger){ | |
648 | AliHLTTPCMemHandler memory; | |
649 | AliHLTTPCTrackSegmentData *trackdata0 = | |
650 | (AliHLTTPCTrackSegmentData *) memory.Allocate(fTracker->GetTracks()); | |
651 | memory.TrackArray2Memory(ntracks0,trackdata0,fTracker->GetTracks()); | |
652 | fpInterMerger->Reset(); | |
653 | fpInterMerger->Init(row,patch); | |
654 | fpInterMerger->FillTracks(ntracks0,trackdata0); | |
655 | fpInterMerger->Merge(); | |
656 | } | |
657 | ntracks0=0; | |
5df0cbb9 | 658 | AliHLTTPCTrackArray* pArray=fTracker->GetTracks(); |
bd34e482 | 659 | if (pArray->GetOutSize()+sizeof(AliHLTTPCTrackletData)<=capacity) { |
660 | outPtr = (AliHLTTPCTrackletData*)(outBPtr); | |
5df0cbb9 | 661 | mysize = pArray->WriteTracks( ntracks0, outPtr->fTracklets ); |
71d7c760 | 662 | outPtr->fTrackletCnt = ntracks0; |
ecefc48a | 663 | |
8d262e30 | 664 | // Matthias 2009-05-22 |
665 | // Somehow the ConfMapFit uses a different sign convention for the magnetic field. | |
666 | // In order to avoid conversions further upstream we change the sign here. | |
667 | // The CM tracker is not the first priority any more as the CA tracker is | |
668 | // going to be used for online TPC reconstruction. But CM tracker has to | |
669 | // remain functional. | |
670 | // Further investigation is ongoing | |
671 | AliHLTTPCTrackSegmentData* segment=outPtr->fTracklets; | |
9ba081fd | 672 | for (unsigned int trackno=0; trackno<ntracks0; trackno++, segment++) { |
8d262e30 | 673 | segment->fCharge*=-1; |
674 | } | |
675 | ||
71d7c760 | 676 | Logging( kHLTLogDebug, "HLT::TPCSliceTracker::DoEvent", "Tracks", |
677 | "Input: Number of tracks: %lu Slice/MinPatch/MaxPatch/RowMin/RowMax: %lu/%lu/%lu/%lu/%lu.", | |
678 | ntracks0, slice, minPatch, maxPatch, row[0], row[1] ); | |
679 | ||
055fed30 | 680 | fTracker->Reset(); |
681 | ||
8ede8717 | 682 | AliHLTComponentBlockData bd; |
71d7c760 | 683 | FillBlockData( bd ); |
684 | bd.fOffset = offset; | |
bd34e482 | 685 | bd.fSize = mysize+sizeof(AliHLTTPCTrackletData); |
71d7c760 | 686 | bd.fSpecification = AliHLTTPCDefinitions::EncodeDataSpecification( slice, slice, minPatch, maxPatch ); |
687 | outputBlocks.push_back( bd ); | |
688 | ||
bd34e482 | 689 | tSize += bd.fSize; |
690 | outBPtr += bd.fSize; | |
691 | } else { | |
692 | iResult=-ENOSPC; | |
693 | } | |
694 | ||
71d7c760 | 695 | #ifdef FORWARD_VERTEX_BLOCK |
696 | if ( vertexIter ) | |
697 | { | |
698 | // Copy the descriptor block for the vertex information. | |
699 | bd = *vertexIter; | |
700 | outputBlocks.push_back( bd ); | |
701 | } | |
702 | #endif // FORWARD_VERTEX_BLOCK | |
703 | ||
704 | size = tSize; | |
bd34e482 | 705 | return iResult; |
71d7c760 | 706 | } |
707 | ||
669159ae | 708 | int AliHLTTPCSliceTrackerComponent::Configure(const char* arguments) |
709 | { | |
710 | // see header file for class documentation | |
711 | int iResult=0; | |
712 | if (!arguments) return iResult; | |
713 | ||
75970b8d | 714 | // Check field |
715 | if (!TGeoGlobalMagField::Instance()) { | |
716 | HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF"); | |
717 | return -ENODEV; | |
718 | } | |
719 | ||
669159ae | 720 | TString allArgs=arguments; |
721 | TString argument; | |
722 | int bMissingParam=0; | |
723 | Bool_t bDoMerger=kTRUE; | |
724 | ||
725 | TObjArray* pTokens=allArgs.Tokenize(" "); | |
726 | if (pTokens) { | |
727 | for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) { | |
728 | argument=((TObjString*)pTokens->At(i))->GetString(); | |
729 | if (argument.IsNull()) continue; | |
730 | ||
731 | if (argument.CompareTo("-disable-merger")==0) { | |
732 | HLTInfo("Disabled Inter Merger"); | |
733 | bDoMerger = kFALSE; | |
734 | continue; | |
735 | } | |
736 | else if (argument.CompareTo("-pp-run")==0) { | |
737 | HLTInfo("Using Trackparameters for pp-run"); | |
738 | fDoPP = true; | |
739 | continue; | |
740 | } | |
741 | else if (argument.CompareTo("-PbPb-run")==0) { | |
742 | HLTInfo("Using Trackparameters for Pb-Pb-run"); | |
743 | fDoPbPb = true; | |
744 | continue; | |
745 | } | |
746 | else if (argument.CompareTo("-nonvertextracking")==0) { | |
747 | HLTInfo("Doing Nonvertex Tracking"); | |
748 | fnonvertextracking = kTRUE; | |
749 | continue; | |
750 | } | |
751 | else if (argument.CompareTo("-mainvertextrackingoff")==0) { | |
752 | HLTInfo("Mainvertex Tracking off"); | |
753 | fmainvertextracking = kFALSE; | |
754 | continue; | |
755 | } | |
756 | else if (argument.CompareTo("-multiplicity")==0) { | |
757 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
758 | HLTInfo("Multiplicity set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
759 | fMultiplicity=((TObjString*)pTokens->At(i))->GetString().Atoi(); | |
760 | continue; | |
761 | } | |
8d262e30 | 762 | else if (argument.CompareTo("-solenoidBz")==0) { |
669159ae | 763 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; |
75970b8d | 764 | HLTWarning("parameter -solenoidBz deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField"); |
91db0db2 | 765 | continue; |
766 | } | |
767 | else if (argument.CompareTo("-bfield")==0) { | |
91db0db2 | 768 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; |
75970b8d | 769 | HLTWarning("parameter -bfield deprecated, magnetic field handled by global AliMagF object and TGeoGlobalMagField"); |
669159ae | 770 | continue; |
771 | } | |
772 | else if (argument.CompareTo("-etarange")==0) { | |
773 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
774 | HLTInfo("Etarange set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
775 | fEta[1]=((TObjString*)pTokens->At(i))->GetString().Atof(); | |
776 | continue; | |
777 | } | |
778 | else if (argument.CompareTo("-etasegment")==0) { | |
779 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
780 | HLTInfo("Number of Etasegment: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
781 | fEtasegment=((TObjString*)pTokens->At(i))->GetString().Atoi(); | |
782 | continue; | |
783 | } | |
784 | else if (argument.CompareTo("-chi2cut")==0) { | |
785 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
786 | HLTInfo("chi2cut set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
787 | fHitChi2Cut=((TObjString*)pTokens->At(i))->GetString().Atof(); | |
788 | continue; | |
789 | } | |
790 | else if (argument.CompareTo("-rowscopetracklet")==0) { | |
791 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
792 | HLTInfo("Number of row to look for next cluster for tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
793 | fRowscopetracklet=((TObjString*)pTokens->At(i))->GetString().Atoi(); | |
794 | continue; | |
795 | } | |
796 | else if (argument.CompareTo("-rowscopetrack")==0) { | |
797 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
798 | HLTInfo("Number of row to look for next cluster for track: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
799 | fRowscopetrack=((TObjString*)pTokens->At(i))->GetString().Atoi(); | |
800 | continue; | |
801 | } | |
802 | else if (argument.CompareTo("-trackletlength")==0) { | |
803 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
804 | HLTInfo("Minimum number of clusters on a Tracklet: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
805 | fTrackletlength=((TObjString*)pTokens->At(i))->GetString().Atoi(); | |
806 | continue; | |
807 | } | |
808 | else if (argument.CompareTo("-tracklength")==0) { | |
809 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
810 | HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
811 | fTracklength=((TObjString*)pTokens->At(i))->GetString().Atoi(); | |
812 | continue; | |
813 | } | |
887a0bd9 | 814 | else if (argument.CompareTo("-clusterZ")==0) { |
815 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
816 | HLTInfo("Minimum number of clusters on a Track: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
817 | fTracker->SetClusterCutZ(((TObjString*)pTokens->At(i))->GetString().Atoi()); | |
818 | continue; | |
819 | } | |
669159ae | 820 | else { |
821 | HLTError("unknown argument %s", argument.Data()); | |
822 | iResult=-EINVAL; | |
823 | break; | |
824 | } | |
825 | } | |
826 | delete pTokens; | |
827 | } | |
828 | if (bMissingParam) { | |
829 | HLTError("missing parameter for argument %s", argument.Data()); | |
830 | iResult=-EINVAL; | |
831 | } | |
75970b8d | 832 | fBField=GetBz()/10.0; |
669159ae | 833 | if (fBField == 0.){ |
834 | // parameter for B=0 T | |
835 | fDoPP = kTRUE; | |
836 | fnonvertextracking = kTRUE; | |
837 | fmainvertextracking = kFALSE; | |
838 | } | |
839 | ||
840 | if (bDoMerger) | |
841 | fpInterMerger = new AliHLTTPCInterMerger(); | |
842 | else | |
843 | fpInterMerger = NULL; | |
844 | ||
845 | SetTrackerParam(fDoPP,fDoPbPb,fMultiplicity,fBField,fEtasegment,fHitChi2Cut,fRowscopetracklet,fRowscopetrack,fTrackletlength,fTracklength); | |
846 | ||
847 | return iResult; | |
848 | } | |
849 | ||
b1d702f1 | 850 | int AliHLTTPCSliceTrackerComponent::ReadPreprocessorValues(const char* modules) |
851 | { | |
852 | // see header file for class documentation | |
853 | ||
854 | int iResult = 0; | |
855 | TString str(modules); | |
856 | if(str.Contains("HLT") || str.Contains("TPC") || str.Contains("GRP")){ | |
857 | ||
75970b8d | 858 | const char* pathBField=NULL; |
b1d702f1 | 859 | if (pathBField) { |
860 | ||
861 | HLTInfo("reconfigure B-Field from entry %s, modules %s", pathBField,(modules!=NULL && modules[0]!=0)?modules:"<none>"); | |
862 | //AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField/*,GetRunNo()*/); | |
863 | ||
864 | AliCDBPath path(pathBField); | |
865 | ||
866 | AliCDBStorage *stor = AliCDBManager::Instance()->GetDefaultStorage(); | |
867 | Int_t version = stor->GetLatestVersion(pathBField, GetRunNo()); | |
868 | Int_t subVersion = stor->GetLatestSubVersion(pathBField, GetRunNo(), version); | |
869 | AliCDBEntry *pEntry = stor->Get(path,GetRunNo(), version, subVersion); | |
870 | ||
871 | HLTImportant("RunNo %d, Version %d, subversion %d", GetRunNo(), version, subVersion); | |
872 | ||
873 | if (pEntry) { | |
874 | TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject()); | |
875 | if (pString) { | |
876 | HLTImportant("received configuration object string: \'%s\'", pString->GetString().Data()); | |
877 | iResult=Configure(pString->GetString().Data()); | |
878 | } else { | |
879 | HLTError("configuration object \"%s\" has wrong type, required TObjString", pathBField); | |
880 | } | |
881 | } else { | |
882 | HLTError("cannot fetch object \"%s\" from CDB", pathBField); | |
883 | } | |
884 | } | |
885 | } | |
886 | return iResult; | |
887 | } | |
888 | ||
669159ae | 889 | int AliHLTTPCSliceTrackerComponent::Reconfigure(const char* cdbEntry, const char* chainId) |
890 | { | |
891 | // see header file for class documentation | |
b1d702f1 | 892 | |
669159ae | 893 | int iResult=0; |
894 | const char* path="HLT/ConfigTPC/SliceTrackerComponent"; | |
895 | const char* defaultNotify=""; | |
896 | if (cdbEntry) { | |
897 | path=cdbEntry; | |
898 | defaultNotify=" (default)"; | |
899 | } | |
900 | if (path) { | |
901 | HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>"); | |
902 | AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/); | |
903 | if (pEntry) { | |
904 | TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject()); | |
905 | if (pString) { | |
906 | HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data()); | |
907 | iResult=Configure(pString->GetString().Data()); | |
908 | } else { | |
909 | HLTError("configuration object \"%s\" has wrong type, required TObjString", path); | |
910 | } | |
911 | } else { | |
b1d702f1 | 912 | HLTError("cannot fetch object \"%s\" from CDB", path); |
669159ae | 913 | } |
914 | } | |
a67402b3 | 915 | |
75970b8d | 916 | const char* pathBField=NULL; |
a67402b3 | 917 | |
918 | if (pathBField) { | |
919 | HLTInfo("reconfigure B-Field from entry %s, chain id %s", path,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>"); | |
920 | AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(pathBField/*,GetRunNo()*/); | |
921 | if (pEntry) { | |
922 | TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject()); | |
923 | if (pString) { | |
924 | HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data()); | |
925 | iResult=Configure(pString->GetString().Data()); | |
926 | } else { | |
927 | HLTError("configuration object \"%s\" has wrong type, required TObjString", path); | |
928 | } | |
929 | } else { | |
b1d702f1 | 930 | HLTError("cannot fetch object \"%s\" from CDB", path); |
a67402b3 | 931 | } |
932 | } | |
933 | ||
669159ae | 934 | return iResult; |
b1d702f1 | 935 | |
669159ae | 936 | } |
937 | ||
5df0cbb9 | 938 | void AliHLTTPCSliceTrackerComponent::SetTrackerParam1() |
939 | { | |
e67b0680 | 940 | // see header file for class documentation |
5df0cbb9 | 941 | SetTrackerParam( 10, 20, 5, 10, 2,2, |
942 | 0, 1.31, 5, 100, | |
e6421c43 | 943 | 50, 100, 50, 0.1, 0.1); |
5df0cbb9 | 944 | } |
945 | ||
71d7c760 | 946 |