In vmctest/*/commonConfig.C:
[u/mrichter/AliRoot.git] / 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
1270 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1271
1272 if (entry) {
1273 AliInfo("Found an AliLHCData in GRP/GRP/LHCData, reading it");
1274 AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1275 for (int ib=2;ib--;) {
1276 double intI,intNI;
c7a22819 1277 if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI)>=0)) {
3d84ad67 1278 fBeamInt[ib][0] = intI;
1279 fBeamInt[ib][1] = intNI;
1280 }
1281 }
1282 return kTRUE;
1283 }
1284 return kFALSE;
1285}
1286
1287
52dd4a8c 1288//_____________________________________________________________________________
21a3aa09 1289Bool_t AliReconstruction::Run(const char* input)
596a855f 1290{
21a3aa09 1291 // Run Run Run
52dd4a8c 1292 AliCodeTimerAuto("",0);
596a855f 1293
4b71572b 1294 InitRun(input);
1295 if (GetAbort() != TSelector::kContinue) return kFALSE;
1296
1297 TChain *chain = NULL;
1298 if (fRawReader && (chain = fRawReader->GetChain())) {
2a284cef 1299 Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
4b71572b 1300 // Proof mode
1301 if (gProof) {
52dd4a8c 1302 // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1303 gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
6c6f2624 1304
1305 if (gGrid)
1306 gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1307
1308 TMessage::EnableSchemaEvolutionForAll(kTRUE);
1309 gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1310
4b71572b 1311 gProof->AddInput(this);
81d57268 1312
1313 if (!ParseOutput()) return kFALSE;
1314
975320a0 1315 gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
4b71572b 1316 chain->SetProof();
2a284cef 1317 chain->Process("AliReconstruction","",nEntries,fFirstEvent);
4b71572b 1318 }
1319 else {
2a284cef 1320 chain->Process(this,"",nEntries,fFirstEvent);
4b71572b 1321 }
1322 }
1323 else {
1324 Begin(NULL);
1325 if (GetAbort() != TSelector::kContinue) return kFALSE;
1326 SlaveBegin(NULL);
1327 if (GetAbort() != TSelector::kContinue) return kFALSE;
1328 //******* The loop over events
44e45fac 1329 AliInfo("Starting looping over events");
4b71572b 1330 Int_t iEvent = 0;
1331 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1332 (fRawReader && fRawReader->NextEvent())) {
1333 if (!ProcessEvent(iEvent)) {
930e6e3e 1334 Abort("ProcessEvent",TSelector::kAbortFile);
1335 return kFALSE;
4b71572b 1336 }
1337 iEvent++;
1338 }
1339 SlaveTerminate();
1340 if (GetAbort() != TSelector::kContinue) return kFALSE;
1341 Terminate();
1342 if (GetAbort() != TSelector::kContinue) return kFALSE;
21a3aa09 1343 }
21a3aa09 1344
1345 return kTRUE;
1346}
1347
1348//_____________________________________________________________________________
4b71572b 1349void AliReconstruction::InitRawReader(const char* input)
21a3aa09 1350{
4b71572b 1351 // Init raw-reader and
21a3aa09 1352 // set the input in case of raw data
0a035be5 1353
1354 AliCodeTimerAuto("",0);
1355
4b71572b 1356 if (input) fRawInput = input;
1357 fRawReader = AliRawReader::Create(fRawInput.Data());
c35f192e 1358 if (!fRawReader) {
1359 if (fRawInput.IsNull()) {
1360 AliInfo("Reconstruction will run over digits");
1361 }
1362 else {
1363 AliFatal("Can not create raw-data reader ! Exiting...");
1364 }
1365 }
e0027792 1366
35042093 1367 if (!fEquipIdMap.IsNull() && fRawReader)
1368 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1369
cd0b062e 1370 if (!fUseHLTData.IsNull()) {
1371 // create the RawReaderHLT which performs redirection of HLT input data for
1372 // the specified detectors
1373 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1374 if (pRawReader) {
1375 fParentRawReader=fRawReader;
1376 fRawReader=pRawReader;
1377 } else {
1378 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1379 }
1380 }
4b71572b 1381 AliSysInfo::AddStamp("CreateRawReader");
1382}
cd0b062e 1383
4b71572b 1384//_____________________________________________________________________________
1385void AliReconstruction::InitRun(const char* input)
1386{
1387 // Initialization of raw-reader,
1388 // run number, CDB etc.
52dd4a8c 1389 AliCodeTimerAuto("",0);
4b71572b 1390 AliSysInfo::AddStamp("Start");
1391
002c9d1b 1392 // Initialize raw-reader if any
4b71572b 1393 InitRawReader(input);
596a855f 1394
ec92bee0 1395 // Initialize the CDB storage
795e4a22 1396 InitCDB();
ec92bee0 1397
6bae477a 1398 // Set run number in CDBManager (if it is not already set by the user)
4b71572b 1399 if (!SetRunNumberFromData()) {
1400 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1401 return;
1402 }
002c9d1b 1403
795e4a22 1404 // Set CDB lock: from now on it is forbidden to reset the run number
1405 // or the default storage or to activate any further storage!
1406 SetCDBLock();
1407
002c9d1b 1408}
1409
1410//_____________________________________________________________________________
1411void AliReconstruction::Begin(TTree *)
1412{
1413 // Initialize AlReconstruction before
1414 // going into the event loop
1415 // Should follow the TSelector convention
1416 // i.e. initialize only the object on the client side
52dd4a8c 1417 AliCodeTimerAuto("",0);
db4aeca1 1418
b4fef0d2 1419 AliReconstruction *reco = NULL;
002c9d1b 1420 if (fInput) {
8fb1f1dc 1421 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
002c9d1b 1422 *this = *reco;
002c9d1b 1423 }
1424 AliSysInfo::AddStamp("ReadInputInBegin");
1425 }
1426
6bae477a 1427 // Import ideal TGeo geometry and apply misalignment
1428 if (!gGeoManager) {
1429 TString geom(gSystem->DirName(fGAliceFileName));
1430 geom += "/geometry.root";
98e303d9 1431 AliGeomManager::LoadGeometry(geom.Data());
4b71572b 1432 if (!gGeoManager) {
1433 Abort("LoadGeometry", TSelector::kAbortProcess);
1434 return;
1435 }
281270d3 1436 AliSysInfo::AddStamp("LoadGeom");
ff5970a3 1437 TString detsToCheck=fRunLocalReconstruction;
4b71572b 1438 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1439 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1440 return;
1441 }
281270d3 1442 AliSysInfo::AddStamp("CheckGeom");
6bae477a 1443 }
8e245d15 1444
4b71572b 1445 if (!MisalignGeometry(fLoadAlignData)) {
1446 Abort("MisalignGeometry", TSelector::kAbortProcess);
1447 return;
1448 }
1449 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
281270d3 1450 AliSysInfo::AddStamp("MisalignGeom");
6bae477a 1451
8cb26cdf 1452 if (!InitGRP()) {
1453 Abort("InitGRP", TSelector::kAbortProcess);
1454 return;
1455 }
1456 AliSysInfo::AddStamp("InitGRP");
1457
4b71572b 1458 if (!LoadCDB()) {
1459 Abort("LoadCDB", TSelector::kAbortProcess);
1460 return;
1461 }
1462 AliSysInfo::AddStamp("LoadCDB");
325aa76f 1463
a6dd87ad 1464 if (!LoadTriggerScalersCDB()) {
1465 Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1466 return;
1467 }
1468 AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1469
52dd4a8c 1470 if (!LoadCTPTimeParamsCDB()) {
1471 Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1472 return;
1473 }
1474 AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
a6dd87ad 1475
bd26f597 1476 if (!ReadIntensityInfoCDB()) {
1477 Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1478 return;
1479 }
1480 AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1481
7e88424f 1482 // Read the reconstruction parameters from OCDB
1483 if (!InitRecoParams()) {
002c9d1b 1484 AliWarning("Not all detectors have correct RecoParam objects initialized");
4b71572b 1485 }
1486 AliSysInfo::AddStamp("InitRecoParams");
1487
fd2b273c 1488 if (fInput && gProof) {
b4fef0d2 1489 if (reco) *reco = *this;
fd2b273c 1490
45a6dee6 1491 gGeoManager->SetName("Geometry");
fd2b273c 1492 gProof->AddInputData(gGeoManager,kTRUE);
002c9d1b 1493 gGeoManager = NULL;
fd2b273c 1494 gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
002c9d1b 1495 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
f7a1cc68 1496 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
ead7b391 1497 magFieldMap->SetName("MagneticFieldMap");
fd2b273c 1498 gProof->AddInputData(magFieldMap,kTRUE);
002c9d1b 1499 }
4b71572b 1500
1501}
1502
1503//_____________________________________________________________________________
1504void AliReconstruction::SlaveBegin(TTree*)
1505{
1506 // Initialization related to run-loader,
1507 // vertexer, trackers, recontructors
1508 // In proof mode it is executed on the slave
52dd4a8c 1509 AliCodeTimerAuto("",0);
4b71572b 1510
db4aeca1 1511 TProofOutputFile *outProofFile = NULL;
81d57268 1512 if (fInput) {
1513 if (AliDebugLevel() > 0) fInput->Print();
ef5e52f6 1514 if (AliDebugLevel() > 10) fInput->Dump();
db4aeca1 1515 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1516 *this = *reco;
1517 }
4b71572b 1518 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1519 gGeoManager = tgeo;
1520 AliGeomManager::SetGeometry(tgeo);
7e88424f 1521 }
281270d3 1522 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1523 Int_t runNumber = -1;
1524 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1525 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1526 man->SetCacheFlag(kTRUE);
1527 man->SetLock(kTRUE);
1528 man->Print();
1529 }
4b71572b 1530 }
ead7b391 1531 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
ef5e52f6 1532 AliMagF *newMap = new AliMagF(*map);
1533 if (!newMap->LoadParameterization()) {
1534 Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1535 return;
1536 }
1537 TGeoGlobalMagField::Instance()->SetField(newMap);
1538 TGeoGlobalMagField::Instance()->Lock();
4b71572b 1539 }
81d57268 1540 if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1541 fProofOutputFileName = outputFileName->GetTitle();
1542 if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1543 fProofOutputLocation = outputLocation->GetTitle();
1544 if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1545 fProofOutputDataset = kTRUE;
1546 if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1547 fProofOutputArchive = archiveList->GetTitle();
1548 if (!fProofOutputFileName.IsNull() &&
1549 !fProofOutputLocation.IsNull() &&
1550 fProofOutputArchive.IsNull()) {
1551 if (!fProofOutputDataset) {
1552 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1553 outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1554 }
1555 else {
1556 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1557 }
1558 if (AliDebugLevel() > 0) outProofFile->Dump();
db4aeca1 1559 fOutput->Add(outProofFile);
4b71572b 1560 }
002c9d1b 1561 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
7e88424f 1562 }
325aa76f 1563
4b71572b 1564 // get the run loader
1565 if (!InitRunLoader()) {
1566 Abort("InitRunLoader", TSelector::kAbortProcess);
1567 return;
1568 }
1569 AliSysInfo::AddStamp("LoadLoader");
1570
325aa76f 1571 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
2257f27e 1572
f08fc9f5 1573 // get trackers
b8cd5251 1574 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
4b71572b 1575 Abort("CreateTrackers", TSelector::kAbortProcess);
1576 return;
1577 }
1578 AliSysInfo::AddStamp("CreateTrackers");
24f7a148 1579
36711aa4 1580 // create the ESD output file and tree
db4aeca1 1581 if (!outProofFile) {
1582 ffile = TFile::Open("AliESDs.root", "RECREATE");
1583 ffile->SetCompressionLevel(2);
1584 if (!ffile->IsOpen()) {
1585 Abort("OpenESDFile", TSelector::kAbortProcess);
1586 return;
1587 }
1588 }
1589 else {
81d57268 1590 AliInfo(Form("Opening output PROOF file: %s/%s",
1591 outProofFile->GetDir(), outProofFile->GetFileName()));
db4aeca1 1592 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1593 Abort(Form("Problems opening output PROOF file: %s/%s",
1594 outProofFile->GetDir(), outProofFile->GetFileName()),
1595 TSelector::kAbortProcess);
1596 return;
1597 }
596a855f 1598 }
46698ae4 1599
21a3aa09 1600 ftree = new TTree("esdTree", "Tree with ESD objects");
1601 fesd = new AliESDEvent();
1602 fesd->CreateStdContent();
8b12d288 1603 // add a so far non-std object to the ESD, this will
1604 // become part of the std content
1605 fesd->AddObject(new AliESDHLTDecision);
1606
32ba9c61 1607 fesd->WriteToTree(ftree);
1d99986f 1608 if (fWriteESDfriend) {
ee7c441c 1609 ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
03a8000a 1610 ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
ee7c441c 1611 fesdf = new AliESDfriend();
03a8000a 1612 ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
21a3aa09 1613 fesd->AddObject(fesdf);
ee7c441c 1614 ffile->cd();
1d99986f 1615 }
f9604a22 1616 ftree->GetUserInfo()->Add(fesd);
1617
1618 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1619 fhltesd = new AliESDEvent();
1620 fhltesd->CreateStdContent();
7491aea6 1621 // read the ESD template from CDB
1622 // HLT is allowed to put non-std content to its ESD, the non-std
1623 // objects need to be created before invocation of WriteToTree in
1624 // order to create all branches. Initialization is done from an
1625 // ESD layout template in CDB
1626 AliCDBManager* man = AliCDBManager::Instance();
1627 AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1628 AliCDBEntry* hltESDConfig=NULL;
1629 if (man->GetId(hltESDConfigPath)!=NULL &&
1630 (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1631 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1632 if (pESDLayout) {
1633 // init all internal variables from the list of objects
1634 pESDLayout->GetStdContent();
1635
1636 // copy content and create non-std objects
1637 *fhltesd=*pESDLayout;
1638 fhltesd->Reset();
1639 } else {
1640 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1641 hltESDConfigPath.GetPath().Data()));
1642 }
1643 }
1644
f9604a22 1645 fhltesd->WriteToTree(fhlttree);
1646 fhlttree->GetUserInfo()->Add(fhltesd);
5728d3d5 1647
ac4a7581 1648 ProcInfo_t procInfo;
1649 gSystem->GetProcInfo(&procInfo);
73bbf779 1650 AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
8661738e 1651
325aa76f 1652 //QA
930e6e3e 1653 //Initialize the QA and start of cycle
f1c1204d 1654 if (fRunQA || fRunGlobalQA)
1655 InitQA() ;
aa3c69a9 1656
7167ae53 1657 //Initialize the Plane Efficiency framework
1658 if (fRunPlaneEff && !InitPlaneEff()) {
4b71572b 1659 Abort("InitPlaneEff", TSelector::kAbortProcess);
1660 return;
7167ae53 1661 }
aa3c69a9 1662
14dd053c 1663 if (strcmp(gProgName,"alieve") == 0)
1664 fRunAliEVE = InitAliEVE();
1665
4b71572b 1666 return;
21a3aa09 1667}
1668
1669//_____________________________________________________________________________
4b71572b 1670Bool_t AliReconstruction::Process(Long64_t entry)
1671{
1672 // run the reconstruction over a single entry
1673 // from the chain with raw data
52dd4a8c 1674 AliCodeTimerAuto("",0);
4b71572b 1675
1676 TTree *currTree = fChain->GetTree();
33314186 1677 AliRawVEvent *event = NULL;
4b71572b 1678 currTree->SetBranchAddress("rawevent",&event);
1679 currTree->GetEntry(entry);
1680 fRawReader = new AliRawReaderRoot(event);
1681 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1682 delete fRawReader;
1683 fRawReader = NULL;
1684 delete event;
1685
1686 return fStatus;
1687}
1688
1689//_____________________________________________________________________________
1690void AliReconstruction::Init(TTree *tree)
1691{
0a035be5 1692 // Implementation of TSelector::Init()
1693 // method
4b71572b 1694 if (tree == 0) {
1695 AliError("The input tree is not found!");
1696 return;
1697 }
1698 fChain = tree;
1699}
1700
1701//_____________________________________________________________________________
1702Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
21a3aa09 1703{
1704 // run the reconstruction over a single event
1705 // The event loop is steered in Run method
1706
10d100d4 1707
470f88b0 1708 static Long_t oldMres=0;
1709 static Long_t oldMvir=0;
1710 static Float_t oldCPU=0;
d97f1dbe 1711 static Long_t aveDMres=0;
1712 static Long_t aveDMvir=0;
1713 static Float_t aveDCPU=0;
470f88b0 1714
52dd4a8c 1715 AliCodeTimerAuto("",0);
21a3aa09 1716
0a035be5 1717 AliESDpid pid;
10d100d4 1718
21a3aa09 1719 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1720 fRunLoader->SetEventNumber(iEvent);
4018c387 1721 if (fRawReader)
1722 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1723 iEvent, iEvent);
21a3aa09 1724 fRunLoader->TreeE()->Fill();
5b3ea9c5 1725
396f89bc 1726 if (fRawReader && fRawReader->UseAutoSaveESD())
4b71572b 1727 fRunLoader->TreeE()->AutoSave("SaveSelf");
21a3aa09 1728 }
1729
1730 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
21a3aa09 1731 return kTRUE;
1732 }
1733
aa3c69a9 1734
16447f18 1735 fRunLoader->GetEvent(iEvent);
1736
7e88424f 1737 // Fill Event-info object
1738 GetEventInfo();
77ba28ba 1739 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
d97f1dbe 1740
1741 ProcInfo_t procInfo;
1742 if(iEvent==fFirstEvent) {
1743 gSystem->GetProcInfo(&procInfo);
1744 oldMres=procInfo.fMemResident;
1745 oldMvir=procInfo.fMemVirtual;
1746 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
1747 }
470f88b0 1748 AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
7e88424f 1749
a00021a7 1750 // Set the reco-params
1751 {
1752 TString detStr = fLoadCDB;
ac4a7581 1753 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
a00021a7 1754 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1755 AliReconstructor *reconstructor = GetReconstructor(iDet);
1756 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
57acd2d2 1757 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1758 reconstructor->SetRecoParam(par);
0a035be5 1759 reconstructor->GetPidSettings(&pid);
10d100d4 1760 reconstructor->SetEventInfo(&fEventInfo);
57acd2d2 1761 if (fRunQA) {
eca4fa66 1762 AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
619aafe6 1763 if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
57acd2d2 1764 }
a00021a7 1765 }
1766 }
92664bc8 1767 //
1768 if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
1769 //
9dad1020 1770 if (fRunQA) {
1771 const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
1772 AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
1773 AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
1774 }
a00021a7 1775 }
1776
ca13fb87 1777 // QA on single raw
514cb8c7 1778 if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
eca4fa66 1779 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1780 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
57acd2d2 1781 }
d506c543 1782 // local single event reconstruction
b26c3770 1783 if (!fRunLocalReconstruction.IsNull()) {
d506c543 1784 TString detectors=fRunLocalReconstruction;
a441bf51 1785 // run HLT event reconstruction first
d506c543 1786 // ;-( IsSelected changes the string
1787 if (IsSelected("HLT", detectors) &&
1788 !RunLocalEventReconstruction("HLT")) {
4b71572b 1789 if (fStopOnError) {CleanUp(); return kFALSE;}
a441bf51 1790 }
1791 detectors=fRunLocalReconstruction;
1792 detectors.ReplaceAll("HLT", "");
1793 if (!RunLocalEventReconstruction(detectors)) {
13effe3f 1794 if (fStopOnError) {
1795 CleanUp();
1796 return kFALSE;
1797 }
b26c3770 1798 }
1799 }
1800
6b3a883f 1801
1802 // fill Event header information from the RawEventHeader
1803 if (fRawReader){FillRawEventHeaderESD(fesd);}
1804 if (fRawReader){FillRawEventHeaderESD(fhltesd);}
1805
21a3aa09 1806 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1807 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
7b649c02 1808
1809 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1810 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1811 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1812 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1813
21a3aa09 1814 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1815 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
fd2e2210 1816
1817 fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1818 fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
46698ae4 1819
d6ee376f 1820 // Set magnetic field from the tracker
21a3aa09 1821 fesd->SetMagneticField(AliTracker::GetBz());
1822 fhltesd->SetMagneticField(AliTracker::GetBz());
33fe5eb1 1823 //
3d84ad67 1824 AliESDRun *esdRun,*esdRunH;
1825 esdRun = (AliESDRun*)fesd->GetESDRun();
1826 esdRunH = (AliESDRun*)fhltesd->GetESDRun();
1827 esdRun->SetBeamEnergyIsSqrtSHalfGeV();
1828 esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
1829 //
1830 for (int ib=2;ib--;) for (int it=2;it--;) {
1831 esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
1832 esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
1833 }
c587bcde 1834 //
33fe5eb1 1835 AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1836 if (fld) { // set info needed for field initialization
1837 fesd->SetCurrentL3(fld->GetCurrentSol());
1838 fesd->SetCurrentDip(fld->GetCurrentDip());
1839 fesd->SetBeamEnergy(fld->GetBeamEnergy());
1840 fesd->SetBeamType(fld->GetBeamTypeText());
1841 fesd->SetUniformBMap(fld->IsUniform());
1842 fesd->SetBInfoStored();
1843 //
1844 fhltesd->SetCurrentL3(fld->GetCurrentSol());
1845 fhltesd->SetCurrentDip(fld->GetCurrentDip());
1846 fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
1847 fhltesd->SetBeamType(fld->GetBeamTypeText());
1848 fhltesd->SetUniformBMap(fld->IsUniform());
1849 fhltesd->SetBInfoStored();
1850 }
1851 //
71f6cda4 1852 // Set most probable pt, for B=0 tracking
9257a1bd 1853 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
ac4a7581 1854 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
71f6cda4 1855 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
46698ae4 1856
2e3550da 1857 // Fill raw-data error log into the ESD
21a3aa09 1858 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1859
2257f27e 1860 // vertex finder
1861 if (fRunVertexFinder) {
4b71572b 1862 if (!RunVertexFinder(fesd)) {
1863 if (fStopOnError) {CleanUp(); return kFALSE;}
2257f27e 1864 }
1865 }
1866
58e8dc31 1867 // For Plane Efficiency: run the SPD trackleter
1868 if (fRunPlaneEff && fSPDTrackleter) {
1869 if (!RunSPDTrackleting(fesd)) {
1870 if (fStopOnError) {CleanUp(); return kFALSE;}
1871 }
1872 }
1873
e66fbafb 1874 // Muon tracking
b8cd5251 1875 if (!fRunTracking.IsNull()) {
e66fbafb 1876 if (fRunMuonTracking) {
21a3aa09 1877 if (!RunMuonTracking(fesd)) {
4b71572b 1878 if (fStopOnError) {CleanUp(); return kFALSE;}
24f7a148 1879 }
596a855f 1880 }
1881 }
1882
e66fbafb 1883 // barrel tracking
1884 if (!fRunTracking.IsNull()) {
0a035be5 1885 if (!RunTracking(fesd,pid)) {
4b71572b 1886 if (fStopOnError) {CleanUp(); return kFALSE;}
e66fbafb 1887 }
1888 }
21c573b7 1889
596a855f 1890 // fill ESD
1891 if (!fFillESD.IsNull()) {
d506c543 1892 TString detectors=fFillESD;
f6806ad3 1893 // run HLT first and on hltesd
d506c543 1894 // ;-( IsSelected changes the string
1895 if (IsSelected("HLT", detectors) &&
1896 !FillESD(fhltesd, "HLT")) {
4b71572b 1897 if (fStopOnError) {CleanUp(); return kFALSE;}
f6806ad3 1898 }
1899 detectors=fFillESD;
d5105682 1900 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1901 if (detectors.Contains("ALL")) {
1902 detectors="";
ac4a7581 1903 for (Int_t idet=0; idet<kNDetectors; ++idet){
d5105682 1904 detectors += fgkDetectorName[idet];
1905 detectors += " ";
1906 }
1907 }
f6806ad3 1908 detectors.ReplaceAll("HLT", "");
1909 if (!FillESD(fesd, detectors)) {
4b71572b 1910 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 1911 }
1912 }
f858b00e 1913
1914 // AdC+FN
bc334fcd 1915 if (fReconstructor[3])
1916 GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
f858b00e 1917
596a855f 1918 // combined PID
0a035be5 1919 pid.MakePID(fesd);
596a855f 1920
b647652d 1921 if (fFillTriggerESD) {
4b71572b 1922 if (!FillTriggerESD(fesd)) {
1923 if (fStopOnError) {CleanUp(); return kFALSE;}
b647652d 1924 }
1925 }
f7812afc 1926 // Always fill scalers
1927 if (!FillTriggerScalers(fesd)) {
1928 if (fStopOnError) {CleanUp(); return kFALSE;}
1929 }
1930
b647652d 1931
21a3aa09 1932 ffile->cd();
a6ee503a 1933
3c3709c4 1934 //
67be5c77 1935 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1936 //
21a3aa09 1937 const Int_t ntracks = fesd->GetNumberOfTracks();
3c3709c4 1938 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1939
1940 TObjArray trkArray;
1941 UShort_t *selectedIdx=new UShort_t[ntracks];
1942
1943 for (Int_t itrack=0; itrack<ntracks; itrack++){
98a50ff3 1944 const Double_t kMaxStep = 1; //max step over the material
3c3709c4 1945 Bool_t ok;
1946
21a3aa09 1947 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1948 if (!track) continue;
1949
1950 AliExternalTrackParam *tpcTrack =
1951 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1952 ok = kFALSE;
1953 if (tpcTrack)
1954 ok = AliTracker::
52dd4a8c 1955 PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
43c9dae1 1956
3c3709c4 1957 if (ok) {
1958 Int_t n=trkArray.GetEntriesFast();
1959 selectedIdx[n]=track->GetID();
1960 trkArray.AddLast(tpcTrack);
1961 }
1962
3d65e645 1963 //Tracks refitted by ITS should already be at the SPD vertex
1964 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1965
1966 AliTracker::
52dd4a8c 1967 PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
1968 Double_t x[3]; track->GetXYZ(x);
1969 Double_t b[3]; AliTracker::GetBxByBz(x,b);
1970 track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
3c3709c4 1971
3c3709c4 1972 }
1973
1974 //
1975 // Improve the reconstructed primary vertex position using the tracks
1976 //
59224b2b 1977 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1978 if(fesd->GetPrimaryVertexSPD()) {
1979 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1980 if(vtitle.Contains("cosmics")) {
1981 runVertexFinderTracks=kFALSE;
1982 }
c060d7fe 1983 }
a00021a7 1984
1985 if (runVertexFinderTracks) {
3c3709c4 1986 // TPC + ITS primary vertex
f09c879d 1987 ftVertexer->SetITSMode();
f2a195c1 1988 ftVertexer->SetConstraintOff();
a00021a7 1989 // get cuts for vertexer from AliGRPRecoParam
1c7554f9 1990 Bool_t constrSPD=kFALSE;
a00021a7 1991 if (grpRecoParam) {
1992 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1993 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1994 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1995 ftVertexer->SetCuts(cutsVertexer);
1996 delete [] cutsVertexer; cutsVertexer = NULL;
1c7554f9 1997 if(grpRecoParam->GetVertexerTracksConstraintITS()) {
1998 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
1999 ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
2000 }else{
2001 if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2002 ftVertexer->SetVtxStart(fDiamondProfileSPD);
2003 constrSPD=kTRUE;
2004 }
2005 }
dd15203b 2006 }
43c9dae1 2007 }
21a3aa09 2008 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 2009 if (pvtx) {
1c7554f9 2010 if(constrSPD){
2011 TString title=pvtx->GetTitle();
2012 title.Append("SPD");
2013 pvtx->SetTitle(title);
2014 }
3c3709c4 2015 if (pvtx->GetStatus()) {
c264b61b 2016 fesd->SetPrimaryVertexTracks(pvtx);
3c3709c4 2017 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 2018 AliESDtrack *t = fesd->GetTrack(i);
52dd4a8c 2019 Double_t x[3]; t->GetXYZ(x);
2020 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2021 t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
3c3709c4 2022 }
2023 }
9bcaa1d7 2024 delete pvtx; pvtx=NULL;
3c3709c4 2025 }
2026
2027 // TPC-only primary vertex
f09c879d 2028 ftVertexer->SetTPCMode();
f2a195c1 2029 ftVertexer->SetConstraintOff();
a00021a7 2030 // get cuts for vertexer from AliGRPRecoParam
2031 if (grpRecoParam) {
2032 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2033 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2034 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
2035 ftVertexer->SetCuts(cutsVertexer);
2036 delete [] cutsVertexer; cutsVertexer = NULL;
dd15203b 2037 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) {
2038 if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
2039 }
43c9dae1 2040 }
21a3aa09 2041 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 2042 if (pvtx) {
2043 if (pvtx->GetStatus()) {
21a3aa09 2044 fesd->SetPrimaryVertexTPC(pvtx);
3d65e645 2045 for (Int_t i=0; i<ntracks; i++) {
2046 AliESDtrack *t = fesd->GetTrack(i);
52dd4a8c 2047 Double_t x[3]; t->GetXYZ(x);
2048 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2049 t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
3c3709c4 2050 }
2051 }
9bcaa1d7 2052 delete pvtx; pvtx=NULL;
3c3709c4 2053 }
2054
2055 }
2056 delete[] selectedIdx;
2057
1c7554f9 2058 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2059 else fesd->SetDiamond(fDiamondProfileSPD);
c5e3e5d1 2060
d1683eef 2061 if (fRunV0Finder) {
2062 // V0 finding
2063 AliV0vertexer vtxer;
61a14552 2064 // get cuts for V0vertexer from AliGRPRecoParam
2065 if (grpRecoParam) {
2066 Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2067 Double_t *cutsV0vertexer = new Double_t[nCutsV0vertexer];
2068 grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2069 vtxer.SetCuts(cutsV0vertexer);
2070 delete [] cutsV0vertexer; cutsV0vertexer = NULL;
2071 }
21a3aa09 2072 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 2073
d1683eef 2074 if (fRunCascadeFinder) {
2075 // Cascade finding
2076 AliCascadeVertexer cvtxer;
61a14552 2077 // get cuts for CascadeVertexer from AliGRPRecoParam
2078 if (grpRecoParam) {
2079 Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2080 Double_t *cutsCascadeVertexer = new Double_t[nCutsCascadeVertexer];
2081 grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2082 cvtxer.SetCuts(cutsCascadeVertexer);
2083 delete [] cutsCascadeVertexer; cutsCascadeVertexer = NULL;
2084 }
21a3aa09 2085 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 2086 }
5e4ff34d 2087 }
c8122432 2088
2089 // write ESD
2090 if (fCleanESD) CleanESD(fesd);
2091 //
1f9831ab 2092 // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
2093 // tracks interpreted as primary, this step should be done in the very end, when full
2094 // ESD info is available (particulalry, V0s)
2095 // vertex finder
c8122432 2096 if (fRunMultFinder) {
2097 if (!RunMultFinder(fesd)) {
2098 if (fStopOnError) {CleanUp(); return kFALSE;}
2099 }
2100 }
854c6476 2101
514cb8c7 2102 if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
eca4fa66 2103 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
aeb8fc30 2104 AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
57acd2d2 2105 }
bea94759 2106 if (fRunGlobalQA) {
eca4fa66 2107 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
4018c387 2108 if (qadm)
57acd2d2 2109 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
514cb8c7 2110 if (qadm && IsInTasks(AliQAv1::kESDS))
4e25ac79 2111 qadm->Exec(AliQAv1::kESDS, fesd);
b03591ab 2112 }
854c6476 2113
8b12d288 2114 // copy HLT decision from HLTesd to esd
2115 // the most relevant information is stored in a reduced container in the esd,
2116 // while the full information can be found in the HLTesd
2117 TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2118 TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2119 if (pHLTSrc && pHLTTgt) {
2120 pHLTSrc->Copy(*pHLTTgt);
2121 }
2122
ee7c441c 2123 if (fWriteESDfriend)
21a3aa09 2124 fesd->GetESDfriend(fesdf);
ee7c441c 2125
21a3aa09 2126 ftree->Fill();
fc01854a 2127 if (fWriteESDfriend) {
f00558b6 2128 WriteESDfriend();
fc01854a 2129 }
500d54ab 2130
2d91a353 2131 // Auto-save the ESD tree in case of prompt reco @P2
396f89bc 2132 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2d91a353 2133 ftree->AutoSave("SaveSelf");
ee7c441c 2134 if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
be103ac8 2135 }
2d91a353 2136
500d54ab 2137 // write HLT ESD
21a3aa09 2138 fhlttree->Fill();
1d99986f 2139
14dd053c 2140 // call AliEVE
2141 if (fRunAliEVE) RunAliEVE();
2142
21a3aa09 2143 fesd->Reset();
2144 fhltesd->Reset();
5728d3d5 2145 if (fWriteESDfriend) {
21a3aa09 2146 fesdf->~AliESDfriend();
2147 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 2148 }
a5fa6165 2149
ac4a7581 2150 gSystem->GetProcInfo(&procInfo);
d97f1dbe 2151 Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
2152 Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
2153 Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
2154 aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
2155 aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
2156 aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
73bbf779 2157 AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
d97f1dbe 2158 iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
470f88b0 2159 oldMres=procInfo.fMemResident;
2160 oldMvir=procInfo.fMemVirtual;
2161 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
a5fa6165 2162
ca13fb87 2163 fEventInfo.Reset();
ac4a7581 2164 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
42ec5d3d 2165 if (fReconstructor[iDet]) {
a00021a7 2166 fReconstructor[iDet]->SetRecoParam(NULL);
42ec5d3d 2167 fReconstructor[iDet]->SetEventInfo(NULL);
2168 }
1f26f3e7 2169 if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
ca13fb87 2170 }
2171
53c8f690 2172 if (fRunQA || fRunGlobalQA)
eca4fa66 2173 AliQAManager::QAManager()->Increment() ;
53c8f690 2174
ca13fb87 2175 return kTRUE;
21a3aa09 2176}
2177
2178//_____________________________________________________________________________
4b71572b 2179void AliReconstruction::SlaveTerminate()
21a3aa09 2180{
4b71572b 2181 // Finalize the run on the slave side
21a3aa09 2182 // Called after the exit
2183 // from the event loop
52dd4a8c 2184 AliCodeTimerAuto("",0);
21a3aa09 2185
2186 if (fIsNewRunLoader) { // galice.root didn't exist
2187 fRunLoader->WriteHeader("OVERWRITE");
5b3ea9c5 2188 fRunLoader->WriteTrigger("OVERWRITE");
21a3aa09 2189 fRunLoader->CdGAFile();
2190 fRunLoader->Write(0, TObject::kOverwrite);
2191 }
2192
f747912b 2193 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
2194 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
2195
2196 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2197 cdbMapCopy->SetOwner(1);
2198 cdbMapCopy->SetName("cdbMap");
2199 TIter iter(cdbMap->GetTable());
2200
2201 TPair* pair = 0;
2202 while((pair = dynamic_cast<TPair*> (iter.Next()))){
2203 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
c7a22819 2204 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2205 if (keyStr && valStr)
2206 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
f747912b 2207 }
2208
2209 TList *cdbListCopy = new TList();
2210 cdbListCopy->SetOwner(1);
2211 cdbListCopy->SetName("cdbList");
2212
2213 TIter iter2(cdbList);
2214
b940cb9b 2215 AliCDBId* id=0;
e84c88f5 2216 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 2217 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 2218 }
2219
21a3aa09 2220 ftree->GetUserInfo()->Add(cdbMapCopy);
2221 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 2222
46698ae4 2223
21a3aa09 2224 ffile->cd();
aa3c69a9 2225
562dd0b4 2226 // we want to have only one tree version number
21a3aa09 2227 ftree->Write(ftree->GetName(),TObject::kOverwrite);
63314086 2228 fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
f3a97c86 2229
ee7c441c 2230 if (fWriteESDfriend) {
2231 ffileF->cd();
2232 ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2233 }
2234
a7a1e1c7 2235// Finish with Plane Efficiency evaluation: before of CleanUp !!!
2236 if (fRunPlaneEff && !FinishPlaneEff()) {
2237 AliWarning("Finish PlaneEff evaluation failed");
2238 }
2239
930e6e3e 2240 // End of cycle for the in-loop
87da0921 2241
2242 if (fRunQA || fRunGlobalQA) {
5cbed243 2243 AliQAManager::QAManager()->EndOfCycle() ;
81d57268 2244 if (fInput &&
2245 !fProofOutputLocation.IsNull() &&
2246 fProofOutputArchive.IsNull() &&
2247 !fProofOutputDataset) {
2248 TString qaOutputFile(Form("%sMerged.%s.Data.root",
2249 fProofOutputLocation.Data(),
2250 AliQAv1::GetQADataFileName()));
2251 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2252 AliQAv1::GetQADataFileName()));
2253 qaProofFile->SetOutputFileName(qaOutputFile.Data());
2254 if (AliDebugLevel() > 0) qaProofFile->Dump();
2255 fOutput->Add(qaProofFile);
2256 MergeQA(qaProofFile->GetFileName());
87da0921 2257 }
2258 else {
2259 MergeQA();
2260 }
2261 }
2262
4b71572b 2263 gROOT->cd();
2264 CleanUp();
81d57268 2265
2266 if (fInput) {
2267 if (!fProofOutputFileName.IsNull() &&
2268 !fProofOutputLocation.IsNull() &&
2269 fProofOutputDataset &&
2270 !fProofOutputArchive.IsNull()) {
2271 TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2272 "DROV",
2273 fProofOutputLocation.Data());
2274 if (AliDebugLevel() > 0) zipProofFile->Dump();
2275 fOutput->Add(zipProofFile);
2276 TString fileList(fProofOutputArchive.Data());
2277 fileList.ReplaceAll(","," ");
38c18bf1 2278 TString command;
2279#if ROOT_SVN_REVISION >= 30174
2280 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2281#else
2282 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2283#endif
2284 AliInfo(Form("Executing: %s",command.Data()));
2285 gSystem->Exec(command.Data());
81d57268 2286 }
2287 }
4b71572b 2288}
2289
2290//_____________________________________________________________________________
2291void AliReconstruction::Terminate()
2292{
f3a97c86 2293 // Create tags for the events in the ESD tree (the ESD tree is always present)
2294 // In case of empty events the tags will contain dummy values
52dd4a8c 2295 AliCodeTimerAuto("",0);
4b71572b 2296
e6d66370 2297 // Do not call the ESD tag creator in case of PROOF-based reconstruction
2298 if (!fInput) {
2299 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2300 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
9bcaa1d7 2301 delete esdtagCreator;
e6d66370 2302 }
e84c88f5 2303
795e4a22 2304 // Cleanup of CDB manager: cache and active storages!
2305 AliCDBManager::Instance()->ClearCache();
596a855f 2306}
2307
2308//_____________________________________________________________________________
b26c3770 2309Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2310{
2311// run the local reconstruction
aa3c69a9 2312
0f88822a 2313 static Int_t eventNr=0;
52dd4a8c 2314 AliCodeTimerAuto("",0)
b26c3770 2315
2316 TString detStr = detectors;
9533b54d 2317 // execute HLT reconstruction first since other detector reconstruction
2318 // might depend on HLT data
2319 // key 'HLT' is removed from detStr by IsSelected
2320 if (!IsSelected("HLT", detStr)) {
2321 AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2322 if (reconstructor) {
2323 // there is no AliLoader for HLT, see
2324 // https://savannah.cern.ch/bugs/?35473
2325 AliInfo("running reconstruction for HLT");
f6806ad3 2326 if (fRawReader) {
44ed7a66 2327 reconstructor->Reconstruct(fRawReader, NULL);
f6806ad3 2328 } else {
44ed7a66 2329 TTree* dummy=NULL;
2330 reconstructor->Reconstruct(dummy, NULL);
f6806ad3 2331 }
f6806ad3 2332 }
9533b54d 2333 }
2334 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2335 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2336 AliReconstructor* reconstructor = GetReconstructor(iDet);
2337 if (!reconstructor) continue;
2338 AliLoader* loader = fLoader[iDet];
d76c31f4 2339 if (!loader) {
2340 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2341 continue;
2342 }
b26c3770 2343 // conversion of digits
2344 if (fRawReader && reconstructor->HasDigitConversion()) {
2345 AliInfo(Form("converting raw data digits into root objects for %s",
2346 fgkDetectorName[iDet]));
30bbd491 2347// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
52dd4a8c 2348// fgkDetectorName[iDet]),0);
b26c3770 2349 loader->LoadDigits("update");
2350 loader->CleanDigits();
2351 loader->MakeDigitsContainer();
2352 TTree* digitsTree = loader->TreeD();
2353 reconstructor->ConvertDigits(fRawReader, digitsTree);
2354 loader->WriteDigits("OVERWRITE");
2355 loader->UnloadDigits();
b26c3770 2356 }
b26c3770 2357 // local reconstruction
b26c3770 2358 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
52dd4a8c 2359 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
b26c3770 2360 loader->LoadRecPoints("update");
2361 loader->CleanRecPoints();
2362 loader->MakeRecPointsContainer();
2363 TTree* clustersTree = loader->TreeR();
2364 if (fRawReader && !reconstructor->HasDigitConversion()) {
2365 reconstructor->Reconstruct(fRawReader, clustersTree);
2366 } else {
2367 loader->LoadDigits("read");
2368 TTree* digitsTree = loader->TreeD();
2369 if (!digitsTree) {
44ed7a66 2370 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
13effe3f 2371 if (fStopOnError)
2372 return kFALSE;
b26c3770 2373 } else {
44ed7a66 2374 reconstructor->Reconstruct(digitsTree, clustersTree);
514cb8c7 2375 if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
eca4fa66 2376 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2377 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
44ed7a66 2378 }
b26c3770 2379 }
2380 loader->UnloadDigits();
2381 }
92664bc8 2382 if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
eca4fa66 2383 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
92664bc8 2384 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
57acd2d2 2385 }
eca4fa66 2386 loader->WriteRecPoints("OVERWRITE");
2387 loader->UnloadRecPoints();
2388 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
a00021a7 2389 }
c7a22819 2390 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
a00021a7 2391 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
b26c3770 2392 AliError(Form("the following detectors were not found: %s",
2393 detStr.Data()));
13effe3f 2394 if (fStopOnError)
2395 return kFALSE;
b26c3770 2396 }
0f88822a 2397 eventNr++;
b26c3770 2398 return kTRUE;
2399}
58e8dc31 2400//_____________________________________________________________________________
2401Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2402{
2403// run the SPD trackleting (for SPD efficiency purpouses)
2404
52dd4a8c 2405 AliCodeTimerAuto("",0)
58e8dc31 2406
2407 Double_t vtxPos[3] = {0, 0, 0};
2408 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2409/*
2410 TArrayF mcVertex(3);
2411 // if(MC)
2412 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2413 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2414 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2415 }
2416*/
2417 const AliESDVertex *vertex = esd->GetVertex();
2418 if(!vertex){
2419 AliWarning("Vertex not found");
2420 return kFALSE;
2421 }
2422 vertex->GetXYZ(vtxPos);
2423 vertex->GetSigmaXYZ(vtxErr);
2424 if (fSPDTrackleter) {
2425 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2426
2427 // load clusters
2428 fLoader[0]->LoadRecPoints("read");
2429 TTree* tree = fLoader[0]->TreeR();
2430 if (!tree) {
2431 AliError("Can't get the ITS cluster tree");
2432 return kFALSE;
2433 }
2434 fSPDTrackleter->LoadClusters(tree);
2435 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2436 // run trackleting
2437 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
84290fcc 2438 AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
58e8dc31 2439 // fLoader[0]->UnloadRecPoints();
2440 return kFALSE;
2441 }
2442//fSPDTrackleter->UnloadRecPoints();
2443 } else {
2444 AliWarning("SPDTrackleter not available");
2445 return kFALSE;
2446 }
2447 return kTRUE;
2448}
b26c3770 2449
2450//_____________________________________________________________________________
af885e0f 2451Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 2452{
2453// run the barrel tracking
2454
52dd4a8c 2455 AliCodeTimerAuto("",0)
030b532d 2456
92bffc4d 2457 AliVertexer *vertexer = CreateVertexer();
2458 if (!vertexer) return kFALSE;
2459
3c99b88f 2460 AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2257f27e 2461 AliESDVertex* vertex = NULL;
92bffc4d 2462 if (fLoader[0]) {
2463 fLoader[0]->LoadRecPoints();
2464 TTree* cltree = fLoader[0]->TreeR();
2465 if (cltree) {
2466 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2467 vertex = vertexer->FindVertexForCurrentEvent(cltree);
308c2f7c 2468 }
2469 else {
92bffc4d 2470 AliError("Can't get the ITS cluster tree");
308c2f7c 2471 }
92bffc4d 2472 fLoader[0]->UnloadRecPoints();
2257f27e 2473 }
92bffc4d 2474 else {
2475 AliError("Can't get the ITS loader");
2476 }
2477 if(!vertex){
2478 AliWarning("Vertex not found");
2479 vertex = new AliESDVertex();
2480 vertex->SetName("default");
2481 }
2482 else {
2483 vertex->SetName("reconstructed");
2257f27e 2484 }
92bffc4d 2485
2486 Double_t vtxPos[3];
2487 Double_t vtxErr[3];
2488 vertex->GetXYZ(vtxPos);
2489 vertex->GetSigmaXYZ(vtxErr);
2490
06cc9d95 2491 esd->SetPrimaryVertexSPD(vertex);
73c51de2 2492 AliESDVertex *vpileup = NULL;
2493 Int_t novertices = 0;
2494 vpileup = vertexer->GetAllVertices(novertices);
2495 if(novertices>1){
2496 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2497 }
1f9831ab 2498 /*
32e449be 2499 // if SPD multiplicity has been determined, it is stored in the ESD
92bffc4d 2500 AliMultiplicity *mult = vertexer->GetMultiplicity();
32e449be 2501 if(mult)esd->SetMultiplicity(mult);
1f9831ab 2502 */
ac4a7581 2503 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2504 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2505 }
2257f27e 2506 delete vertex;
2507
92bffc4d 2508 delete vertexer;
2509
2257f27e 2510 return kTRUE;
2511}
2512
2513//_____________________________________________________________________________
1f9831ab 2514Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2515{
2516 // run the trackleter for multiplicity study
2517
2518 AliCodeTimerAuto("",0)
2519
2520 AliTrackleter *trackleter = CreateMultFinder();
2521 if (!trackleter) return kFALSE;
2522
2523 AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2524
2525 if (fLoader[0]) {
2526 fLoader[0]->LoadRecPoints();
2527 TTree* cltree = fLoader[0]->TreeR();
2528 if (cltree) {
2529 trackleter->Reconstruct(esd,cltree);
2530 AliMultiplicity *mult = trackleter->GetMultiplicity();
2531 if(mult) esd->SetMultiplicity(mult);
2532 }
2533 else {
2534 AliError("Can't get the ITS cluster tree");
2535 }
2536 fLoader[0]->UnloadRecPoints();
2537 }
2538 else {
2539 AliError("Can't get the ITS loader");
2540 }
2541
2542 delete trackleter;
2543
2544 return kTRUE;
2545}
2546
2547//_____________________________________________________________________________
af885e0f 2548Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 2549{
2550// run the HLT barrel tracking
2551
52dd4a8c 2552 AliCodeTimerAuto("",0)
1f46a9ae 2553
2554 if (!fRunLoader) {
2555 AliError("Missing runLoader!");
2556 return kFALSE;
2557 }
2558
2559 AliInfo("running HLT tracking");
2560
2561 // Get a pointer to the HLT reconstructor
ac4a7581 2562 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
1f46a9ae 2563 if (!reconstructor) return kFALSE;
2564
2565 // TPC + ITS
2566 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2567 TString detName = fgkDetectorName[iDet];
2568 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2569 reconstructor->SetOption(detName.Data());
d76c31f4 2570 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 2571 if (!tracker) {
2572 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2573 if (fStopOnError) return kFALSE;
9dcc06e1 2574 continue;
1f46a9ae 2575 }
2576 Double_t vtxPos[3];
2577 Double_t vtxErr[3]={0.005,0.005,0.010};
2578 const AliESDVertex *vertex = esd->GetVertex();
2579 vertex->GetXYZ(vtxPos);
2580 tracker->SetVertex(vtxPos,vtxErr);
2581 if(iDet != 1) {
2582 fLoader[iDet]->LoadRecPoints("read");
2583 TTree* tree = fLoader[iDet]->TreeR();
2584 if (!tree) {
2585 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2586 return kFALSE;
2587 }
2588 tracker->LoadClusters(tree);
2589 }
2590 if (tracker->Clusters2Tracks(esd) != 0) {
2591 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2592 return kFALSE;
2593 }
2594 if(iDet != 1) {
2595 tracker->UnloadClusters();
2596 }
2597 delete tracker;
2598 }
2599
1f46a9ae 2600 return kTRUE;
2601}
2602
2603//_____________________________________________________________________________
af885e0f 2604Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 2605{
2606// run the muon spectrometer tracking
2607
52dd4a8c 2608 AliCodeTimerAuto("",0)
e66fbafb 2609
2610 if (!fRunLoader) {
2611 AliError("Missing runLoader!");
2612 return kFALSE;
2613 }
2614 Int_t iDet = 7; // for MUON
2615
2616 AliInfo("is running...");
2617
2618 // Get a pointer to the MUON reconstructor
2619 AliReconstructor *reconstructor = GetReconstructor(iDet);
2620 if (!reconstructor) return kFALSE;
2621
2622
2623 TString detName = fgkDetectorName[iDet];
2624 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 2625 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 2626 if (!tracker) {
2627 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2628 return kFALSE;
2629 }
2630
e66fbafb 2631 // read RecPoints
761350a6 2632 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 2633
761350a6 2634 tracker->LoadClusters(fLoader[iDet]->TreeR());
2635
2636 Int_t rv = tracker->Clusters2Tracks(esd);
2637
e66fbafb 2638 fLoader[iDet]->UnloadRecPoints();
2639
c1954ee5 2640 tracker->UnloadClusters();
2641
e66fbafb 2642 delete tracker;
2643
cb23c6ca 2644 if ( rv )
2645 {
2646 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2647 return kFALSE;
2648 }
2649
e66fbafb 2650 return kTRUE;
2651}
2652
2653
2654//_____________________________________________________________________________
10d100d4 2655Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
2257f27e 2656{
2657// run the barrel tracking
0f88822a 2658 static Int_t eventNr=0;
52dd4a8c 2659 AliCodeTimerAuto("",0)
24f7a148 2660
815c2b38 2661 AliInfo("running tracking");
596a855f 2662
1f26f3e7 2663 // Set the event info which is used
2664 // by the trackers in order to obtain
2665 // information about read-out detectors,
2666 // trigger etc.
2667 AliDebug(1, "Setting event info");
2668 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2669 if (!fTracker[iDet]) continue;
2670 fTracker[iDet]->SetEventInfo(&fEventInfo);
2671 }
2672
91b876d1 2673 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 2674 if (fReconstructor[11] && fLoader[11]) {
2675 fLoader[11]->LoadRecPoints("READ");
2676 TTree *treeR = fLoader[11]->TreeR();
89916438 2677 if (treeR) {
2678 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2679 }
d76c31f4 2680 }
91b876d1 2681
b8cd5251 2682 // pass 1: TPC + ITS inwards
2683 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2684 if (!fTracker[iDet]) continue;
2685 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 2686
b8cd5251 2687 // load clusters
2688 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2689 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 2690 TTree* tree = fLoader[iDet]->TreeR();
2691 if (!tree) {
2692 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 2693 return kFALSE;
2694 }
b8cd5251 2695 fTracker[iDet]->LoadClusters(tree);
6efecea1 2696 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2697 // run tracking
2698 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2699 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 2700 return kFALSE;
2701 }
878e1fe1 2702 // preliminary PID in TPC needed by the ITS tracker
2703 if (iDet == 1) {
b26c3770 2704 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
10d100d4 2705 PID.MakePID(esd,kTRUE);
0f88822a 2706 }
6efecea1 2707 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 2708 }
596a855f 2709
b8cd5251 2710 // pass 2: ALL backwards
aa3c69a9 2711
ac4a7581 2712 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2713 if (!fTracker[iDet]) continue;
2714 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2715
2716 // load clusters
2717 if (iDet > 1) { // all except ITS, TPC
2718 TTree* tree = NULL;
7b61cd9c 2719 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2720 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 2721 tree = fLoader[iDet]->TreeR();
b8cd5251 2722 if (!tree) {
eca4fa66 2723 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2724 return kFALSE;
24f7a148 2725 }
0f88822a 2726 fTracker[iDet]->LoadClusters(tree);
6efecea1 2727 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2728 }
24f7a148 2729
b8cd5251 2730 // run tracking
283f39c6 2731 if (iDet>1) // start filling residuals for the "outer" detectors
eca4fa66 2732 if (fRunGlobalQA) {
2733 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2734 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2735 if (arr) {
0a349581 2736 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2737 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
c9526f68 2738 if ( elem && (! elem->At(0)) ) {
2739 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2740 if (qadm) qadm->InitRecPointsForTracker() ;
2741 }
2742 }
eca4fa66 2743 }
b8cd5251 2744 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2745 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 2746 // return kFALSE;
b8cd5251 2747 }
24f7a148 2748
b8cd5251 2749 // unload clusters
6e65648b 2750 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
b8cd5251 2751 fTracker[iDet]->UnloadClusters();
7b61cd9c 2752 fLoader[iDet]->UnloadRecPoints();
b8cd5251 2753 }
8f37df88 2754 // updated PID in TPC needed by the ITS tracker -MI
2755 if (iDet == 1) {
10d100d4 2756 //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2757 //AliESDpid::MakePID(esd);
2758 PID.MakePID(esd,kTRUE);
8f37df88 2759 }
6efecea1 2760 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 2761 }
283f39c6 2762 //stop filling residuals for the "outer" detectors
57acd2d2 2763 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
596a855f 2764
b8cd5251 2765 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 2766
b8cd5251 2767 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2768 if (!fTracker[iDet]) continue;
2769 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 2770
b8cd5251 2771 // run tracking
283f39c6 2772 if (iDet<2) // start filling residuals for TPC and ITS
eca4fa66 2773 if (fRunGlobalQA) {
2774 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2775 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2776 if (arr) {
0a349581 2777 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2778 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
c9526f68 2779 if ( elem && (! elem->At(0)) ) {
2780 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2781 if (qadm) qadm->InitRecPointsForTracker() ;
2782 }
2783 }
eca4fa66 2784 }
2785
b8cd5251 2786 if (fTracker[iDet]->RefitInward(esd) != 0) {
2787 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 2788 // return kFALSE;
b8cd5251 2789 }
db2368d0 2790 // run postprocessing
2791 if (fTracker[iDet]->PostProcess(esd) != 0) {
2792 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2793 // return kFALSE;
2794 }
6efecea1 2795 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
6e65648b 2796 }
2797
2798 // write space-points to the ESD in case alignment data output
2799 // is switched on
2800 if (fWriteAlignmentData)
2801 WriteAlignmentData(esd);
2802
2803 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2804 if (!fTracker[iDet]) continue;
b8cd5251 2805 // unload clusters
2806 fTracker[iDet]->UnloadClusters();
6efecea1 2807 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 2808 fLoader[iDet]->UnloadRecPoints();
6efecea1 2809 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 2810 }
283f39c6 2811 // stop filling residuals for TPC and ITS
57acd2d2 2812 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
854c6476 2813
0f88822a 2814 eventNr++;
596a855f 2815 return kTRUE;
2816}
2817
2818//_____________________________________________________________________________
d64bd07d 2819Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2820 //
2821 // Remove the data which are not needed for the physics analysis.
2822 //
2823
d64bd07d 2824 Int_t nTracks=esd->GetNumberOfTracks();
18571674 2825 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 2826 AliInfo
2827 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 2828
18571674 2829 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 2830 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 2831
7f68891d 2832 nTracks=esd->GetNumberOfTracks();
18571674 2833 nV0s=esd->GetNumberOfV0s();
cf37fd88 2834 AliInfo
ae5d5566 2835 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 2836
7f68891d 2837 return rc;
d64bd07d 2838}
2839
2840//_____________________________________________________________________________
af885e0f 2841Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 2842{
2843// fill the event summary data
2844
52dd4a8c 2845 AliCodeTimerAuto("",0)
0f88822a 2846 static Int_t eventNr=0;
596a855f 2847 TString detStr = detectors;
abe0c04e 2848
f1640d23 2849 AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
ac4a7581 2850 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
abe0c04e 2851 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 2852 AliReconstructor* reconstructor = GetReconstructor(iDet);
2853 if (!reconstructor) continue;
4b71572b 2854 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2855 TTree* clustersTree = NULL;
2856 if (fLoader[iDet]) {
2857 fLoader[iDet]->LoadRecPoints("read");
2858 clustersTree = fLoader[iDet]->TreeR();
2859 if (!clustersTree) {
2860 AliError(Form("Can't get the %s clusters tree",
2861 fgkDetectorName[iDet]));
2862 if (fStopOnError) return kFALSE;
2863 }
2864 }
2865 if (fRawReader && !reconstructor->HasDigitConversion()) {
2866 reconstructor->FillESD(fRawReader, clustersTree, esd);
2867 } else {
2868 TTree* digitsTree = NULL;
d76c31f4 2869 if (fLoader[iDet]) {
4b71572b 2870 fLoader[iDet]->LoadDigits("read");
2871 digitsTree = fLoader[iDet]->TreeD();
2872 if (!digitsTree) {
2873 AliError(Form("Can't get the %s digits tree",
b26c3770 2874 fgkDetectorName[iDet]));
2875 if (fStopOnError) return kFALSE;
2876 }
2877 }
4b71572b 2878 reconstructor->FillESD(digitsTree, clustersTree, esd);
2879 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2880 }
2881 if (fLoader[iDet]) {
2882 fLoader[iDet]->UnloadRecPoints();
596a855f 2883 }
2884 }
13effe3f 2885
c7a22819 2886 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
596a855f 2887 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 2888 AliError(Form("the following detectors were not found: %s",
2889 detStr.Data()));
596a855f 2890 if (fStopOnError) return kFALSE;
2891 }
f1640d23 2892 AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
0f88822a 2893 eventNr++;
596a855f 2894 return kTRUE;
2895}
2896
b647652d 2897//_____________________________________________________________________________
af885e0f 2898Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 2899{
2900 // Reads the trigger decision which is
2901 // stored in Trigger.root file and fills
2902 // the corresponding esd entries
2903
52dd4a8c 2904 AliCodeTimerAuto("",0)
87932dab 2905
b647652d 2906 AliInfo("Filling trigger information into the ESD");
2907
2908 if (fRawReader) {
2909 AliCTPRawStream input(fRawReader);
2910 if (!input.Next()) {
7e88424f 2911 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
b647652d 2912 }
2913 else {
7e88424f 2914 if (esd->GetTriggerMask() != input.GetClassMask())
2915 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2916 input.GetClassMask(),esd->GetTriggerMask()));
2917 if (esd->GetOrbitNumber() != input.GetOrbitID())
2918 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2919 input.GetOrbitID(),esd->GetOrbitNumber()));
2920 if (esd->GetBunchCrossNumber() != input.GetBCID())
2921 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2922 input.GetBCID(),esd->GetBunchCrossNumber()));
e61ed4b1 2923 AliESDHeader* esdheader = esd->GetHeader();
2924 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
2925 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
2926 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
a6dd87ad 2927 // IR
2928 UInt_t orbit=input.GetOrbitID();
2929 for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
2930 if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
2931 esdheader->AddTriggerIR(input.GetIR(i));
2932 }
5b3ea9c5 2933 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();