git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Updated ZDCPEDESTALda.cxx
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
CommitLineData
596a855f 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
16/* $Id$ */
17
18///////////////////////////////////////////////////////////////////////////////
19// //
20// class for running the reconstruction //
21// //
22// Clusters and tracks are created for all detectors and all events by //
23// typing: //
24// //
25// AliReconstruction rec; //
26// rec.Run(); //
27// //
28// The Run method returns kTRUE in case of successful execution. //
c71de921 29// //
30// If the input to the reconstruction are not simulated digits but raw data, //
31// this can be specified by an argument of the Run method or by the method //
32// //
33// rec.SetInput("..."); //
34// //
35// The input formats and the corresponding argument are: //
36// - DDL raw data files: directory name, ends with "/" //
37// - raw data root file: root file name, extension ".root" //
38// - raw data DATE file: DATE file name, any other non-empty string //
39// - MC root files : empty string, default //
40// //
b26c3770 41// By default all events are reconstructed. The reconstruction can be //
42// limited to a range of events by giving the index of the first and the //
43// last event as an argument to the Run method or by calling //
44// //
45// rec.SetEventRange(..., ...); //
46// //
47// The index -1 (default) can be used for the last event to indicate no //
48// upper limit of the event range. //
49// //
973388c2 50// In case of raw-data reconstruction the user can modify the default //
51// number of events per digits/clusters/tracks file. In case the option //
52// is not used the number is set 1. In case the user provides 0, than //
53// the number of events is equal to the number of events inside the //
54// raw-data file (i.e. one digits/clusters/tracks file): //
55// //
56// rec.SetNumberOfEventsPerFile(...); //
57// //
58// //
596a855f 59// The name of the galice file can be changed from the default //
e583c30d 60// "galice.root" by passing it as argument to the AliReconstruction //
61// constructor or by //
596a855f 62// //
63// rec.SetGAliceFile("..."); //
64// //
59697224 65// The local reconstruction can be switched on or off for individual //
66// detectors by //
596a855f 67// //
59697224 68// rec.SetRunLocalReconstruction("..."); //
596a855f 69// //
70// The argument is a (case sensitive) string with the names of the //
71// detectors separated by a space. The special string "ALL" selects all //
72// available detectors. This is the default. //
73// //
c71de921 74// The reconstruction of the primary vertex position can be switched off by //
75// //
76// rec.SetRunVertexFinder(kFALSE); //
77// //
b8cd5251 78// The tracking and the creation of ESD tracks can be switched on for //
79// selected detectors by //
596a855f 80// //
b8cd5251 81// rec.SetRunTracking("..."); //
596a855f 82// //
c84a5e9e 83// Uniform/nonuniform field tracking switches (default: uniform field) //
84// //
1d99986f 85// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
c84a5e9e 86// //
596a855f 87// The filling of additional ESD information can be steered by //
88// //
89// rec.SetFillESD("..."); //
90// //
b8cd5251 91// Again, for both methods the string specifies the list of detectors. //
92// The default is "ALL". //
93// //
94// The call of the shortcut method //
95// //
96// rec.SetRunReconstruction("..."); //
97// //
98// is equivalent to calling SetRunLocalReconstruction, SetRunTracking and //
99// SetFillESD with the same detector selecting string as argument. //
596a855f 100// //
c71de921 101// The reconstruction requires digits or raw data as input. For the creation //
102// of digits and raw data have a look at the class AliSimulation. //
596a855f 103// //
cd0b062e 104// The input data of a detector can be replaced by the corresponding HLT //
105// data by calling (usual detector string) //
106// SetUseHLTData("..."); //
107// //
24f7a148 108// //
596a855f 109///////////////////////////////////////////////////////////////////////////////
110
024a7e64 111#include <TArrayF.h>
112#include <TFile.h>
444753c6 113#include <TList.h>
024a7e64 114#include <TSystem.h>
115#include <TROOT.h>
116#include <TPluginManager.h>
3103d196 117#include <TGeoManager.h>
2bdb9d38 118#include <TLorentzVector.h>
3dd9f9e3 119#include <TArrayS.h>
120#include <TArrayD.h>
3c3709c4 121#include <TObjArray.h>
325aa76f 122#include <TMap.h>
4b71572b 123#include <TChain.h>
124#include <TProof.h>
db4aeca1 125#include <TProofOutputFile.h>
002c9d1b 126#include <TParameter.h>
596a855f 127
128#include "AliReconstruction.h"
87932dab 129#include "AliCodeTimer.h"
b8cd5251 130#include "AliReconstructor.h"
815c2b38 131#include "AliLog.h"
596a855f 132#include "AliRunLoader.h"
133#include "AliRun.h"
b649205a 134#include "AliRawReaderFile.h"
135#include "AliRawReaderDate.h"
136#include "AliRawReaderRoot.h"
001397cd 137#include "AliRawEventHeaderBase.h"
4b71572b 138#include "AliRawEvent.h"
af885e0f 139#include "AliESDEvent.h"
faffd83e 140#include "AliESDMuonTrack.h"
1d99986f 141#include "AliESDfriend.h"
2257f27e 142#include "AliESDVertex.h"
faffd83e 143#include "AliESDcascade.h"
144#include "AliESDkink.h"
145#include "AliESDtrack.h"
146#include "AliESDCaloCluster.h"
e649177a 147#include "AliESDCaloCells.h"
32e449be 148#include "AliMultiplicity.h"
c84a5e9e 149#include "AliTracker.h"
2257f27e 150#include "AliVertexer.h"
c5e3e5d1 151#include "AliVertexerTracks.h"
5e4ff34d 152#include "AliV0vertexer.h"
153#include "AliCascadeVertexer.h"
596a855f 154#include "AliHeader.h"
155#include "AliGenEventHeader.h"
b26c3770 156#include "AliPID.h"
596a855f 157#include "AliESDpid.h"
ff8bb5ae 158#include "AliESDtrack.h"
3dd9f9e3 159#include "AliESDPmdTrack.h"
f3a97c86 160
08e1a23e 161#include "AliESDTagCreator.h"
f3a97c86 162
25be1e5c 163#include "AliGeomManager.h"
98937d93 164#include "AliTrackPointArray.h"
b0314964 165#include "AliCDBManager.h"
795e4a22 166#include "AliCDBStorage.h"
6bae477a 167#include "AliCDBEntry.h"
168#include "AliAlignObj.h"
f3a97c86 169
b647652d 170#include "AliCentralTrigger.h"
b024fd7f 171#include "AliTriggerConfiguration.h"
172#include "AliTriggerClass.h"
a0c2cf2d 173#include "AliTriggerCluster.h"
b647652d 174#include "AliCTPRawStream.h"
175
04236e67 176#include "AliQADataMakerRec.h"
aa3c69a9 177#include "AliGlobalQADataMaker.h"
c65c502a 178#include "AliQA.h"
179#include "AliQADataMakerSteer.h"
f29f1726 180
7167ae53 181#include "AliPlaneEff.h"
182
0f88822a 183#include "AliSysInfo.h" // memory snapshots
cd0b062e 184#include "AliRawHLTManager.h"
0f88822a 185
325aa76f 186#include "AliMagWrapCheb.h"
6efecea1 187
7e88424f 188#include "AliDetectorRecoParam.h"
a00021a7 189#include "AliGRPRecoParam.h"
7e88424f 190#include "AliRunInfo.h"
191#include "AliEventInfo.h"
192
193#include "AliDAQ.h"
194
596a855f 195ClassImp(AliReconstruction)
196
c757bafd 197//_____________________________________________________________________________
b384f8a4 198const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
c757bafd 199
596a855f 200//_____________________________________________________________________________
4b71572b 201AliReconstruction::AliReconstruction(const char* gAliceFilename) :
202 TSelector(),
f8b507e0 203 fUniformField(kFALSE),
4b71572b 204 fForcedFieldMap(NULL),
2257f27e 205 fRunVertexFinder(kTRUE),
a84e2607 206 fRunVertexFinderTracks(kTRUE),
1f46a9ae 207 fRunHLTTracking(kFALSE),
e66fbafb 208 fRunMuonTracking(kFALSE),
d1683eef 209 fRunV0Finder(kTRUE),
210 fRunCascadeFinder(kTRUE),
1d99986f 211 fStopOnError(kFALSE),
212 fWriteAlignmentData(kFALSE),
213 fWriteESDfriend(kFALSE),
b647652d 214 fFillTriggerESD(kTRUE),
1d99986f 215
7f68891d 216 fCleanESD(kTRUE),
a023d8d8 217 fV0DCAmax(3.),
218 fV0CsPmin(0.),
7f68891d 219 fDmax(50.),
220 fZmax(50.),
221
1d99986f 222 fRunLocalReconstruction("ALL"),
b8cd5251 223 fRunTracking("ALL"),
e583c30d 224 fFillESD("ALL"),
7d566c20 225 fLoadCDB(""),
48ce48d1 226 fUseTrackingErrorsForAlignment(""),
e583c30d 227 fGAliceFileName(gAliceFilename),
4b71572b 228 fRawInput(""),
35042093 229 fEquipIdMap(""),
b26c3770 230 fFirstEvent(0),
231 fLastEvent(-1),
973388c2 232 fNumberOfEventsPerFile(1),
b8cd5251 233 fOptions(),
6bae477a 234 fLoadAlignFromCDB(kTRUE),
235 fLoadAlignData("ALL"),
46698ae4 236 fESDPar(""),
cd0b062e 237 fUseHLTData(),
7e88424f 238 fRunInfo(NULL),
239 fEventInfo(),
e583c30d 240
241 fRunLoader(NULL),
b649205a 242 fRawReader(NULL),
cd0b062e 243 fParentRawReader(NULL),
b8cd5251 244
7e88424f 245 fRecoParam(),
246
98937d93 247 fVertexer(NULL),
9178838a 248 fDiamondProfile(NULL),
43c9dae1 249 fDiamondProfileTPC(NULL),
87317a47 250 fMeanVertexConstraint(kTRUE),
98937d93 251
6b6e4472 252 fGRPData(NULL),
444753c6 253
6bae477a 254 fAlignObjArray(NULL),
795e4a22 255 fCDBUri(),
759c1df1 256 fSpecCDBUri(),
795e4a22 257 fInitCDBCalled(kFALSE),
258 fSetRunNumberFromDataCalled(kFALSE),
ce43afbe 259 fQADetectors("ALL"),
30bbd491 260 fQASteer(NULL),
ce43afbe 261 fQATasks("ALL"),
7e963665 262 fRunQA(kTRUE),
6b150027 263 fRunGlobalQA(kTRUE),
e4a998ed 264 fSameQACycle(kFALSE),
7167ae53 265
21a3aa09 266 fRunPlaneEff(kFALSE),
267
268 fesd(NULL),
269 fhltesd(NULL),
270 fesdf(NULL),
271 ffile(NULL),
272 ftree(NULL),
273 fhlttree(NULL),
21a3aa09 274 ftVertexer(NULL),
14dd053c 275 fIsNewRunLoader(kFALSE),
4b71572b 276 fRunAliEVE(kFALSE),
277 fChain(NULL)
596a855f 278{
279// create reconstruction object with default parameters
002c9d1b 280 gGeoManager = NULL;
b8cd5251 281
282 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
283 fReconstructor[iDet] = NULL;
284 fLoader[iDet] = NULL;
285 fTracker[iDet] = NULL;
286 }
252f8aa8 287 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
288 fQACycles[iDet] = 999999 ;
289 fQAWriteExpert[iDet] = kFALSE ;
290 }
291
e47c4c2e 292 AliPID pid;
596a855f 293}
294
295//_____________________________________________________________________________
296AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
4b71572b 297 TSelector(),
c84a5e9e 298 fUniformField(rec.fUniformField),
4b71572b 299 fForcedFieldMap(NULL),
2257f27e 300 fRunVertexFinder(rec.fRunVertexFinder),
a84e2607 301 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
1f46a9ae 302 fRunHLTTracking(rec.fRunHLTTracking),
e66fbafb 303 fRunMuonTracking(rec.fRunMuonTracking),
d1683eef 304 fRunV0Finder(rec.fRunV0Finder),
305 fRunCascadeFinder(rec.fRunCascadeFinder),
1d99986f 306 fStopOnError(rec.fStopOnError),
307 fWriteAlignmentData(rec.fWriteAlignmentData),
308 fWriteESDfriend(rec.fWriteESDfriend),
b647652d 309 fFillTriggerESD(rec.fFillTriggerESD),
1d99986f 310
7f68891d 311 fCleanESD(rec.fCleanESD),
a023d8d8 312 fV0DCAmax(rec.fV0DCAmax),
5e5c1aa9 313 fV0CsPmin(rec.fV0CsPmin),
7f68891d 314 fDmax(rec.fDmax),
315 fZmax(rec.fZmax),
316
1d99986f 317 fRunLocalReconstruction(rec.fRunLocalReconstruction),
e583c30d 318 fRunTracking(rec.fRunTracking),
319 fFillESD(rec.fFillESD),
7d566c20 320 fLoadCDB(rec.fLoadCDB),
48ce48d1 321 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
e583c30d 322 fGAliceFileName(rec.fGAliceFileName),
4b71572b 323 fRawInput(rec.fRawInput),
35042093 324 fEquipIdMap(rec.fEquipIdMap),
b26c3770 325 fFirstEvent(rec.fFirstEvent),
326 fLastEvent(rec.fLastEvent),
973388c2 327 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
b8cd5251 328 fOptions(),
6bae477a 329 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
330 fLoadAlignData(rec.fLoadAlignData),
46698ae4 331 fESDPar(rec.fESDPar),
2972d4eb 332 fUseHLTData(rec.fUseHLTData),
7e88424f 333 fRunInfo(NULL),
334 fEventInfo(),
e583c30d 335
336 fRunLoader(NULL),
b649205a 337 fRawReader(NULL),
2972d4eb 338 fParentRawReader(NULL),
b8cd5251 339
4b71572b 340 fRecoParam(rec.fRecoParam),
7e88424f 341
98937d93 342 fVertexer(NULL),
4b71572b 343 fDiamondProfile(rec.fDiamondProfile),
344 fDiamondProfileTPC(rec.fDiamondProfileTPC),
87317a47 345 fMeanVertexConstraint(rec.fMeanVertexConstraint),
98937d93 346
6b6e4472 347 fGRPData(NULL),
444753c6 348
6bae477a 349 fAlignObjArray(rec.fAlignObjArray),
ec92bee0 350 fCDBUri(rec.fCDBUri),
7e963665 351 fSpecCDBUri(),
795e4a22 352 fInitCDBCalled(rec.fInitCDBCalled),
353 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
ce43afbe 354 fQADetectors(rec.fQADetectors),
4b71572b 355 fQASteer(NULL),
ce43afbe 356 fQATasks(rec.fQATasks),
aa3c69a9 357 fRunQA(rec.fRunQA),
358 fRunGlobalQA(rec.fRunGlobalQA),
e4a998ed 359 fSameQACycle(rec.fSameQACycle),
21a3aa09 360 fRunPlaneEff(rec.fRunPlaneEff),
361
362 fesd(NULL),
363 fhltesd(NULL),
364 fesdf(NULL),
365 ffile(NULL),
366 ftree(NULL),
367 fhlttree(NULL),
21a3aa09 368 ftVertexer(NULL),
14dd053c 369 fIsNewRunLoader(rec.fIsNewRunLoader),
4b71572b 370 fRunAliEVE(kFALSE),
371 fChain(NULL)
596a855f 372{
373// copy constructor
374
ec92bee0 375 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
efd2085e 376 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
377 }
b8cd5251 378 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
379 fReconstructor[iDet] = NULL;
380 fLoader[iDet] = NULL;
381 fTracker[iDet] = NULL;
b1af1125 382 }
383
252f8aa8 384 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
b1af1125 385 fQACycles[iDet] = rec.fQACycles[iDet];
252f8aa8 386 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
387 }
b1af1125 388
ec92bee0 389 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
390 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
391 }
596a855f 392}
393
394//_____________________________________________________________________________
395AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
396{
397// assignment operator
4b71572b 398// Used in PROOF mode
399// Be very careful while modifing it!
400// Simple rules to follow:
401// for persistent data members - use their assignment operators
402// for non-persistent ones - do nothing or take the default values from constructor
403// TSelector members should not be touched
404 if(&rec == this) return *this;
405
406 fUniformField = rec.fUniformField;
407 fForcedFieldMap = NULL;
408 fRunVertexFinder = rec.fRunVertexFinder;
409 fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
410 fRunHLTTracking = rec.fRunHLTTracking;
411 fRunMuonTracking = rec.fRunMuonTracking;
412 fRunV0Finder = rec.fRunV0Finder;
413 fRunCascadeFinder = rec.fRunCascadeFinder;
414 fStopOnError = rec.fStopOnError;
415 fWriteAlignmentData = rec.fWriteAlignmentData;
416 fWriteESDfriend = rec.fWriteESDfriend;
417 fFillTriggerESD = rec.fFillTriggerESD;
418
419 fCleanESD = rec.fCleanESD;
420 fV0DCAmax = rec.fV0DCAmax;
421 fV0CsPmin = rec.fV0CsPmin;
422 fDmax = rec.fDmax;
423 fZmax = rec.fZmax;
424
425 fRunLocalReconstruction = rec.fRunLocalReconstruction;
426 fRunTracking = rec.fRunTracking;
427 fFillESD = rec.fFillESD;
7d566c20 428 fLoadCDB = rec.fLoadCDB;
4b71572b 429 fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
430 fGAliceFileName = rec.fGAliceFileName;
431 fRawInput = rec.fRawInput;
432 fEquipIdMap = rec.fEquipIdMap;
433 fFirstEvent = rec.fFirstEvent;
434 fLastEvent = rec.fLastEvent;
435 fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
436
437 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
438 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
439 }
440
441 fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
442 fLoadAlignData = rec.fLoadAlignData;
443 fESDPar = rec.fESDPar;
444 fUseHLTData = rec.fUseHLTData;
445
446 delete fRunInfo; fRunInfo = NULL;
447 if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
448
449 fEventInfo = rec.fEventInfo;
450
451 fRunLoader = NULL;
452 fRawReader = NULL;
453 fParentRawReader = NULL;
454
455 fRecoParam = rec.fRecoParam;
456
457 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
458 delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
459 delete fLoader[iDet]; fLoader[iDet] = NULL;
460 delete fTracker[iDet]; fTracker[iDet] = NULL;
4b71572b 461 }
b1af1125 462
252f8aa8 463 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
b1af1125 464 fQACycles[iDet] = rec.fQACycles[iDet];
252f8aa8 465 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
466 }
467
4b71572b 468 fVertexer = NULL;
469 delete fDiamondProfile; fDiamondProfile = NULL;
470 if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
471 delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
472 if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
473 fMeanVertexConstraint = rec.fMeanVertexConstraint;
474
475 delete fGRPData; fGRPData = NULL;
476 if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
477
478 delete fAlignObjArray; fAlignObjArray = NULL;
479
480 fCDBUri = "";
481 fSpecCDBUri.Delete();
482 fInitCDBCalled = rec.fInitCDBCalled;
483 fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
484 fQADetectors = rec.fQADetectors;
485 fQASteer = NULL;
486 fQATasks = rec.fQATasks;
487 fRunQA = rec.fRunQA;
488 fRunGlobalQA = rec.fRunGlobalQA;
4b71572b 489 fSameQACycle = rec.fSameQACycle;
490 fRunPlaneEff = rec.fRunPlaneEff;
491
492 fesd = NULL;
493 fhltesd = NULL;
494 fesdf = NULL;
495 ffile = NULL;
496 ftree = NULL;
497 fhlttree = NULL;
498 ftVertexer = NULL;
499 fIsNewRunLoader = rec.fIsNewRunLoader;
500 fRunAliEVE = kFALSE;
501 fChain = NULL;
596a855f 502
596a855f 503 return *this;
504}
505
506//_____________________________________________________________________________
507AliReconstruction::~AliReconstruction()
508{
509// clean up
510
e583c30d 511 CleanUp();
4f3c479a 512 delete fGRPData;
4b71572b 513 delete fForcedFieldMap;
efd2085e 514 fOptions.Delete();
4b71572b 515 if (fAlignObjArray) {
516 fAlignObjArray->Delete();
517 delete fAlignObjArray;
518 }
ec92bee0 519 fSpecCDBUri.Delete();
4b71572b 520 delete fQASteer;
87932dab 521 AliCodeTimer::Instance()->Print();
596a855f 522}
523
024cf675 524//_____________________________________________________________________________
795e4a22 525void AliReconstruction::InitCDB()
024cf675 526{
527// activate a default CDB storage
528// First check if we have any CDB storage set, because it is used
529// to retrieve the calibration and alignment constants
002c9d1b 530 AliCodeTimerAuto("");
024cf675 531
795e4a22 532 if (fInitCDBCalled) return;
533 fInitCDBCalled = kTRUE;
534
024cf675 535 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 536 if (man->IsDefaultStorageSet())
024cf675 537 {
538 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 539 AliWarning("Default CDB storage has been already set !");
540 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
024cf675 541 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 542 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 543 }
544 else {
795e4a22 545 if (fCDBUri.Length() > 0)
546 {
547 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
548 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
549 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
550 } else {
551 fCDBUri="local://$ALICE_ROOT";
552 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
553 AliWarning("Default CDB storage not yet set !!!!");
554 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
555 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
556
557 }
ec92bee0 558 man->SetDefaultStorage(fCDBUri);
559 }
560
561 // Now activate the detector specific CDB storage locations
c3a7b59a 562 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
563 TObject* obj = fSpecCDBUri[i];
564 if (!obj) continue;
b8ec52f6 565 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
566 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
567 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 568 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 569 }
002c9d1b 570 AliSysInfo::AddStamp("InitCDB");
024cf675 571}
572
573//_____________________________________________________________________________
574void AliReconstruction::SetDefaultStorage(const char* uri) {
ec92bee0 575// Store the desired default CDB storage location
576// Activate it later within the Run() method
024cf675 577
ec92bee0 578 fCDBUri = uri;
024cf675 579
580}
581
00aa02d5 582//_____________________________________________________________________________
c3a7b59a 583void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 584// Store a detector-specific CDB storage location
585// Activate it later within the Run() method
024cf675 586
c3a7b59a 587 AliCDBPath aPath(calibType);
588 if(!aPath.IsValid()){
589 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
590 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
591 if(!strcmp(calibType, fgkDetectorName[iDet])) {
592 aPath.SetPath(Form("%s/*", calibType));
593 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
594 break;
595 }
596 }
597 if(!aPath.IsValid()){
598 AliError(Form("Not a valid path or detector: %s", calibType));
599 return;
600 }
601 }
602
53dd3c3d 603// // check that calibType refers to a "valid" detector name
604// Bool_t isDetector = kFALSE;
605// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
606// TString detName = fgkDetectorName[iDet];
607// if(aPath.GetLevel0() == detName) {
608// isDetector = kTRUE;
609// break;
610// }
611// }
612//
613// if(!isDetector) {
614// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
615// return;
616// }
c3a7b59a 617
618 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
ec92bee0 619 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 620 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
024cf675 621
622}
623
6bae477a 624//_____________________________________________________________________________
795e4a22 625Bool_t AliReconstruction::SetRunNumberFromData()
6bae477a 626{
627 // The method is called in Run() in order
628 // to set a correct run number.
629 // In case of raw data reconstruction the
630 // run number is taken from the raw data header
631
795e4a22 632 if (fSetRunNumberFromDataCalled) return kTRUE;
633 fSetRunNumberFromDataCalled = kTRUE;
634
635 AliCDBManager* man = AliCDBManager::Instance();
4b71572b 636
637 if(fRawReader) {
638 if(fRawReader->NextEvent()) {
639 if(man->GetRun() > 0) {
21a3aa09 640 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
4b71572b 641 }
642 man->SetRun(fRawReader->GetRunNumber());
643 fRawReader->RewindEvents();
644 }
645 else {
646 if(man->GetRun() > 0) {
647 AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
648 }
649 else {
650 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
651 return kFALSE;
652 }
653 }
654 }
655 else {
656 AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
657 if (!rl) {
658 AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
6bae477a 659 return kFALSE;
660 }
ec92bee0 661 else {
4b71572b 662 rl->LoadHeader();
663 // read run number from gAlice
664 if(rl->GetHeader()) {
665 man->SetRun(rl->GetHeader()->GetRun());
666 rl->UnloadHeader();
667 delete rl;
ec92bee0 668 }
669 else {
4b71572b 670 AliError("Neither run-loader header nor RawReader objects are found !");
671 delete rl;
ec92bee0 672 return kFALSE;
673 }
4b71572b 674 }
6bae477a 675 }
795e4a22 676
677 man->Print();
678
6bae477a 679 return kTRUE;
680}
681
795e4a22 682//_____________________________________________________________________________
683void AliReconstruction::SetCDBLock() {
684 // Set CDB lock: from now on it is forbidden to reset the run number
685 // or the default storage or to activate any further storage!
686
687 AliCDBManager::Instance()->SetLock(1);
688}
689
6bae477a 690//_____________________________________________________________________________
691Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
692{
693 // Read the alignment objects from CDB.
694 // Each detector is supposed to have the
695 // alignment objects in DET/Align/Data CDB path.
696 // All the detector objects are then collected,
697 // sorted by geometry level (starting from ALIC) and
698 // then applied to the TGeo geometry.
699 // Finally an overlaps check is performed.
700
701 // Load alignment data from CDB and fill fAlignObjArray
702 if(fLoadAlignFromCDB){
6bae477a 703
25be1e5c 704 TString detStr = detectors;
705 TString loadAlObjsListOfDets = "";
706
707 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
8cb26cdf 708 if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
709 if(fgkDetectorName[iDet]=="HLT") continue;
710 if(AliGeomManager::IsModuleInGeom(fgkDetectorName[iDet]))
711 {
712 loadAlObjsListOfDets += fgkDetectorName[iDet];
713 loadAlObjsListOfDets += " ";
714 }
25be1e5c 715 } // end loop over detectors
8cb26cdf 716 if(AliGeomManager::IsModuleInGeom("FRAME"))
717 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
98e303d9 718 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
e30a9b4d 719 AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
25be1e5c 720 }else{
721 // Check if the array with alignment objects was
722 // provided by the user. If yes, apply the objects
723 // to the present TGeo geometry
724 if (fAlignObjArray) {
725 if (gGeoManager && gGeoManager->IsClosed()) {
98e303d9 726 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
25be1e5c 727 AliError("The misalignment of one or more volumes failed!"
728 "Compare the list of simulated detectors and the list of detector alignment data!");
729 return kFALSE;
730 }
731 }
732 else {
733 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
6bae477a 734 return kFALSE;
735 }
736 }
6bae477a 737 }
25be1e5c 738
4b71572b 739 if (fAlignObjArray) {
740 fAlignObjArray->Delete();
741 delete fAlignObjArray; fAlignObjArray=NULL;
742 }
a03b0371 743
6bae477a 744 return kTRUE;
745}
596a855f 746
747//_____________________________________________________________________________
748void AliReconstruction::SetGAliceFile(const char* fileName)
749{
750// set the name of the galice file
751
752 fGAliceFileName = fileName;
753}
754
21a3aa09 755//_____________________________________________________________________________
b58710ef 756void AliReconstruction::SetInput(const char* input)
21a3aa09 757{
b58710ef 758 // In case the input string starts with 'mem://', we run in an online mode
759 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
760 // file is assumed. One can give as an input:
761 // mem://: - events taken from DAQ monitoring libs online
762 // or
763 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
4b71572b 764 if (input) fRawInput = input;
21a3aa09 765}
766
efd2085e 767//_____________________________________________________________________________
768void AliReconstruction::SetOption(const char* detector, const char* option)
769{
770// set options for the reconstruction of a detector
771
772 TObject* obj = fOptions.FindObject(detector);
773 if (obj) fOptions.Remove(obj);
774 fOptions.Add(new TNamed(detector, option));
775}
776
7e88424f 777//_____________________________________________________________________________
778void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
779{
780 // Set custom reconstruction parameters for a given detector
781 // Single set of parameters for all the events
a00021a7 782
783 // First check if the reco-params are global
784 if(!strcmp(detector, "GRP")) {
785 par->SetAsDefault();
786 fRecoParam.AddDetRecoParam(fgkNDetectors,par);
787 return;
788 }
789
7e88424f 790 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
791 if(!strcmp(detector, fgkDetectorName[iDet])) {
792 par->SetAsDefault();
793 fRecoParam.AddDetRecoParam(iDet,par);
794 break;
795 }
796 }
797
798}
799
61807e09 800//_____________________________________________________________________________
856024f0 801Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) {
61807e09 802 //------------------------------------------------
803 // The magnetic field map, defined externally...
804 // L3 current 30000 A -> 0.5 T
805 // L3 current 12000 A -> 0.2 T
806 // dipole current 6000 A
807 // The polarities must be the same
808 //------------------------------------------------
809 const Float_t l3NominalCurrent1=30000.; // (A)
810 const Float_t l3NominalCurrent2=12000.; // (A)
811 const Float_t diNominalCurrent =6000. ; // (A)
812
813 const Float_t tolerance=0.03; // relative current tolerance
814 const Float_t zero=77.; // "zero" current (A)
815
816 Int_t map=0;
817 Bool_t dipoleON=kFALSE;
818
856024f0 819 TString s=(factor < 0) ? "L3: -" : "L3: +";
61807e09 820
bb91052d 821 l3Current = TMath::Abs(l3Current);
61807e09 822 if (TMath::Abs(l3Current-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
823 map=AliMagWrapCheb::k5kG;
824 s+="0.5 T; ";
825 } else
826 if (TMath::Abs(l3Current-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
827 map=AliMagWrapCheb::k2kG;
828 s+="0.2 T; ";
829 } else
bb91052d 830 if (l3Current < zero) {
61807e09 831 map=AliMagWrapCheb::k2kG;
832 s+="0.0 T; ";
833 factor=0.; // in fact, this is a global factor...
4d338614 834 fUniformField=kTRUE; // track with the uniform (zero) B field
61807e09 835 } else {
bb91052d 836 AliError(Form("Wrong L3 current (%f A)!",l3Current));
61807e09 837 return kFALSE;
838 }
839
bb91052d 840 diCurrent = TMath::Abs(diCurrent);
61807e09 841 if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
842 // 3% current tolerance...
843 dipoleON=kTRUE;
844 s+="Dipole ON";
845 } else
bb91052d 846 if (diCurrent < zero) { // some small current..
61807e09 847 dipoleON=kFALSE;
848 s+="Dipole OFF";
849 } else {
bb91052d 850 AliError(Form("Wrong dipole current (%f A)!",diCurrent));
61807e09 851 return kFALSE;
852 }
853
854 delete fForcedFieldMap;
855 fForcedFieldMap=
856 new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path);
857
858 fForcedFieldMap->Print();
859
860 AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
861
862 return kTRUE;
863}
864
865
866Bool_t AliReconstruction::InitGRP() {
867 //------------------------------------
868 // Initialization of the GRP entry
869 //------------------------------------
870 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
871
4b71572b 872 if (entry) {
873 fGRPData = dynamic_cast<TMap*>(entry->GetObject());
874 entry->SetOwner(0);
875 AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
876 }
61807e09 877
878 if (!fGRPData) {
879 AliError("No GRP entry found in OCDB!");
880 return kFALSE;
881 }
882
7e88424f 883 TObjString *lhcState=
884 dynamic_cast<TObjString*>(fGRPData->GetValue("fLHCState"));
885 if (!lhcState) {
886 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
887 }
888
889 TObjString *beamType=
890 dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamType"));
891 if (!beamType) {
892 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
893 }
894
895 TObjString *beamEnergyStr=
896 dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamEnergy"));
897 if (!beamEnergyStr) {
898 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
899 }
900
901 TObjString *runType=
902 dynamic_cast<TObjString*>(fGRPData->GetValue("fRunType"));
903 if (!runType) {
904 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
905 }
906
907 TObjString *activeDetectors=
908 dynamic_cast<TObjString*>(fGRPData->GetValue("fDetectorMask"));
909 if (!activeDetectors) {
910 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
911 }
912
913 fRunInfo = new AliRunInfo(lhcState ? lhcState->GetString().Data() : "UNKNOWN",
914 beamType ? beamType->GetString().Data() : "UNKNOWN",
915 beamEnergyStr ? beamEnergyStr->GetString().Atof() : 0,
916 runType ? runType->GetString().Data() : "UNKNOWN",
917 activeDetectors ? activeDetectors->GetString().Atoi() : 1074790399);
918
919 // Process the list of active detectors
920 if (activeDetectors && activeDetectors->GetString().IsDigit()) {
921 UInt_t detMask = activeDetectors->GetString().Atoi();
7d566c20 922 fLoadCDB.Form("%s %s %s %s",
923 fRunLocalReconstruction.Data(),
924 fRunTracking.Data(),
925 fFillESD.Data(),
926 fQADetectors.Data());
7e88424f 927 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
928 fRunTracking = MatchDetectorList(fRunTracking,detMask);
929 fFillESD = MatchDetectorList(fFillESD,detMask);
ca13fb87 930 fQADetectors = MatchDetectorList(fQADetectors,detMask);
7d566c20 931 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
7e88424f 932 }
933
934 AliInfo("===================================================================================");
935 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
936 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
937 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
ca13fb87 938 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
7d566c20 939 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
7e88424f 940 AliInfo("===================================================================================");
61807e09 941
942 //*** Dealing with the magnetic field map
943 if (AliTracker::GetFieldMap()) {
944 AliInfo("Running with the externally set B field !");
945 } else {
946 // Construct the field map out of the information retrieved from GRP.
947
856024f0 948 Bool_t ok = kTRUE;
949
61807e09 950 // L3
951 TObjString *l3Current=
952 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
953 if (!l3Current) {
954 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
856024f0 955 ok = kFALSE;
61807e09 956 }
957 TObjString *l3Polarity=
958 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
959 if (!l3Polarity) {
960 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
856024f0 961 ok = kFALSE;
61807e09 962 }
963
964 // Dipole
965 TObjString *diCurrent=
966 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
967 if (!diCurrent) {
968 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
856024f0 969 ok = kFALSE;
61807e09 970 }
971 TObjString *diPolarity=
972 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
973 if (!diPolarity) {
974 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
856024f0 975 ok = kFALSE;
61807e09 976 }
977
856024f0 978 if (ok) {
979 Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
980 Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
981 Float_t l3Pol=atof(l3Polarity->GetName());
982 Float_t factor=1.;
983 if (l3Pol != 0.) factor=-1.;
984
61807e09 985
856024f0 986 if (!SetFieldMap(l3Cur, diCur, factor)) {
987 AliFatal("Failed to creat a B field map ! Exiting...");
988 }
989 AliInfo("Running with the B field constructed out of GRP !");
990 }
991 else {
992 AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
61807e09 993 }
994
61807e09 995 }
996
61807e09 997 //*** Get the diamond profile from OCDB
998 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
999 if (entry) {
479673dd 1000 if (fMeanVertexConstraint)
1001 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
61807e09 1002 } else {
1003 AliError("No diamond profile found in OCDB!");
1004 }
1005
1006 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1007 if (entry) {
479673dd 1008 if (fMeanVertexConstraint)
1009 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
61807e09 1010 } else {
1011 AliError("No diamond profile found in OCDB!");
1012 }
1013
1014 return kTRUE;
1015}
1016
4b71572b 1017//_____________________________________________________________________________
1018Bool_t AliReconstruction::LoadCDB()
1019{
1020 AliCodeTimerAuto("");
1021
1022 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1023
7d566c20 1024 TString detStr = fLoadCDB;
4b71572b 1025 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1026 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1027 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1028 }
1029 return kTRUE;
1030}
1031
596a855f 1032//_____________________________________________________________________________
21a3aa09 1033Bool_t AliReconstruction::Run(const char* input)
596a855f 1034{
21a3aa09 1035 // Run Run Run
1036 AliCodeTimerAuto("");
596a855f 1037
4b71572b 1038 InitRun(input);
1039 if (GetAbort() != TSelector::kContinue) return kFALSE;
1040
1041 TChain *chain = NULL;
1042 if (fRawReader && (chain = fRawReader->GetChain())) {
1043 // Proof mode
1044 if (gProof) {
4b71572b 1045 gProof->AddInput(this);
db4aeca1 1046 TUrl outputFile;
1047 outputFile.SetProtocol("root",kTRUE);
1048 outputFile.SetHost(gSystem->HostName());
1049 outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
1050 AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl()));
1051 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl()));
4b71572b 1052 chain->SetProof();
1053 chain->Process("AliReconstruction");
1054 }
1055 else {
1056 chain->Process(this);
1057 }
1058 }
1059 else {
1060 Begin(NULL);
1061 if (GetAbort() != TSelector::kContinue) return kFALSE;
1062 SlaveBegin(NULL);
1063 if (GetAbort() != TSelector::kContinue) return kFALSE;
1064 //******* The loop over events
1065 Int_t iEvent = 0;
1066 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1067 (fRawReader && fRawReader->NextEvent())) {
1068 if (!ProcessEvent(iEvent)) {
930e6e3e 1069 Abort("ProcessEvent",TSelector::kAbortFile);
1070 return kFALSE;
4b71572b 1071 }
1072 iEvent++;
1073 }
1074 SlaveTerminate();
1075 if (GetAbort() != TSelector::kContinue) return kFALSE;
1076 Terminate();
1077 if (GetAbort() != TSelector::kContinue) return kFALSE;
21a3aa09 1078 }
21a3aa09 1079
1080 return kTRUE;
1081}
1082
1083//_____________________________________________________________________________
4b71572b 1084void AliReconstruction::InitRawReader(const char* input)
21a3aa09 1085{
21a3aa09 1086 AliCodeTimerAuto("");
1087
4b71572b 1088 // Init raw-reader and
21a3aa09 1089 // set the input in case of raw data
4b71572b 1090 if (input) fRawInput = input;
1091 fRawReader = AliRawReader::Create(fRawInput.Data());
b58710ef 1092 if (!fRawReader)
21a3aa09 1093 AliInfo("Reconstruction will run over digits");
e0027792 1094
35042093 1095 if (!fEquipIdMap.IsNull() && fRawReader)
1096 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1097
cd0b062e 1098 if (!fUseHLTData.IsNull()) {
1099 // create the RawReaderHLT which performs redirection of HLT input data for
1100 // the specified detectors
1101 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1102 if (pRawReader) {
1103 fParentRawReader=fRawReader;
1104 fRawReader=pRawReader;
1105 } else {
1106 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1107 }
1108 }
4b71572b 1109 AliSysInfo::AddStamp("CreateRawReader");
1110}
cd0b062e 1111
4b71572b 1112//_____________________________________________________________________________
1113void AliReconstruction::InitRun(const char* input)
1114{
1115 // Initialization of raw-reader,
1116 // run number, CDB etc.
1117 AliCodeTimerAuto("");
1118 AliSysInfo::AddStamp("Start");
1119
002c9d1b 1120 // Initialize raw-reader if any
4b71572b 1121 InitRawReader(input);
596a855f 1122
ec92bee0 1123 // Initialize the CDB storage
795e4a22 1124 InitCDB();
ec92bee0 1125
6bae477a 1126 // Set run number in CDBManager (if it is not already set by the user)
4b71572b 1127 if (!SetRunNumberFromData()) {
1128 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1129 return;
1130 }
002c9d1b 1131
795e4a22 1132 // Set CDB lock: from now on it is forbidden to reset the run number
1133 // or the default storage or to activate any further storage!
1134 SetCDBLock();
1135
002c9d1b 1136}
1137
1138//_____________________________________________________________________________
1139void AliReconstruction::Begin(TTree *)
1140{
1141 // Initialize AlReconstruction before
1142 // going into the event loop
1143 // Should follow the TSelector convention
1144 // i.e. initialize only the object on the client side
db4aeca1 1145 AliCodeTimerAuto("");
1146
b4fef0d2 1147 AliReconstruction *reco = NULL;
002c9d1b 1148 if (fInput) {
8fb1f1dc 1149 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
002c9d1b 1150 *this = *reco;
002c9d1b 1151 }
1152 AliSysInfo::AddStamp("ReadInputInBegin");
1153 }
1154
6bae477a 1155 // Import ideal TGeo geometry and apply misalignment
1156 if (!gGeoManager) {
1157 TString geom(gSystem->DirName(fGAliceFileName));
1158 geom += "/geometry.root";
98e303d9 1159 AliGeomManager::LoadGeometry(geom.Data());
4b71572b 1160 if (!gGeoManager) {
1161 Abort("LoadGeometry", TSelector::kAbortProcess);
1162 return;
1163 }
281270d3 1164 AliSysInfo::AddStamp("LoadGeom");
ff5970a3 1165 TString detsToCheck=fRunLocalReconstruction;
4b71572b 1166 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1167 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1168 return;
1169 }
281270d3 1170 AliSysInfo::AddStamp("CheckGeom");
6bae477a 1171 }
8e245d15 1172
4b71572b 1173 if (!MisalignGeometry(fLoadAlignData)) {
1174 Abort("MisalignGeometry", TSelector::kAbortProcess);
1175 return;
1176 }
1177 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
281270d3 1178 AliSysInfo::AddStamp("MisalignGeom");
6bae477a 1179
8cb26cdf 1180 if (!InitGRP()) {
1181 Abort("InitGRP", TSelector::kAbortProcess);
1182 return;
1183 }
1184 AliSysInfo::AddStamp("InitGRP");
1185
4b71572b 1186 if (!LoadCDB()) {
1187 Abort("LoadCDB", TSelector::kAbortProcess);
1188 return;
1189 }
1190 AliSysInfo::AddStamp("LoadCDB");
325aa76f 1191
7e88424f 1192 // Read the reconstruction parameters from OCDB
1193 if (!InitRecoParams()) {
002c9d1b 1194 AliWarning("Not all detectors have correct RecoParam objects initialized");
4b71572b 1195 }
1196 AliSysInfo::AddStamp("InitRecoParams");
1197
002c9d1b 1198 if (fInput) {
b4fef0d2 1199 if (reco) *reco = *this;
002c9d1b 1200 fInput->Add(gGeoManager);
1201 gGeoManager = NULL;
1202 fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
1203 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
ead7b391 1204 AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap();
1205 magFieldMap->SetName("MagneticFieldMap");
1206 fInput->Add(magFieldMap);
002c9d1b 1207 }
4b71572b 1208
1209}
1210
1211//_____________________________________________________________________________
1212void AliReconstruction::SlaveBegin(TTree*)
1213{
1214 // Initialization related to run-loader,
1215 // vertexer, trackers, recontructors
1216 // In proof mode it is executed on the slave
1217 AliCodeTimerAuto("");
1218
db4aeca1 1219 TProofOutputFile *outProofFile = NULL;
ead7b391 1220 if (fInput) {
db4aeca1 1221 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1222 *this = *reco;
1223 }
4b71572b 1224 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1225 gGeoManager = tgeo;
1226 AliGeomManager::SetGeometry(tgeo);
7e88424f 1227 }
281270d3 1228 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1229 Int_t runNumber = -1;
1230 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1231 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1232 man->SetCacheFlag(kTRUE);
1233 man->SetLock(kTRUE);
1234 man->Print();
1235 }
4b71572b 1236 }
ead7b391 1237 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
4b71572b 1238 AliTracker::SetFieldMap(map,fUniformField);
1239 }
db4aeca1 1240 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1241 outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
1242 outProofFile->SetOutputFileName(outputFileName->GetTitle());
1243 fOutput->Add(outProofFile);
4b71572b 1244 }
002c9d1b 1245 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
7e88424f 1246 }
325aa76f 1247
4b71572b 1248 // get the run loader
1249 if (!InitRunLoader()) {
1250 Abort("InitRunLoader", TSelector::kAbortProcess);
1251 return;
1252 }
1253 AliSysInfo::AddStamp("LoadLoader");
1254
325aa76f 1255 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1256 if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
2257f27e 1257
1258 // get vertexer
1259 if (fRunVertexFinder && !CreateVertexer()) {
4b71572b 1260 Abort("CreateVertexer", TSelector::kAbortProcess);
1261 return;
2257f27e 1262 }
4b71572b 1263 AliSysInfo::AddStamp("CreateVertexer");
596a855f 1264
f08fc9f5 1265 // get trackers
b8cd5251 1266 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
4b71572b 1267 Abort("CreateTrackers", TSelector::kAbortProcess);
1268 return;
1269 }
1270 AliSysInfo::AddStamp("CreateTrackers");
24f7a148 1271
36711aa4 1272 // create the ESD output file and tree
db4aeca1 1273 if (!outProofFile) {
1274 ffile = TFile::Open("AliESDs.root", "RECREATE");
1275 ffile->SetCompressionLevel(2);
1276 if (!ffile->IsOpen()) {
1277 Abort("OpenESDFile", TSelector::kAbortProcess);
1278 return;
1279 }
1280 }
1281 else {
1282 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1283 Abort(Form("Problems opening output PROOF file: %s/%s",
1284 outProofFile->GetDir(), outProofFile->GetFileName()),
1285 TSelector::kAbortProcess);
1286 return;
1287 }
596a855f 1288 }
46698ae4 1289
21a3aa09 1290 ftree = new TTree("esdTree", "Tree with ESD objects");
1291 fesd = new AliESDEvent();
1292 fesd->CreateStdContent();
1d99986f 1293 if (fWriteESDfriend) {
21a3aa09 1294 fesdf = new AliESDfriend();
1295 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
46698ae4 1296 br->SetFile("AliESDfriends.root");
21a3aa09 1297 fesd->AddObject(fesdf);
1d99986f 1298 }
f9604a22 1299 fesd->WriteToTree(ftree);
1300 ftree->GetUserInfo()->Add(fesd);
1301
1302 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1303 fhltesd = new AliESDEvent();
1304 fhltesd->CreateStdContent();
1305 fhltesd->WriteToTree(fhlttree);
1306 fhlttree->GetUserInfo()->Add(fhltesd);
5728d3d5 1307
95cee32f 1308 ProcInfo_t ProcInfo;
1309 gSystem->GetProcInfo(&ProcInfo);
1310 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
8661738e 1311
325aa76f 1312 //QA
930e6e3e 1313 //Initialize the QA and start of cycle
f6806ad3 1314 if (fRunQA) {
930e6e3e 1315 fQASteer = new AliQADataMakerSteer("rec") ;
1316 fQASteer->SetActiveDetectors(fQADetectors) ;
252f8aa8 1317 for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
930e6e3e 1318 fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
252f8aa8 1319 if (fQAWriteExpert[det])
1320 fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
1321 }
1322
930e6e3e 1323 if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
1324 fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
1325 fQASteer->SetTasks(fQATasks) ;
1326 fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam) ;
4b71572b 1327 }
930e6e3e 1328
4b71572b 1329 if (fRunGlobalQA) {
0de86d1a 1330 Bool_t sameCycle = kFALSE ;
1331 if (!fQASteer) fQASteer = new AliQADataMakerSteer("rec") ;
4b71572b 1332 AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1333 AliInfo(Form("Initializing the global QA data maker"));
1334 if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
930e6e3e 1335 qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
1336 TObjArray *arr=qadm->Init(AliQA::kRECPOINTS);
4b71572b 1337 AliTracker::SetResidualsArray(arr);
930e6e3e 1338 sameCycle = kTRUE ;
4b71572b 1339 }
1340 if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
930e6e3e 1341 qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
1342 qadm->Init(AliQA::kESDS);
4b71572b 1343 }
1344 }
aa3c69a9 1345
7167ae53 1346 //Initialize the Plane Efficiency framework
1347 if (fRunPlaneEff && !InitPlaneEff()) {
4b71572b 1348 Abort("InitPlaneEff", TSelector::kAbortProcess);
1349 return;
7167ae53 1350 }
aa3c69a9 1351
14dd053c 1352 if (strcmp(gProgName,"alieve") == 0)
1353 fRunAliEVE = InitAliEVE();
1354
4b71572b 1355 return;
21a3aa09 1356}
1357
1358//_____________________________________________________________________________
4b71572b 1359Bool_t AliReconstruction::Process(Long64_t entry)
1360{
1361 // run the reconstruction over a single entry
1362 // from the chain with raw data
1363 AliCodeTimerAuto("");
1364
1365 TTree *currTree = fChain->GetTree();
1366 AliRawEvent *event = new AliRawEvent;
1367 currTree->SetBranchAddress("rawevent",&event);
1368 currTree->GetEntry(entry);
1369 fRawReader = new AliRawReaderRoot(event);
1370 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1371 delete fRawReader;
1372 fRawReader = NULL;
1373 delete event;
1374
1375 return fStatus;
1376}
1377
1378//_____________________________________________________________________________
1379void AliReconstruction::Init(TTree *tree)
1380{
1381 if (tree == 0) {
1382 AliError("The input tree is not found!");
1383 return;
1384 }
1385 fChain = tree;
1386}
1387
1388//_____________________________________________________________________________
1389Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
21a3aa09 1390{
1391 // run the reconstruction over a single event
1392 // The event loop is steered in Run method
1393
1394 AliCodeTimerAuto("");
1395
1396 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1397 fRunLoader->SetEventNumber(iEvent);
1398 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1399 iEvent, iEvent);
21a3aa09 1400 fRunLoader->TreeE()->Fill();
4b71572b 1401 if (fRawReader && fRawReader->UseAutoSaveESD())
1402 fRunLoader->TreeE()->AutoSave("SaveSelf");
21a3aa09 1403 }
1404
1405 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
21a3aa09 1406 return kTRUE;
1407 }
1408
1409 AliInfo(Form("processing event %d", iEvent));
aa3c69a9 1410
7e88424f 1411 // Fill Event-info object
1412 GetEventInfo();
1413 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
1414
a00021a7 1415 // Set the reco-params
1416 {
1417 TString detStr = fLoadCDB;
1418 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1419 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1420 AliReconstructor *reconstructor = GetReconstructor(iDet);
1421 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1422 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1423 reconstructor->SetRecoParam(par);
1424 }
1425 }
1426 }
1427
4b71572b 1428 fRunLoader->GetEvent(iEvent);
24f7a148 1429
ca13fb87 1430 // QA on single raw
930e6e3e 1431 if (fRunQA)
e84c88f5 1432 fQASteer->RunOneEvent(fRawReader) ;
ca13fb87 1433
d506c543 1434 // local single event reconstruction
b26c3770 1435 if (!fRunLocalReconstruction.IsNull()) {
d506c543 1436 TString detectors=fRunLocalReconstruction;
a441bf51 1437 // run HLT event reconstruction first
d506c543 1438 // ;-( IsSelected changes the string
1439 if (IsSelected("HLT", detectors) &&
1440 !RunLocalEventReconstruction("HLT")) {
4b71572b 1441 if (fStopOnError) {CleanUp(); return kFALSE;}
a441bf51 1442 }
1443 detectors=fRunLocalReconstruction;
1444 detectors.ReplaceAll("HLT", "");
1445 if (!RunLocalEventReconstruction(detectors)) {
4b71572b 1446 if (fStopOnError) {CleanUp(); return kFALSE;}
b26c3770 1447 }
1448 }
1449
21a3aa09 1450 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1451 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1452 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1453 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 1454
d6ee376f 1455 // Set magnetic field from the tracker
21a3aa09 1456 fesd->SetMagneticField(AliTracker::GetBz());
1457 fhltesd->SetMagneticField(AliTracker::GetBz());
596a855f 1458
71f6cda4 1459 // Set most probable pt, for B=0 tracking
1460 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
1461 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
46698ae4 1462
2e3550da 1463 // Fill raw-data error log into the ESD
21a3aa09 1464 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1465
2257f27e 1466 // vertex finder
1467 if (fRunVertexFinder) {
4b71572b 1468 if (!RunVertexFinder(fesd)) {
1469 if (fStopOnError) {CleanUp(); return kFALSE;}
2257f27e 1470 }
1471 }
1472
e66fbafb 1473 // Muon tracking
b8cd5251 1474 if (!fRunTracking.IsNull()) {
e66fbafb 1475 if (fRunMuonTracking) {
21a3aa09 1476 if (!RunMuonTracking(fesd)) {
4b71572b 1477 if (fStopOnError) {CleanUp(); return kFALSE;}
24f7a148 1478 }
596a855f 1479 }
1480 }
1481
e66fbafb 1482 // barrel tracking
1483 if (!fRunTracking.IsNull()) {
4b71572b 1484 if (!RunTracking(fesd)) {
1485 if (fStopOnError) {CleanUp(); return kFALSE;}
e66fbafb 1486 }
1487 }
21c573b7 1488
596a855f 1489 // fill ESD
1490 if (!fFillESD.IsNull()) {
d506c543 1491 TString detectors=fFillESD;
f6806ad3 1492 // run HLT first and on hltesd
d506c543 1493 // ;-( IsSelected changes the string
1494 if (IsSelected("HLT", detectors) &&
1495 !FillESD(fhltesd, "HLT")) {
4b71572b 1496 if (fStopOnError) {CleanUp(); return kFALSE;}
f6806ad3 1497 }
1498 detectors=fFillESD;
d5105682 1499 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1500 if (detectors.Contains("ALL")) {
1501 detectors="";
1502 for (Int_t idet=0; idet<fgkNDetectors; ++idet){
1503 detectors += fgkDetectorName[idet];
1504 detectors += " ";
1505 }
1506 }
f6806ad3 1507 detectors.ReplaceAll("HLT", "");
1508 if (!FillESD(fesd, detectors)) {
4b71572b 1509 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 1510 }
1511 }
a5fa6165 1512
001397cd 1513 // fill Event header information from the RawEventHeader
21a3aa09 1514 if (fRawReader){FillRawEventHeaderESD(fesd);}
596a855f 1515
1516 // combined PID
21a3aa09 1517 AliESDpid::MakePID(fesd);
596a855f 1518
b647652d 1519 if (fFillTriggerESD) {
4b71572b 1520 if (!FillTriggerESD(fesd)) {
1521 if (fStopOnError) {CleanUp(); return kFALSE;}
b647652d 1522 }
1523 }
1524
21a3aa09 1525 ffile->cd();
a6ee503a 1526
3c3709c4 1527 //
67be5c77 1528 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1529 //
21a3aa09 1530 const Int_t ntracks = fesd->GetNumberOfTracks();
1531 const Double_t kBz = fesd->GetMagneticField();
3c3709c4 1532 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1533
1534 TObjArray trkArray;
1535 UShort_t *selectedIdx=new UShort_t[ntracks];
1536
1537 for (Int_t itrack=0; itrack<ntracks; itrack++){
1538 const Double_t kMaxStep = 5; //max step over the material
1539 Bool_t ok;
1540
21a3aa09 1541 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1542 if (!track) continue;
1543
1544 AliExternalTrackParam *tpcTrack =
1545 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1546 ok = kFALSE;
1547 if (tpcTrack)
1548 ok = AliTracker::
1549 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
43c9dae1 1550
3c3709c4 1551 if (ok) {
1552 Int_t n=trkArray.GetEntriesFast();
1553 selectedIdx[n]=track->GetID();
1554 trkArray.AddLast(tpcTrack);
1555 }
1556
3d65e645 1557 //Tracks refitted by ITS should already be at the SPD vertex
1558 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1559
1560 AliTracker::
1561 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1562 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
3c3709c4 1563
3c3709c4 1564 }
1565
1566 //
1567 // Improve the reconstructed primary vertex position using the tracks
1568 //
59224b2b 1569 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1570 if(fesd->GetPrimaryVertexSPD()) {
1571 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1572 if(vtitle.Contains("cosmics")) {
1573 runVertexFinderTracks=kFALSE;
1574 }
c060d7fe 1575 }
a00021a7 1576
1577 if (runVertexFinderTracks) {
1578 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
1579 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
1580
3c3709c4 1581 // TPC + ITS primary vertex
f09c879d 1582 ftVertexer->SetITSMode();
a00021a7 1583 // get cuts for vertexer from AliGRPRecoParam
1584 if (grpRecoParam) {
1585 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1586 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1587 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1588 ftVertexer->SetCuts(cutsVertexer);
1589 delete [] cutsVertexer; cutsVertexer = NULL;
1590 }
43c9dae1 1591 if(fDiamondProfile && fMeanVertexConstraint) {
21a3aa09 1592 ftVertexer->SetVtxStart(fDiamondProfile);
43c9dae1 1593 } else {
21a3aa09 1594 ftVertexer->SetConstraintOff();
43c9dae1 1595 }
21a3aa09 1596 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 1597 if (pvtx) {
1598 if (pvtx->GetStatus()) {
21a3aa09 1599 fesd->SetPrimaryVertex(pvtx);
3c3709c4 1600 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 1601 AliESDtrack *t = fesd->GetTrack(i);
3d65e645 1602 t->RelateToVertex(pvtx, kBz, kVeryBig);
3c3709c4 1603 }
1604 }
1605 }
1606
1607 // TPC-only primary vertex
f09c879d 1608 ftVertexer->SetTPCMode();
a00021a7 1609 // get cuts for vertexer from AliGRPRecoParam
1610 if (grpRecoParam) {
1611 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1612 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1613 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1614 ftVertexer->SetCuts(cutsVertexer);
1615 delete [] cutsVertexer; cutsVertexer = NULL;
1616 }
43c9dae1 1617 if(fDiamondProfileTPC && fMeanVertexConstraint) {
21a3aa09 1618 ftVertexer->SetVtxStart(fDiamondProfileTPC);
43c9dae1 1619 } else {
21a3aa09 1620 ftVertexer->SetConstraintOff();
43c9dae1 1621 }
21a3aa09 1622 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 1623 if (pvtx) {
1624 if (pvtx->GetStatus()) {
21a3aa09 1625 fesd->SetPrimaryVertexTPC(pvtx);
3d65e645 1626 for (Int_t i=0; i<ntracks; i++) {
1627 AliESDtrack *t = fesd->GetTrack(i);
1628 t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
3c3709c4 1629 }
1630 }
1631 }
1632
1633 }
1634 delete[] selectedIdx;
1635
21a3aa09 1636 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
17c86e90 1637
c5e3e5d1 1638
d1683eef 1639 if (fRunV0Finder) {
1640 // V0 finding
1641 AliV0vertexer vtxer;
21a3aa09 1642 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 1643
d1683eef 1644 if (fRunCascadeFinder) {
1645 // Cascade finding
1646 AliCascadeVertexer cvtxer;
21a3aa09 1647 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 1648 }
5e4ff34d 1649 }
1650
596a855f 1651 // write ESD
21a3aa09 1652 if (fCleanESD) CleanESD(fesd);
854c6476 1653
bea94759 1654 if (fRunQA)
1655 fQASteer->RunOneEvent(fesd) ;
1656
1657 if (fRunGlobalQA) {
0d106d88 1658 AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1659 if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
bea94759 1660 qadm->Exec(AliQA::kESDS, fesd);
b8bd1ab8 1661 }
854c6476 1662
1d99986f 1663 if (fWriteESDfriend) {
b090e6a3 1664 // fesdf->~AliESDfriend();
1665 // new (fesdf) AliESDfriend(); // Reset...
21a3aa09 1666 fesd->GetESDfriend(fesdf);
1d99986f 1667 }
21a3aa09 1668 ftree->Fill();
500d54ab 1669
2d91a353 1670 // Auto-save the ESD tree in case of prompt reco @P2
be103ac8 1671 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2d91a353 1672 ftree->AutoSave("SaveSelf");
be103ac8 1673 TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1674 if (friendfile) friendfile->Save();
1675 }
2d91a353 1676
500d54ab 1677 // write HLT ESD
21a3aa09 1678 fhlttree->Fill();
1d99986f 1679
14dd053c 1680 // call AliEVE
1681 if (fRunAliEVE) RunAliEVE();
1682
21a3aa09 1683 fesd->Reset();
1684 fhltesd->Reset();
5728d3d5 1685 if (fWriteESDfriend) {
21a3aa09 1686 fesdf->~AliESDfriend();
1687 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 1688 }
a5fa6165 1689
21a3aa09 1690 ProcInfo_t ProcInfo;
95cee32f 1691 gSystem->GetProcInfo(&ProcInfo);
1692 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
a5fa6165 1693
ca13fb87 1694 fEventInfo.Reset();
1695 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1696 if (fReconstructor[iDet])
a00021a7 1697 fReconstructor[iDet]->SetRecoParam(NULL);
ca13fb87 1698 }
1699
53c8f690 1700 if (fRunQA || fRunGlobalQA)
1701 fQASteer->Increment() ;
1702
ca13fb87 1703 return kTRUE;
21a3aa09 1704}
1705
21a3aa09 1706//_____________________________________________________________________________
4b71572b 1707void AliReconstruction::SlaveTerminate()
21a3aa09 1708{
4b71572b 1709 // Finalize the run on the slave side
21a3aa09 1710 // Called after the exit
1711 // from the event loop
1712 AliCodeTimerAuto("");
1713
1714 if (fIsNewRunLoader) { // galice.root didn't exist
1715 fRunLoader->WriteHeader("OVERWRITE");
1716 fRunLoader->CdGAFile();
1717 fRunLoader->Write(0, TObject::kOverwrite);
1718 }
1719
f747912b 1720 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1721 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1722
1723 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1724 cdbMapCopy->SetOwner(1);
1725 cdbMapCopy->SetName("cdbMap");
1726 TIter iter(cdbMap->GetTable());
1727
1728 TPair* pair = 0;
1729 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1730 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1731 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1732 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1733 }
1734
1735 TList *cdbListCopy = new TList();
1736 cdbListCopy->SetOwner(1);
1737 cdbListCopy->SetName("cdbList");
1738
1739 TIter iter2(cdbList);
1740
b940cb9b 1741 AliCDBId* id=0;
e84c88f5 1742 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1743 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1744 }
1745
21a3aa09 1746 ftree->GetUserInfo()->Add(cdbMapCopy);
1747 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1748
46698ae4 1749
1750 if(fESDPar.Contains("ESD.par")){
1751 AliInfo("Attaching ESD.par to Tree");
1752 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
21a3aa09 1753 ftree->GetUserInfo()->Add(fn);
596a855f 1754 }
1755
46698ae4 1756
21a3aa09 1757 ffile->cd();
aa3c69a9 1758
a9c0e6db 1759 if (fWriteESDfriend)
21a3aa09 1760 ftree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1761 // we want to have only one tree version number
21a3aa09 1762 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1763 fhlttree->Write();
f3a97c86 1764
a7a1e1c7 1765// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1766 if (fRunPlaneEff && !FinishPlaneEff()) {
1767 AliWarning("Finish PlaneEff evaluation failed");
1768 }
1769
930e6e3e 1770 // End of cycle for the in-loop
1771 if (fRunQA) {
930e6e3e 1772 fQASteer->EndOfCycle() ;
1773 }
1774 if (fRunGlobalQA) {
4b71572b 1775 AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1776 if (qadm) {
1777 if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
930e6e3e 1778 qadm->EndOfCycle(AliQA::kRECPOINTS);
4b71572b 1779 if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
930e6e3e 1780 qadm->EndOfCycle(AliQA::kESDS);
4b71572b 1781 qadm->Finish();
1782 }
a7807689 1783 }
4b71572b 1784 gROOT->cd();
1785 CleanUp();
1786}
1787
1788//_____________________________________________________________________________
1789void AliReconstruction::Terminate()
1790{
f3a97c86 1791 // Create tags for the events in the ESD tree (the ESD tree is always present)
1792 // In case of empty events the tags will contain dummy values
4b71572b 1793 AliCodeTimerAuto("");
1794
08e1a23e 1795 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
6b6e4472 1796 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
e84c88f5 1797
795e4a22 1798 // Cleanup of CDB manager: cache and active storages!
1799 AliCDBManager::Instance()->ClearCache();
596a855f 1800}
1801
b26c3770 1802//_____________________________________________________________________________
1803Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1804{
1805// run the local reconstruction
aa3c69a9 1806
0f88822a 1807 static Int_t eventNr=0;
87932dab 1808 AliCodeTimerAuto("")
b26c3770 1809
1810 TString detStr = detectors;
1811 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1812 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1813 AliReconstructor* reconstructor = GetReconstructor(iDet);
1814 if (!reconstructor) continue;
1815 AliLoader* loader = fLoader[iDet];
f6806ad3 1816 // Matthias April 2008: temporary fix to run HLT reconstruction
1817 // although the HLT loader is missing
1818 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1819 if (fRawReader) {
1820 reconstructor->Reconstruct(fRawReader, NULL);
1821 } else {
1822 TTree* dummy=NULL;
1823 reconstructor->Reconstruct(dummy, NULL);
1824 }
1825 continue;
1826 }
d76c31f4 1827 if (!loader) {
1828 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1829 continue;
1830 }
b26c3770 1831 // conversion of digits
1832 if (fRawReader && reconstructor->HasDigitConversion()) {
1833 AliInfo(Form("converting raw data digits into root objects for %s",
1834 fgkDetectorName[iDet]));
30bbd491 1835// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1836// fgkDetectorName[iDet]));
b26c3770 1837 loader->LoadDigits("update");
1838 loader->CleanDigits();
1839 loader->MakeDigitsContainer();
1840 TTree* digitsTree = loader->TreeD();
1841 reconstructor->ConvertDigits(fRawReader, digitsTree);
1842 loader->WriteDigits("OVERWRITE");
1843 loader->UnloadDigits();
b26c3770 1844 }
b26c3770 1845 // local reconstruction
b26c3770 1846 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
30bbd491 1847 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 1848 loader->LoadRecPoints("update");
1849 loader->CleanRecPoints();
1850 loader->MakeRecPointsContainer();
1851 TTree* clustersTree = loader->TreeR();
1852 if (fRawReader && !reconstructor->HasDigitConversion()) {
1853 reconstructor->Reconstruct(fRawReader, clustersTree);
1854 } else {
1855 loader->LoadDigits("read");
1856 TTree* digitsTree = loader->TreeD();
1857 if (!digitsTree) {
1858 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1859 if (fStopOnError) return kFALSE;
1860 } else {
1861 reconstructor->Reconstruct(digitsTree, clustersTree);
1862 }
1863 loader->UnloadDigits();
1864 }
d76c31f4 1865
30bbd491 1866 TString detQAStr(fQADetectors) ;
930e6e3e 1867 if (fRunQA)
e84c88f5 1868 fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
1869
1870 loader->WriteRecPoints("OVERWRITE");
1871 loader->UnloadRecPoints();
1872 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
a00021a7 1873 }
1874 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
b26c3770 1875 AliError(Form("the following detectors were not found: %s",
1876 detStr.Data()));
1877 if (fStopOnError) return kFALSE;
1878 }
0f88822a 1879 eventNr++;
b26c3770 1880 return kTRUE;
1881}
1882
596a855f 1883//_____________________________________________________________________________
af885e0f 1884Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 1885{
1886// run the barrel tracking
1887
87932dab 1888 AliCodeTimerAuto("")
030b532d 1889
2257f27e 1890 AliESDVertex* vertex = NULL;
1891 Double_t vtxPos[3] = {0, 0, 0};
1892 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1893 TArrayF mcVertex(3);
a6b0b91b 1894 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1895 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1896 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1897 }
2257f27e 1898
b8cd5251 1899 if (fVertexer) {
815c2b38 1900 AliInfo("running the ITS vertex finder");
308c2f7c 1901 if (fLoader[0]) {
1902 fLoader[0]->LoadRecPoints();
1903 TTree* cltree = fLoader[0]->TreeR();
1904 if (cltree) {
1905 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1906 vertex = fVertexer->FindVertexForCurrentEvent(cltree);
1907 }
1908 else {
1909 AliError("Can't get the ITS cluster tree");
1910 }
1911 fLoader[0]->UnloadRecPoints();
1912 }
1913 else {
1914 AliError("Can't get the ITS loader");
1915 }
2257f27e 1916 if(!vertex){
815c2b38 1917 AliWarning("Vertex not found");
c710f220 1918 vertex = new AliESDVertex();
d1a50cb5 1919 vertex->SetName("default");
2257f27e 1920 }
1921 else {
d1a50cb5 1922 vertex->SetName("reconstructed");
2257f27e 1923 }
1924
1925 } else {
815c2b38 1926 AliInfo("getting the primary vertex from MC");
2257f27e 1927 vertex = new AliESDVertex(vtxPos, vtxErr);
1928 }
1929
1930 if (vertex) {
1931 vertex->GetXYZ(vtxPos);
1932 vertex->GetSigmaXYZ(vtxErr);
1933 } else {
815c2b38 1934 AliWarning("no vertex reconstructed");
2257f27e 1935 vertex = new AliESDVertex(vtxPos, vtxErr);
1936 }
06cc9d95 1937 esd->SetPrimaryVertexSPD(vertex);
32e449be 1938 // if SPD multiplicity has been determined, it is stored in the ESD
25be1e5c 1939 AliMultiplicity *mult = fVertexer->GetMultiplicity();
32e449be 1940 if(mult)esd->SetMultiplicity(mult);
1941
b8cd5251 1942 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1943 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1944 }
2257f27e 1945 delete vertex;
1946
2257f27e 1947 return kTRUE;
1948}
1949
1f46a9ae 1950//_____________________________________________________________________________
af885e0f 1951Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 1952{
1953// run the HLT barrel tracking
1954
87932dab 1955 AliCodeTimerAuto("")
1f46a9ae 1956
1957 if (!fRunLoader) {
1958 AliError("Missing runLoader!");
1959 return kFALSE;
1960 }
1961
1962 AliInfo("running HLT tracking");
1963
1964 // Get a pointer to the HLT reconstructor
1965 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1966 if (!reconstructor) return kFALSE;
1967
1968 // TPC + ITS
1969 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1970 TString detName = fgkDetectorName[iDet];
1971 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1972 reconstructor->SetOption(detName.Data());
d76c31f4 1973 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 1974 if (!tracker) {
1975 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1976 if (fStopOnError) return kFALSE;
9dcc06e1 1977 continue;
1f46a9ae 1978 }
1979 Double_t vtxPos[3];
1980 Double_t vtxErr[3]={0.005,0.005,0.010};
1981 const AliESDVertex *vertex = esd->GetVertex();
1982 vertex->GetXYZ(vtxPos);
1983 tracker->SetVertex(vtxPos,vtxErr);
1984 if(iDet != 1) {
1985 fLoader[iDet]->LoadRecPoints("read");
1986 TTree* tree = fLoader[iDet]->TreeR();
1987 if (!tree) {
1988 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1989 return kFALSE;
1990 }
1991 tracker->LoadClusters(tree);
1992 }
1993 if (tracker->Clusters2Tracks(esd) != 0) {
1994 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1995 return kFALSE;
1996 }
1997 if(iDet != 1) {
1998 tracker->UnloadClusters();
1999 }
2000 delete tracker;
2001 }
2002
1f46a9ae 2003 return kTRUE;
2004}
2005
e66fbafb 2006//_____________________________________________________________________________
af885e0f 2007Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 2008{
2009// run the muon spectrometer tracking
2010
87932dab 2011 AliCodeTimerAuto("")
e66fbafb 2012
2013 if (!fRunLoader) {
2014 AliError("Missing runLoader!");
2015 return kFALSE;
2016 }
2017 Int_t iDet = 7; // for MUON
2018
2019 AliInfo("is running...");
2020
2021 // Get a pointer to the MUON reconstructor
2022 AliReconstructor *reconstructor = GetReconstructor(iDet);
2023 if (!reconstructor) return kFALSE;
2024
2025
2026 TString detName = fgkDetectorName[iDet];
2027 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 2028 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 2029 if (!tracker) {
2030 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2031 return kFALSE;
2032 }
2033
e66fbafb 2034 // read RecPoints
761350a6 2035 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 2036
761350a6 2037 tracker->LoadClusters(fLoader[iDet]->TreeR());
2038
2039 Int_t rv = tracker->Clusters2Tracks(esd);
2040
761350a6 2041 if ( rv )
2042 {
e66fbafb 2043 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2044 return kFALSE;
2045 }
761350a6 2046
e66fbafb 2047 fLoader[iDet]->UnloadRecPoints();
2048
c1954ee5 2049 tracker->UnloadClusters();
2050
e66fbafb 2051 delete tracker;
2052
e66fbafb 2053 return kTRUE;
2054}
2055
2056
2257f27e 2057//_____________________________________________________________________________
af885e0f 2058Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 2059{
2060// run the barrel tracking
0f88822a 2061 static Int_t eventNr=0;
87932dab 2062 AliCodeTimerAuto("")
24f7a148 2063
815c2b38 2064 AliInfo("running tracking");
596a855f 2065
91b876d1 2066 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 2067 if (fReconstructor[11] && fLoader[11]) {
2068 fLoader[11]->LoadRecPoints("READ");
2069 TTree *treeR = fLoader[11]->TreeR();
2070 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2071 }
91b876d1 2072
b8cd5251 2073 // pass 1: TPC + ITS inwards
2074 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2075 if (!fTracker[iDet]) continue;
2076 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 2077
b8cd5251 2078 // load clusters
2079 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2080 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 2081 TTree* tree = fLoader[iDet]->TreeR();
2082 if (!tree) {
2083 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 2084 return kFALSE;
2085 }
b8cd5251 2086 fTracker[iDet]->LoadClusters(tree);
6efecea1 2087 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2088 // run tracking
2089 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2090 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 2091 return kFALSE;
2092 }
878e1fe1 2093 // preliminary PID in TPC needed by the ITS tracker
2094 if (iDet == 1) {
b26c3770 2095 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 2096 AliESDpid::MakePID(esd);
0f88822a 2097 }
6efecea1 2098 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 2099 }
596a855f 2100
b8cd5251 2101 // pass 2: ALL backwards
aa3c69a9 2102
b8cd5251 2103 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2104 if (!fTracker[iDet]) continue;
2105 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2106
2107 // load clusters
2108 if (iDet > 1) { // all except ITS, TPC
2109 TTree* tree = NULL;
7b61cd9c 2110 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2111 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 2112 tree = fLoader[iDet]->TreeR();
b8cd5251 2113 if (!tree) {
2114 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 2115 return kFALSE;
2116 }
0f88822a 2117 fTracker[iDet]->LoadClusters(tree);
6efecea1 2118 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2119 }
24f7a148 2120
b8cd5251 2121 // run tracking
283f39c6 2122 if (iDet>1) // start filling residuals for the "outer" detectors
2123 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
2124
b8cd5251 2125 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2126 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 2127 // return kFALSE;
b8cd5251 2128 }
24f7a148 2129
b8cd5251 2130 // unload clusters
6e65648b 2131 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
b8cd5251 2132 fTracker[iDet]->UnloadClusters();
7b61cd9c 2133 fLoader[iDet]->UnloadRecPoints();
b8cd5251 2134 }
8f37df88 2135 // updated PID in TPC needed by the ITS tracker -MI
2136 if (iDet == 1) {
8f37df88 2137 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2138 AliESDpid::MakePID(esd);
2139 }
6efecea1 2140 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 2141 }
283f39c6 2142 //stop filling residuals for the "outer" detectors
2143 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
596a855f 2144
b8cd5251 2145 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 2146
b8cd5251 2147 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2148 if (!fTracker[iDet]) continue;
2149 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 2150
b8cd5251 2151 // run tracking
283f39c6 2152 if (iDet<2) // start filling residuals for TPC and ITS
2153 if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
2154
b8cd5251 2155 if (fTracker[iDet]->RefitInward(esd) != 0) {
2156 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 2157 // return kFALSE;
b8cd5251 2158 }
db2368d0 2159 // run postprocessing
2160 if (fTracker[iDet]->PostProcess(esd) != 0) {
2161 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2162 // return kFALSE;
2163 }
6efecea1 2164 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
6e65648b 2165 }
2166
2167 // write space-points to the ESD in case alignment data output
2168 // is switched on
2169 if (fWriteAlignmentData)
2170 WriteAlignmentData(esd);
2171
2172 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2173 if (!fTracker[iDet]) continue;
b8cd5251 2174 // unload clusters
2175 fTracker[iDet]->UnloadClusters();
6efecea1 2176 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 2177 fLoader[iDet]->UnloadRecPoints();
6efecea1 2178 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 2179 }
283f39c6 2180 // stop filling residuals for TPC and ITS
3b378a42 2181 if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
854c6476 2182
0f88822a 2183 eventNr++;
596a855f 2184 return kTRUE;
2185}
2186
d64bd07d 2187//_____________________________________________________________________________
2188Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2189 //
2190 // Remove the data which are not needed for the physics analysis.
2191 //
2192
d64bd07d 2193 Int_t nTracks=esd->GetNumberOfTracks();
18571674 2194 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 2195 AliInfo
2196 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 2197
18571674 2198 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 2199 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 2200
7f68891d 2201 nTracks=esd->GetNumberOfTracks();
18571674 2202 nV0s=esd->GetNumberOfV0s();
cf37fd88 2203 AliInfo
ae5d5566 2204 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 2205
7f68891d 2206 return rc;
d64bd07d 2207}
2208
596a855f 2209//_____________________________________________________________________________
af885e0f 2210Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 2211{
2212// fill the event summary data
2213
87932dab 2214 AliCodeTimerAuto("")
0f88822a 2215 static Int_t eventNr=0;
596a855f 2216 TString detStr = detectors;
abe0c04e 2217
b8cd5251 2218 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
abe0c04e 2219 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 2220 AliReconstructor* reconstructor = GetReconstructor(iDet);
2221 if (!reconstructor) continue;
4b71572b 2222 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2223 TTree* clustersTree = NULL;
2224 if (fLoader[iDet]) {
2225 fLoader[iDet]->LoadRecPoints("read");
2226 clustersTree = fLoader[iDet]->TreeR();
2227 if (!clustersTree) {
2228 AliError(Form("Can't get the %s clusters tree",
2229 fgkDetectorName[iDet]));
2230 if (fStopOnError) return kFALSE;
2231 }
2232 }
2233 if (fRawReader && !reconstructor->HasDigitConversion()) {
2234 reconstructor->FillESD(fRawReader, clustersTree, esd);
2235 } else {
2236 TTree* digitsTree = NULL;
d76c31f4 2237 if (fLoader[iDet]) {
4b71572b 2238 fLoader[iDet]->LoadDigits("read");
2239 digitsTree = fLoader[iDet]->TreeD();
2240 if (!digitsTree) {
2241 AliError(Form("Can't get the %s digits tree",
b26c3770 2242 fgkDetectorName[iDet]));
2243 if (fStopOnError) return kFALSE;
2244 }
2245 }
4b71572b 2246 reconstructor->FillESD(digitsTree, clustersTree, esd);
2247 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2248 }
2249 if (fLoader[iDet]) {
2250 fLoader[iDet]->UnloadRecPoints();
596a855f 2251 }
2252 }
2253
2254 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 2255 AliError(Form("the following detectors were not found: %s",
2256 detStr.Data()));
596a855f 2257 if (fStopOnError) return kFALSE;
2258 }
6efecea1 2259 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 2260 eventNr++;
596a855f 2261 return kTRUE;
2262}
2263
b647652d 2264//_____________________________________________________________________________
af885e0f 2265Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 2266{
2267 // Reads the trigger decision which is
2268 // stored in Trigger.root file and fills
2269 // the corresponding esd entries
2270
87932dab 2271 AliCodeTimerAuto("")
2272
b647652d 2273 AliInfo("Filling trigger information into the ESD");
2274
2275 if (fRawReader) {
2276 AliCTPRawStream input(fRawReader);
2277 if (!input.Next()) {
7e88424f 2278 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
b647652d 2279 }
2280 else {
7e88424f 2281 if (esd->GetTriggerMask() != input.GetClassMask())
2282 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2283 input.GetClassMask(),esd->GetTriggerMask()));
2284 if (esd->GetOrbitNumber() != input.GetOrbitID())
2285 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2286 input.GetOrbitID(),esd->GetOrbitNumber()));
2287 if (esd->GetBunchCrossNumber() != input.GetBCID())
2288 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2289 input.GetBCID(),esd->GetBunchCrossNumber()));
b647652d 2290 }
b024fd7f 2291
7e88424f 2292 // Here one has to add the filling of trigger inputs and
2293 // interaction records
2294 // ...
b024fd7f 2295 }
b647652d 2296 return kTRUE;
2297}
596a855f 2298
001397cd 2299
2300
2301
2302
2303//_____________________________________________________________________________
af885e0f 2304Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 2305{
2306 //
2307 // Filling information from RawReader Header
2308 //
2309
151bea4e 2310 if (!fRawReader) return kFALSE;
2311
001397cd 2312 AliInfo("Filling information from RawReader Header");
151bea4e 2313
2314 esd->SetBunchCrossNumber(fRawReader->GetBCID());
2315 esd->SetOrbitNumber(fRawReader->GetOrbitID());
2316 esd->SetPeriodNumber(fRawReader->GetPeriod());
2317
2318 esd->SetTimeStamp(fRawReader->GetTimestamp());
2319 esd->SetEventType(fRawReader->GetType());
001397cd 2320
2321 return kTRUE;
2322}
2323
2324
596a855f 2325//_____________________________________________________________________________
2326Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2327{
2328// check whether detName is contained in detectors
2329// if yes, it is removed from detectors
2330
2331 // check if all detectors are selected
2332 if ((detectors.CompareTo("ALL") == 0) ||
2333 detectors.BeginsWith("ALL ") ||
2334 detectors.EndsWith(" ALL") ||
2335 detectors.Contains(" ALL ")) {
2336 detectors = "ALL";
2337 return kTRUE;
2338 }
2339
2340 // search for the given detector
2341 Bool_t result = kFALSE;
2342 if ((detectors.CompareTo(detName) == 0) ||
2343 detectors.BeginsWith(detName+" ") ||
2344 detectors.EndsWith(" "+detName) ||
2345 detectors.Contains(" "+detName+" ")) {
2346 detectors.ReplaceAll(detName, "");
2347 result = kTRUE;
2348 }
2349
2350 // clean up the detectors string
2351 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2352 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2353 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2354
2355 return result;
2356}
e583c30d 2357
f08fc9f5 2358//_____________________________________________________________________________
2359Bool_t AliReconstruction::InitRunLoader()
2360{
2361// get or create the run loader
2362
2363 if (gAlice) delete gAlice;
2364 gAlice = NULL;
2365
b26c3770 2366 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2367 // load all base libraries to get the loader classes
2368 TString libs = gSystem->GetLibraries();
2369 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2370 TString detName = fgkDetectorName[iDet];
2371 if (detName == "HLT") continue;
2372 if (libs.Contains("lib" + detName + "base.so")) continue;
2373 gSystem->Load("lib" + detName + "base.so");
2374 }
f08fc9f5 2375 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2376 if (!fRunLoader) {
2377 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2378 CleanUp();
2379 return kFALSE;
2380 }
325aa76f 2381
b26c3770 2382 fRunLoader->CdGAFile();
325aa76f 2383 fRunLoader->LoadgAlice();
f08fc9f5 2384
6cae184e 2385 //PH This is a temporary fix to give access to the kinematics
2386 //PH that is needed for the labels of ITS clusters
f2ee4290 2387 fRunLoader->LoadHeader();
6cae184e 2388 fRunLoader->LoadKinematics();
2389
f08fc9f5 2390 } else { // galice.root does not exist
2391 if (!fRawReader) {
2392 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
f08fc9f5 2393 }
2394 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2395 AliConfig::GetDefaultEventFolderName(),
2396 "recreate");
2397 if (!fRunLoader) {
2398 AliError(Form("could not create run loader in file %s",
2399 fGAliceFileName.Data()));
2400 CleanUp();
2401 return kFALSE;
2402 }
21a3aa09 2403 fIsNewRunLoader = kTRUE;
f08fc9f5 2404 fRunLoader->MakeTree("E");
21a3aa09 2405
973388c2 2406 if (fNumberOfEventsPerFile > 0)
2407 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2408 else
21a3aa09 2409 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
f08fc9f5 2410 }
2411
2412 return kTRUE;
2413}
2414
c757bafd 2415//_____________________________________________________________________________
b8cd5251 2416AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 2417{
f08fc9f5 2418// get the reconstructor object and the loader for a detector
c757bafd 2419
7e88424f 2420 if (fReconstructor[iDet]) {
2421 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2422 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2423 fReconstructor[iDet]->SetRecoParam(par);
2424 }
2425 return fReconstructor[iDet];
2426 }
b8cd5251 2427
2428 // load the reconstructor object
2429 TPluginManager* pluginManager = gROOT->GetPluginManager();
2430 TString detName = fgkDetectorName[iDet];
2431 TString recName = "Ali" + detName + "Reconstructor";
f0999a9a 2432
2433 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
b8cd5251 2434
b8cd5251 2435 AliReconstructor* reconstructor = NULL;
2436 // first check if a plugin is defined for the reconstructor
2437 TPluginHandler* pluginHandler =
2438 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 2439 // if not, add a plugin for it
2440 if (!pluginHandler) {
b8cd5251 2441 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 2442 TString libs = gSystem->GetLibraries();
2443 if (libs.Contains("lib" + detName + "base.so") ||
2444 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 2445 pluginManager->AddHandler("AliReconstructor", detName,
2446 recName, detName + "rec", recName + "()");
2447 } else {
2448 pluginManager->AddHandler("AliReconstructor", detName,
2449 recName, detName, recName + "()");
c757bafd 2450 }
b8cd5251 2451 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2452 }
2453 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2454 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 2455 }
b8cd5251 2456 if (reconstructor) {
2457 TObject* obj = fOptions.FindObject(detName.Data());
2458 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 2459 reconstructor->Init();
b8cd5251 2460 fReconstructor[iDet] = reconstructor;
2461 }
2462
f08fc9f5 2463 // get or create the loader
2464 if (detName != "HLT") {
2465 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2466 if (!fLoader[iDet]) {
2467 AliConfig::Instance()
2468 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2469 detName, detName);
2470 // first check if a plugin is defined for the loader
bb0901a4 2471 pluginHandler =
f08fc9f5 2472 pluginManager->FindHandler("AliLoader", detName);
2473 // if not, add a plugin for it
2474 if (!pluginHandler) {
2475 TString loaderName = "Ali" + detName + "Loader";
2476 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2477 pluginManager->AddHandler("AliLoader", detName,
2478 loaderName, detName + "base",
2479 loaderName + "(const char*, TFolder*)");
2480 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2481 }
2482 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2483 fLoader[iDet] =
2484 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2485 fRunLoader->GetEventFolder());
2486 }
2487 if (!fLoader[iDet]) { // use default loader
2488 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2489 }
2490 if (!fLoader[iDet]) {
2491 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2492 if (fStopOnError) return NULL;
f08fc9f5 2493 } else {
2494 fRunLoader->AddLoader(fLoader[iDet]);
2495 fRunLoader->CdGAFile();
2496 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2497 fRunLoader->Write(0, TObject::kOverwrite);
2498 }
2499 }
2500 }
2501
7e88424f 2502 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2503 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2504 reconstructor->SetRecoParam(par);
2505 }
b8cd5251 2506 return reconstructor;
c757bafd 2507}
2508
2257f27e 2509//_____________________________________________________________________________
2510Bool_t AliReconstruction::CreateVertexer()
2511{
2512// create the vertexer
2513
b8cd5251 2514 fVertexer = NULL;
2515 AliReconstructor* itsReconstructor = GetReconstructor(0);
59697224 2516 if (itsReconstructor) {
d76c31f4 2517 fVertexer = itsReconstructor->CreateVertexer();
2257f27e 2518 }
b8cd5251 2519 if (!fVertexer) {
815c2b38 2520 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2521 if (fStopOnError) return kFALSE;
2522 }
2523
2524 return kTRUE;
2525}
2526
24f7a148 2527//_____________________________________________________________________________
b8cd5251 2528Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2529{
f08fc9f5 2530// create the trackers
24f7a148 2531
b8cd5251 2532 TString detStr = detectors;
2533 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2534 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2535 AliReconstructor* reconstructor = GetReconstructor(iDet);
2536 if (!reconstructor) continue;
2537 TString detName = fgkDetectorName[iDet];
1f46a9ae 2538 if (detName == "HLT") {
2539 fRunHLTTracking = kTRUE;
2540 continue;
2541 }
e66fbafb 2542 if (detName == "MUON") {
2543 fRunMuonTracking = kTRUE;
2544 continue;
2545 }
2546
f08fc9f5 2547
d76c31f4 2548 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2549 if (!fTracker[iDet] && (iDet < 7)) {
2550 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2551 if (fStopOnError) return kFALSE;
2552 }
6efecea1 2553 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2554 }
2555
24f7a148 2556 return kTRUE;
2557}
2558
e583c30d 2559//_____________________________________________________________________________
4b71572b 2560void AliReconstruction::CleanUp()
e583c30d 2561{
2562// delete trackers and the run loader and close and delete the file
2563
b8cd5251 2564 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2565 delete fReconstructor[iDet];
2566 fReconstructor[iDet] = NULL;
2567 fLoader[iDet] = NULL;
2568 delete fTracker[iDet];
2569 fTracker[iDet] = NULL;
2570 }
4b71572b 2571 delete fRunInfo;
7e88424f 2572 fRunInfo = NULL;
2573
b8cd5251 2574 delete fVertexer;
2575 fVertexer = NULL;
21a3aa09 2576
4b71572b 2577 delete ftVertexer;
21a3aa09 2578 ftVertexer = NULL;
795e4a22 2579
2580 if(!(AliCDBManager::Instance()->GetCacheFlag())) {
4b71572b 2581 delete fDiamondProfile;
2582 fDiamondProfile = NULL;
2583 delete fDiamondProfileTPC;
2584 fDiamondProfileTPC = NULL;
795e4a22 2585 }
e583c30d 2586 delete fRunLoader;
2587 fRunLoader = NULL;
b649205a 2588 delete fRawReader;
2589 fRawReader = NULL;
4b71572b 2590 delete fParentRawReader;
cd0b062e 2591 fParentRawReader=NULL;
e583c30d 2592
4b71572b 2593 if (ffile) {
2594 ffile->Close();
2595 delete ffile;
2596 ffile = NULL;
24f7a148 2597 }
24f7a148 2598}
f3a97c86 2599
af885e0f 2600void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2601{
2602 // Write space-points which are then used in the alignment procedures
6e65648b 2603 // For the moment only ITS, TPC, TRD and TOF
98937d93 2604
98937d93 2605 Int_t ntracks = esd->GetNumberOfTracks();
2606 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2607 {
2608 AliESDtrack *track = esd->GetTrack(itrack);
2609 Int_t nsp = 0;
ef7253ac 2610 Int_t idx[200];
6e65648b 2611 for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
2612 nsp += track->GetNcls(iDet);
2613
2614 if (iDet==0) { // ITS "extra" clusters
2615 track->GetClusters(iDet,idx);
2616 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
2617 }
2618 }
2619
98937d93 2620 if (nsp) {
2621 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2622 track->SetTrackPointArray(sp);
2623 Int_t isptrack = 0;
2624 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2625 AliTracker *tracker = fTracker[iDet];
2626 if (!tracker) continue;
6e65648b 2627 Int_t nspdet = track->GetClusters(iDet,idx);
2628
2629 if (iDet==0) // ITS "extra" clusters
2630 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
2631
98937d93 2632 if (nspdet <= 0) continue;
98937d93 2633 AliTrackPoint p;
2634 Int_t isp = 0;
2635 Int_t isp2 = 0;
4ed6fb1c 2636 while (isp2 < nspdet) {
f3c6e4c9 2637 Bool_t isvalid=kTRUE;
2638
2639 Int_t index=idx[isp++];
2640 if (index < 0) continue;
2641
c12b6e44 2642 TString dets = fgkDetectorName[iDet];
2643 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2644 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2645 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2646 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
f3c6e4c9 2647 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
48ce48d1 2648 } else {
f3c6e4c9 2649 isvalid = tracker->GetTrackPoint(index,p);
48ce48d1 2650 }
2651 isp2++;
98937d93 2652 if (!isvalid) continue;
f3c6e4c9 2653 sp->AddPoint(isptrack,&p); isptrack++;
98937d93 2654 }
98937d93 2655 }
2656 }
2657 }
98937d93 2658}
2e3550da 2659
2660//_____________________________________________________________________________
af885e0f 2661void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 2662{
2663 // The method reads the raw-data error log
2664 // accumulated within the rawReader.
2665 // It extracts the raw-data errors related to
2666 // the current event and stores them into
2667 // a TClonesArray inside the esd object.
2668
2669 if (!fRawReader) return;
2670
2671 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2672
2673 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2674 if (!log) continue;
2675 if (iEvent != log->GetEventNumber()) continue;
2676
2677 esd->AddRawDataErrorLog(log);
2678 }
2679
2680}
46698ae4 2681
605cb8bb 2682TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
b545009a 2683 // Dump a file content into a char in TNamed
46698ae4 2684 ifstream in;
2685 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2686 Int_t kBytes = (Int_t)in.tellg();
2687 printf("Size: %d \n",kBytes);
2688 TNamed *fn = 0;
2689 if(in.good()){
2690 char* memblock = new char [kBytes];
2691 in.seekg (0, ios::beg);
2692 in.read (memblock, kBytes);
2693 in.close();
2694 TString fData(memblock,kBytes);
605cb8bb 2695 fn = new TNamed(pName,fData);
46698ae4 2696 printf("fData Size: %d \n",fData.Sizeof());
605cb8bb 2697 printf("pName Size: %d \n",pName.Sizeof());
46698ae4 2698 printf("fn Size: %d \n",fn->Sizeof());
2699 delete[] memblock;
2700 }
2701 else{
2702 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2703 }
2704
2705 return fn;
2706}
2707
605cb8bb 2708void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
46698ae4 2709 // This is not really needed in AliReconstruction at the moment
2710 // but can serve as a template
2711
2712 TList *fList = fTree->GetUserInfo();
605cb8bb 2713 TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
46698ae4 2714 printf("fn Size: %d \n",fn->Sizeof());
2715
605cb8bb 2716 TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
46698ae4 2717 const char* cdata = fn->GetTitle();
2718 printf("fTmp Size %d\n",fTmp.Sizeof());
2719
2720 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2721 printf("calculated size %d\n",size);
605cb8bb 2722 ofstream out(pName.Data(),ios::out | ios::binary);
46698ae4 2723 out.write(cdata,size);
2724 out.close();
2725
2726}
6efecea1 2727
8661738e 2728//_____________________________________________________________________________
2729void AliReconstruction::CheckQA()
2730{
2731// check the QA of SIM for this run and remove the detectors
2732// with status Fatal
2733
abe0c04e 2734 TString newRunLocalReconstruction ;
2735 TString newRunTracking ;
2736 TString newFillESD ;
2737
8661738e 2738 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2739 TString detName(AliQA::GetDetName(iDet)) ;
96d67a8d 2740 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2741 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
8661738e 2742 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
abe0c04e 2743 } else {
2744 if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2745 fRunLocalReconstruction.Contains("ALL") ) {
2746 newRunLocalReconstruction += detName ;
2747 newRunLocalReconstruction += " " ;
2748 }
2749 if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2750 fRunTracking.Contains("ALL") ) {
2751 newRunTracking += detName ;
2752 newRunTracking += " " ;
2753 }
2754 if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2755 fFillESD.Contains("ALL") ) {
2756 newFillESD += detName ;
2757 newFillESD += " " ;
8661738e 2758 }
2759 }
2760 }
abe0c04e 2761 fRunLocalReconstruction = newRunLocalReconstruction ;
2762 fRunTracking = newRunTracking ;
2763 fFillESD = newFillESD ;
a5fa6165 2764}
5b188f2f 2765
2766//_____________________________________________________________________________
2767Int_t AliReconstruction::GetDetIndex(const char* detector)
2768{
2769 // return the detector index corresponding to detector
2770 Int_t index = -1 ;
2771 for (index = 0; index < fgkNDetectors ; index++) {
2772 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2773 break ;
2774 }
2775 return index ;
2776}
7167ae53 2777//_____________________________________________________________________________
2778Bool_t AliReconstruction::FinishPlaneEff() {
2779 //
2780 // Here execute all the necessary operationis, at the end of the tracking phase,
d7f8fd68 2781 // in case that evaluation of PlaneEfficiencies was required for some detector.
2782 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
7167ae53 2783 //
2784 // This Preliminary version works only FOR ITS !!!!!
2785 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2786 //
2787 // Input: none
d7f8fd68 2788 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
7167ae53 2789 //
2790 Bool_t ret=kFALSE;
2791 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
d7f8fd68 2792 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
7167ae53 2793 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
5fbd4fd6 2794 if(fTracker[iDet]) {
d7f8fd68 2795 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2796 TString name=planeeff->GetName();
2797 name+=".root";
2798 TFile* pefile = TFile::Open(name, "RECREATE");
2799 ret=(Bool_t)planeeff->Write();
2800 pefile->Close();
5fbd4fd6 2801 if(planeeff->GetCreateHistos()) {
d7f8fd68 2802 TString hname=planeeff->GetName();
2803 hname+="Histo.root";
2804 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
5fbd4fd6 2805 }
2806 }
7167ae53 2807 }
2808 return ret;
2809}
2810//_____________________________________________________________________________
2811Bool_t AliReconstruction::InitPlaneEff() {
2812//
2813 // Here execute all the necessary operations, before of the tracking phase,
2814 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2815 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2816 // which should be updated/recalculated.
2817 //
2818 // This Preliminary version will work only FOR ITS !!!!!
2819 // other detectors (TOF,TRD, etc. have to develop their specific codes)
2820 //
2821 // Input: none
2822 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
2823 //
2824 AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2825 return kTRUE;
7520312d 2826}
14dd053c 2827
2828//_____________________________________________________________________________
2829Bool_t AliReconstruction::InitAliEVE()
2830{
2831 // This method should be called only in case
2832 // AliReconstruction is run
2833 // within the alieve environment.
2834 // It will initialize AliEVE in a way
2835 // so that it can visualize event processed
2836 // by AliReconstruction.
2837 // The return flag shows whenever the
2838 // AliEVE initialization was successful or not.
2839
2840 TString macroStr;
2841 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
2842 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
2843 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
2844
47aab29b 2845 gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
de33999e 2846 gROOT->ProcessLine("alieve_online_init()");
14dd053c 2847
2848 return kTRUE;
2849}
2850
2851//_____________________________________________________________________________
2852void AliReconstruction::RunAliEVE()
2853{
2854 // Runs AliEVE visualisation of
2855 // the current event.
2856 // Should be executed only after
2857 // successful initialization of AliEVE.
2858
2859 AliInfo("Running AliEVE...");
2860 gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
14dd053c 2861 gSystem->Run();
2862}
ce43afbe 2863
2864//_____________________________________________________________________________
2865Bool_t AliReconstruction::SetRunQA(TString detAndAction)
2866{
2867 // Allows to run QA for a selected set of detectors
2868 // and a selected set of tasks among RAWS, RECPOINTS and ESDS
2869 // all selected detectors run the same selected tasks
2870
2871 if (!detAndAction.Contains(":")) {
2872 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2873 fRunQA = kFALSE ;
2874 return kFALSE ;
2875 }
2876 Int_t colon = detAndAction.Index(":") ;
2877 fQADetectors = detAndAction(0, colon) ;
2878 if (fQADetectors.Contains("ALL") )
2879 fQADetectors = fFillESD ;
e84c88f5 2880 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
ce43afbe 2881 if (fQATasks.Contains("ALL") ) {
2882 fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
2883 } else {
2884 fQATasks.ToUpper() ;
2885 TString tempo("") ;
2886 if ( fQATasks.Contains("RAW") )
2887 tempo = Form("%d ", AliQA::kRAWS) ;
2888 if ( fQATasks.Contains("RECPOINT") )
2889 tempo += Form("%d ", AliQA::kRECPOINTS) ;
2890 if ( fQATasks.Contains("ESD") )
2891 tempo += Form("%d ", AliQA::kESDS) ;
2892 fQATasks = tempo ;
2893 if (fQATasks.IsNull()) {
2894 AliInfo("No QA requested\n") ;
2895 fRunQA = kFALSE ;
2896 return kTRUE ;
2897 }
2898 }
2899 TString tempo(fQATasks) ;
e84c88f5 2900 tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ;
2901 tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
2902 tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
ce43afbe 2903 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
2904 fRunQA = kTRUE ;
2905 return kTRUE;
2906}
2907
7e88424f 2908//_____________________________________________________________________________
2909Bool_t AliReconstruction::InitRecoParams()
2910{
2911 // The method accesses OCDB and retrieves all
2912 // the available reco-param objects from there.
2913
2914 Bool_t isOK = kTRUE;
2915
7d566c20 2916 TString detStr = fLoadCDB;
7e88424f 2917 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2918
7d566c20 2919 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2920
7e88424f 2921 if (fRecoParam.GetDetRecoParamArray(iDet)) {
2922 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
2923 continue;
2924 }
2925
ac232c75 2926 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
7e88424f 2927
2928 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
2929 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
2930 if(!entry){
2931 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
2932 isOK = kFALSE;
2933 }
2934 else {
2935 TObject *recoParamObj = entry->GetObject();
2936 if (dynamic_cast<TObjArray*>(recoParamObj)) {
2937 // The detector has a normal TobjArray of AliDetectorRecoParam objects
2938 // Registering them in AliRecoParam
2939 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
2940 }
2941 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
2942 // The detector has only onse set of reco parameters
2943 // Registering it in AliRecoParam
ac232c75 2944 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
7e88424f 2945 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
2946 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
2947 }
2948 else {
2949 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
2950 isOK = kFALSE;
2951 }
2952 entry->SetOwner(0);
4b71572b 2953 AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
7e88424f 2954 }
2955 }
2956
e30a9b4d 2957 if (AliDebugLevel() > 0) fRecoParam.Print();
ac232c75 2958
7e88424f 2959 return isOK;
2960}
2961
2962//_____________________________________________________________________________
2963Bool_t AliReconstruction::GetEventInfo()
2964{
2965 // Fill the event info object
2966 // ...
2967 AliCodeTimerAuto("")
2968
2969 AliCentralTrigger *aCTP = NULL;
2970 if (fRawReader) {
2971 fEventInfo.SetEventType(fRawReader->GetType());
2972
2973 ULong64_t mask = fRawReader->GetClassMask();
2974 fEventInfo.SetTriggerMask(mask);
2975 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2976 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
2977
2978 aCTP = new AliCentralTrigger();
2979 TString configstr("");
2980 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
2981 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
2982 delete aCTP;
2983 return kFALSE;
2984 }
2985 aCTP->SetClassMask(mask);
2986 aCTP->SetClusterMask(clmask);
2987 }
2988 else {
2989 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
2990
2991 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
2992 aCTP = fRunLoader->GetTrigger();
2993 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
2994 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
2995 }
2996 else {
2997 AliWarning("No trigger can be loaded! The trigger information will not be used!");
2998 return kFALSE;
2999 }
3000 }
3001
3002 AliTriggerConfiguration *config = aCTP->GetConfiguration();
3003 if (!config) {
3004 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3005 if (fRawReader) delete aCTP;
3006 return kFALSE;
3007 }
3008
a0c2cf2d 3009 UChar_t clustmask = 0;
7e88424f 3010 TString trclasses;
3011 ULong64_t trmask = fEventInfo.GetTriggerMask();
3012 const TObjArray& classesArray = config->GetClasses();
3013 Int_t nclasses = classesArray.GetEntriesFast();
3014 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3015 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3016 if (trclass) {
3017 Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
3018 fesd->SetTriggerClass(trclass->GetName(),trindex);
3019 if (trmask & (1 << trindex)) {
3020 trclasses += " ";
3021 trclasses += trclass->GetName();
3022 trclasses += " ";
a0c2cf2d 3023 clustmask |= trclass->GetCluster()->GetClusterMask();
7e88424f 3024 }
3025 }
3026 }
3027 fEventInfo.SetTriggerClasses(trclasses);
3028
a0c2cf2d 3029 // Set the information in ESD
3030 fesd->SetTriggerMask(trmask);
3031 fesd->SetTriggerCluster(clustmask);
3032
7e88424f 3033 if (!aCTP->CheckTriggeredDetectors()) {
3034 if (fRawReader) delete aCTP;
3035 return kFALSE;
3036 }
3037
3038 if (fRawReader) delete aCTP;
3039
3040 // We have to fill also the HLT decision here!!
3041 // ...
3042
3043 return kTRUE;
3044}
3045