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