]>
Commit | Line | Data |
---|---|---|
c9598e1c | 1 | // ************************************************************************** |
2 | // This file is property of and copyright by the ALICE HLT Project * | |
3 | // ALICE Experiment at CERN, All rights reserved. * | |
4 | // * | |
5 | // Primary Authors: Sergey Gorbunov <sergey.gorbunov@kip.uni-heidelberg.de> * | |
6 | // Ivan Kisel <kisel@kip.uni-heidelberg.de> * | |
7 | // for The ALICE HLT Project. * | |
8 | // * | |
9 | // Permission to use, copy, modify and distribute this software and its * | |
10 | // documentation strictly for non-commercial purposes is hereby granted * | |
11 | // without fee, provided that the above copyright notice appears in all * | |
12 | // copies and that both the copyright notice and this permission notice * | |
13 | // appear in the supporting documentation. The authors make no claims * | |
14 | // about the suitability of this software for any purpose. It is * | |
15 | // provided "as is" without express or implied warranty. * | |
16 | // * | |
17 | //*************************************************************************** | |
18 | ||
19 | /// @file AliHLTITSSAPTrackerComponent.h | |
20 | /// @author Ruben Shahoyan <ruben.shahoyan@cern.ch> | |
21 | /// @date August 2014 | |
22 | /// @brief An ITS standalone primaries tracker/vertexer processing component for the HLT | |
23 | /// Adapted from HLT/ITS/tracking/AliHLTITSSAPTrackerComponent component | |
24 | ||
25 | ///////////////////////////////////////////////////// | |
26 | // // | |
27 | // a ITS tracker processing component for the HLT // | |
28 | // // | |
29 | ///////////////////////////////////////////////////// | |
30 | ||
31 | #include "AliHLTITSSAPTrackerComponent.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 "AliGeomManager.h" | |
39 | #include "TObjString.h" | |
40 | #include <TClonesArray.h> | |
41 | #include <TGeoGlobalMagField.h> | |
42 | #include "AliITSSAPTracker.h" | |
43 | #include "AliHLTITSSpacePointData.h" | |
44 | #include "AliHLTITSClusterDataFormat.h" | |
45 | #include "AliHLTDataTypes.h" | |
46 | #include "AliHLTExternalTrackParam.h" | |
47 | #include "AliGeomManager.h" | |
48 | #include "AliHLTTrackMCLabel.h" | |
49 | #include "AliITSRecPoint.h" | |
c1cd4fce | 50 | #include "AliHLTSAPTrackerData.h" |
a48865c5 | 51 | #include "AliHLTMessage.h" |
52 | #include "AliFlatESDVertex.h" | |
c9598e1c | 53 | #include <map> |
54 | ||
55 | using namespace std; | |
56 | ||
57 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
58 | ClassImp( AliHLTITSSAPTrackerComponent ) | |
59 | AliHLTITSSAPTrackerComponent::AliHLTITSSAPTrackerComponent() | |
60 | : fSolenoidBz( 0 ), | |
61 | fBenchmark("ITSSAPTracker"), | |
62 | fTracker(0), | |
63 | fClusters(0) | |
64 | ||
65 | { | |
66 | // see header file for class documentation | |
67 | // or | |
68 | // refer to README to build package | |
69 | // or | |
70 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
71 | } | |
72 | ||
73 | AliHLTITSSAPTrackerComponent::AliHLTITSSAPTrackerComponent( const AliHLTITSSAPTrackerComponent& ) | |
74 | :AliHLTProcessor(), | |
75 | fSolenoidBz( 0 ), | |
76 | fBenchmark("ITSSAPTracker"), | |
77 | fTracker(0), | |
78 | fClusters(0) | |
79 | { | |
80 | // see header file for class documentation | |
81 | HLTFatal( "copy constructor untested" ); | |
82 | } | |
83 | ||
84 | AliHLTITSSAPTrackerComponent& AliHLTITSSAPTrackerComponent::operator=( const AliHLTITSSAPTrackerComponent& ) | |
85 | { | |
86 | // see header file for class documentation | |
87 | HLTFatal( "assignment operator untested" ); | |
88 | return *this; | |
89 | } | |
90 | ||
91 | AliHLTITSSAPTrackerComponent::~AliHLTITSSAPTrackerComponent() | |
92 | { | |
93 | // see header file for class documentation | |
94 | delete fTracker; | |
95 | delete fClusters; | |
96 | } | |
97 | ||
98 | // | |
99 | // Public functions to implement AliHLTComponent's interface. | |
100 | // These functions are required for the registration process | |
101 | // | |
102 | ||
103 | const char* AliHLTITSSAPTrackerComponent::GetComponentID() | |
104 | { | |
105 | // see header file for class documentation | |
c1cd4fce | 106 | return "ITSSAPTracker"; |
c9598e1c | 107 | } |
108 | ||
109 | void AliHLTITSSAPTrackerComponent::GetInputDataTypes( vector<AliHLTComponentDataType>& list ) | |
110 | { | |
111 | // see header file for class documentation | |
112 | list.clear(); | |
113 | list.push_back( kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS ); | |
114 | list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD ); | |
115 | list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD ); | |
116 | list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD ); | |
117 | list.push_back( kAliHLTDataTypeClusters|kAliHLTDataOriginITS ); | |
118 | } | |
119 | ||
120 | AliHLTComponentDataType AliHLTITSSAPTrackerComponent::GetOutputDataType() | |
121 | { | |
122 | // see header file for class documentation | |
123 | return kAliHLTMultipleDataType; | |
124 | } | |
125 | ||
126 | int AliHLTITSSAPTrackerComponent::GetOutputDataTypes(AliHLTComponentDataTypeList& tgtList) | |
127 | { | |
128 | // see header file for class documentation | |
129 | tgtList.clear(); | |
a48865c5 | 130 | tgtList.push_back(kAliHLTDataTypeITSSAPData|kAliHLTDataOriginITS); |
131 | tgtList.push_back(kAliHLTDataTypeFlatESDVertex|kAliHLTDataOriginITS ); // RS??: is this correct? | |
c9598e1c | 132 | return tgtList.size(); |
133 | } | |
134 | ||
135 | void AliHLTITSSAPTrackerComponent::GetOutputDataSize( unsigned long& constBase, double& inputMultiplier ) | |
136 | { | |
137 | // define guess for the output data size | |
138 | constBase = 200; // minimum size | |
139 | inputMultiplier = 2.; // size relative to input | |
140 | } | |
141 | ||
142 | AliHLTComponent* AliHLTITSSAPTrackerComponent::Spawn() | |
143 | { | |
144 | // see header file for class documentation | |
145 | return new AliHLTITSSAPTrackerComponent; | |
146 | } | |
147 | ||
148 | void AliHLTITSSAPTrackerComponent::SetDefaultConfiguration() | |
149 | { | |
150 | // Set default configuration for the CA tracker component | |
151 | // Some parameters can be later overwritten from the OCDB | |
152 | ||
153 | fSolenoidBz = -5.00668; | |
154 | ||
155 | } | |
156 | ||
157 | int AliHLTITSSAPTrackerComponent::ReadConfigurationString( const char* arguments ) | |
158 | { | |
159 | // Set configuration parameters for the CA tracker component from the string | |
160 | ||
161 | int iResult = 0; | |
162 | if ( !arguments ) return iResult; | |
163 | ||
164 | TString allArgs = arguments; | |
165 | TString argument; | |
166 | int bMissingParam = 0; | |
167 | ||
168 | TObjArray* pTokens = allArgs.Tokenize( " " ); | |
169 | ||
170 | int nArgs = pTokens ? pTokens->GetEntries() : 0; | |
171 | ||
172 | for ( int i = 0; i < nArgs; i++ ) { | |
173 | argument = ( ( TObjString* )pTokens->At( i ) )->GetString(); | |
174 | if ( argument.IsNull() ) continue; | |
175 | ||
176 | if ( argument.CompareTo( "-solenoidBz" ) == 0 ) { | |
177 | if ( ( bMissingParam = ( ++i >= pTokens->GetEntries() ) ) ) break; | |
178 | HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz()); | |
179 | continue; | |
180 | } | |
181 | ||
182 | HLTError( "Unknown option \"%s\"", argument.Data() ); | |
183 | iResult = -EINVAL; | |
184 | } | |
185 | delete pTokens; | |
186 | ||
187 | if ( bMissingParam ) { | |
188 | HLTError( "Specifier missed for parameter \"%s\"", argument.Data() ); | |
189 | iResult = -EINVAL; | |
190 | } | |
191 | ||
192 | return iResult; | |
193 | } | |
194 | ||
195 | ||
196 | int AliHLTITSSAPTrackerComponent::ReadCDBEntry( const char* cdbEntry, const char* chainId ) | |
197 | { | |
198 | // see header file for class documentation | |
199 | ||
200 | const char* defaultNotify = ""; | |
201 | ||
202 | if ( !cdbEntry ) { | |
203 | return 0;// need to add the HLT/ConfigITS/ITSTracker directory to cdb SG!!! | |
204 | //cdbEntry = "HLT/ConfigITS/ITSTracker"; | |
205 | //defaultNotify = " (default)"; | |
206 | //chainId = 0; | |
207 | } | |
208 | ||
209 | HLTInfo( "configure from entry \"%s\"%s, chain id %s", cdbEntry, defaultNotify, ( chainId != NULL && chainId[0] != 0 ) ? chainId : "<none>" ); | |
210 | AliCDBEntry *pEntry = AliCDBManager::Instance()->Get( cdbEntry );//,GetRunNo()); | |
211 | ||
212 | if ( !pEntry ) { | |
213 | HLTError( "cannot fetch object \"%s\" from CDB", cdbEntry ); | |
214 | return -EINVAL; | |
215 | } | |
216 | ||
217 | TObjString* pString = dynamic_cast<TObjString*>( pEntry->GetObject() ); | |
218 | ||
219 | if ( !pString ) { | |
220 | HLTError( "configuration object \"%s\" has wrong type, required TObjString", cdbEntry ); | |
221 | return -EINVAL; | |
222 | } | |
223 | ||
224 | HLTInfo( "received configuration object string: \"%s\"", pString->GetString().Data() ); | |
225 | ||
226 | return ReadConfigurationString( pString->GetString().Data() ); | |
227 | } | |
228 | ||
229 | ||
230 | int AliHLTITSSAPTrackerComponent::Configure( const char* cdbEntry, const char* chainId, const char *commandLine ) | |
231 | { | |
232 | // Configure the component | |
233 | // There are few levels of configuration, | |
234 | // parameters which are set on one step can be overwritten on the next step | |
235 | ||
236 | //* read hard-coded values | |
237 | ||
238 | SetDefaultConfiguration(); | |
239 | ||
240 | //* read the default CDB entry | |
241 | ||
242 | int iResult1 = ReadCDBEntry( NULL, chainId ); | |
243 | ||
244 | //* read magnetic field | |
245 | ||
246 | fSolenoidBz = GetBz(); | |
247 | ||
248 | //* read the actual CDB entry if required | |
249 | ||
250 | int iResult2 = ( cdbEntry ) ? ReadCDBEntry( cdbEntry, chainId ) : 0; | |
251 | ||
252 | //* read extra parameters from input (if they are) | |
253 | ||
254 | int iResult3 = 0; | |
255 | ||
256 | if ( commandLine && commandLine[0] != '\0' ) { | |
257 | HLTInfo( "received configuration string from HLT framework: \"%s\"", commandLine ); | |
258 | iResult3 = ReadConfigurationString( commandLine ); | |
259 | } | |
260 | ||
261 | // Initialise the tracker here | |
262 | ||
263 | return iResult1 ? iResult1 : ( iResult2 ? iResult2 : iResult3 ); | |
264 | } | |
265 | ||
266 | ||
267 | ||
268 | int AliHLTITSSAPTrackerComponent::DoInit( int argc, const char** argv ) | |
269 | { | |
270 | // Configure the ITS tracker component | |
271 | ||
272 | if ( fTracker ) return -EINPROGRESS; | |
273 | ||
274 | if(AliGeomManager::GetGeometry()==NULL){ | |
275 | AliGeomManager::LoadGeometry(); | |
276 | } | |
277 | AliGeomManager::ApplyAlignObjsFromCDB("ITS"); | |
278 | ||
279 | TString arguments = ""; | |
280 | for ( int i = 0; i < argc; i++ ) { | |
281 | if ( !arguments.IsNull() ) arguments += " "; | |
282 | arguments += argv[i]; | |
283 | } | |
284 | ||
285 | int ret = Configure( NULL, NULL, arguments.Data() ); | |
286 | ||
287 | // Check field | |
288 | if (!TGeoGlobalMagField::Instance()) { | |
289 | HLTError("magnetic field not initialized, please set up TGeoGlobalMagField and AliMagF"); | |
290 | return -ENODEV; | |
291 | } | |
292 | fSolenoidBz=GetBz(); | |
293 | ||
294 | fTracker = new AliITSSAPTracker(); | |
295 | fTracker->Init(); | |
296 | fBenchmark.Reset(); | |
297 | fBenchmark.SetTimer(0,"total"); | |
298 | fBenchmark.SetTimer(1,"reco"); | |
299 | return ret; | |
300 | } | |
301 | ||
302 | ||
303 | int AliHLTITSSAPTrackerComponent::DoDeinit() | |
304 | { | |
305 | // see header file for class documentation | |
306 | delete fTracker; | |
307 | fTracker = 0; | |
308 | return 0; | |
309 | } | |
310 | ||
311 | ||
312 | ||
313 | int AliHLTITSSAPTrackerComponent::Reconfigure( const char* cdbEntry, const char* chainId ) | |
314 | { | |
315 | // Reconfigure the component from OCDB . | |
316 | ||
317 | return Configure( cdbEntry, chainId, NULL ); | |
318 | } | |
319 | ||
320 | ||
321 | ||
322 | int AliHLTITSSAPTrackerComponent::DoEvent | |
323 | ( | |
324 | const AliHLTComponentEventData& evtData, | |
325 | const AliHLTComponentBlockData* blocks, | |
326 | AliHLTComponentTriggerData& /*trigData*/, | |
c1cd4fce | 327 | AliHLTUInt8_t* outputPtr, |
c9598e1c | 328 | AliHLTUInt32_t& size, |
c1cd4fce | 329 | vector<AliHLTComponentBlockData>& outputBlocks ) |
c9598e1c | 330 | { |
331 | //* process event | |
332 | ||
c1cd4fce | 333 | AliHLTUInt32_t maxBufferSize = size; |
c9598e1c | 334 | size = 0; // output size |
335 | ||
336 | if (!IsDataEvent()) return 0; | |
337 | ||
338 | if ( evtData.fBlockCnt <= 0 ) { | |
339 | HLTWarning( "no blocks in event" ); | |
340 | return 0; | |
341 | } | |
342 | ||
343 | fBenchmark.StartNewEvent(); | |
344 | fBenchmark.Start(0); | |
345 | ||
346 | // Event reconstruction in ITS | |
347 | ||
348 | int iResult=0; | |
349 | ||
350 | ||
351 | // Check if there is an SPD vertex | |
352 | const AliESDVertex *vertexSPD = 0; | |
353 | ||
354 | { | |
c1cd4fce | 355 | const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITSSPD); |
c9598e1c | 356 | if( iter != NULL ) { |
357 | if( !( vertexSPD = dynamic_cast<AliESDVertex*>(const_cast<TObject*>( iter ) ) ) ){ | |
358 | HLTError("ITS SPD vertex object is corrupted"); | |
359 | iResult = -EINVAL; | |
360 | } | |
361 | } | |
362 | else { | |
363 | HLTWarning("No SPD vertex, skip ITS standalone reconstruction"); | |
364 | return 0; | |
365 | } | |
366 | } | |
367 | ||
368 | int nBlocks = evtData.fBlockCnt; | |
369 | if (!fClusters) fClusters = new TClonesArray("AliITSRecPoint",1000); | |
370 | // | |
371 | int nClTotal = 0; | |
372 | for (int ndx=0; ndx<nBlocks && iResult>=0; ndx++) { | |
373 | ||
374 | const AliHLTComponentBlockData* iter = blocks+ndx; | |
375 | ||
376 | // Read ITS clusters | |
377 | ||
378 | if ( (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSSD) ) || | |
379 | (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSPD) ) || | |
380 | (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITSSDD) ) || | |
381 | (iter->fDataType == (kAliHLTDataTypeClusters|kAliHLTDataOriginITS) ) | |
382 | ){ | |
383 | ||
384 | fBenchmark.AddInput(iter->fSize); | |
385 | ||
386 | AliHLTITSClusterData *inPtr=reinterpret_cast<AliHLTITSClusterData*>( iter->fPtr ); | |
387 | int nClusters = inPtr->fSpacePointCnt; | |
388 | for( int icl=0; icl<nClusters; icl++ ){ | |
389 | AliHLTITSSpacePointData &d = inPtr->fSpacePoints[icl]; | |
390 | ||
391 | Int_t lab[4] = { d.fTracks[0], d.fTracks[1], d.fTracks[2], d.fIndex }; | |
392 | Int_t info[3] = { d.fNy, d.fNz, d.fLayer }; | |
393 | Float_t hit[6] = { d.fY, d.fZ, d.fSigmaY2, d.fSigmaZ2, d.fQ, d.fSigmaYZ }; | |
394 | if( d.fLayer==4 ) hit[5] = -hit[5]; | |
395 | // tracker does not out the clusters, add them to transient array | |
396 | fTracker->AddCluster( new((*fClusters)[nClTotal++]) AliITSRecPoint(lab,hit,info) ); | |
397 | } | |
398 | } | |
399 | ||
400 | }// end read input blocks | |
401 | ||
402 | // Reconstruct the event | |
403 | ||
404 | fBenchmark.Start(1); | |
405 | fTracker->SetSPDVertex(vertexSPD); | |
406 | fTracker->ProcessEvent(); | |
407 | fBenchmark.Stop(1); | |
408 | ||
409 | ||
410 | // Fill output tracks | |
c9598e1c | 411 | int nAddedTracks = 0; |
c1cd4fce | 412 | { |
413 | int nFoundTracks = fTracker->GetNTracks(); | |
414 | AliHLTUInt32_t blockSize = sizeof(AliHLTITSSAPTrackerDataContainer) + nFoundTracks*sizeof(AliHLTITSSAPTrackerData); | |
a48865c5 | 415 | if( size + blockSize + AliFlatESDVertex::GetSize() > maxBufferSize ){ |
c1cd4fce | 416 | HLTWarning( "Output buffer size exceed (buffer size %d, current size %d), %d tracks are not stored", |
417 | maxBufferSize, size + blockSize, nFoundTracks); | |
418 | iResult = -ENOSPC; | |
419 | } | |
420 | if( iResult>=0 ){ | |
421 | blockSize = sizeof(AliHLTITSSAPTrackerDataContainer); | |
422 | AliHLTITSSAPTrackerDataContainer *data = reinterpret_cast<AliHLTITSSAPTrackerDataContainer*>(outputPtr); | |
423 | data->fCount=0; | |
424 | for (int itr=0;itr<nFoundTracks;itr++) { | |
425 | const AliITSSAPTracker::ITStrack_t& track = fTracker->GetTrack(itr); | |
426 | // the track is just a struct of 2 AliExternalTrackParams (params at vertex and at the outer ITS layer) | |
427 | // + some extra info, see "struct ITStrack" in the AliITSSAPTracker.h | |
428 | if ( track.paramOut.TestBit(AliITSSAPTracker::kInvalidBit) || | |
429 | track.paramInw.TestBit(AliITSSAPTracker::kInvalidBit)) continue; | |
430 | // use only those tracks whose both inward and outward params are OK. | |
431 | AliHLTITSSAPTrackerData &trcHLT = data->fTracks[data->fCount]; | |
432 | trcHLT.paramOut.SetExternalTrackParam(&track.paramOut); | |
433 | trcHLT.paramInw.SetExternalTrackParam(&track.paramInw); | |
434 | trcHLT.chi2 = track.chi2; | |
435 | trcHLT.ncl = track.ncl; | |
436 | trcHLT.label = track.label; | |
437 | data->fCount++; | |
438 | blockSize += sizeof(AliHLTITSSAPTrackerData); | |
439 | nAddedTracks++; | |
440 | } | |
441 | ||
442 | AliHLTComponentBlockData resultData; | |
443 | FillBlockData( resultData ); | |
444 | resultData.fOffset = size; | |
445 | resultData.fSize = blockSize; | |
446 | resultData.fDataType = kAliHLTDataTypeITSSAPData|kAliHLTDataOriginITS; | |
447 | fBenchmark.AddOutput(resultData.fSize); | |
448 | outputBlocks.push_back( resultData ); | |
449 | size += resultData.fSize; | |
450 | } | |
c9598e1c | 451 | } |
452 | ||
c9598e1c | 453 | Bool_t vtxOK = kFALSE; |
c1cd4fce | 454 | { // Fill output vertexTracks |
455 | AliESDVertex& vtxTracks = fTracker->GetTrackVertex(); | |
a48865c5 | 456 | if ( iResult>=0 && vtxTracks.GetStatus()==1 ) { |
457 | AliFlatESDVertex *flatVtx = reinterpret_cast<AliFlatESDVertex*>( outputPtr + size ); | |
458 | flatVtx->SetFromESDVertex( vtxTracks ); | |
459 | AliHLTComponentBlockData resultData; | |
460 | FillBlockData( resultData ); | |
461 | resultData.fOffset = size; | |
462 | resultData.fSize = flatVtx->GetSize(); | |
463 | resultData.fDataType = kAliHLTDataTypeFlatESDVertex|kAliHLTDataOriginITS; | |
464 | fBenchmark.AddOutput(resultData.fSize); | |
465 | outputBlocks.push_back( resultData ); | |
466 | size += resultData.fSize; | |
c1cd4fce | 467 | vtxOK = kTRUE; |
468 | } | |
c9598e1c | 469 | } |
470 | // | |
471 | fTracker->Clear(); | |
472 | fClusters->Clear(); | |
473 | // | |
474 | fBenchmark.Stop(0); | |
475 | ||
476 | // Set log level to "Warning" for on-line system monitoring | |
218c15cf | 477 | HLTInfo( "ITS SAP Tracker: output %d tracks; input %d clusters, VertexTracks: %s", |
c9598e1c | 478 | nAddedTracks, nClTotal, vtxOK ? "OK" : "Found" ); |
479 | ||
7dca3459 | 480 | HLTBenchmark(fBenchmark.GetStatistics()); |
c9598e1c | 481 | return iResult; |
482 | } |