]>
Commit | Line | Data |
---|---|---|
a1408c4b | 1 | // $Id$ |
2 | ||
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 | //* for The ALICE HLT 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 AliHLTGlobalEsdConverterComponent.cxx | |
20 | @author Matthias Richter | |
21 | @date | |
22 | @brief Global ESD converter component. | |
23 | */ | |
24 | ||
25 | // see header file for class documentation | |
26 | // or | |
27 | // refer to README to build package | |
28 | // or | |
29 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
30 | ||
31 | #include <cassert> | |
32 | #include "AliHLTGlobalEsdConverterComponent.h" | |
33 | #include "AliHLTGlobalBarrelTrack.h" | |
34 | #include "AliHLTExternalTrackParam.h" | |
093b64dc | 35 | #include "AliHLTTrackMCLabel.h" |
6117ef63 | 36 | #include "AliHLTCTPData.h" |
a1408c4b | 37 | #include "AliESDEvent.h" |
38 | #include "AliESDtrack.h" | |
f064ef44 | 39 | #include "AliESDMuonTrack.h" |
a1408c4b | 40 | #include "AliCDBEntry.h" |
41 | #include "AliCDBManager.h" | |
18ada816 | 42 | #include "AliPID.h" |
a1408c4b | 43 | #include "TTree.h" |
44 | #include "TList.h" | |
f064ef44 | 45 | #include "TClonesArray.h" |
9a9467ed | 46 | #include "AliHLTESDCaloClusterMaker.h" |
47 | #include "AliHLTCaloClusterDataStruct.h" | |
48 | #include "AliHLTCaloClusterReader.h" | |
49 | #include "AliESDCaloCluster.h" | |
d9386025 | 50 | #include "AliHLTGlobalVertexerComponent.h" |
a1408c4b | 51 | |
52 | /** ROOT macro for the implementation of ROOT specific class methods */ | |
53 | ClassImp(AliHLTGlobalEsdConverterComponent) | |
54 | ||
55 | AliHLTGlobalEsdConverterComponent::AliHLTGlobalEsdConverterComponent() | |
56 | : AliHLTProcessor() | |
a1408c4b | 57 | , fWriteTree(0) |
093b64dc | 58 | , fVerbosity(0) |
8b7a0f3c | 59 | , fESD(NULL) |
a8714ffa | 60 | , fSolenoidBz(-5.00668) |
57a4102f | 61 | , fBenchmark("EsdConverter") |
a1408c4b | 62 | { |
63 | // see header file for class documentation | |
64 | // or | |
65 | // refer to README to build package | |
66 | // or | |
67 | // visit http://web.ift.uib.no/~kjeks/doc/alice-hlt | |
68 | } | |
69 | ||
70 | AliHLTGlobalEsdConverterComponent::~AliHLTGlobalEsdConverterComponent() | |
71 | { | |
72 | // see header file for class documentation | |
73 | if (fESD) delete fESD; | |
74 | fESD=NULL; | |
75 | } | |
76 | ||
77 | int AliHLTGlobalEsdConverterComponent::Configure(const char* arguments) | |
78 | { | |
79 | // see header file for class documentation | |
80 | int iResult=0; | |
81 | if (!arguments) return iResult; | |
82 | ||
83 | TString allArgs=arguments; | |
84 | TString argument; | |
85 | int bMissingParam=0; | |
86 | ||
87 | TObjArray* pTokens=allArgs.Tokenize(" "); | |
88 | if (pTokens) { | |
89 | for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) { | |
fe0af255 | 90 | argument=((TObjString*)pTokens->At(i))->GetString(); |
a1408c4b | 91 | if (argument.IsNull()) continue; |
92 | ||
93 | if (argument.CompareTo("-solenoidBz")==0) { | |
94 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
75970b8d | 95 | HLTWarning("argument -solenoidBz is deprecated, magnetic field set up globally (%f)", GetBz()); |
a1408c4b | 96 | continue; |
97 | } else { | |
98 | HLTError("unknown argument %s", argument.Data()); | |
99 | iResult=-EINVAL; | |
100 | break; | |
101 | } | |
102 | } | |
103 | delete pTokens; | |
104 | } | |
105 | if (bMissingParam) { | |
106 | HLTError("missing parameter for argument %s", argument.Data()); | |
107 | iResult=-EINVAL; | |
108 | } | |
109 | ||
110 | return iResult; | |
111 | } | |
112 | ||
113 | int AliHLTGlobalEsdConverterComponent::Reconfigure(const char* cdbEntry, const char* chainId) | |
114 | { | |
115 | // see header file for class documentation | |
116 | int iResult=0; | |
75970b8d | 117 | const char* path=NULL; |
a1408c4b | 118 | const char* defaultNotify=""; |
119 | if (cdbEntry) { | |
120 | path=cdbEntry; | |
121 | defaultNotify=" (default)"; | |
122 | } | |
123 | if (path) { | |
124 | HLTInfo("reconfigure from entry %s%s, chain id %s", path, defaultNotify,(chainId!=NULL && chainId[0]!=0)?chainId:"<none>"); | |
125 | AliCDBEntry *pEntry = AliCDBManager::Instance()->Get(path/*,GetRunNo()*/); | |
126 | if (pEntry) { | |
127 | TObjString* pString=dynamic_cast<TObjString*>(pEntry->GetObject()); | |
128 | if (pString) { | |
129 | HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data()); | |
130 | iResult=Configure(pString->GetString().Data()); | |
131 | } else { | |
132 | HLTError("configuration object \"%s\" has wrong type, required TObjString", path); | |
133 | } | |
134 | } else { | |
135 | HLTError("can not fetch object \"%s\" from CDB", path); | |
136 | } | |
137 | } | |
138 | ||
139 | return iResult; | |
140 | } | |
141 | ||
142 | void AliHLTGlobalEsdConverterComponent::GetInputDataTypes(AliHLTComponentDataTypeList& list) | |
143 | { | |
144 | // see header file for class documentation | |
145 | list.push_back(kAliHLTDataTypeTrack); | |
146 | list.push_back(kAliHLTDataTypeTrackMC); | |
9a9467ed | 147 | list.push_back(kAliHLTDataTypeCaloCluster); |
0973c527 | 148 | list.push_back(kAliHLTDataTypedEdx ); |
7f167a74 | 149 | list.push_back(kAliHLTDataTypeESDVertex ); |
f064ef44 | 150 | list.push_back(kAliHLTDataTypeESDObject); |
151 | list.push_back(kAliHLTDataTypeTObject); | |
d9963894 | 152 | list.push_back(kAliHLTDataTypeGlobalVertexer); |
a1408c4b | 153 | } |
154 | ||
155 | AliHLTComponentDataType AliHLTGlobalEsdConverterComponent::GetOutputDataType() | |
156 | { | |
157 | // see header file for class documentation | |
7a9de6d1 | 158 | return kAliHLTDataTypeESDObject|kAliHLTDataOriginOut; |
a1408c4b | 159 | } |
160 | ||
161 | void AliHLTGlobalEsdConverterComponent::GetOutputDataSize(unsigned long& constBase, double& inputMultiplier) | |
162 | { | |
163 | // see header file for class documentation | |
164 | constBase=2000000; | |
165 | inputMultiplier=10.0; | |
166 | } | |
167 | ||
168 | int AliHLTGlobalEsdConverterComponent::DoInit(int argc, const char** argv) | |
169 | { | |
170 | // see header file for class documentation | |
171 | int iResult=0; | |
172 | TString argument=""; | |
173 | int bMissingParam=0; | |
a1408c4b | 174 | |
d57fc872 | 175 | // default list of skiped ESD objects |
176 | TString skipObjects= | |
177 | // "AliESDRun," | |
178 | // "AliESDHeader," | |
179 | "AliESDZDC," | |
180 | "AliESDFMD," | |
181 | // "AliESDVZERO," | |
182 | // "AliESDTZERO," | |
183 | // "TPCVertex," | |
184 | // "SPDVertex," | |
185 | // "PrimaryVertex," | |
186 | // "AliMultiplicity," | |
187 | // "PHOSTrigger," | |
188 | // "EMCALTrigger," | |
189 | // "SPDPileupVertices," | |
190 | // "TrkPileupVertices," | |
191 | "Cascades," | |
192 | "Kinks," | |
193 | "AliRawDataErrorLogs," | |
194 | "AliESDACORDE"; | |
195 | ||
f167b631 | 196 | iResult=Reconfigure(NULL, NULL); |
197 | TString allArgs = ""; | |
198 | for ( int i = 0; i < argc; i++ ) { | |
199 | if ( !allArgs.IsNull() ) allArgs += " "; | |
200 | allArgs += argv[i]; | |
201 | } | |
a1408c4b | 202 | |
f167b631 | 203 | TObjArray* pTokens=allArgs.Tokenize(" "); |
204 | if (pTokens) { | |
205 | for (int i=0; i<pTokens->GetEntries() && iResult>=0; i++) { | |
206 | argument=((TObjString*)pTokens->At(i))->GetString(); | |
207 | if (argument.IsNull()) continue; | |
208 | ||
209 | // -notree | |
210 | if (argument.CompareTo("-notree")==0) { | |
211 | fWriteTree=0; | |
212 | ||
213 | // -tree | |
214 | } else if (argument.CompareTo("-tree")==0) { | |
215 | fWriteTree=1; | |
216 | } else if (argument.CompareTo("-solenoidBz")==0) { | |
217 | if ((bMissingParam=(++i>=pTokens->GetEntries()))) break; | |
218 | HLTInfo("Magnetic Field set to: %s", ((TObjString*)pTokens->At(i))->GetString().Data()); | |
d57fc872 | 219 | HLTWarning("argument '-solenoidBz' is deprecated, solenoid field initiaized from CDB settings"); |
f167b631 | 220 | continue; |
d57fc872 | 221 | } else if (argument.Contains("-skipobject=")) { |
222 | argument.ReplaceAll("-skipobject=", ""); | |
223 | skipObjects=argument; | |
f167b631 | 224 | } else { |
225 | HLTError("unknown argument %s", argument.Data()); | |
d57fc872 | 226 | iResult=-EINVAL; |
f167b631 | 227 | break; |
228 | } | |
a1408c4b | 229 | } |
230 | } | |
231 | if (bMissingParam) { | |
232 | HLTError("missing parameter for argument %s", argument.Data()); | |
233 | iResult=-EINVAL; | |
234 | } | |
235 | ||
75970b8d | 236 | fSolenoidBz=GetBz(); |
237 | ||
a1408c4b | 238 | if (iResult>=0) { |
239 | fESD = new AliESDEvent; | |
240 | if (fESD) { | |
241 | fESD->CreateStdContent(); | |
d57fc872 | 242 | |
243 | // remove some of the objects which are not needed | |
244 | if (fESD->GetList() && !skipObjects.IsNull()) { | |
245 | pTokens=skipObjects.Tokenize(","); | |
246 | if (pTokens) { | |
247 | const char* id=NULL; | |
248 | TIter next(pTokens); | |
249 | TObject* pObject=NULL; | |
250 | while ((pObject=next())!=NULL) { | |
251 | id=((TObjString*)pObject)->GetString().Data(); | |
252 | if (fESD->GetList()->FindObject(id)) { | |
253 | HLTDebug("removing object %s", id); | |
254 | fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
255 | } else { | |
256 | HLTWarning("failed to remove object '%s' from ESD", id); | |
257 | } | |
258 | } | |
259 | // id="AliESDRun"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
260 | // id="AliESDHeader"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
261 | // id="AliESDZDC"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
262 | // id="AliESDFMD"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
263 | // id="AliESDVZERO"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
264 | // id="AliESDTZERO"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
265 | // id="TPCVertex"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
266 | // id="SPDVertex"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
267 | // id="PrimaryVertex"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
268 | // id="AliMultiplicity"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
269 | // id="PHOSTrigger"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
270 | // id="EMCALTrigger"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
271 | // id="SPDPileupVertices"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
272 | // id="TrkPileupVertices"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
273 | // id="Cascades"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
274 | // id="Kinks"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
275 | // id="AliRawDataErrorLogs"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
276 | // id="AliESDACORDE"; if (fESD->GetList()->FindObject(id)) fESD->GetList()->Remove(fESD->GetList()->FindObject(id)); | |
277 | fESD->GetStdContent(); | |
278 | delete pTokens; | |
279 | } | |
280 | } | |
a1408c4b | 281 | } else { |
282 | iResult=-ENOMEM; | |
283 | } | |
6117ef63 | 284 | |
285 | SetupCTPData(); | |
a1408c4b | 286 | } |
287 | ||
57a4102f | 288 | fBenchmark.SetTimer(0,"total"); |
289 | ||
a1408c4b | 290 | return iResult; |
291 | } | |
292 | ||
293 | int AliHLTGlobalEsdConverterComponent::DoDeinit() | |
294 | { | |
295 | // see header file for class documentation | |
296 | if (fESD) delete fESD; | |
297 | fESD=NULL; | |
298 | ||
299 | return 0; | |
300 | } | |
301 | ||
302 | int AliHLTGlobalEsdConverterComponent::DoEvent(const AliHLTComponentEventData& /*evtData*/, | |
6117ef63 | 303 | AliHLTComponentTriggerData& trigData) |
a1408c4b | 304 | { |
305 | // see header file for class documentation | |
306 | int iResult=0; | |
307 | if (!fESD) return -ENODEV; | |
308 | ||
57a4102f | 309 | if (IsDataEvent()) fBenchmark.StartNewEvent(); |
310 | fBenchmark.Start(0); | |
311 | ||
a1408c4b | 312 | AliESDEvent* pESD = fESD; |
313 | ||
314 | pESD->Reset(); | |
315 | pESD->SetMagneticField(fSolenoidBz); | |
6117ef63 | 316 | pESD->SetRunNumber(GetRunNo()); |
6700298e | 317 | pESD->SetPeriodNumber(GetPeriodNumber()); |
318 | pESD->SetOrbitNumber(GetOrbitNumber()); | |
319 | pESD->SetBunchCrossNumber(GetBunchCrossNumber()); | |
320 | pESD->SetTimeStamp(GetTimeStamp()); | |
a1408c4b | 321 | |
6117ef63 | 322 | const AliHLTCTPData* pCTPData=CTPData(); |
323 | if (pCTPData) { | |
324 | AliHLTUInt64_t mask=pCTPData->ActiveTriggers(trigData); | |
325 | for (int index=0; index<gkNCTPTriggerClasses; index++) { | |
326 | if ((mask&((AliHLTUInt64_t)0x1<<index)) == 0) continue; | |
327 | pESD->SetTriggerClass(pCTPData->Name(index), index); | |
328 | } | |
329 | pESD->SetTriggerMask(mask); | |
330 | } | |
331 | ||
a1408c4b | 332 | TTree* pTree = NULL; |
333 | if (fWriteTree) | |
334 | pTree = new TTree("esdTree", "Tree with HLT ESD objects"); | |
335 | ||
336 | if (pTree) { | |
337 | pTree->SetDirectory(0); | |
338 | } | |
339 | ||
81509fd3 | 340 | if ((iResult=ProcessBlocks(pTree, pESD))>=0) { |
a1408c4b | 341 | // TODO: set the specification correctly |
342 | if (pTree) { | |
343 | // the esd structure is written to the user info and is | |
344 | // needed in te ReadFromTree method to read all objects correctly | |
345 | pTree->GetUserInfo()->Add(pESD); | |
346 | pESD->WriteToTree(pTree); | |
7a9de6d1 | 347 | iResult=PushBack(pTree, kAliHLTDataTypeESDTree|kAliHLTDataOriginOut, 0); |
a1408c4b | 348 | } else { |
7a9de6d1 | 349 | iResult=PushBack(pESD, kAliHLTDataTypeESDObject|kAliHLTDataOriginOut, 0); |
a1408c4b | 350 | } |
57a4102f | 351 | fBenchmark.AddOutput(GetLastObjectSize()); |
a1408c4b | 352 | } |
353 | if (pTree) { | |
354 | // clear user info list to prevent objects from being deleted | |
355 | pTree->GetUserInfo()->Clear(); | |
356 | delete pTree; | |
357 | } | |
57a4102f | 358 | |
359 | fBenchmark.Stop(0); | |
360 | HLTInfo( fBenchmark.GetStatistics() ); | |
361 | ||
a1408c4b | 362 | return iResult; |
363 | } | |
364 | ||
365 | int AliHLTGlobalEsdConverterComponent::ProcessBlocks(TTree* pTree, AliESDEvent* pESD) | |
366 | { | |
367 | // see header file for class documentation | |
368 | ||
369 | int iResult=0; | |
370 | int iAddedDataBlocks=0; | |
371 | ||
372 | // Barrel tracking | |
373 | ||
374 | // in the first attempt this component reads the TPC tracks and updates in the | |
375 | // second step from the ITS tracks | |
093b64dc | 376 | |
093b64dc | 377 | // first read MC information (if present) |
378 | std::map<int,int> mcLabels; | |
379 | ||
380 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrackMC|kAliHLTDataOriginTPC); | |
381 | pBlock!=NULL; pBlock=GetNextInputBlock()) { | |
57a4102f | 382 | |
383 | fBenchmark.AddInput(pBlock->fSize); | |
384 | ||
093b64dc | 385 | AliHLTTrackMCData* dataPtr = reinterpret_cast<AliHLTTrackMCData*>( pBlock->fPtr ); |
386 | if (sizeof(AliHLTTrackMCData)+dataPtr->fCount*sizeof(AliHLTTrackMCLabel)==pBlock->fSize) { | |
387 | for( unsigned int il=0; il<dataPtr->fCount; il++ ){ | |
388 | AliHLTTrackMCLabel &lab = dataPtr->fLabels[il]; | |
389 | mcLabels[lab.fTrackID] = lab.fMCLabel; | |
390 | } | |
391 | } else { | |
392 | HLTWarning("data mismatch in block %s (0x%08x): count %d, size %d -> ignoring track MC information", | |
393 | DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, | |
394 | dataPtr->fCount, pBlock->fSize); | |
395 | } | |
396 | } | |
397 | ||
0973c527 | 398 | // read dEdx information (if present) |
399 | ||
400 | AliHLTFloat32_t *dEdxTPC = 0; | |
401 | Int_t ndEdxTPC = 0; | |
402 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypedEdx|kAliHLTDataOriginTPC); | |
403 | pBlock!=NULL; pBlock=GetNextInputBlock()) { | |
57a4102f | 404 | fBenchmark.AddInput(pBlock->fSize); |
0973c527 | 405 | dEdxTPC = reinterpret_cast<AliHLTFloat32_t*>( pBlock->fPtr ); |
406 | ndEdxTPC = pBlock->fSize / sizeof(AliHLTFloat32_t); | |
407 | break; | |
408 | } | |
409 | ||
cd60a73f | 410 | // convert the TPC tracks to ESD tracks |
a1408c4b | 411 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginTPC); |
412 | pBlock!=NULL; pBlock=GetNextInputBlock()) { | |
57a4102f | 413 | fBenchmark.AddInput(pBlock->fSize); |
a1408c4b | 414 | vector<AliHLTGlobalBarrelTrack> tracks; |
81509fd3 | 415 | if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>=0) { |
a1408c4b | 416 | for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin(); |
417 | element!=tracks.end(); element++) { | |
418 | Float_t points[4] = { | |
419 | element->GetX(), | |
420 | element->GetY(), | |
421 | element->GetLastPointX(), | |
422 | element->GetLastPointY() | |
423 | }; | |
093b64dc | 424 | |
425 | Int_t mcLabel = -1; | |
426 | if( mcLabels.find(element->TrackID())!=mcLabels.end() ) | |
427 | mcLabel = mcLabels[element->TrackID()]; | |
428 | element->SetLabel( mcLabel ); | |
429 | ||
a1408c4b | 430 | AliESDtrack iotrack; |
550ecaab | 431 | |
432 | // for the moment, the number of clusters are not set when processing the | |
433 | // kTPCin update, only at kTPCout | |
434 | // there ar emainly three parameters updated for kTPCout | |
435 | // number of clusters | |
436 | // chi2 | |
437 | // pid signal | |
438 | // The first one can be updated already at that stage here, while the two others | |
439 | // eventually require to update from the ITS tracks before. The exact scheme | |
440 | // needs to be checked | |
c3261a7d | 441 | iotrack.SetID( element->TrackID() ); |
a1408c4b | 442 | iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTPCin); |
c3261a7d | 443 | { |
f167b631 | 444 | AliHLTGlobalBarrelTrack outPar(*element); |
c3261a7d | 445 | outPar.AliExternalTrackParam::PropagateTo( element->GetLastPointX(), fSolenoidBz ); |
446 | iotrack.UpdateTrackParams(&outPar,AliESDtrack::kTPCout); | |
447 | } | |
a1408c4b | 448 | iotrack.SetTPCPoints(points); |
0973c527 | 449 | if( element->TrackID()<ndEdxTPC ){ |
7e32fedf | 450 | iotrack.SetTPCsignal( dEdxTPC[element->TrackID()], 0, 0 ); |
451 | //AliTPCseed s; | |
452 | //s.Set( element->GetX(), element->GetAlpha(), | |
453 | //element->GetParameter(), element->GetCovariance() ); | |
454 | //s.SetdEdx( dEdxTPC[element->TrackID()] ); | |
455 | //s.CookPID(); | |
456 | //iotrack.SetTPCpid(s.TPCrPIDs() ); | |
0973c527 | 457 | } else { |
458 | if( dEdxTPC ) HLTWarning("Wrong number of dEdx TPC labels"); | |
459 | } | |
a1408c4b | 460 | pESD->AddTrack(&iotrack); |
093b64dc | 461 | if (fVerbosity>0) element->Print(); |
a1408c4b | 462 | } |
093b64dc | 463 | HLTInfo("converted %d track(s) to AliESDtrack and added to ESD", tracks.size()); |
a1408c4b | 464 | iAddedDataBlocks++; |
465 | } else if (iResult<0) { | |
093b64dc | 466 | HLTError("can not extract tracks from data block of type %s (specification %08x) of size %d: error %d", |
467 | DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, pBlock->fSize, iResult); | |
a1408c4b | 468 | } |
469 | } | |
470 | ||
7f167a74 | 471 | |
472 | // Get ITS SPD vertex | |
57a4102f | 473 | for( const AliHLTComponentBlockData *i= GetFirstInputBlock(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS); i!=NULL; i=GetNextInputBlock() ){ |
474 | fBenchmark.AddInput(i->fSize); | |
475 | } | |
7f167a74 | 476 | |
477 | for ( const TObject *iter = GetFirstInputObject(kAliHLTDataTypeESDVertex|kAliHLTDataOriginITS); iter != NULL; iter = GetNextInputObject() ) { | |
478 | AliESDVertex *vtx = dynamic_cast<AliESDVertex*>(const_cast<TObject*>( iter ) ); | |
479 | pESD->SetPrimaryVertexSPD( vtx ); | |
480 | } | |
481 | ||
f167b631 | 482 | // now update ESD tracks with the ITSOut info |
483 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginITSOut); | |
cd60a73f | 484 | pBlock!=NULL; pBlock=GetNextInputBlock()) { |
57a4102f | 485 | fBenchmark.AddInput(pBlock->fSize); |
cd60a73f | 486 | vector<AliHLTGlobalBarrelTrack> tracks; |
487 | if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) { | |
488 | for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin(); | |
489 | element!=tracks.end(); element++) { | |
cd60a73f | 490 | int tpcID=element->TrackID(); |
491 | // the ITS tracker assigns the TPC track used as seed for a certain track to | |
492 | // the trackID | |
493 | if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue; | |
cd60a73f | 494 | AliESDtrack *tESD = pESD->GetTrack( tpcID ); |
f167b631 | 495 | if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSout ); |
a1408c4b | 496 | } |
cd60a73f | 497 | } |
498 | } | |
18ada816 | 499 | |
f167b631 | 500 | // now update ESD tracks with the ITS info |
501 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack|kAliHLTDataOriginITS); | |
b7ed2eb4 | 502 | pBlock!=NULL; pBlock=GetNextInputBlock()) { |
57a4102f | 503 | fBenchmark.AddInput(pBlock->fSize); |
b7ed2eb4 | 504 | vector<AliHLTGlobalBarrelTrack> tracks; |
505 | if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) { | |
506 | for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin(); | |
507 | element!=tracks.end(); element++) { | |
b7ed2eb4 | 508 | int tpcID=element->TrackID(); |
509 | // the ITS tracker assigns the TPC track used as seed for a certain track to | |
510 | // the trackID | |
511 | if( tpcID<0 || tpcID>=pESD->GetNumberOfTracks()) continue; | |
512 | AliESDtrack *tESD = pESD->GetTrack( tpcID ); | |
f167b631 | 513 | if( tESD ) tESD->UpdateTrackParams( &(*element), AliESDtrack::kITSin ); |
b7ed2eb4 | 514 | } |
515 | } | |
516 | } | |
517 | ||
d9386025 | 518 | // update with vertices and vertex-fitted tracks |
519 | ||
520 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeGlobalVertexer); | |
521 | pBlock!=NULL; pBlock=GetNextInputBlock()) { | |
57a4102f | 522 | fBenchmark.AddInput(pBlock->fSize); |
d9386025 | 523 | AliHLTGlobalVertexerComponent::FillESD( pESD, reinterpret_cast<AliHLTGlobalVertexerComponent::AliHLTGlobalVertexerData* >(pBlock->fPtr) ); |
524 | } | |
525 | ||
b7ed2eb4 | 526 | |
18ada816 | 527 | // convert the HLT TRD tracks to ESD tracks |
528 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeTrack | kAliHLTDataOriginTRD); | |
529 | pBlock!=NULL; pBlock=GetNextInputBlock()) { | |
57a4102f | 530 | fBenchmark.AddInput(pBlock->fSize); |
18ada816 | 531 | vector<AliHLTGlobalBarrelTrack> tracks; |
532 | if ((iResult=AliHLTGlobalBarrelTrack::ConvertTrackDataArray(reinterpret_cast<const AliHLTTracksData*>(pBlock->fPtr), pBlock->fSize, tracks))>0) { | |
533 | for (vector<AliHLTGlobalBarrelTrack>::iterator element=tracks.begin(); | |
534 | element!=tracks.end(); element++) { | |
535 | ||
536 | Double_t TRDpid[AliPID::kSPECIES], eProb(0.2), restProb((1-eProb)/(AliPID::kSPECIES-1)); //eprob(element->GetTRDpid...); | |
537 | for(Int_t i=0; i<AliPID::kSPECIES; i++){ | |
538 | switch(i){ | |
539 | case AliPID::kElectron: TRDpid[AliPID::kElectron]=eProb; break; | |
540 | default: TRDpid[i]=restProb; break; | |
541 | } | |
542 | } | |
543 | ||
544 | AliESDtrack iotrack; | |
545 | iotrack.UpdateTrackParams(&(*element),AliESDtrack::kTRDin); | |
546 | iotrack.SetTRDpid(TRDpid); | |
547 | ||
548 | pESD->AddTrack(&iotrack); | |
549 | if (fVerbosity>0) element->Print(); | |
550 | } | |
551 | HLTInfo("converted %d track(s) to AliESDtrack and added to ESD", tracks.size()); | |
552 | iAddedDataBlocks++; | |
553 | } else if (iResult<0) { | |
554 | HLTError("can not extract tracks from data block of type %s (specification %08x) of size %d: error %d", | |
555 | DataType2Text(pBlock->fDataType).c_str(), pBlock->fSpecification, pBlock->fSize, iResult); | |
556 | } | |
557 | } | |
b4479a87 | 558 | for (const AliHLTComponentBlockData* pBlock=GetFirstInputBlock(kAliHLTDataTypeCaloCluster | kAliHLTDataOriginAny); pBlock!=NULL; pBlock=GetNextInputBlock()) |
9a9467ed | 559 | { |
57a4102f | 560 | fBenchmark.AddInput(pBlock->fSize); |
9a9467ed | 561 | AliHLTCaloClusterHeaderStruct *caloClusterHeaderPtr = reinterpret_cast<AliHLTCaloClusterHeaderStruct*>(pBlock->fPtr); |
562 | ||
563 | HLTDebug("%d HLT clusters from spec: 0x%X", caloClusterHeaderPtr->fNClusters, pBlock->fSpecification); | |
564 | ||
2a24cbbe | 565 | //AliHLTCaloClusterReader reader; |
566 | //reader.SetMemory(caloClusterHeaderPtr); | |
9a9467ed | 567 | |
568 | AliHLTESDCaloClusterMaker clusterMaker; | |
569 | ||
570 | int nClusters = clusterMaker.FillESD(pESD, caloClusterHeaderPtr); | |
2a24cbbe | 571 | |
9a9467ed | 572 | HLTInfo("converted %d cluster(s) to AliESDCaloCluster and added to ESD", nClusters); |
573 | iAddedDataBlocks++; | |
574 | } | |
f064ef44 | 575 | |
576 | // Add tracks from MUON. | |
57a4102f | 577 | for( const AliHLTComponentBlockData *i= GetFirstInputBlock(kAliHLTAnyDataType | kAliHLTDataOriginMUON); i!=NULL; i=GetNextInputBlock() ){ |
578 | fBenchmark.AddInput(i->fSize); | |
579 | } | |
580 | ||
f064ef44 | 581 | for (const TObject* obj = GetFirstInputObject(kAliHLTAnyDataType | kAliHLTDataOriginMUON); |
582 | obj != NULL; | |
583 | obj = GetNextInputObject() | |
584 | ) | |
585 | { | |
586 | const TClonesArray* tracklist = NULL; | |
587 | if (obj->IsA() == AliESDEvent::Class()) | |
588 | { | |
589 | const AliESDEvent* event = static_cast<const AliESDEvent*>(obj); | |
590 | HLTDebug("Received a MUON ESD with specification: 0x%X", GetSpecification(obj)); | |
591 | if (event->GetList() == NULL) continue; | |
592 | tracklist = dynamic_cast<const TClonesArray*>(event->GetList()->FindObject("MuonTracks")); | |
593 | if (tracklist == NULL) continue; | |
594 | } | |
595 | else if (obj->IsA() == TClonesArray::Class()) | |
596 | { | |
597 | tracklist = static_cast<const TClonesArray*>(obj); | |
598 | HLTDebug("Received a MUON TClonesArray of tracks with specification: 0x%X", GetSpecification(obj)); | |
599 | } | |
600 | else | |
601 | { | |
602 | // Cannot handle this object type. | |
603 | continue; | |
604 | } | |
605 | HLTDebug("Received %d MUON tracks.", tracklist->GetEntriesFast()); | |
606 | if (tracklist->GetEntriesFast() > 0) | |
607 | { | |
608 | const AliESDMuonTrack* track = dynamic_cast<const AliESDMuonTrack*>(tracklist->UncheckedAt(0)); | |
609 | if (track == NULL) | |
610 | { | |
611 | HLTError(Form("%s from MUON does not contain AliESDMuonTrack objects.", obj->ClassName())); | |
612 | continue; | |
a1408c4b | 613 | } |
f064ef44 | 614 | } |
615 | for (Int_t i = 0; i < tracklist->GetEntriesFast(); ++i) | |
616 | { | |
617 | const AliESDMuonTrack* track = static_cast<const AliESDMuonTrack*>(tracklist->UncheckedAt(i)); | |
618 | pESD->AddMuonTrack(track); | |
619 | } | |
620 | } | |
621 | ||
622 | if (iAddedDataBlocks>0 && pTree) { | |
623 | pTree->Fill(); | |
624 | } | |
a1408c4b | 625 | |
626 | if (iResult>=0) iResult=iAddedDataBlocks; | |
627 | return iResult; | |
628 | } |