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