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