]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliReconstruction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
added creation of image file in the Finish method
[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>
596a855f 130
f7a1cc68 131#include "AliAlignObj.h"
132#include "AliCDBEntry.h"
133#include "AliCDBManager.h"
134#include "AliCDBStorage.h"
135#include "AliCTPRawStream.h"
136#include "AliCascadeVertexer.h"
137#include "AliCentralTrigger.h"
87932dab 138#include "AliCodeTimer.h"
f7a1cc68 139#include "AliDAQ.h"
140#include "AliDetectorRecoParam.h"
141#include "AliESDCaloCells.h"
142#include "AliESDCaloCluster.h"
af885e0f 143#include "AliESDEvent.h"
faffd83e 144#include "AliESDMuonTrack.h"
f7a1cc68 145#include "AliESDPmdTrack.h"
146#include "AliESDTagCreator.h"
2257f27e 147#include "AliESDVertex.h"
faffd83e 148#include "AliESDcascade.h"
f7a1cc68 149#include "AliESDfriend.h"
faffd83e 150#include "AliESDkink.h"
596a855f 151#include "AliESDpid.h"
ff8bb5ae 152#include "AliESDtrack.h"
f7a1cc68 153#include "AliESDtrack.h"
154#include "AliEventInfo.h"
155#include "AliGRPObject.h"
156#include "AliGRPRecoParam.h"
157#include "AliGenEventHeader.h"
25be1e5c 158#include "AliGeomManager.h"
aa3c69a9 159#include "AliGlobalQADataMaker.h"
f7a1cc68 160#include "AliHeader.h"
161#include "AliLog.h"
162#include "AliMagF.h"
163#include "AliMultiplicity.h"
164#include "AliPID.h"
165#include "AliPlaneEff.h"
4e25ac79 166#include "AliQAv1.h"
f7a1cc68 167#include "AliQADataMakerRec.h"
b03591ab 168#include "AliQAManager.h"
33314186 169#include "AliRawVEvent.h"
f7a1cc68 170#include "AliRawEventHeaderBase.h"
cd0b062e 171#include "AliRawHLTManager.h"
f7a1cc68 172#include "AliRawReaderDate.h"
173#include "AliRawReaderFile.h"
174#include "AliRawReaderRoot.h"
175#include "AliReconstruction.h"
176#include "AliReconstructor.h"
177#include "AliRun.h"
7e88424f 178#include "AliRunInfo.h"
f7a1cc68 179#include "AliRunLoader.h"
180#include "AliSysInfo.h" // memory snapshots
181#include "AliTrackPointArray.h"
182#include "AliTracker.h"
183#include "AliTriggerClass.h"
184#include "AliTriggerCluster.h"
a6dd87ad 185#include "AliTriggerIR.h"
f7a1cc68 186#include "AliTriggerConfiguration.h"
187#include "AliV0vertexer.h"
188#include "AliVertexer.h"
189#include "AliVertexerTracks.h"
44e45fac 190
596a855f 191ClassImp(AliReconstruction)
192
c757bafd 193//_____________________________________________________________________________
ac4a7581 194const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
c757bafd 195
596a855f 196//_____________________________________________________________________________
4b71572b 197AliReconstruction::AliReconstruction(const char* gAliceFilename) :
198 TSelector(),
2257f27e 199 fRunVertexFinder(kTRUE),
a84e2607 200 fRunVertexFinderTracks(kTRUE),
1f46a9ae 201 fRunHLTTracking(kFALSE),
e66fbafb 202 fRunMuonTracking(kFALSE),
d1683eef 203 fRunV0Finder(kTRUE),
204 fRunCascadeFinder(kTRUE),
1d99986f 205 fStopOnError(kFALSE),
206 fWriteAlignmentData(kFALSE),
207 fWriteESDfriend(kFALSE),
b647652d 208 fFillTriggerESD(kTRUE),
1d99986f 209
7f68891d 210 fCleanESD(kTRUE),
a023d8d8 211 fV0DCAmax(3.),
212 fV0CsPmin(0.),
7f68891d 213 fDmax(50.),
214 fZmax(50.),
215
1d99986f 216 fRunLocalReconstruction("ALL"),
b8cd5251 217 fRunTracking("ALL"),
e583c30d 218 fFillESD("ALL"),
7d566c20 219 fLoadCDB(""),
48ce48d1 220 fUseTrackingErrorsForAlignment(""),
e583c30d 221 fGAliceFileName(gAliceFilename),
4b71572b 222 fRawInput(""),
975320a0 223 fESDOutput(""),
35042093 224 fEquipIdMap(""),
b26c3770 225 fFirstEvent(0),
226 fLastEvent(-1),
9d705769 227 fNumberOfEventsPerFile((UInt_t)-1),
b8cd5251 228 fOptions(),
6bae477a 229 fLoadAlignFromCDB(kTRUE),
230 fLoadAlignData("ALL"),
cd0b062e 231 fUseHLTData(),
7e88424f 232 fRunInfo(NULL),
233 fEventInfo(),
522fdd91 234 fRunScalers(NULL),
e583c30d 235
236 fRunLoader(NULL),
b649205a 237 fRawReader(NULL),
cd0b062e 238 fParentRawReader(NULL),
b8cd5251 239
7e88424f 240 fRecoParam(),
241
58e8dc31 242 fSPDTrackleter(NULL),
243
f2a195c1 244 fDiamondProfileSPD(NULL),
9178838a 245 fDiamondProfile(NULL),
43c9dae1 246 fDiamondProfileTPC(NULL),
77ba28ba 247 fListOfCosmicTriggers(NULL),
f2a195c1 248
6b6e4472 249 fGRPData(NULL),
444753c6 250
6bae477a 251 fAlignObjArray(NULL),
795e4a22 252 fCDBUri(),
f1c1204d 253 fQARefUri(),
759c1df1 254 fSpecCDBUri(),
795e4a22 255 fInitCDBCalled(kFALSE),
256 fSetRunNumberFromDataCalled(kFALSE),
ce43afbe 257 fQADetectors("ALL"),
258 fQATasks("ALL"),
7e963665 259 fRunQA(kTRUE),
6b150027 260 fRunGlobalQA(kTRUE),
e4a998ed 261 fSameQACycle(kFALSE),
f1c1204d 262 fInitQACalled(kFALSE),
75373542 263 fWriteQAExpertData(kTRUE),
21a3aa09 264 fRunPlaneEff(kFALSE),
265
266 fesd(NULL),
267 fhltesd(NULL),
268 fesdf(NULL),
269 ffile(NULL),
270 ftree(NULL),
271 fhlttree(NULL),
21a3aa09 272 ftVertexer(NULL),
14dd053c 273 fIsNewRunLoader(kFALSE),
4b71572b 274 fRunAliEVE(kFALSE),
275 fChain(NULL)
596a855f 276{
277// create reconstruction object with default parameters
002c9d1b 278 gGeoManager = NULL;
b8cd5251 279
ac4a7581 280 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 281 fReconstructor[iDet] = NULL;
282 fLoader[iDet] = NULL;
283 fTracker[iDet] = NULL;
284 }
4e25ac79 285 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
252f8aa8 286 fQACycles[iDet] = 999999 ;
287 fQAWriteExpert[iDet] = kFALSE ;
288 }
289
e47c4c2e 290 AliPID pid;
596a855f 291}
292
293//_____________________________________________________________________________
294AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
4b71572b 295 TSelector(),
2257f27e 296 fRunVertexFinder(rec.fRunVertexFinder),
a84e2607 297 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
1f46a9ae 298 fRunHLTTracking(rec.fRunHLTTracking),
e66fbafb 299 fRunMuonTracking(rec.fRunMuonTracking),
d1683eef 300 fRunV0Finder(rec.fRunV0Finder),
301 fRunCascadeFinder(rec.fRunCascadeFinder),
1d99986f 302 fStopOnError(rec.fStopOnError),
303 fWriteAlignmentData(rec.fWriteAlignmentData),
304 fWriteESDfriend(rec.fWriteESDfriend),
b647652d 305 fFillTriggerESD(rec.fFillTriggerESD),
1d99986f 306
7f68891d 307 fCleanESD(rec.fCleanESD),
a023d8d8 308 fV0DCAmax(rec.fV0DCAmax),
5e5c1aa9 309 fV0CsPmin(rec.fV0CsPmin),
7f68891d 310 fDmax(rec.fDmax),
311 fZmax(rec.fZmax),
312
1d99986f 313 fRunLocalReconstruction(rec.fRunLocalReconstruction),
e583c30d 314 fRunTracking(rec.fRunTracking),
315 fFillESD(rec.fFillESD),
7d566c20 316 fLoadCDB(rec.fLoadCDB),
48ce48d1 317 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
e583c30d 318 fGAliceFileName(rec.fGAliceFileName),
4b71572b 319 fRawInput(rec.fRawInput),
975320a0 320 fESDOutput(rec.fESDOutput),
35042093 321 fEquipIdMap(rec.fEquipIdMap),
b26c3770 322 fFirstEvent(rec.fFirstEvent),
323 fLastEvent(rec.fLastEvent),
973388c2 324 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
b8cd5251 325 fOptions(),
6bae477a 326 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
327 fLoadAlignData(rec.fLoadAlignData),
2972d4eb 328 fUseHLTData(rec.fUseHLTData),
7e88424f 329 fRunInfo(NULL),
330 fEventInfo(),
522fdd91 331 fRunScalers(NULL),
e583c30d 332
333 fRunLoader(NULL),
b649205a 334 fRawReader(NULL),
2972d4eb 335 fParentRawReader(NULL),
b8cd5251 336
4b71572b 337 fRecoParam(rec.fRecoParam),
7e88424f 338
58e8dc31 339 fSPDTrackleter(NULL),
340
f2a195c1 341 fDiamondProfileSPD(rec.fDiamondProfileSPD),
4b71572b 342 fDiamondProfile(rec.fDiamondProfile),
343 fDiamondProfileTPC(rec.fDiamondProfileTPC),
77ba28ba 344 fListOfCosmicTriggers(NULL),
f2a195c1 345
6b6e4472 346 fGRPData(NULL),
444753c6 347
6bae477a 348 fAlignObjArray(rec.fAlignObjArray),
ec92bee0 349 fCDBUri(rec.fCDBUri),
f1c1204d 350 fQARefUri(rec.fQARefUri),
7e963665 351 fSpecCDBUri(),
795e4a22 352 fInitCDBCalled(rec.fInitCDBCalled),
353 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
ce43afbe 354 fQADetectors(rec.fQADetectors),
355 fQATasks(rec.fQATasks),
aa3c69a9 356 fRunQA(rec.fRunQA),
357 fRunGlobalQA(rec.fRunGlobalQA),
e4a998ed 358 fSameQACycle(rec.fSameQACycle),
f1c1204d 359 fInitQACalled(rec.fInitQACalled),
75373542 360 fWriteQAExpertData(rec.fWriteQAExpertData),
21a3aa09 361 fRunPlaneEff(rec.fRunPlaneEff),
362
363 fesd(NULL),
364 fhltesd(NULL),
365 fesdf(NULL),
366 ffile(NULL),
367 ftree(NULL),
368 fhlttree(NULL),
21a3aa09 369 ftVertexer(NULL),
14dd053c 370 fIsNewRunLoader(rec.fIsNewRunLoader),
4b71572b 371 fRunAliEVE(kFALSE),
372 fChain(NULL)
596a855f 373{
374// copy constructor
375
ec92bee0 376 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
efd2085e 377 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
378 }
ac4a7581 379 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 380 fReconstructor[iDet] = NULL;
381 fLoader[iDet] = NULL;
382 fTracker[iDet] = NULL;
b1af1125 383 }
384
4e25ac79 385 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
b1af1125 386 fQACycles[iDet] = rec.fQACycles[iDet];
252f8aa8 387 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
388 }
b1af1125 389
ec92bee0 390 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
391 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
392 }
596a855f 393}
394
395//_____________________________________________________________________________
396AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
397{
398// assignment operator
4b71572b 399// Used in PROOF mode
400// Be very careful while modifing it!
401// Simple rules to follow:
402// for persistent data members - use their assignment operators
403// for non-persistent ones - do nothing or take the default values from constructor
404// TSelector members should not be touched
405 if(&rec == this) return *this;
406
4b71572b 407 fRunVertexFinder = rec.fRunVertexFinder;
408 fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
409 fRunHLTTracking = rec.fRunHLTTracking;
410 fRunMuonTracking = rec.fRunMuonTracking;
411 fRunV0Finder = rec.fRunV0Finder;
412 fRunCascadeFinder = rec.fRunCascadeFinder;
413 fStopOnError = rec.fStopOnError;
414 fWriteAlignmentData = rec.fWriteAlignmentData;
415 fWriteESDfriend = rec.fWriteESDfriend;
416 fFillTriggerESD = rec.fFillTriggerESD;
417
418 fCleanESD = rec.fCleanESD;
419 fV0DCAmax = rec.fV0DCAmax;
420 fV0CsPmin = rec.fV0CsPmin;
421 fDmax = rec.fDmax;
422 fZmax = rec.fZmax;
423
424 fRunLocalReconstruction = rec.fRunLocalReconstruction;
425 fRunTracking = rec.fRunTracking;
426 fFillESD = rec.fFillESD;
7d566c20 427 fLoadCDB = rec.fLoadCDB;
4b71572b 428 fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
429 fGAliceFileName = rec.fGAliceFileName;
430 fRawInput = rec.fRawInput;
975320a0 431 fESDOutput = rec.fESDOutput;
4b71572b 432 fEquipIdMap = rec.fEquipIdMap;
433 fFirstEvent = rec.fFirstEvent;
434 fLastEvent = rec.fLastEvent;
435 fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
436
437 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
438 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
439 }
440
441 fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
442 fLoadAlignData = rec.fLoadAlignData;
4b71572b 443 fUseHLTData = rec.fUseHLTData;
444
445 delete fRunInfo; fRunInfo = NULL;
446 if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
447
448 fEventInfo = rec.fEventInfo;
449
522fdd91 450 delete fRunScalers; fRunScalers = NULL;
451 if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
452
453
4b71572b 454 fRunLoader = NULL;
455 fRawReader = NULL;
456 fParentRawReader = NULL;
457
458 fRecoParam = rec.fRecoParam;
459
ac4a7581 460 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4b71572b 461 delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
462 delete fLoader[iDet]; fLoader[iDet] = NULL;
463 delete fTracker[iDet]; fTracker[iDet] = NULL;
4b71572b 464 }
b1af1125 465
4e25ac79 466 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
b1af1125 467 fQACycles[iDet] = rec.fQACycles[iDet];
252f8aa8 468 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
469 }
58e8dc31 470
471 delete fSPDTrackleter; fSPDTrackleter = NULL;
252f8aa8 472
f2a195c1 473 delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
474 if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
4b71572b 475 delete fDiamondProfile; fDiamondProfile = NULL;
476 if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
477 delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
478 if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
4b71572b 479
77ba28ba 480 delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
481 if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
482
4b71572b 483 delete fGRPData; fGRPData = NULL;
44e45fac 484 // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
485 if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
4b71572b 486
487 delete fAlignObjArray; fAlignObjArray = NULL;
488
489 fCDBUri = "";
f1c1204d 490 fQARefUri = rec.fQARefUri;
4b71572b 491 fSpecCDBUri.Delete();
492 fInitCDBCalled = rec.fInitCDBCalled;
493 fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
494 fQADetectors = rec.fQADetectors;
4b71572b 495 fQATasks = rec.fQATasks;
496 fRunQA = rec.fRunQA;
497 fRunGlobalQA = rec.fRunGlobalQA;
4b71572b 498 fSameQACycle = rec.fSameQACycle;
f1c1204d 499 fInitQACalled = rec.fInitQACalled;
75373542 500 fWriteQAExpertData = rec.fWriteQAExpertData;
4b71572b 501 fRunPlaneEff = rec.fRunPlaneEff;
502
503 fesd = NULL;
504 fhltesd = NULL;
505 fesdf = NULL;
506 ffile = NULL;
507 ftree = NULL;
508 fhlttree = NULL;
509 ftVertexer = NULL;
510 fIsNewRunLoader = rec.fIsNewRunLoader;
511 fRunAliEVE = kFALSE;
512 fChain = NULL;
596a855f 513
596a855f 514 return *this;
515}
516
517//_____________________________________________________________________________
518AliReconstruction::~AliReconstruction()
519{
520// clean up
521
e583c30d 522 CleanUp();
77ba28ba 523 if (fListOfCosmicTriggers) {
524 fListOfCosmicTriggers->Delete();
525 delete fListOfCosmicTriggers;
526 }
4f3c479a 527 delete fGRPData;
522fdd91 528 delete fRunScalers;
efd2085e 529 fOptions.Delete();
4b71572b 530 if (fAlignObjArray) {
531 fAlignObjArray->Delete();
532 delete fAlignObjArray;
533 }
ec92bee0 534 fSpecCDBUri.Delete();
e6d66370 535
87932dab 536 AliCodeTimer::Instance()->Print();
596a855f 537}
538
f1c1204d 539//_____________________________________________________________________________
540void AliReconstruction::InitQA()
541{
542 //Initialize the QA and start of cycle
543 AliCodeTimerAuto("");
544
545 if (fInitQACalled) return;
546 fInitQACalled = kTRUE;
547
634696f5 548 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
75373542 549 if (fWriteQAExpertData)
eca4fa66 550 qam->SetWriteExpert() ;
75373542 551
eca4fa66 552 if (qam->IsDefaultStorageSet()) {
f1c1204d 553 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
554 AliWarning("Default QA reference storage has been already set !");
555 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
556 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
eca4fa66 557 fQARefUri = qam->GetDefaultStorage()->GetURI();
f1c1204d 558 } else {
559 if (fQARefUri.Length() > 0) {
560 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
561 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
562 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
563 } else {
564 fQARefUri="local://$ALICE_ROOT/QAref";
565 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
566 AliWarning("Default QA refeference storage not yet set !!!!");
567 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
568 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
569
570 }
eca4fa66 571 qam->SetDefaultStorage(fQARefUri);
f1c1204d 572 }
573
574 if (fRunQA) {
eca4fa66 575 qam->SetActiveDetectors(fQADetectors) ;
4e25ac79 576 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
eca4fa66 577 qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
578 qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
f1c1204d 579 }
87da0921 580 if (!fRawReader && !fInput && fQATasks.Contains(AliQAv1::kRAWS))
4e25ac79 581 fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
eca4fa66 582 qam->SetTasks(fQATasks) ;
583 qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
f1c1204d 584 }
585 if (fRunGlobalQA) {
586 Bool_t sameCycle = kFALSE ;
eca4fa66 587 AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
f1c1204d 588 AliInfo(Form("Initializing the global QA data maker"));
4e25ac79 589 if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS))) {
590 qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
591 TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
f1c1204d 592 AliTracker::SetResidualsArray(arr);
593 sameCycle = kTRUE ;
594 }
4e25ac79 595 if (fQATasks.Contains(Form("%d", AliQAv1::kESDS))) {
596 qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
597 qadm->Init(AliQAv1::kESDS);
f1c1204d 598 }
f1c1204d 599 }
fc07289e 600 AliSysInfo::AddStamp("InitQA") ;
f1c1204d 601}
602
fc07289e 603//_____________________________________________________________________________
87da0921 604void AliReconstruction::MergeQA(const char *fileName)
fc07289e 605{
606 //Initialize the QA and start of cycle
607 AliCodeTimerAuto("") ;
eca4fa66 608 AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
fc07289e 609 AliSysInfo::AddStamp("MergeQA") ;
610}
611
024cf675 612//_____________________________________________________________________________
795e4a22 613void AliReconstruction::InitCDB()
024cf675 614{
615// activate a default CDB storage
616// First check if we have any CDB storage set, because it is used
617// to retrieve the calibration and alignment constants
002c9d1b 618 AliCodeTimerAuto("");
024cf675 619
795e4a22 620 if (fInitCDBCalled) return;
621 fInitCDBCalled = kTRUE;
622
024cf675 623 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 624 if (man->IsDefaultStorageSet())
024cf675 625 {
626 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 627 AliWarning("Default CDB storage has been already set !");
628 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
024cf675 629 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
795e4a22 630 fCDBUri = man->GetDefaultStorage()->GetURI();
ec92bee0 631 }
632 else {
795e4a22 633 if (fCDBUri.Length() > 0)
634 {
635 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
636 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
637 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
638 } else {
162637e4 639 fCDBUri="local://$ALICE_ROOT/OCDB";
795e4a22 640 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
641 AliWarning("Default CDB storage not yet set !!!!");
642 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
643 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
644
645 }
ec92bee0 646 man->SetDefaultStorage(fCDBUri);
647 }
648
649 // Now activate the detector specific CDB storage locations
c3a7b59a 650 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
651 TObject* obj = fSpecCDBUri[i];
652 if (!obj) continue;
b8ec52f6 653 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
654 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
655 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 656 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 657 }
002c9d1b 658 AliSysInfo::AddStamp("InitCDB");
024cf675 659}
660
661//_____________________________________________________________________________
662void AliReconstruction::SetDefaultStorage(const char* uri) {
ec92bee0 663// Store the desired default CDB storage location
664// Activate it later within the Run() method
024cf675 665
ec92bee0 666 fCDBUri = uri;
024cf675 667
668}
669
f1c1204d 670//_____________________________________________________________________________
671void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
672 // Store the desired default CDB storage location
673 // Activate it later within the Run() method
674
675 fQARefUri = uri;
4e25ac79 676 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
f1c1204d 677
678}
00aa02d5 679//_____________________________________________________________________________
c3a7b59a 680void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 681// Store a detector-specific CDB storage location
682// Activate it later within the Run() method
024cf675 683
c3a7b59a 684 AliCDBPath aPath(calibType);
685 if(!aPath.IsValid()){
686 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
ac4a7581 687 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
c3a7b59a 688 if(!strcmp(calibType, fgkDetectorName[iDet])) {
689 aPath.SetPath(Form("%s/*", calibType));
690 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
691 break;
692 }
693 }
694 if(!aPath.IsValid()){
695 AliError(Form("Not a valid path or detector: %s", calibType));
696 return;
697 }
698 }
699
53dd3c3d 700// // check that calibType refers to a "valid" detector name
701// Bool_t isDetector = kFALSE;
ac4a7581 702// for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
53dd3c3d 703// TString detName = fgkDetectorName[iDet];
704// if(aPath.GetLevel0() == detName) {
705// isDetector = kTRUE;
706// break;
707// }
708// }
709//
710// if(!isDetector) {
711// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
712// return;
713// }
c3a7b59a 714
715 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
ec92bee0 716 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 717 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
024cf675 718
719}
720
6bae477a 721//_____________________________________________________________________________
795e4a22 722Bool_t AliReconstruction::SetRunNumberFromData()
6bae477a 723{
724 // The method is called in Run() in order
725 // to set a correct run number.
726 // In case of raw data reconstruction the
727 // run number is taken from the raw data header
728
795e4a22 729 if (fSetRunNumberFromDataCalled) return kTRUE;
730 fSetRunNumberFromDataCalled = kTRUE;
731
732 AliCDBManager* man = AliCDBManager::Instance();
4b71572b 733
734 if(fRawReader) {
735 if(fRawReader->NextEvent()) {
736 if(man->GetRun() > 0) {
21a3aa09 737 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
4b71572b 738 }
739 man->SetRun(fRawReader->GetRunNumber());
740 fRawReader->RewindEvents();
741 }
742 else {
743 if(man->GetRun() > 0) {
744 AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
745 }
746 else {
747 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
748 return kFALSE;
749 }
750 }
751 }
752 else {
753 AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
754 if (!rl) {
755 AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
6bae477a 756 return kFALSE;
757 }
ec92bee0 758 else {
4b71572b 759 rl->LoadHeader();
760 // read run number from gAlice
761 if(rl->GetHeader()) {
762 man->SetRun(rl->GetHeader()->GetRun());
763 rl->UnloadHeader();
764 delete rl;
ec92bee0 765 }
766 else {
4b71572b 767 AliError("Neither run-loader header nor RawReader objects are found !");
768 delete rl;
ec92bee0 769 return kFALSE;
770 }
4b71572b 771 }
6bae477a 772 }
795e4a22 773
774 man->Print();
775
6bae477a 776 return kTRUE;
777}
778
795e4a22 779//_____________________________________________________________________________
780void AliReconstruction::SetCDBLock() {
781 // Set CDB lock: from now on it is forbidden to reset the run number
782 // or the default storage or to activate any further storage!
783
784 AliCDBManager::Instance()->SetLock(1);
785}
786
6bae477a 787//_____________________________________________________________________________
788Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
789{
790 // Read the alignment objects from CDB.
791 // Each detector is supposed to have the
792 // alignment objects in DET/Align/Data CDB path.
793 // All the detector objects are then collected,
794 // sorted by geometry level (starting from ALIC) and
795 // then applied to the TGeo geometry.
796 // Finally an overlaps check is performed.
797
798 // Load alignment data from CDB and fill fAlignObjArray
799 if(fLoadAlignFromCDB){
6bae477a 800
25be1e5c 801 TString detStr = detectors;
802 TString loadAlObjsListOfDets = "";
803
ac4a7581 804 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
8cb26cdf 805 if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
f12d42ce 806 if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
4fbb8e9d 807
808 if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
8cb26cdf 809 {
810 loadAlObjsListOfDets += fgkDetectorName[iDet];
811 loadAlObjsListOfDets += " ";
812 }
25be1e5c 813 } // end loop over detectors
4fbb8e9d 814
815 if(AliGeomManager::GetNalignable("GRP") != 0)
8cb26cdf 816 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
98e303d9 817 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
e30a9b4d 818 AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
25be1e5c 819 }else{
820 // Check if the array with alignment objects was
821 // provided by the user. If yes, apply the objects
822 // to the present TGeo geometry
823 if (fAlignObjArray) {
824 if (gGeoManager && gGeoManager->IsClosed()) {
98e303d9 825 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
25be1e5c 826 AliError("The misalignment of one or more volumes failed!"
827 "Compare the list of simulated detectors and the list of detector alignment data!");
828 return kFALSE;
829 }
830 }
831 else {
832 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
6bae477a 833 return kFALSE;
834 }
835 }
6bae477a 836 }
25be1e5c 837
4b71572b 838 if (fAlignObjArray) {
839 fAlignObjArray->Delete();
840 delete fAlignObjArray; fAlignObjArray=NULL;
841 }
a03b0371 842
6bae477a 843 return kTRUE;
844}
596a855f 845
846//_____________________________________________________________________________
847void AliReconstruction::SetGAliceFile(const char* fileName)
848{
849// set the name of the galice file
850
851 fGAliceFileName = fileName;
852}
853
21a3aa09 854//_____________________________________________________________________________
b58710ef 855void AliReconstruction::SetInput(const char* input)
21a3aa09 856{
b58710ef 857 // In case the input string starts with 'mem://', we run in an online mode
858 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
859 // file is assumed. One can give as an input:
860 // mem://: - events taken from DAQ monitoring libs online
861 // or
862 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
4b71572b 863 if (input) fRawInput = input;
21a3aa09 864}
865
975320a0 866//_____________________________________________________________________________
867void AliReconstruction::SetOutput(const char* output)
868{
869 // Set the output ESD filename
870 // 'output' is a normalt ROOT url
871 // The method is used in case of raw-data reco with PROOF
872 if (output) fESDOutput.SetUrl(output);
873}
874
efd2085e 875//_____________________________________________________________________________
876void AliReconstruction::SetOption(const char* detector, const char* option)
877{
878// set options for the reconstruction of a detector
879
880 TObject* obj = fOptions.FindObject(detector);
881 if (obj) fOptions.Remove(obj);
882 fOptions.Add(new TNamed(detector, option));
883}
884
7e88424f 885//_____________________________________________________________________________
886void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
887{
888 // Set custom reconstruction parameters for a given detector
889 // Single set of parameters for all the events
a00021a7 890
891 // First check if the reco-params are global
892 if(!strcmp(detector, "GRP")) {
893 par->SetAsDefault();
ac4a7581 894 fRecoParam.AddDetRecoParam(kNDetectors,par);
a00021a7 895 return;
896 }
897
ac4a7581 898 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
7e88424f 899 if(!strcmp(detector, fgkDetectorName[iDet])) {
900 par->SetAsDefault();
901 fRecoParam.AddDetRecoParam(iDet,par);
902 break;
903 }
904 }
905
906}
907
61807e09 908//_____________________________________________________________________________
33c3c91a 909Bool_t AliReconstruction::SetFieldMap(Float_t l3Cur, Float_t diCur, Float_t l3Pol,
910 Float_t diPol, Float_t beamenergy,
911 const Char_t *beamtype, const Char_t *path)
912{
61807e09 913 //------------------------------------------------
914 // The magnetic field map, defined externally...
915 // L3 current 30000 A -> 0.5 T
916 // L3 current 12000 A -> 0.2 T
917 // dipole current 6000 A
918 // The polarities must be the same
919 //------------------------------------------------
920 const Float_t l3NominalCurrent1=30000.; // (A)
921 const Float_t l3NominalCurrent2=12000.; // (A)
922 const Float_t diNominalCurrent =6000. ; // (A)
923
924 const Float_t tolerance=0.03; // relative current tolerance
925 const Float_t zero=77.; // "zero" current (A)
f7a1cc68 926 //
927 TString s=(l3Pol < 0) ? "L3: -" : "L3: +";
928 //
929 AliMagF::BMap_t map = AliMagF::k5kG;
930 //
931 double fcL3,fcDip;
932 //
933 l3Cur = TMath::Abs(l3Cur);
934 if (TMath::Abs(l3Cur-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
935 fcL3 = l3Cur/l3NominalCurrent1;
936 map = AliMagF::k5kG;
937 s += "0.5 T; ";
938 } else if (TMath::Abs(l3Cur-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
939 fcL3 = l3Cur/l3NominalCurrent2;
940 map = AliMagF::k2kG;
941 s += "0.2 T; ";
942 } else if (l3Cur <= zero) {
943 fcL3 = 0;
944 map = AliMagF::k5kGUniform;
945 s += "0.0 T; ";
61807e09 946 } else {
f7a1cc68 947 AliError(Form("Wrong L3 current (%f A)!",l3Cur));
61807e09 948 return kFALSE;
949 }
f7a1cc68 950 //
951 diCur = TMath::Abs(diCur);
952 if (TMath::Abs(diCur-diNominalCurrent)/diNominalCurrent < tolerance) {
61807e09 953 // 3% current tolerance...
f7a1cc68 954 fcDip = diCur/diNominalCurrent;
955 s += "Dipole ON";
956 } else if (diCur <= zero) { // some small current..
957 fcDip = 0.;
958 s += "Dipole OFF";
61807e09 959 } else {
f7a1cc68 960 AliError(Form("Wrong dipole current (%f A)!",diCur));
61807e09 961 return kFALSE;
962 }
f7a1cc68 963 //
964 if (l3Pol!=diPol && (map==AliMagF::k5kG || map==AliMagF::k2kG) && fcDip!=0) {
965 AliError("L3 and Dipole polarities must be the same");
966 return kFALSE;
967 }
968 //
969 if (l3Pol<0) fcL3 = -fcL3;
970 if (diPol<0) fcDip = -fcDip;
971 //
972 AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
973 TString btypestr = beamtype;
974 btypestr.ToLower();
975 TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1");
976 TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1");
977 if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
978 else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
979 else {
980 AliInfo(Form("Cannot determine the beam type from %s, assume no LHC magnet field",beamtype));
981 }
982
983 AliMagF* fld = new AliMagF("MagneticFieldMap", s.Data(), 2, fcL3, fcDip, 10., map, path,
9251fceb 984 btype,beamenergy);
f7a1cc68 985 TGeoGlobalMagField::Instance()->SetField( fld );
986 TGeoGlobalMagField::Instance()->Lock();
987 //
61807e09 988 return kTRUE;
989}
990
991
992Bool_t AliReconstruction::InitGRP() {
993 //------------------------------------
994 // Initialization of the GRP entry
995 //------------------------------------
996 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
997
4b71572b 998 if (entry) {
44e45fac 999
1000 TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
1001
1002 if (m) {
1003 AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1004 m->Print();
1005 fGRPData = new AliGRPObject();
1006 fGRPData->ReadValuesFromMap(m);
1007 }
1008
1009 else {
1010 AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1011 fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
1012 entry->SetOwner(0);
1013 }
1014
4b71572b 1015 AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1016 }
61807e09 1017
1018 if (!fGRPData) {
1019 AliError("No GRP entry found in OCDB!");
1020 return kFALSE;
1021 }
1022
44e45fac 1023 TString lhcState = fGRPData->GetLHCState();
1024 if (lhcState==AliGRPObject::GetInvalidString()) {
7e88424f 1025 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
44e45fac 1026 lhcState = "UNKNOWN";
7e88424f 1027 }
1028
44e45fac 1029 TString beamType = fGRPData->GetBeamType();
1030 if (beamType==AliGRPObject::GetInvalidString()) {
7e88424f 1031 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
44e45fac 1032 beamType = "UNKNOWN";
7e88424f 1033 }
1034
44e45fac 1035 Float_t beamEnergy = fGRPData->GetBeamEnergy();
1036 if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
7e88424f 1037 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
44e45fac 1038 beamEnergy = 0;
7e88424f 1039 }
f7a1cc68 1040 // energy is provided in MeV*120
1041 beamEnergy /= 120E3;
7e88424f 1042
44e45fac 1043 TString runType = fGRPData->GetRunType();
1044 if (runType==AliGRPObject::GetInvalidString()) {
7e88424f 1045 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
44e45fac 1046 runType = "UNKNOWN";
7e88424f 1047 }
1048
44e45fac 1049 Int_t activeDetectors = fGRPData->GetDetectorMask();
a5dede5c 1050 if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
7e88424f 1051 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
44e45fac 1052 activeDetectors = 1074790399;
7e88424f 1053 }
1054
44e45fac 1055 fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
44e45fac 1056 fRunInfo->Dump();
1057
7e88424f 1058
1059 // Process the list of active detectors
44e45fac 1060 if (activeDetectors) {
1061 UInt_t detMask = activeDetectors;
7a317bef 1062 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1063 fRunTracking = MatchDetectorList(fRunTracking,detMask);
1064 fFillESD = MatchDetectorList(fFillESD,detMask);
1065 fQADetectors = MatchDetectorList(fQADetectors,detMask);
7d566c20 1066 fLoadCDB.Form("%s %s %s %s",
1067 fRunLocalReconstruction.Data(),
1068 fRunTracking.Data(),
1069 fFillESD.Data(),
1070 fQADetectors.Data());
7d566c20 1071 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
91e2f025 1072 if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
1073 // switch off the vertexer
1074 AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
1075 fRunVertexFinder = kFALSE;
1076 }
304d7f0b 1077 if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1078 // switch off the reading of CTP raw-data payload
1079 if (fFillTriggerESD) {
1080 AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1081 fFillTriggerESD = kFALSE;
1082 }
1083 }
7e88424f 1084 }
1085
1086 AliInfo("===================================================================================");
1087 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1088 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1089 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
ca13fb87 1090 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
7d566c20 1091 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
7e88424f 1092 AliInfo("===================================================================================");
61807e09 1093
1094 //*** Dealing with the magnetic field map
f7a1cc68 1095 if ( TGeoGlobalMagField::Instance()->IsLocked() ) {AliInfo("Running with the externally locked B field !");}
1096 else {
61807e09 1097 // Construct the field map out of the information retrieved from GRP.
856024f0 1098 Bool_t ok = kTRUE;
61807e09 1099 // L3
44e45fac 1100 Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1101 if (l3Current == AliGRPObject::GetInvalidFloat()) {
1102 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
1103 ok = kFALSE;
1104 }
f7a1cc68 1105
44e45fac 1106 Char_t l3Polarity = fGRPData->GetL3Polarity();
1107 if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1108 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
1109 ok = kFALSE;
1110 }
1111
1112 // Dipole
1113 Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1114 if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1115 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1116 ok = kFALSE;
1117 }
1118
1119 Char_t diPolarity = fGRPData->GetDipolePolarity();
1120 if (diPolarity == AliGRPObject::GetInvalidChar()) {
1121 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1122 ok = kFALSE;
1123 }
1124
1125 /*
61807e09 1126 TObjString *l3Current=
1127 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
1128 if (!l3Current) {
1129 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
856024f0 1130 ok = kFALSE;
61807e09 1131 }
1132 TObjString *l3Polarity=
1133 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
1134 if (!l3Polarity) {
1135 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
856024f0 1136 ok = kFALSE;
61807e09 1137 }
44e45fac 1138
61807e09 1139 // Dipole
1140 TObjString *diCurrent=
1141 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
1142 if (!diCurrent) {
1143 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
856024f0 1144 ok = kFALSE;
61807e09 1145 }
1146 TObjString *diPolarity=
1147 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
1148 if (!diPolarity) {
1149 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
856024f0 1150 ok = kFALSE;
61807e09 1151 }
44e45fac 1152 */
61807e09 1153
856024f0 1154 if (ok) {
f7a1cc68 1155 if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1) )
1156 AliFatal("Failed to creat a B field map ! Exiting...");
856024f0 1157 AliInfo("Running with the B field constructed out of GRP !");
1158 }
f7a1cc68 1159 else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1160
61807e09 1161 }
f7a1cc68 1162
f2a195c1 1163 //*** Get the diamond profiles from OCDB
1164 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1165 if (entry) {
1166 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1167 } else {
1168 AliError("No SPD diamond profile found in OCDB!");
1169 }
1170
61807e09 1171 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1172 if (entry) {
f2a195c1 1173 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
61807e09 1174 } else {
1175 AliError("No diamond profile found in OCDB!");
1176 }
1177
1178 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1179 if (entry) {
f2a195c1 1180 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
61807e09 1181 } else {
f2a195c1 1182 AliError("No TPC diamond profile found in OCDB!");
61807e09 1183 }
1184
77ba28ba 1185 entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1186 if (entry) {
1187 fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1188 entry->SetOwner(0);
1189 AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1190 }
1191
1192 if (!fListOfCosmicTriggers) {
1193 AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1194 }
1195
61807e09 1196 return kTRUE;
1197}
1198
4b71572b 1199//_____________________________________________________________________________
1200Bool_t AliReconstruction::LoadCDB()
1201{
1202 AliCodeTimerAuto("");
1203
1204 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1205
7d566c20 1206 TString detStr = fLoadCDB;
ac4a7581 1207 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4b71572b 1208 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1209 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1210 }
1211 return kTRUE;
1212}
522fdd91 1213//_____________________________________________________________________________
1214Bool_t AliReconstruction::LoadTriggerScalersCDB()
1215{
1216 AliCodeTimerAuto("");
1217
1218 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
4b71572b 1219
522fdd91 1220 if (entry) {
1221
1222 AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1223 fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1224 entry->SetOwner(0);
82ebedd6 1225 if (fRunScalers->CorrectScalersOverflow() == 0) AliInfo("32bit Trigger counters corrected for overflow");
1226
522fdd91 1227 }
1228 return kTRUE;
1229}
596a855f 1230//_____________________________________________________________________________
21a3aa09 1231Bool_t AliReconstruction::Run(const char* input)
596a855f 1232{
21a3aa09 1233 // Run Run Run
1234 AliCodeTimerAuto("");
596a855f 1235
4b71572b 1236 InitRun(input);
1237 if (GetAbort() != TSelector::kContinue) return kFALSE;
1238
1239 TChain *chain = NULL;
1240 if (fRawReader && (chain = fRawReader->GetChain())) {
1241 // Proof mode
1242 if (gProof) {
4b71572b 1243 gProof->AddInput(this);
975320a0 1244 if (!fESDOutput.IsValid()) {
1245 fESDOutput.SetProtocol("root",kTRUE);
1246 fESDOutput.SetHost(gSystem->HostName());
1247 fESDOutput.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
1248 }
1249 AliInfo(Form("Output file with ESDs is %s",fESDOutput.GetUrl()));
1250 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",fESDOutput.GetUrl()));
1251 gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
4b71572b 1252 chain->SetProof();
1253 chain->Process("AliReconstruction");
1254 }
1255 else {
1256 chain->Process(this);
1257 }
1258 }
1259 else {
1260 Begin(NULL);
1261 if (GetAbort() != TSelector::kContinue) return kFALSE;
1262 SlaveBegin(NULL);
1263 if (GetAbort() != TSelector::kContinue) return kFALSE;
1264 //******* The loop over events
44e45fac 1265 AliInfo("Starting looping over events");
4b71572b 1266 Int_t iEvent = 0;
1267 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1268 (fRawReader && fRawReader->NextEvent())) {
1269 if (!ProcessEvent(iEvent)) {
930e6e3e 1270 Abort("ProcessEvent",TSelector::kAbortFile);
1271 return kFALSE;
4b71572b 1272 }
1273 iEvent++;
1274 }
1275 SlaveTerminate();
1276 if (GetAbort() != TSelector::kContinue) return kFALSE;
1277 Terminate();
1278 if (GetAbort() != TSelector::kContinue) return kFALSE;
21a3aa09 1279 }
21a3aa09 1280
1281 return kTRUE;
1282}
1283
1284//_____________________________________________________________________________
4b71572b 1285void AliReconstruction::InitRawReader(const char* input)
21a3aa09 1286{
21a3aa09 1287 AliCodeTimerAuto("");
1288
4b71572b 1289 // Init raw-reader and
21a3aa09 1290 // set the input in case of raw data
4b71572b 1291 if (input) fRawInput = input;
1292 fRawReader = AliRawReader::Create(fRawInput.Data());
b58710ef 1293 if (!fRawReader)
21a3aa09 1294 AliInfo("Reconstruction will run over digits");
e0027792 1295
35042093 1296 if (!fEquipIdMap.IsNull() && fRawReader)
1297 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1298
cd0b062e 1299 if (!fUseHLTData.IsNull()) {
1300 // create the RawReaderHLT which performs redirection of HLT input data for
1301 // the specified detectors
1302 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1303 if (pRawReader) {
1304 fParentRawReader=fRawReader;
1305 fRawReader=pRawReader;
1306 } else {
1307 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1308 }
1309 }
4b71572b 1310 AliSysInfo::AddStamp("CreateRawReader");
1311}
cd0b062e 1312
4b71572b 1313//_____________________________________________________________________________
1314void AliReconstruction::InitRun(const char* input)
1315{
1316 // Initialization of raw-reader,
1317 // run number, CDB etc.
1318 AliCodeTimerAuto("");
1319 AliSysInfo::AddStamp("Start");
1320
002c9d1b 1321 // Initialize raw-reader if any
4b71572b 1322 InitRawReader(input);
596a855f 1323
ec92bee0 1324 // Initialize the CDB storage
795e4a22 1325 InitCDB();
ec92bee0 1326
6bae477a 1327 // Set run number in CDBManager (if it is not already set by the user)
4b71572b 1328 if (!SetRunNumberFromData()) {
1329 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1330 return;
1331 }
002c9d1b 1332
795e4a22 1333 // Set CDB lock: from now on it is forbidden to reset the run number
1334 // or the default storage or to activate any further storage!
1335 SetCDBLock();
1336
002c9d1b 1337}
1338
1339//_____________________________________________________________________________
1340void AliReconstruction::Begin(TTree *)
1341{
1342 // Initialize AlReconstruction before
1343 // going into the event loop
1344 // Should follow the TSelector convention
1345 // i.e. initialize only the object on the client side
db4aeca1 1346 AliCodeTimerAuto("");
1347
b4fef0d2 1348 AliReconstruction *reco = NULL;
002c9d1b 1349 if (fInput) {
8fb1f1dc 1350 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
002c9d1b 1351 *this = *reco;
002c9d1b 1352 }
1353 AliSysInfo::AddStamp("ReadInputInBegin");
1354 }
1355
6bae477a 1356 // Import ideal TGeo geometry and apply misalignment
1357 if (!gGeoManager) {
1358 TString geom(gSystem->DirName(fGAliceFileName));
1359 geom += "/geometry.root";
98e303d9 1360 AliGeomManager::LoadGeometry(geom.Data());
4b71572b 1361 if (!gGeoManager) {
1362 Abort("LoadGeometry", TSelector::kAbortProcess);
1363 return;
1364 }
281270d3 1365 AliSysInfo::AddStamp("LoadGeom");
ff5970a3 1366 TString detsToCheck=fRunLocalReconstruction;
4b71572b 1367 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1368 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1369 return;
1370 }
281270d3 1371 AliSysInfo::AddStamp("CheckGeom");
6bae477a 1372 }
8e245d15 1373
4b71572b 1374 if (!MisalignGeometry(fLoadAlignData)) {
1375 Abort("MisalignGeometry", TSelector::kAbortProcess);
1376 return;
1377 }
1378 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
281270d3 1379 AliSysInfo::AddStamp("MisalignGeom");
6bae477a 1380
8cb26cdf 1381 if (!InitGRP()) {
1382 Abort("InitGRP", TSelector::kAbortProcess);
1383 return;
1384 }
1385 AliSysInfo::AddStamp("InitGRP");
1386
4b71572b 1387 if (!LoadCDB()) {
1388 Abort("LoadCDB", TSelector::kAbortProcess);
1389 return;
1390 }
1391 AliSysInfo::AddStamp("LoadCDB");
325aa76f 1392
a6dd87ad 1393 if (!LoadTriggerScalersCDB()) {
1394 Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1395 return;
1396 }
1397 AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1398
1399
7e88424f 1400 // Read the reconstruction parameters from OCDB
1401 if (!InitRecoParams()) {
002c9d1b 1402 AliWarning("Not all detectors have correct RecoParam objects initialized");
4b71572b 1403 }
1404 AliSysInfo::AddStamp("InitRecoParams");
1405
fd2b273c 1406 if (fInput && gProof) {
b4fef0d2 1407 if (reco) *reco = *this;
fd2b273c 1408
1409 gProof->AddInputData(gGeoManager,kTRUE);
002c9d1b 1410 gGeoManager = NULL;
fd2b273c 1411 gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
002c9d1b 1412 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
f7a1cc68 1413 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
ead7b391 1414 magFieldMap->SetName("MagneticFieldMap");
fd2b273c 1415 gProof->AddInputData(magFieldMap,kTRUE);
002c9d1b 1416 }
4b71572b 1417
1418}
1419
1420//_____________________________________________________________________________
1421void AliReconstruction::SlaveBegin(TTree*)
1422{
1423 // Initialization related to run-loader,
1424 // vertexer, trackers, recontructors
1425 // In proof mode it is executed on the slave
1426 AliCodeTimerAuto("");
1427
db4aeca1 1428 TProofOutputFile *outProofFile = NULL;
ead7b391 1429 if (fInput) {
db4aeca1 1430 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1431 *this = *reco;
1432 }
4b71572b 1433 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1434 gGeoManager = tgeo;
1435 AliGeomManager::SetGeometry(tgeo);
7e88424f 1436 }
281270d3 1437 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1438 Int_t runNumber = -1;
1439 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1440 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1441 man->SetCacheFlag(kTRUE);
1442 man->SetLock(kTRUE);
1443 man->Print();
1444 }
4b71572b 1445 }
ead7b391 1446 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
f7a1cc68 1447 TGeoGlobalMagField::Instance()->SetField(map);
4b71572b 1448 }
db4aeca1 1449 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1450 outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
1451 outProofFile->SetOutputFileName(outputFileName->GetTitle());
1452 fOutput->Add(outProofFile);
4b71572b 1453 }
002c9d1b 1454 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
7e88424f 1455 }
325aa76f 1456
4b71572b 1457 // get the run loader
1458 if (!InitRunLoader()) {
1459 Abort("InitRunLoader", TSelector::kAbortProcess);
1460 return;
1461 }
1462 AliSysInfo::AddStamp("LoadLoader");
1463
325aa76f 1464 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
2257f27e 1465
f08fc9f5 1466 // get trackers
b8cd5251 1467 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
4b71572b 1468 Abort("CreateTrackers", TSelector::kAbortProcess);
1469 return;
1470 }
1471 AliSysInfo::AddStamp("CreateTrackers");
24f7a148 1472
36711aa4 1473 // create the ESD output file and tree
db4aeca1 1474 if (!outProofFile) {
1475 ffile = TFile::Open("AliESDs.root", "RECREATE");
1476 ffile->SetCompressionLevel(2);
1477 if (!ffile->IsOpen()) {
1478 Abort("OpenESDFile", TSelector::kAbortProcess);
1479 return;
1480 }
1481 }
1482 else {
1483 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1484 Abort(Form("Problems opening output PROOF file: %s/%s",
1485 outProofFile->GetDir(), outProofFile->GetFileName()),
1486 TSelector::kAbortProcess);
1487 return;
1488 }
596a855f 1489 }
46698ae4 1490
21a3aa09 1491 ftree = new TTree("esdTree", "Tree with ESD objects");
1492 fesd = new AliESDEvent();
1493 fesd->CreateStdContent();
32ba9c61 1494
1495 fesd->WriteToTree(ftree);
1d99986f 1496 if (fWriteESDfriend) {
32ba9c61 1497 // careful:
1498 // Since we add the branch manually we must
1499 // book and add it after WriteToTree
1500 // otherwise it is created twice,
1501 // once via writetotree and once here.
1502 // The case for AliESDfriend is now
1503 // caught also in AlIESDEvent::WriteToTree but
1504 // be careful when changing the name (AliESDfriend is not
1505 // a TNamed so we had to hardwire it)
21a3aa09 1506 fesdf = new AliESDfriend();
1507 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
46698ae4 1508 br->SetFile("AliESDfriends.root");
21a3aa09 1509 fesd->AddObject(fesdf);
1d99986f 1510 }
f9604a22 1511 ftree->GetUserInfo()->Add(fesd);
1512
1513 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1514 fhltesd = new AliESDEvent();
1515 fhltesd->CreateStdContent();
7491aea6 1516
1517 // read the ESD template from CDB
1518 // HLT is allowed to put non-std content to its ESD, the non-std
1519 // objects need to be created before invocation of WriteToTree in
1520 // order to create all branches. Initialization is done from an
1521 // ESD layout template in CDB
1522 AliCDBManager* man = AliCDBManager::Instance();
1523 AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1524 AliCDBEntry* hltESDConfig=NULL;
1525 if (man->GetId(hltESDConfigPath)!=NULL &&
1526 (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1527 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1528 if (pESDLayout) {
1529 // init all internal variables from the list of objects
1530 pESDLayout->GetStdContent();
1531
1532 // copy content and create non-std objects
1533 *fhltesd=*pESDLayout;
1534 fhltesd->Reset();
1535 } else {
1536 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1537 hltESDConfigPath.GetPath().Data()));
1538 }
1539 }
1540
f9604a22 1541 fhltesd->WriteToTree(fhlttree);
1542 fhlttree->GetUserInfo()->Add(fhltesd);
5728d3d5 1543
ac4a7581 1544 ProcInfo_t procInfo;
1545 gSystem->GetProcInfo(&procInfo);
1546 AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
8661738e 1547
325aa76f 1548 //QA
930e6e3e 1549 //Initialize the QA and start of cycle
f1c1204d 1550 if (fRunQA || fRunGlobalQA)
1551 InitQA() ;
aa3c69a9 1552
7167ae53 1553 //Initialize the Plane Efficiency framework
1554 if (fRunPlaneEff && !InitPlaneEff()) {
4b71572b 1555 Abort("InitPlaneEff", TSelector::kAbortProcess);
1556 return;
7167ae53 1557 }
aa3c69a9 1558
14dd053c 1559 if (strcmp(gProgName,"alieve") == 0)
1560 fRunAliEVE = InitAliEVE();
1561
4b71572b 1562 return;
21a3aa09 1563}
1564
1565//_____________________________________________________________________________
4b71572b 1566Bool_t AliReconstruction::Process(Long64_t entry)
1567{
1568 // run the reconstruction over a single entry
1569 // from the chain with raw data
1570 AliCodeTimerAuto("");
1571
1572 TTree *currTree = fChain->GetTree();
33314186 1573 AliRawVEvent *event = NULL;
4b71572b 1574 currTree->SetBranchAddress("rawevent",&event);
1575 currTree->GetEntry(entry);
1576 fRawReader = new AliRawReaderRoot(event);
1577 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1578 delete fRawReader;
1579 fRawReader = NULL;
1580 delete event;
1581
1582 return fStatus;
1583}
1584
1585//_____________________________________________________________________________
1586void AliReconstruction::Init(TTree *tree)
1587{
1588 if (tree == 0) {
1589 AliError("The input tree is not found!");
1590 return;
1591 }
1592 fChain = tree;
1593}
1594
1595//_____________________________________________________________________________
1596Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
21a3aa09 1597{
1598 // run the reconstruction over a single event
1599 // The event loop is steered in Run method
1600
1601 AliCodeTimerAuto("");
1602
1603 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1604 fRunLoader->SetEventNumber(iEvent);
1605 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1606 iEvent, iEvent);
21a3aa09 1607 fRunLoader->TreeE()->Fill();
4b71572b 1608 if (fRawReader && fRawReader->UseAutoSaveESD())
1609 fRunLoader->TreeE()->AutoSave("SaveSelf");
21a3aa09 1610 }
1611
1612 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
21a3aa09 1613 return kTRUE;
1614 }
1615
1616 AliInfo(Form("processing event %d", iEvent));
aa3c69a9 1617
16447f18 1618 fRunLoader->GetEvent(iEvent);
1619
7e88424f 1620 // Fill Event-info object
1621 GetEventInfo();
77ba28ba 1622 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
48f5e52d 1623 AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
7e88424f 1624
a00021a7 1625 // Set the reco-params
1626 {
1627 TString detStr = fLoadCDB;
ac4a7581 1628 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
a00021a7 1629 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1630 AliReconstructor *reconstructor = GetReconstructor(iDet);
1631 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
57acd2d2 1632 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1633 reconstructor->SetRecoParam(par);
1634 if (fRunQA) {
eca4fa66 1635 AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
6252ceeb 1636 AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
57acd2d2 1637 }
a00021a7 1638 }
1639 }
1640 }
1641
ca13fb87 1642 // QA on single raw
57acd2d2 1643 if (fRunQA) {
eca4fa66 1644 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1645 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
57acd2d2 1646 }
d506c543 1647 // local single event reconstruction
b26c3770 1648 if (!fRunLocalReconstruction.IsNull()) {
d506c543 1649 TString detectors=fRunLocalReconstruction;
a441bf51 1650 // run HLT event reconstruction first
d506c543 1651 // ;-( IsSelected changes the string
1652 if (IsSelected("HLT", detectors) &&
1653 !RunLocalEventReconstruction("HLT")) {
4b71572b 1654 if (fStopOnError) {CleanUp(); return kFALSE;}
a441bf51 1655 }
1656 detectors=fRunLocalReconstruction;
1657 detectors.ReplaceAll("HLT", "");
1658 if (!RunLocalEventReconstruction(detectors)) {
4b71572b 1659 if (fStopOnError) {CleanUp(); return kFALSE;}
b26c3770 1660 }
1661 }
1662
21a3aa09 1663 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1664 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1665 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1666 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 1667
d6ee376f 1668 // Set magnetic field from the tracker
21a3aa09 1669 fesd->SetMagneticField(AliTracker::GetBz());
1670 fhltesd->SetMagneticField(AliTracker::GetBz());
596a855f 1671
71f6cda4 1672 // Set most probable pt, for B=0 tracking
9257a1bd 1673 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
ac4a7581 1674 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
71f6cda4 1675 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
46698ae4 1676
2e3550da 1677 // Fill raw-data error log into the ESD
21a3aa09 1678 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1679
2257f27e 1680 // vertex finder
1681 if (fRunVertexFinder) {
4b71572b 1682 if (!RunVertexFinder(fesd)) {
1683 if (fStopOnError) {CleanUp(); return kFALSE;}
2257f27e 1684 }
1685 }
1686
58e8dc31 1687 // For Plane Efficiency: run the SPD trackleter
1688 if (fRunPlaneEff && fSPDTrackleter) {
1689 if (!RunSPDTrackleting(fesd)) {
1690 if (fStopOnError) {CleanUp(); return kFALSE;}
1691 }
1692 }
1693
e66fbafb 1694 // Muon tracking
b8cd5251 1695 if (!fRunTracking.IsNull()) {
e66fbafb 1696 if (fRunMuonTracking) {
21a3aa09 1697 if (!RunMuonTracking(fesd)) {
4b71572b 1698 if (fStopOnError) {CleanUp(); return kFALSE;}
24f7a148 1699 }
596a855f 1700 }
1701 }
1702
e66fbafb 1703 // barrel tracking
1704 if (!fRunTracking.IsNull()) {
4b71572b 1705 if (!RunTracking(fesd)) {
1706 if (fStopOnError) {CleanUp(); return kFALSE;}
e66fbafb 1707 }
1708 }
21c573b7 1709
596a855f 1710 // fill ESD
1711 if (!fFillESD.IsNull()) {
d506c543 1712 TString detectors=fFillESD;
f6806ad3 1713 // run HLT first and on hltesd
d506c543 1714 // ;-( IsSelected changes the string
1715 if (IsSelected("HLT", detectors) &&
1716 !FillESD(fhltesd, "HLT")) {
4b71572b 1717 if (fStopOnError) {CleanUp(); return kFALSE;}
f6806ad3 1718 }
1719 detectors=fFillESD;
d5105682 1720 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1721 if (detectors.Contains("ALL")) {
1722 detectors="";
ac4a7581 1723 for (Int_t idet=0; idet<kNDetectors; ++idet){
d5105682 1724 detectors += fgkDetectorName[idet];
1725 detectors += " ";
1726 }
1727 }
f6806ad3 1728 detectors.ReplaceAll("HLT", "");
1729 if (!FillESD(fesd, detectors)) {
4b71572b 1730 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 1731 }
1732 }
a5fa6165 1733
001397cd 1734 // fill Event header information from the RawEventHeader
21a3aa09 1735 if (fRawReader){FillRawEventHeaderESD(fesd);}
596a855f 1736
1737 // combined PID
21a3aa09 1738 AliESDpid::MakePID(fesd);
596a855f 1739
b647652d 1740 if (fFillTriggerESD) {
4b71572b 1741 if (!FillTriggerESD(fesd)) {
1742 if (fStopOnError) {CleanUp(); return kFALSE;}
b647652d 1743 }
1744 }
1745
21a3aa09 1746 ffile->cd();
a6ee503a 1747
3c3709c4 1748 //
67be5c77 1749 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1750 //
21a3aa09 1751 const Int_t ntracks = fesd->GetNumberOfTracks();
1752 const Double_t kBz = fesd->GetMagneticField();
3c3709c4 1753 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1754
1755 TObjArray trkArray;
1756 UShort_t *selectedIdx=new UShort_t[ntracks];
1757
1758 for (Int_t itrack=0; itrack<ntracks; itrack++){
98a50ff3 1759 const Double_t kMaxStep = 1; //max step over the material
3c3709c4 1760 Bool_t ok;
1761
21a3aa09 1762 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1763 if (!track) continue;
1764
1765 AliExternalTrackParam *tpcTrack =
1766 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1767 ok = kFALSE;
1768 if (tpcTrack)
1769 ok = AliTracker::
e92d2a64 1770 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
43c9dae1 1771
3c3709c4 1772 if (ok) {
1773 Int_t n=trkArray.GetEntriesFast();
1774 selectedIdx[n]=track->GetID();
1775 trkArray.AddLast(tpcTrack);
1776 }
1777
3d65e645 1778 //Tracks refitted by ITS should already be at the SPD vertex
1779 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1780
1781 AliTracker::
e92d2a64 1782 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
3d65e645 1783 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
3c3709c4 1784
3c3709c4 1785 }
1786
1787 //
1788 // Improve the reconstructed primary vertex position using the tracks
1789 //
59224b2b 1790 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1791 if(fesd->GetPrimaryVertexSPD()) {
1792 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1793 if(vtitle.Contains("cosmics")) {
1794 runVertexFinderTracks=kFALSE;
1795 }
c060d7fe 1796 }
a00021a7 1797
1798 if (runVertexFinderTracks) {
3c3709c4 1799 // TPC + ITS primary vertex
f09c879d 1800 ftVertexer->SetITSMode();
f2a195c1 1801 ftVertexer->SetConstraintOff();
a00021a7 1802 // get cuts for vertexer from AliGRPRecoParam
1803 if (grpRecoParam) {
1804 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1805 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1806 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1807 ftVertexer->SetCuts(cutsVertexer);
1808 delete [] cutsVertexer; cutsVertexer = NULL;
f2a195c1 1809 if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
1810 ftVertexer->SetVtxStart(fDiamondProfile);
43c9dae1 1811 }
21a3aa09 1812 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 1813 if (pvtx) {
1814 if (pvtx->GetStatus()) {
c264b61b 1815 fesd->SetPrimaryVertexTracks(pvtx);
3c3709c4 1816 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 1817 AliESDtrack *t = fesd->GetTrack(i);
3d65e645 1818 t->RelateToVertex(pvtx, kBz, kVeryBig);
3c3709c4 1819 }
1820 }
1821 }
1822
1823 // TPC-only primary vertex
f09c879d 1824 ftVertexer->SetTPCMode();
f2a195c1 1825 ftVertexer->SetConstraintOff();
a00021a7 1826 // get cuts for vertexer from AliGRPRecoParam
1827 if (grpRecoParam) {
1828 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1829 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1830 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1831 ftVertexer->SetCuts(cutsVertexer);
1832 delete [] cutsVertexer; cutsVertexer = NULL;
f2a195c1 1833 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
1834 ftVertexer->SetVtxStart(fDiamondProfileTPC);
43c9dae1 1835 }
21a3aa09 1836 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 1837 if (pvtx) {
1838 if (pvtx->GetStatus()) {
21a3aa09 1839 fesd->SetPrimaryVertexTPC(pvtx);
3d65e645 1840 for (Int_t i=0; i<ntracks; i++) {
1841 AliESDtrack *t = fesd->GetTrack(i);
1842 t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
3c3709c4 1843 }
1844 }
1845 }
1846
1847 }
1848 delete[] selectedIdx;
1849
21a3aa09 1850 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
17c86e90 1851
c5e3e5d1 1852
d1683eef 1853 if (fRunV0Finder) {
1854 // V0 finding
1855 AliV0vertexer vtxer;
21a3aa09 1856 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 1857
d1683eef 1858 if (fRunCascadeFinder) {
1859 // Cascade finding
1860 AliCascadeVertexer cvtxer;
21a3aa09 1861 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 1862 }
5e4ff34d 1863 }
1864
596a855f 1865 // write ESD
21a3aa09 1866 if (fCleanESD) CleanESD(fesd);
854c6476 1867
57acd2d2 1868 if (fRunQA) {
eca4fa66 1869 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1870 AliQAManager::QAManager()->RunOneEvent(fesd) ;
57acd2d2 1871 }
bea94759 1872 if (fRunGlobalQA) {
eca4fa66 1873 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
57acd2d2 1874 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
4e25ac79 1875 if (qadm && fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
1876 qadm->Exec(AliQAv1::kESDS, fesd);
b03591ab 1877 }
854c6476 1878
1d99986f 1879 if (fWriteESDfriend) {
b090e6a3 1880 // fesdf->~AliESDfriend();
1881 // new (fesdf) AliESDfriend(); // Reset...
21a3aa09 1882 fesd->GetESDfriend(fesdf);
1d99986f 1883 }
21a3aa09 1884 ftree->Fill();
500d54ab 1885
2d91a353 1886 // Auto-save the ESD tree in case of prompt reco @P2
be103ac8 1887 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2d91a353 1888 ftree->AutoSave("SaveSelf");
be103ac8 1889 TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1890 if (friendfile) friendfile->Save();
1891 }
2d91a353 1892
500d54ab 1893 // write HLT ESD
21a3aa09 1894 fhlttree->Fill();
1d99986f 1895
14dd053c 1896 // call AliEVE
1897 if (fRunAliEVE) RunAliEVE();
1898
21a3aa09 1899 fesd->Reset();
1900 fhltesd->Reset();
5728d3d5 1901 if (fWriteESDfriend) {
21a3aa09 1902 fesdf->~AliESDfriend();
1903 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 1904 }
a5fa6165 1905
ac4a7581 1906 ProcInfo_t procInfo;
1907 gSystem->GetProcInfo(&procInfo);
1908 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
a5fa6165 1909
ca13fb87 1910 fEventInfo.Reset();
ac4a7581 1911 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
ca13fb87 1912 if (fReconstructor[iDet])
a00021a7 1913 fReconstructor[iDet]->SetRecoParam(NULL);
ca13fb87 1914 }
1915
53c8f690 1916 if (fRunQA || fRunGlobalQA)
eca4fa66 1917 AliQAManager::QAManager()->Increment() ;
53c8f690 1918
ca13fb87 1919 return kTRUE;
21a3aa09 1920}
1921
21a3aa09 1922//_____________________________________________________________________________
4b71572b 1923void AliReconstruction::SlaveTerminate()
21a3aa09 1924{
4b71572b 1925 // Finalize the run on the slave side
21a3aa09 1926 // Called after the exit
1927 // from the event loop
1928 AliCodeTimerAuto("");
1929
1930 if (fIsNewRunLoader) { // galice.root didn't exist
1931 fRunLoader->WriteHeader("OVERWRITE");
1932 fRunLoader->CdGAFile();
1933 fRunLoader->Write(0, TObject::kOverwrite);
1934 }
1935
f747912b 1936 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1937 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1938
1939 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1940 cdbMapCopy->SetOwner(1);
1941 cdbMapCopy->SetName("cdbMap");
1942 TIter iter(cdbMap->GetTable());
1943
1944 TPair* pair = 0;
1945 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1946 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1947 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1948 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1949 }
1950
1951 TList *cdbListCopy = new TList();
1952 cdbListCopy->SetOwner(1);
1953 cdbListCopy->SetName("cdbList");
1954
1955 TIter iter2(cdbList);
1956
b940cb9b 1957 AliCDBId* id=0;
e84c88f5 1958 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1959 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1960 }
1961
21a3aa09 1962 ftree->GetUserInfo()->Add(cdbMapCopy);
1963 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1964
46698ae4 1965
21a3aa09 1966 ffile->cd();
aa3c69a9 1967
a9c0e6db 1968 if (fWriteESDfriend)
21a3aa09 1969 ftree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1970 // we want to have only one tree version number
21a3aa09 1971 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1972 fhlttree->Write();
f3a97c86 1973
a7a1e1c7 1974// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1975 if (fRunPlaneEff && !FinishPlaneEff()) {
1976 AliWarning("Finish PlaneEff evaluation failed");
1977 }
1978
930e6e3e 1979 // End of cycle for the in-loop
57acd2d2 1980 if (fRunQA)
eca4fa66 1981 AliQAManager::QAManager()->EndOfCycle() ;
57acd2d2 1982
930e6e3e 1983 if (fRunGlobalQA) {
eca4fa66 1984 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
4b71572b 1985 if (qadm) {
4e25ac79 1986 if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS)))
1987 qadm->EndOfCycle(AliQAv1::kRECPOINTS);
1988 if (fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
1989 qadm->EndOfCycle(AliQAv1::kESDS);
4b71572b 1990 qadm->Finish();
1991 }
a7807689 1992 }
87da0921 1993
1994 if (fRunQA || fRunGlobalQA) {
1995 if (fInput) {
1996 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1997 TString qaOutputFile = outputFileName->GetTitle();
1998 qaOutputFile.ReplaceAll(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()),
1999 Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
2000 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
2001 qaProofFile->SetOutputFileName(qaOutputFile.Data());
2002 fOutput->Add(qaProofFile);
2003 MergeQA(qaProofFile->GetFileName());
2004 }
2005 }
2006 else {
2007 MergeQA();
2008 }
2009 }
2010
4b71572b 2011 gROOT->cd();
2012 CleanUp();
2013}
2014
2015//_____________________________________________________________________________
2016void AliReconstruction::Terminate()
2017{
f3a97c86 2018 // Create tags for the events in the ESD tree (the ESD tree is always present)
2019 // In case of empty events the tags will contain dummy values
4b71572b 2020 AliCodeTimerAuto("");
2021
e6d66370 2022 // Do not call the ESD tag creator in case of PROOF-based reconstruction
2023 if (!fInput) {
2024 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2025 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2026 }
e84c88f5 2027
795e4a22 2028 // Cleanup of CDB manager: cache and active storages!
2029 AliCDBManager::Instance()->ClearCache();
596a855f 2030}
2031
b26c3770 2032//_____________________________________________________________________________
2033Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2034{
2035// run the local reconstruction
aa3c69a9 2036
0f88822a 2037 static Int_t eventNr=0;
87932dab 2038 AliCodeTimerAuto("")
b26c3770 2039
2040 TString detStr = detectors;
ac4a7581 2041 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b26c3770 2042 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2043 AliReconstructor* reconstructor = GetReconstructor(iDet);
2044 if (!reconstructor) continue;
2045 AliLoader* loader = fLoader[iDet];
f6806ad3 2046 // Matthias April 2008: temporary fix to run HLT reconstruction
2047 // although the HLT loader is missing
2048 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
2049 if (fRawReader) {
44ed7a66 2050 reconstructor->Reconstruct(fRawReader, NULL);
f6806ad3 2051 } else {
44ed7a66 2052 TTree* dummy=NULL;
2053 reconstructor->Reconstruct(dummy, NULL);
f6806ad3 2054 }
2055 continue;
2056 }
d76c31f4 2057 if (!loader) {
2058 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2059 continue;
2060 }
b26c3770 2061 // conversion of digits
2062 if (fRawReader && reconstructor->HasDigitConversion()) {
2063 AliInfo(Form("converting raw data digits into root objects for %s",
2064 fgkDetectorName[iDet]));
30bbd491 2065// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2066// fgkDetectorName[iDet]));
b26c3770 2067 loader->LoadDigits("update");
2068 loader->CleanDigits();
2069 loader->MakeDigitsContainer();
2070 TTree* digitsTree = loader->TreeD();
2071 reconstructor->ConvertDigits(fRawReader, digitsTree);
2072 loader->WriteDigits("OVERWRITE");
2073 loader->UnloadDigits();
b26c3770 2074 }
b26c3770 2075 // local reconstruction
b26c3770 2076 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
30bbd491 2077 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 2078 loader->LoadRecPoints("update");
2079 loader->CleanRecPoints();
2080 loader->MakeRecPointsContainer();
2081 TTree* clustersTree = loader->TreeR();
2082 if (fRawReader && !reconstructor->HasDigitConversion()) {
2083 reconstructor->Reconstruct(fRawReader, clustersTree);
2084 } else {
2085 loader->LoadDigits("read");
2086 TTree* digitsTree = loader->TreeD();
2087 if (!digitsTree) {
44ed7a66 2088 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2089 if (fStopOnError) return kFALSE;
b26c3770 2090 } else {
44ed7a66 2091 reconstructor->Reconstruct(digitsTree, clustersTree);
2092 if (fRunQA) {
eca4fa66 2093 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2094 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
44ed7a66 2095 }
b26c3770 2096 }
2097 loader->UnloadDigits();
2098 }
57acd2d2 2099 if (fRunQA) {
eca4fa66 2100 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2101 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
57acd2d2 2102 }
eca4fa66 2103 loader->WriteRecPoints("OVERWRITE");
2104 loader->UnloadRecPoints();
2105 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
a00021a7 2106 }
2107 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
b26c3770 2108 AliError(Form("the following detectors were not found: %s",
2109 detStr.Data()));
2110 if (fStopOnError) return kFALSE;
2111 }
0f88822a 2112 eventNr++;
b26c3770 2113 return kTRUE;
2114}
58e8dc31 2115//_____________________________________________________________________________
2116Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2117{
2118// run the SPD trackleting (for SPD efficiency purpouses)
2119
2120 AliCodeTimerAuto("")
2121
2122 Double_t vtxPos[3] = {0, 0, 0};
2123 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2124/*
2125 TArrayF mcVertex(3);
2126 // if(MC)
2127 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2128 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2129 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2130 }
2131*/
2132 const AliESDVertex *vertex = esd->GetVertex();
2133 if(!vertex){
2134 AliWarning("Vertex not found");
2135 return kFALSE;
2136 }
2137 vertex->GetXYZ(vtxPos);
2138 vertex->GetSigmaXYZ(vtxErr);
2139 if (fSPDTrackleter) {
2140 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2141
2142 // load clusters
2143 fLoader[0]->LoadRecPoints("read");
2144 TTree* tree = fLoader[0]->TreeR();
2145 if (!tree) {
2146 AliError("Can't get the ITS cluster tree");
2147 return kFALSE;
2148 }
2149 fSPDTrackleter->LoadClusters(tree);
2150 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2151 // run trackleting
2152 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2153 AliError("AliITSTrackleterSPDEff Clusters2Tracks failed");
2154 // fLoader[0]->UnloadRecPoints();
2155 return kFALSE;
2156 }
2157//fSPDTrackleter->UnloadRecPoints();
2158 } else {
2159 AliWarning("SPDTrackleter not available");
2160 return kFALSE;
2161 }
2162 return kTRUE;
2163}
b26c3770 2164
596a855f 2165//_____________________________________________________________________________
af885e0f 2166Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 2167{
2168// run the barrel tracking
2169
87932dab 2170 AliCodeTimerAuto("")
030b532d 2171
92bffc4d 2172 AliVertexer *vertexer = CreateVertexer();
2173 if (!vertexer) return kFALSE;
2174
2175 AliInfo("running the ITS vertex finder");
2257f27e 2176 AliESDVertex* vertex = NULL;
92bffc4d 2177 if (fLoader[0]) {
2178 fLoader[0]->LoadRecPoints();
2179 TTree* cltree = fLoader[0]->TreeR();
2180 if (cltree) {
2181 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2182 vertex = vertexer->FindVertexForCurrentEvent(cltree);
308c2f7c 2183 }
2184 else {
92bffc4d 2185 AliError("Can't get the ITS cluster tree");
308c2f7c 2186 }
92bffc4d 2187 fLoader[0]->UnloadRecPoints();
2257f27e 2188 }
92bffc4d 2189 else {
2190 AliError("Can't get the ITS loader");
2191 }
2192 if(!vertex){
2193 AliWarning("Vertex not found");
2194 vertex = new AliESDVertex();
2195 vertex->SetName("default");
2196 }
2197 else {
2198 vertex->SetName("reconstructed");
2257f27e 2199 }
92bffc4d 2200
2201 Double_t vtxPos[3];
2202 Double_t vtxErr[3];
2203 vertex->GetXYZ(vtxPos);
2204 vertex->GetSigmaXYZ(vtxErr);
2205
06cc9d95 2206 esd->SetPrimaryVertexSPD(vertex);
73c51de2 2207 AliESDVertex *vpileup = NULL;
2208 Int_t novertices = 0;
2209 vpileup = vertexer->GetAllVertices(novertices);
2210 if(novertices>1){
2211 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2212 }
32e449be 2213 // if SPD multiplicity has been determined, it is stored in the ESD
92bffc4d 2214 AliMultiplicity *mult = vertexer->GetMultiplicity();
32e449be 2215 if(mult)esd->SetMultiplicity(mult);
2216
ac4a7581 2217 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2218 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2219 }
2257f27e 2220 delete vertex;
2221
92bffc4d 2222 delete vertexer;
2223
2257f27e 2224 return kTRUE;
2225}
2226
1f46a9ae 2227//_____________________________________________________________________________
af885e0f 2228Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 2229{
2230// run the HLT barrel tracking
2231
87932dab 2232 AliCodeTimerAuto("")
1f46a9ae 2233
2234 if (!fRunLoader) {
2235 AliError("Missing runLoader!");
2236 return kFALSE;
2237 }
2238
2239 AliInfo("running HLT tracking");
2240
2241 // Get a pointer to the HLT reconstructor
ac4a7581 2242 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
1f46a9ae 2243 if (!reconstructor) return kFALSE;
2244
2245 // TPC + ITS
2246 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2247 TString detName = fgkDetectorName[iDet];
2248 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2249 reconstructor->SetOption(detName.Data());
d76c31f4 2250 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 2251 if (!tracker) {
2252 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2253 if (fStopOnError) return kFALSE;
9dcc06e1 2254 continue;
1f46a9ae 2255 }
2256 Double_t vtxPos[3];
2257 Double_t vtxErr[3]={0.005,0.005,0.010};
2258 const AliESDVertex *vertex = esd->GetVertex();
2259 vertex->GetXYZ(vtxPos);
2260 tracker->SetVertex(vtxPos,vtxErr);
2261 if(iDet != 1) {
2262 fLoader[iDet]->LoadRecPoints("read");
2263 TTree* tree = fLoader[iDet]->TreeR();
2264 if (!tree) {
2265 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2266 return kFALSE;
2267 }
2268 tracker->LoadClusters(tree);
2269 }
2270 if (tracker->Clusters2Tracks(esd) != 0) {
2271 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2272 return kFALSE;
2273 }
2274 if(iDet != 1) {
2275 tracker->UnloadClusters();
2276 }
2277 delete tracker;
2278 }
2279
1f46a9ae 2280 return kTRUE;
2281}
2282
e66fbafb 2283//_____________________________________________________________________________
af885e0f 2284Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 2285{
2286// run the muon spectrometer tracking
2287
87932dab 2288 AliCodeTimerAuto("")
e66fbafb 2289
2290 if (!fRunLoader) {
2291 AliError("Missing runLoader!");
2292 return kFALSE;
2293 }
2294 Int_t iDet = 7; // for MUON
2295
2296 AliInfo("is running...");
2297
2298 // Get a pointer to the MUON reconstructor
2299 AliReconstructor *reconstructor = GetReconstructor(iDet);
2300 if (!reconstructor) return kFALSE;
2301
2302
2303 TString detName = fgkDetectorName[iDet];
2304 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 2305 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 2306 if (!tracker) {
2307 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2308 return kFALSE;
2309 }
2310
e66fbafb 2311 // read RecPoints
761350a6 2312 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 2313
761350a6 2314 tracker->LoadClusters(fLoader[iDet]->TreeR());
2315
2316 Int_t rv = tracker->Clusters2Tracks(esd);
2317
761350a6 2318 if ( rv )
2319 {
e66fbafb 2320 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2321 return kFALSE;
2322 }
761350a6 2323
e66fbafb 2324 fLoader[iDet]->UnloadRecPoints();
2325
c1954ee5 2326 tracker->UnloadClusters();
2327
e66fbafb 2328 delete tracker;
2329
e66fbafb 2330 return kTRUE;
2331}
2332
2333
2257f27e 2334//_____________________________________________________________________________
af885e0f 2335Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 2336{
2337// run the barrel tracking
0f88822a 2338 static Int_t eventNr=0;
87932dab 2339 AliCodeTimerAuto("")
24f7a148 2340
815c2b38 2341 AliInfo("running tracking");
596a855f 2342
eca4fa66 2343
91b876d1 2344 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 2345 if (fReconstructor[11] && fLoader[11]) {
2346 fLoader[11]->LoadRecPoints("READ");
2347 TTree *treeR = fLoader[11]->TreeR();
89916438 2348 if (treeR) {
2349 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2350 }
d76c31f4 2351 }
91b876d1 2352
b8cd5251 2353 // pass 1: TPC + ITS inwards
2354 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2355 if (!fTracker[iDet]) continue;
2356 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 2357
b8cd5251 2358 // load clusters
2359 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2360 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 2361 TTree* tree = fLoader[iDet]->TreeR();
2362 if (!tree) {
2363 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 2364 return kFALSE;
2365 }
b8cd5251 2366 fTracker[iDet]->LoadClusters(tree);
6efecea1 2367 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2368 // run tracking
2369 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2370 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 2371 return kFALSE;
2372 }
878e1fe1 2373 // preliminary PID in TPC needed by the ITS tracker
2374 if (iDet == 1) {
b26c3770 2375 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 2376 AliESDpid::MakePID(esd);
0f88822a 2377 }
6efecea1 2378 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 2379 }
596a855f 2380
b8cd5251 2381 // pass 2: ALL backwards
aa3c69a9 2382
ac4a7581 2383 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2384 if (!fTracker[iDet]) continue;
2385 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2386
2387 // load clusters
2388 if (iDet > 1) { // all except ITS, TPC
2389 TTree* tree = NULL;
7b61cd9c 2390 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2391 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 2392 tree = fLoader[iDet]->TreeR();
b8cd5251 2393 if (!tree) {
eca4fa66 2394 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2395 return kFALSE;
24f7a148 2396 }
0f88822a 2397 fTracker[iDet]->LoadClusters(tree);
6efecea1 2398 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2399 }
24f7a148 2400
b8cd5251 2401 // run tracking
283f39c6 2402 if (iDet>1) // start filling residuals for the "outer" detectors
eca4fa66 2403 if (fRunGlobalQA) {
2404 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2405 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2406 if (arr) {
0a349581 2407 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2408 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
c9526f68 2409 if ( elem && (! elem->At(0)) ) {
2410 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2411 if (qadm) qadm->InitRecPointsForTracker() ;
2412 }
2413 }
eca4fa66 2414 }
b8cd5251 2415 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2416 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 2417 // return kFALSE;
b8cd5251 2418 }
24f7a148 2419
b8cd5251 2420 // unload clusters
6e65648b 2421 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
b8cd5251 2422 fTracker[iDet]->UnloadClusters();
7b61cd9c 2423 fLoader[iDet]->UnloadRecPoints();
b8cd5251 2424 }
8f37df88 2425 // updated PID in TPC needed by the ITS tracker -MI
2426 if (iDet == 1) {
8f37df88 2427 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2428 AliESDpid::MakePID(esd);
2429 }
6efecea1 2430 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 2431 }
283f39c6 2432 //stop filling residuals for the "outer" detectors
57acd2d2 2433 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
596a855f 2434
b8cd5251 2435 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 2436
b8cd5251 2437 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2438 if (!fTracker[iDet]) continue;
2439 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 2440
b8cd5251 2441 // run tracking
283f39c6 2442 if (iDet<2) // start filling residuals for TPC and ITS
eca4fa66 2443 if (fRunGlobalQA) {
2444 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2445 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2446 if (arr) {
0a349581 2447 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2448 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
c9526f68 2449 if ( elem && (! elem->At(0)) ) {
2450 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2451 if (qadm) qadm->InitRecPointsForTracker() ;
2452 }
2453 }
eca4fa66 2454 }
2455
b8cd5251 2456 if (fTracker[iDet]->RefitInward(esd) != 0) {
2457 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 2458 // return kFALSE;
b8cd5251 2459 }
db2368d0 2460 // run postprocessing
2461 if (fTracker[iDet]->PostProcess(esd) != 0) {
2462 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2463 // return kFALSE;
2464 }
6efecea1 2465 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
6e65648b 2466 }
2467
2468 // write space-points to the ESD in case alignment data output
2469 // is switched on
2470 if (fWriteAlignmentData)
2471 WriteAlignmentData(esd);
2472
2473 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2474 if (!fTracker[iDet]) continue;
b8cd5251 2475 // unload clusters
2476 fTracker[iDet]->UnloadClusters();
6efecea1 2477 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 2478 fLoader[iDet]->UnloadRecPoints();
6efecea1 2479 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 2480 }
283f39c6 2481 // stop filling residuals for TPC and ITS
57acd2d2 2482 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
854c6476 2483
0f88822a 2484 eventNr++;
596a855f 2485 return kTRUE;
2486}
2487
d64bd07d 2488//_____________________________________________________________________________
2489Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2490 //
2491 // Remove the data which are not needed for the physics analysis.
2492 //
2493
d64bd07d 2494 Int_t nTracks=esd->GetNumberOfTracks();
18571674 2495 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 2496 AliInfo
2497 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 2498
18571674 2499 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 2500 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 2501
7f68891d 2502 nTracks=esd->GetNumberOfTracks();
18571674 2503 nV0s=esd->GetNumberOfV0s();
cf37fd88 2504 AliInfo
ae5d5566 2505 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 2506
7f68891d 2507 return rc;
d64bd07d 2508}
2509
596a855f 2510//_____________________________________________________________________________
af885e0f 2511Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 2512{
2513// fill the event summary data
2514
87932dab 2515 AliCodeTimerAuto("")
0f88822a 2516 static Int_t eventNr=0;
596a855f 2517 TString detStr = detectors;
abe0c04e 2518
ac4a7581 2519 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
abe0c04e 2520 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 2521 AliReconstructor* reconstructor = GetReconstructor(iDet);
2522 if (!reconstructor) continue;
4b71572b 2523 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2524 TTree* clustersTree = NULL;
2525 if (fLoader[iDet]) {
2526 fLoader[iDet]->LoadRecPoints("read");
2527 clustersTree = fLoader[iDet]->TreeR();
2528 if (!clustersTree) {
2529 AliError(Form("Can't get the %s clusters tree",
2530 fgkDetectorName[iDet]));
2531 if (fStopOnError) return kFALSE;
2532 }
2533 }
2534 if (fRawReader && !reconstructor->HasDigitConversion()) {
2535 reconstructor->FillESD(fRawReader, clustersTree, esd);
2536 } else {
2537 TTree* digitsTree = NULL;
d76c31f4 2538 if (fLoader[iDet]) {
4b71572b 2539 fLoader[iDet]->LoadDigits("read");
2540 digitsTree = fLoader[iDet]->TreeD();
2541 if (!digitsTree) {
2542 AliError(Form("Can't get the %s digits tree",
b26c3770 2543 fgkDetectorName[iDet]));
2544 if (fStopOnError) return kFALSE;
2545 }
2546 }
4b71572b 2547 reconstructor->FillESD(digitsTree, clustersTree, esd);
2548 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2549 }
2550 if (fLoader[iDet]) {
2551 fLoader[iDet]->UnloadRecPoints();
596a855f 2552 }
2553 }
2554
2555 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 2556 AliError(Form("the following detectors were not found: %s",
2557 detStr.Data()));
596a855f 2558 if (fStopOnError) return kFALSE;
2559 }
6efecea1 2560 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 2561 eventNr++;
596a855f 2562 return kTRUE;
2563}
2564
b647652d 2565//_____________________________________________________________________________
af885e0f 2566Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 2567{
2568 // Reads the trigger decision which is
2569 // stored in Trigger.root file and fills
2570 // the corresponding esd entries
2571
87932dab 2572 AliCodeTimerAuto("")
2573
b647652d 2574 AliInfo("Filling trigger information into the ESD");
2575
2576 if (fRawReader) {
2577 AliCTPRawStream input(fRawReader);
2578 if (!input.Next()) {
7e88424f 2579 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
b647652d 2580 }
2581 else {
7e88424f 2582 if (esd->GetTriggerMask() != input.GetClassMask())
2583 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2584 input.GetClassMask(),esd->GetTriggerMask()));
2585 if (esd->GetOrbitNumber() != input.GetOrbitID())
2586 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2587 input.GetOrbitID(),esd->GetOrbitNumber()));
2588 if (esd->GetBunchCrossNumber() != input.GetBCID())
2589 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2590 input.GetBCID(),esd->GetBunchCrossNumber()));
e61ed4b1 2591 AliESDHeader* esdheader = esd->GetHeader();
2592 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
2593 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
2594 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
a6dd87ad 2595 // IR
2596 UInt_t orbit=input.GetOrbitID();
2597 for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
2598 if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
2599 esdheader->AddTriggerIR(input.GetIR(i));
2600 }
b647652d 2601 }
b024fd7f 2602 }
522fdd91 2603 //Scalers
82ebedd6 2604 //fRunScalers->Print();
2605 if(fRunScalers && fRunScalers->CheckRunScalers()){
a6dd87ad 2606 AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
82ebedd6 2607 //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
522fdd91 2608 AliESDHeader* esdheader = fesd->GetHeader();
2609 for(Int_t i=0;i<50;i++){
82ebedd6 2610 if((1<<i) & esd->GetTriggerMask()){
522fdd91 2611 AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i);
82ebedd6 2612 if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
522fdd91 2613 }
2614 }
2615 }
b647652d 2616 return kTRUE;
2617}
596a855f 2618
001397cd 2619
2620
2621
2622
2623//_____________________________________________________________________________
af885e0f 2624Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 2625{
2626 //
2627 // Filling information from RawReader Header
2628 //
2629
151bea4e 2630 if (!fRawReader) return kFALSE;
2631
001397cd 2632 AliInfo("Filling information from RawReader Header");
151bea4e 2633
2634 esd->SetBunchCrossNumber(fRawReader->GetBCID());
2635 esd->SetOrbitNumber(fRawReader->GetOrbitID());
2636 esd->SetPeriodNumber(fRawReader->GetPeriod());
2637
2638 esd->SetTimeStamp(fRawReader->GetTimestamp());
2639 esd->SetEventType(fRawReader->GetType());
001397cd 2640
2641 return kTRUE;
2642}
2643
2644
596a855f 2645//_____________________________________________________________________________
2646Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2647{
2648// check whether detName is contained in detectors
2649// if yes, it is removed from detectors
2650
2651 // check if all detectors are selected
2652 if ((detectors.CompareTo("ALL") == 0) ||
2653 detectors.BeginsWith("ALL ") ||
2654 detectors.EndsWith(" ALL") ||
2655 detectors.Contains(" ALL ")) {
2656 detectors = "ALL";
2657 return kTRUE;
2658 }
2659
2660 // search for the given detector
2661 Bool_t result = kFALSE;
2662 if ((detectors.CompareTo(detName) == 0) ||
2663 detectors.BeginsWith(detName+" ") ||
2664 detectors.EndsWith(" "+detName) ||
2665 detectors.Contains(" "+detName+" ")) {
2666 detectors.ReplaceAll(detName, "");
2667 result = kTRUE;
2668 }
2669
2670 // clean up the detectors string
2671 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2672 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2673 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2674
2675 return result;
2676}
e583c30d 2677
f08fc9f5 2678//_____________________________________________________________________________
2679Bool_t AliReconstruction::InitRunLoader()
2680{
2681// get or create the run loader
2682
2683 if (gAlice) delete gAlice;
2684 gAlice = NULL;
2685
b26c3770 2686 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2687 // load all base libraries to get the loader classes
2688 TString libs = gSystem->GetLibraries();
ac4a7581 2689 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b26c3770 2690 TString detName = fgkDetectorName[iDet];
2691 if (detName == "HLT") continue;
2692 if (libs.Contains("lib" + detName + "base.so")) continue;
2693 gSystem->Load("lib" + detName + "base.so");
2694 }
f08fc9f5 2695 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2696 if (!fRunLoader) {
2697 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2698 CleanUp();
2699 return kFALSE;
2700 }
325aa76f 2701
b26c3770 2702 fRunLoader->CdGAFile();
325aa76f 2703 fRunLoader->LoadgAlice();
f08fc9f5 2704
6cae184e 2705 //PH This is a temporary fix to give access to the kinematics
2706 //PH that is needed for the labels of ITS clusters
f2ee4290 2707 fRunLoader->LoadHeader();
6cae184e 2708 fRunLoader->LoadKinematics();
2709
f08fc9f5 2710 } else { // galice.root does not exist
2711 if (!fRawReader) {
2712 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
f08fc9f5 2713 }
2714 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2715 AliConfig::GetDefaultEventFolderName(),
2716 "recreate");
2717 if (!fRunLoader) {
2718 AliError(Form("could not create run loader in file %s",
2719 fGAliceFileName.Data()));
2720 CleanUp();
2721 return kFALSE;
2722 }
21a3aa09 2723 fIsNewRunLoader = kTRUE;
f08fc9f5 2724 fRunLoader->MakeTree("E");
21a3aa09 2725
973388c2 2726 if (fNumberOfEventsPerFile > 0)
2727 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2728 else
21a3aa09 2729 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
f08fc9f5 2730 }
2731
2732 return kTRUE;
2733}
2734
c757bafd 2735//_____________________________________________________________________________
b8cd5251 2736AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 2737{
f08fc9f5 2738// get the reconstructor object and the loader for a detector
c757bafd 2739
7e88424f 2740 if (fReconstructor[iDet]) {
2741 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2742 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2743 fReconstructor[iDet]->SetRecoParam(par);
2744 }
2745 return fReconstructor[iDet];
2746 }
b8cd5251 2747
2748 // load the reconstructor object
2749 TPluginManager* pluginManager = gROOT->GetPluginManager();
2750 TString detName = fgkDetectorName[iDet];
2751 TString recName = "Ali" + detName + "Reconstructor";
f0999a9a 2752
2753 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
b8cd5251 2754
b8cd5251 2755 AliReconstructor* reconstructor = NULL;
2756 // first check if a plugin is defined for the reconstructor
2757 TPluginHandler* pluginHandler =
2758 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 2759 // if not, add a plugin for it
2760 if (!pluginHandler) {
b8cd5251 2761 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 2762 TString libs = gSystem->GetLibraries();
2763 if (libs.Contains("lib" + detName + "base.so") ||
2764 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 2765 pluginManager->AddHandler("AliReconstructor", detName,
2766 recName, detName + "rec", recName + "()");
2767 } else {
2768 pluginManager->AddHandler("AliReconstructor", detName,
2769 recName, detName, recName + "()");
c757bafd 2770 }
b8cd5251 2771 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2772 }
2773 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2774 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 2775 }
b8cd5251 2776 if (reconstructor) {
2777 TObject* obj = fOptions.FindObject(detName.Data());
2778 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 2779 reconstructor->Init();
b8cd5251 2780 fReconstructor[iDet] = reconstructor;
2781 }
2782
f08fc9f5 2783 // get or create the loader
2784 if (detName != "HLT") {
2785 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2786 if (!fLoader[iDet]) {
2787 AliConfig::Instance()
2788 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2789 detName, detName);
2790 // first check if a plugin is defined for the loader
bb0901a4 2791 pluginHandler =
f08fc9f5 2792 pluginManager->FindHandler("AliLoader", detName);
2793 // if not, add a plugin for it
2794 if (!pluginHandler) {
2795 TString loaderName = "Ali" + detName + "Loader";
2796 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2797 pluginManager->AddHandler("AliLoader", detName,
2798 loaderName, detName + "base",
2799 loaderName + "(const char*, TFolder*)");
2800 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2801 }
2802 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2803 fLoader[iDet] =
2804 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2805 fRunLoader->GetEventFolder());
2806 }
2807 if (!fLoader[iDet]) { // use default loader
2808 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2809 }
2810 if (!fLoader[iDet]) {
2811 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2812 if (fStopOnError) return NULL;
f08fc9f5 2813 } else {
2814 fRunLoader->AddLoader(fLoader[iDet]);
2815 fRunLoader->CdGAFile();
2816 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2817 fRunLoader->Write(0, TObject::kOverwrite);
2818 }
2819 }
2820 }
2821
7e88424f 2822 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2823 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2824 reconstructor->SetRecoParam(par);
2825 }
b8cd5251 2826 return reconstructor;
c757bafd 2827}
2828
2257f27e 2829//_____________________________________________________________________________
92bffc4d 2830AliVertexer* AliReconstruction::CreateVertexer()
2257f27e 2831{
2832// create the vertexer
92bffc4d 2833// Please note that the caller is the owner of the
2834// vertexer
2257f27e 2835
92bffc4d 2836 AliVertexer* vertexer = NULL;
b8cd5251 2837 AliReconstructor* itsReconstructor = GetReconstructor(0);
70d06e85 2838 if (itsReconstructor && (fRunLocalReconstruction.Contains("ITS"))) {
92bffc4d 2839 vertexer = itsReconstructor->CreateVertexer();
2257f27e 2840 }
92bffc4d 2841 if (!vertexer) {
815c2b38 2842 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2843 }
2844
92bffc4d 2845 return vertexer;
2257f27e 2846}
2847
24f7a148 2848//_____________________________________________________________________________
b8cd5251 2849Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2850{
f08fc9f5 2851// create the trackers
44e45fac 2852 AliInfo("Creating trackers");
24f7a148 2853
b8cd5251 2854 TString detStr = detectors;
ac4a7581 2855 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2856 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2857 AliReconstructor* reconstructor = GetReconstructor(iDet);
2858 if (!reconstructor) continue;
2859 TString detName = fgkDetectorName[iDet];
1f46a9ae 2860 if (detName == "HLT") {
2861 fRunHLTTracking = kTRUE;
2862 continue;
2863 }
e66fbafb 2864 if (detName == "MUON") {
2865 fRunMuonTracking = kTRUE;
2866 continue;
2867 }
2868
f08fc9f5 2869
d76c31f4 2870 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2871 if (!fTracker[iDet] && (iDet < 7)) {
2872 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2873 if (fStopOnError) return kFALSE;
2874 }
6efecea1 2875 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2876 }
2877
24f7a148 2878 return kTRUE;
2879}
2880
e583c30d 2881//_____________________________________________________________________________
4b71572b 2882void AliReconstruction::CleanUp()
e583c30d 2883{
2884// delete trackers and the run loader and close and delete the file
2885
ac4a7581 2886 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2887 delete fReconstructor[iDet];
2888 fReconstructor[iDet] = NULL;
2889 fLoader[iDet] = NULL;
2890 delete fTracker[iDet];
2891 fTracker[iDet] = NULL;
2892 }
4b71572b 2893 delete fRunInfo;
7e88424f 2894 fRunInfo = NULL;
2895
58e8dc31 2896 delete fSPDTrackleter;
2897 fSPDTrackleter = NULL;
2898
4b71572b 2899 delete ftVertexer;
21a3aa09 2900 ftVertexer = NULL;
795e4a22 2901
e583c30d 2902 delete fRunLoader;
2903 fRunLoader = NULL;
b649205a 2904 delete fRawReader;
2905 fRawReader = NULL;
4b71572b 2906 delete fParentRawReader;
cd0b062e 2907 fParentRawReader=NULL;
e583c30d 2908
4b71572b 2909 if (ffile) {
2910 ffile->Close();
2911 delete ffile;
2912 ffile = NULL;
24f7a148 2913 }
87da0921 2914
bf76b847 2915 if (AliQAManager::QAManager())
2916 AliQAManager::QAManager()->ShowQA() ;
eca4fa66 2917 AliQAManager::Destroy() ;
2918
87da0921 2919 TGeoGlobalMagField::Instance()->SetField(NULL);
24f7a148 2920}
f3a97c86 2921
af885e0f 2922void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2923{
2924 // Write space-points which are then used in the alignment procedures
6e65648b 2925 // For the moment only ITS, TPC, TRD and TOF
98937d93 2926
98937d93 2927 Int_t ntracks = esd->GetNumberOfTracks();
2928 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2929 {
2930 AliESDtrack *track = esd->GetTrack(itrack);
2931 Int_t nsp = 0;
ef7253ac 2932 Int_t idx[200];
76741755 2933 for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
81aa7a0d 2934 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
6e65648b 2935 nsp += track->GetNcls(iDet);
2936
2937 if (iDet==0) { // ITS "extra" clusters
2938 track->GetClusters(iDet,idx);
2939 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
2940 }
2941 }
2942
98937d93 2943 if (nsp) {
2944 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2945 track->SetTrackPointArray(sp);
2946 Int_t isptrack = 0;
81aa7a0d 2947 for (Int_t iDet = 5; iDet >= 0; iDet--) {
98937d93 2948 AliTracker *tracker = fTracker[iDet];
2949 if (!tracker) continue;
6e65648b 2950 Int_t nspdet = track->GetClusters(iDet,idx);
2951
2952 if (iDet==0) // ITS "extra" clusters
2953 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
2954
98937d93 2955 if (nspdet <= 0) continue;
98937d93 2956 AliTrackPoint p;
2957 Int_t isp = 0;
2958 Int_t isp2 = 0;
4ed6fb1c 2959 while (isp2 < nspdet) {
f3c6e4c9 2960 Bool_t isvalid=kTRUE;
2961
2962 Int_t index=idx[isp++];
2963 if (index < 0) continue;
2964
c12b6e44 2965 TString dets = fgkDetectorName[iDet];
2966 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2967 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2968 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2969 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
f3c6e4c9 2970 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
48ce48d1 2971 } else {
f3c6e4c9 2972 isvalid = tracker->GetTrackPoint(index,p);
48ce48d1 2973 }
2974 isp2++;
98937d93 2975 if (!isvalid) continue;
eb2d90b9 2976 if (iDet==0 && (isp-1)>=6) p.SetExtra();
f3c6e4c9 2977 sp->AddPoint(isptrack,&p); isptrack++;
98937d93 2978 }
98937d93 2979 }
2980 }
2981 }
98937d93 2982}
2e3550da 2983
2984//_____________________________________________________________________________
af885e0f 2985void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 2986{
2987 // The method reads the raw-data error log
2988 // accumulated within the rawReader.
2989 // It extracts the raw-data errors related to
2990 // the current event and stores them into
2991 // a TClonesArray inside the esd object.
2992
2993 if (!fRawReader) return;
2994
2995 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2996
2997 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2998 if (!log) continue;
2999 if (iEvent != log->GetEventNumber()) continue;
3000
3001 esd->AddRawDataErrorLog(log);
3002 }
3003
3004}
46698ae4 3005
8661738e 3006//_____________________________________________________________________________
3007void AliReconstruction::CheckQA()
3008{
3009// check the QA of SIM for this run and remove the detectors
3010// with status Fatal
3011
57acd2d2 3012// TString newRunLocalReconstruction ;
3013// TString newRunTracking ;
3014// TString newFillESD ;
3015//
4e25ac79 3016// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3017// TString detName(AliQAv1::GetDetName(iDet)) ;
3018// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3019// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
57acd2d2 3020// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
3021// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3022// } else {
4e25ac79 3023// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 3024// fRunLocalReconstruction.Contains("ALL") ) {
3025// newRunLocalReconstruction += detName ;
3026// newRunLocalReconstruction += " " ;
3027// }
4e25ac79 3028// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 3029// fRunTracking.Contains("ALL") ) {
3030// newRunTracking += detName ;
3031// newRunTracking += " " ;
3032// }
4e25ac79 3033// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 3034// fFillESD.Contains("ALL") ) {
3035// newFillESD += detName ;
3036// newFillESD += " " ;
3037// }
3038// }
3039// }
3040// fRunLocalReconstruction = newRunLocalReconstruction ;
3041// fRunTracking = newRunTracking ;
3042// fFillESD = newFillESD ;
a5fa6165 3043}
5b188f2f 3044
3045//_____________________________________________________________________________
3046Int_t AliReconstruction::GetDetIndex(const char* detector)
3047{
3048 // return the detector index corresponding to detector
3049 Int_t index = -1 ;
ac4a7581 3050 for (index = 0; index < kNDetectors ; index++) {
5b188f2f 3051 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3052 break ;
3053 }
3054 return index ;
3055}
7167ae53 3056//_____________________________________________________________________________
3057Bool_t AliReconstruction::FinishPlaneEff() {
3058 //
3059 // Here execute all the necessary operationis, at the end of the tracking phase,
d7f8fd68 3060 // in case that evaluation of PlaneEfficiencies was required for some detector.
3061 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
7167ae53 3062 //
3063 // This Preliminary version works only FOR ITS !!!!!
3064 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3065 //
3066 // Input: none
d7f8fd68 3067 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
7167ae53 3068 //
3069 Bool_t ret=kFALSE;
58e8dc31 3070 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
d7f8fd68 3071 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
7167ae53 3072 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
58e8dc31 3073 if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
d7f8fd68 3074 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3075 TString name=planeeff->GetName();
3076 name+=".root";
3077 TFile* pefile = TFile::Open(name, "RECREATE");
3078 ret=(Bool_t)planeeff->Write();
3079 pefile->Close();
5fbd4fd6 3080 if(planeeff->GetCreateHistos()) {
d7f8fd68 3081 TString hname=planeeff->GetName();
3082 hname+="Histo.root";
3083 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
5fbd4fd6 3084 }
3085 }
58e8dc31 3086 if(fSPDTrackleter) {
3087 AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3088 TString name="AliITSPlaneEffSPDtracklet.root";
3089 TFile* pefile = TFile::Open(name, "RECREATE");
3090 ret=(Bool_t)planeeff->Write();
3091 pefile->Close();
3092 AliESDEvent *dummy=NULL;
3093 ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3094 }
7167ae53 3095 }
3096 return ret;
3097}
3098//_____________________________________________________________________________
3099Bool_t AliReconstruction::InitPlaneEff() {
3100//
3101 // Here execute all the necessary operations, before of the tracking phase,
3102 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
58e8dc31 3103 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
7167ae53 3104 // which should be updated/recalculated.
3105 //
3106 // This Preliminary version will work only FOR ITS !!!!!
3107 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3108 //
3109 // Input: none
3110 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3111 //
58e8dc31 3112 AliWarning(Form("Implementation of this method not yet completed !! Method return kTRUE"));
3113
3114 fSPDTrackleter = NULL;
3115 AliReconstructor* itsReconstructor = GetReconstructor(0);
3116 if (itsReconstructor) {
3117 fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3118 }
3119 if (fSPDTrackleter) {
3120 AliInfo("Trackleter for SPD has been created");
3121 }
3122
7167ae53 3123 return kTRUE;
7520312d 3124}
14dd053c 3125
3126//_____________________________________________________________________________
3127Bool_t AliReconstruction::InitAliEVE()
3128{
3129 // This method should be called only in case
3130 // AliReconstruction is run
3131 // within the alieve environment.
3132 // It will initialize AliEVE in a way
3133 // so that it can visualize event processed
3134 // by AliReconstruction.
3135 // The return flag shows whenever the
3136 // AliEVE initialization was successful or not.
3137
3138 TString macroStr;
3139 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3140 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3141 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3142
6a840f1e 3143 gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
de33999e 3144 gROOT->ProcessLine("alieve_online_init()");
14dd053c 3145
3146 return kTRUE;
3147}
3148
3149//_____________________________________________________________________________
3150void AliReconstruction::RunAliEVE()
3151{
3152 // Runs AliEVE visualisation of
3153 // the current event.
3154 // Should be executed only after
3155 // successful initialization of AliEVE.
3156
3157 AliInfo("Running AliEVE...");
519975fe 3158 gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
14dd053c 3159 gSystem->Run();
3160}
ce43afbe 3161
3162//_____________________________________________________________________________
3163Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3164{
3165 // Allows to run QA for a selected set of detectors
44ed7a66 3166 // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
ce43afbe 3167 // all selected detectors run the same selected tasks
3168
3169 if (!detAndAction.Contains(":")) {
3170 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3171 fRunQA = kFALSE ;
3172 return kFALSE ;
3173 }
3174 Int_t colon = detAndAction.Index(":") ;
3175 fQADetectors = detAndAction(0, colon) ;
3176 if (fQADetectors.Contains("ALL") )
3177 fQADetectors = fFillESD ;
e84c88f5 3178 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
ce43afbe 3179 if (fQATasks.Contains("ALL") ) {
44ed7a66 3180 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
ce43afbe 3181 } else {
3182 fQATasks.ToUpper() ;
3183 TString tempo("") ;
3184 if ( fQATasks.Contains("RAW") )
4e25ac79 3185 tempo = Form("%d ", AliQAv1::kRAWS) ;
44ed7a66 3186 if ( fQATasks.Contains("DIGIT") )
3187 tempo += Form("%d ", AliQAv1::kDIGITSR) ;
ce43afbe 3188 if ( fQATasks.Contains("RECPOINT") )
4e25ac79 3189 tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
ce43afbe 3190 if ( fQATasks.Contains("ESD") )
4e25ac79 3191 tempo += Form("%d ", AliQAv1::kESDS) ;
ce43afbe 3192 fQATasks = tempo ;
3193 if (fQATasks.IsNull()) {
3194 AliInfo("No QA requested\n") ;
3195 fRunQA = kFALSE ;
3196 return kTRUE ;
3197 }
3198 }
3199 TString tempo(fQATasks) ;
4e25ac79 3200 tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
44ed7a66 3201 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
4e25ac79 3202 tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3203 tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
ce43afbe 3204 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3205 fRunQA = kTRUE ;
3206 return kTRUE;
3207}
3208
7e88424f 3209//_____________________________________________________________________________
3210Bool_t AliReconstruction::InitRecoParams()
3211{
3212 // The method accesses OCDB and retrieves all
3213 // the available reco-param objects from there.
3214
3215 Bool_t isOK = kTRUE;
3216
7d566c20 3217 TString detStr = fLoadCDB;
ac4a7581 3218 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
7e88424f 3219
7d566c20 3220 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3221
7e88424f 3222 if (fRecoParam.GetDetRecoParamArray(iDet)) {
3223 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3224 continue;
3225 }
3226
ac232c75 3227 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
7e88424f 3228
3229 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3230 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3231 if(!entry){
3232 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3233 isOK = kFALSE;
3234 }
3235 else {
3236 TObject *recoParamObj = entry->GetObject();
3237 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3238 // The detector has a normal TobjArray of AliDetectorRecoParam objects
3239 // Registering them in AliRecoParam
3240 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3241 }
3242 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3243 // The detector has only onse set of reco parameters
3244 // Registering it in AliRecoParam
ac232c75 3245 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
7e88424f 3246 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3247 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3248 }
3249 else {
3250 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3251 isOK = kFALSE;
3252 }
3253 entry->SetOwner(0);
4b71572b 3254 AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
7e88424f 3255 }
3256 }
3257
e30a9b4d 3258 if (AliDebugLevel() > 0) fRecoParam.Print();
ac232c75 3259
7e88424f 3260 return isOK;
3261}
3262
3263//_____________________________________________________________________________
3264Bool_t AliReconstruction::GetEventInfo()
3265{
3266 // Fill the event info object
3267 // ...
3268 AliCodeTimerAuto("")
3269
3270 AliCentralTrigger *aCTP = NULL;
3271 if (fRawReader) {
3272 fEventInfo.SetEventType(fRawReader->GetType());
3273
3274 ULong64_t mask = fRawReader->GetClassMask();
3275 fEventInfo.SetTriggerMask(mask);
3276 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3277 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3278
3279 aCTP = new AliCentralTrigger();
3280 TString configstr("");
3281 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3282 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3283 delete aCTP;
3284 return kFALSE;
3285 }
3286 aCTP->SetClassMask(mask);
3287 aCTP->SetClusterMask(clmask);
3288 }
3289 else {
3290 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3291
3292 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3293 aCTP = fRunLoader->GetTrigger();
3294 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
e61ed4b1 3295 // get inputs from actp - just get
3296 AliESDHeader* esdheader = fesd->GetHeader();
3297 esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
3298 esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
3299 esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
7e88424f 3300 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
3301 }
3302 else {
3303 AliWarning("No trigger can be loaded! The trigger information will not be used!");
3304 return kFALSE;
3305 }
3306 }
3307
3308 AliTriggerConfiguration *config = aCTP->GetConfiguration();
3309 if (!config) {
3310 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3311 if (fRawReader) delete aCTP;
3312 return kFALSE;
3313 }
3314
a0c2cf2d 3315 UChar_t clustmask = 0;
7e88424f 3316 TString trclasses;
3317 ULong64_t trmask = fEventInfo.GetTriggerMask();
3318 const TObjArray& classesArray = config->GetClasses();
3319 Int_t nclasses = classesArray.GetEntriesFast();
3320 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3321 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3322 if (trclass) {
a4b0683d 3323 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
7e88424f 3324 fesd->SetTriggerClass(trclass->GetName(),trindex);
8a933107 3325 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
e61ed4b1 3326 if (trmask & (1ull << trindex)) {
7e88424f 3327 trclasses += " ";
3328 trclasses += trclass->GetName();
3329 trclasses += " ";
a0c2cf2d 3330 clustmask |= trclass->GetCluster()->GetClusterMask();
7e88424f 3331 }
3332 }
3333 }
3334 fEventInfo.SetTriggerClasses(trclasses);
3335
a0c2cf2d 3336 // Set the information in ESD
3337 fesd->SetTriggerMask(trmask);
3338 fesd->SetTriggerCluster(clustmask);
3339
7e88424f 3340 if (!aCTP->CheckTriggeredDetectors()) {
3341 if (fRawReader) delete aCTP;
3342 return kFALSE;
3343 }
3344
3345 if (fRawReader) delete aCTP;
3346
3347 // We have to fill also the HLT decision here!!
3348 // ...
3349
3350 return kTRUE;
3351}
3352
3353const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
3354{
3355 // Match the detector list found in the rec.C or the default 'ALL'
3356 // to the list found in the GRP (stored there by the shuttle PP which
3357 // gets the information from ECS)
3358 static TString resultList;
3359 TString detList = detectorList;
3360
3361 resultList = "";
3362
3363 for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
3364 if ((detectorMask >> iDet) & 0x1) {
3365 TString det = AliDAQ::OfflineModuleName(iDet);
3366 if ((detList.CompareTo("ALL") == 0) ||
a101e1dd 3367 ((detList.BeginsWith("ALL ") ||
3368 detList.EndsWith(" ALL") ||
3369 detList.Contains(" ALL ")) &&
3370 !(detList.BeginsWith("-"+det+" ") ||
3371 detList.EndsWith(" -"+det) ||
3372 detList.Contains(" -"+det+" "))) ||
7e88424f 3373 (detList.CompareTo(det) == 0) ||
a101e1dd 3374 detList.BeginsWith(det+" ") ||
3375 detList.EndsWith(" "+det) ||
7e88424f 3376 detList.Contains( " "+det+" " )) {
3377 if (!resultList.EndsWith(det + " ")) {
3378 resultList += det;
3379 resultList += " ";
3380 }
3381 }
3382 }
3383 }
3384
3385 // HLT
3386 if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
3387 TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
3388 if ((detList.CompareTo("ALL") == 0) ||
a101e1dd 3389 ((detList.BeginsWith("ALL ") ||
3390 detList.EndsWith(" ALL") ||
3391 detList.Contains(" ALL ")) &&
3392 !(detList.BeginsWith("-"+hltDet+" ") ||
3393 detList.EndsWith(" -"+hltDet) ||
3394 detList.Contains(" -"+hltDet+" "))) ||
7e88424f 3395 (detList.CompareTo(hltDet) == 0) ||
a101e1dd 3396 detList.BeginsWith(hltDet+" ") ||
3397 detList.EndsWith(" "+hltDet) ||
7e88424f 3398 detList.Contains( " "+hltDet+" " )) {
3399 resultList += hltDet;
3400 }
3401 }
3402
3403 return resultList.Data();
3404
3405}
4b71572b 3406
3407//______________________________________________________________________________
3408void AliReconstruction::Abort(const char *method, EAbort what)
3409{
3410 // Abort processing. If what = kAbortProcess, the Process() loop will be
3411 // aborted. If what = kAbortFile, the current file in a chain will be
3412 // aborted and the processing will continue with the next file, if there
3413 // is no next file then Process() will be aborted. Abort() can also be
3414 // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
3415 // the SlaveTerminate() and Terminate() are always called. The abort flag
3416 // can be checked in these methods using GetAbort().
3417 //
3418 // The method is overwritten in AliReconstruction for better handling of
3419 // reco specific errors
3420
3421 if (!fStopOnError) return;
3422
3423 CleanUp();
3424
3425 TString whyMess = method;
3426 whyMess += " failed! Aborting...";
3427
3428 AliError(whyMess.Data());
3429
3430 fAbort = what;
3431 TString mess = "Abort";
3432 if (fAbort == kAbortProcess)
3433 mess = "AbortProcess";
3434 else if (fAbort == kAbortFile)
3435 mess = "AbortFile";
3436
3437 Info(mess, whyMess.Data());
3438}
3439