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