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