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