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