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