]> 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
Add a protection to fitter->Eval
[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 //
1dd3d90e 964 //
965 if (fcDip!=0 && (map==AliMagF::k5kG || map==AliMagF::k2kG) &&
966 ((AliMagF::GetPolarityConvention()==AliMagF::kConvMap2005 && l3Pol!=diPol) ||
967 (AliMagF::GetPolarityConvention()==AliMagF::kConvDCS2008 && l3Pol==diPol) ||
968 (AliMagF::GetPolarityConvention()==AliMagF::kConvLHC && l3Pol!=diPol)) ) {
969 AliError(Form("Wrong combination for L3/Dipole polarities (%c/%c) for convention %d",
970 l3Pol>0?'+':'-',diPol>0?'+':'-',AliMagF::GetPolarityConvention()));
f7a1cc68 971 return kFALSE;
972 }
973 //
974 if (l3Pol<0) fcL3 = -fcL3;
975 if (diPol<0) fcDip = -fcDip;
976 //
977 AliMagF::BeamType_t btype = AliMagF::kNoBeamField;
978 TString btypestr = beamtype;
979 btypestr.ToLower();
980 TPRegexp protonBeam("(proton|p)\\s*-?\\s*\\1");
981 TPRegexp ionBeam("(lead|pb|ion|a)\\s*-?\\s*\\1");
982 if (btypestr.Contains(ionBeam)) btype = AliMagF::kBeamTypeAA;
983 else if (btypestr.Contains(protonBeam)) btype = AliMagF::kBeamTypepp;
984 else {
985 AliInfo(Form("Cannot determine the beam type from %s, assume no LHC magnet field",beamtype));
986 }
987
988 AliMagF* fld = new AliMagF("MagneticFieldMap", s.Data(), 2, fcL3, fcDip, 10., map, path,
9251fceb 989 btype,beamenergy);
f7a1cc68 990 TGeoGlobalMagField::Instance()->SetField( fld );
991 TGeoGlobalMagField::Instance()->Lock();
992 //
61807e09 993 return kTRUE;
994}
995
996
997Bool_t AliReconstruction::InitGRP() {
998 //------------------------------------
999 // Initialization of the GRP entry
1000 //------------------------------------
1001 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1002
4b71572b 1003 if (entry) {
44e45fac 1004
1005 TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
1006
1007 if (m) {
1008 AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1009 m->Print();
1010 fGRPData = new AliGRPObject();
1011 fGRPData->ReadValuesFromMap(m);
1012 }
1013
1014 else {
1015 AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1016 fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
1017 entry->SetOwner(0);
1018 }
1019
f168abba 1020 // FIX ME: The unloading of GRP entry is temporarily disabled
1021 // because ZDC and VZERO are using it in order to initialize
1022 // their reconstructor objects. In the future one has to think
1023 // of propagating AliRunInfo to the reconstructors.
1024 // AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
4b71572b 1025 }
61807e09 1026
1027 if (!fGRPData) {
1028 AliError("No GRP entry found in OCDB!");
1029 return kFALSE;
1030 }
1031
44e45fac 1032 TString lhcState = fGRPData->GetLHCState();
1033 if (lhcState==AliGRPObject::GetInvalidString()) {
7e88424f 1034 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
44e45fac 1035 lhcState = "UNKNOWN";
7e88424f 1036 }
1037
44e45fac 1038 TString beamType = fGRPData->GetBeamType();
1039 if (beamType==AliGRPObject::GetInvalidString()) {
7e88424f 1040 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
44e45fac 1041 beamType = "UNKNOWN";
7e88424f 1042 }
1043
44e45fac 1044 Float_t beamEnergy = fGRPData->GetBeamEnergy();
1045 if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
7e88424f 1046 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
44e45fac 1047 beamEnergy = 0;
7e88424f 1048 }
f7a1cc68 1049 // energy is provided in MeV*120
1050 beamEnergy /= 120E3;
7e88424f 1051
44e45fac 1052 TString runType = fGRPData->GetRunType();
1053 if (runType==AliGRPObject::GetInvalidString()) {
7e88424f 1054 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
44e45fac 1055 runType = "UNKNOWN";
7e88424f 1056 }
1057
44e45fac 1058 Int_t activeDetectors = fGRPData->GetDetectorMask();
a5dede5c 1059 if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
7e88424f 1060 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
44e45fac 1061 activeDetectors = 1074790399;
7e88424f 1062 }
1063
44e45fac 1064 fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
44e45fac 1065 fRunInfo->Dump();
1066
7e88424f 1067
1068 // Process the list of active detectors
44e45fac 1069 if (activeDetectors) {
1070 UInt_t detMask = activeDetectors;
7a317bef 1071 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1072 fRunTracking = MatchDetectorList(fRunTracking,detMask);
1073 fFillESD = MatchDetectorList(fFillESD,detMask);
1074 fQADetectors = MatchDetectorList(fQADetectors,detMask);
7d566c20 1075 fLoadCDB.Form("%s %s %s %s",
1076 fRunLocalReconstruction.Data(),
1077 fRunTracking.Data(),
1078 fFillESD.Data(),
1079 fQADetectors.Data());
7d566c20 1080 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
91e2f025 1081 if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
1082 // switch off the vertexer
1083 AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
1084 fRunVertexFinder = kFALSE;
1085 }
304d7f0b 1086 if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1087 // switch off the reading of CTP raw-data payload
1088 if (fFillTriggerESD) {
1089 AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1090 fFillTriggerESD = kFALSE;
1091 }
1092 }
7e88424f 1093 }
1094
1095 AliInfo("===================================================================================");
1096 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1097 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1098 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
ca13fb87 1099 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
7d566c20 1100 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
7e88424f 1101 AliInfo("===================================================================================");
61807e09 1102
1103 //*** Dealing with the magnetic field map
f7a1cc68 1104 if ( TGeoGlobalMagField::Instance()->IsLocked() ) {AliInfo("Running with the externally locked B field !");}
1105 else {
61807e09 1106 // Construct the field map out of the information retrieved from GRP.
856024f0 1107 Bool_t ok = kTRUE;
61807e09 1108 // L3
44e45fac 1109 Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1110 if (l3Current == AliGRPObject::GetInvalidFloat()) {
1111 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
1112 ok = kFALSE;
1113 }
f7a1cc68 1114
44e45fac 1115 Char_t l3Polarity = fGRPData->GetL3Polarity();
1116 if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1117 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
1118 ok = kFALSE;
1119 }
1120
1121 // Dipole
1122 Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1123 if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1124 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1125 ok = kFALSE;
1126 }
1127
1128 Char_t diPolarity = fGRPData->GetDipolePolarity();
1129 if (diPolarity == AliGRPObject::GetInvalidChar()) {
1130 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1131 ok = kFALSE;
1132 }
1133
1134 /*
61807e09 1135 TObjString *l3Current=
1136 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
1137 if (!l3Current) {
1138 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
856024f0 1139 ok = kFALSE;
61807e09 1140 }
1141 TObjString *l3Polarity=
1142 dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
1143 if (!l3Polarity) {
1144 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
856024f0 1145 ok = kFALSE;
61807e09 1146 }
44e45fac 1147
61807e09 1148 // Dipole
1149 TObjString *diCurrent=
1150 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
1151 if (!diCurrent) {
1152 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
856024f0 1153 ok = kFALSE;
61807e09 1154 }
1155 TObjString *diPolarity=
1156 dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
1157 if (!diPolarity) {
1158 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
856024f0 1159 ok = kFALSE;
61807e09 1160 }
44e45fac 1161 */
61807e09 1162
856024f0 1163 if (ok) {
f7a1cc68 1164 if ( !SetFieldMap(l3Current, diCurrent, l3Polarity ? -1:1, diPolarity ? -1:1) )
1165 AliFatal("Failed to creat a B field map ! Exiting...");
856024f0 1166 AliInfo("Running with the B field constructed out of GRP !");
1167 }
f7a1cc68 1168 else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1169
61807e09 1170 }
f7a1cc68 1171
f2a195c1 1172 //*** Get the diamond profiles from OCDB
1173 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1174 if (entry) {
1175 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1176 } else {
1177 AliError("No SPD diamond profile found in OCDB!");
1178 }
1179
61807e09 1180 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1181 if (entry) {
f2a195c1 1182 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
61807e09 1183 } else {
1184 AliError("No diamond profile found in OCDB!");
1185 }
1186
1187 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1188 if (entry) {
f2a195c1 1189 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
61807e09 1190 } else {
f2a195c1 1191 AliError("No TPC diamond profile found in OCDB!");
61807e09 1192 }
1193
77ba28ba 1194 entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1195 if (entry) {
1196 fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1197 entry->SetOwner(0);
1198 AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1199 }
1200
1201 if (!fListOfCosmicTriggers) {
1202 AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1203 }
1204
61807e09 1205 return kTRUE;
1206}
1207
4b71572b 1208//_____________________________________________________________________________
1209Bool_t AliReconstruction::LoadCDB()
1210{
1211 AliCodeTimerAuto("");
1212
1213 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1214
7d566c20 1215 TString detStr = fLoadCDB;
ac4a7581 1216 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4b71572b 1217 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1218 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1219 }
1220 return kTRUE;
1221}
522fdd91 1222//_____________________________________________________________________________
1223Bool_t AliReconstruction::LoadTriggerScalersCDB()
1224{
1225 AliCodeTimerAuto("");
1226
1227 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
4b71572b 1228
522fdd91 1229 if (entry) {
1230
1231 AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1232 fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1233 entry->SetOwner(0);
82ebedd6 1234 if (fRunScalers->CorrectScalersOverflow() == 0) AliInfo("32bit Trigger counters corrected for overflow");
1235
522fdd91 1236 }
1237 return kTRUE;
1238}
596a855f 1239//_____________________________________________________________________________
21a3aa09 1240Bool_t AliReconstruction::Run(const char* input)
596a855f 1241{
21a3aa09 1242 // Run Run Run
1243 AliCodeTimerAuto("");
596a855f 1244
4b71572b 1245 InitRun(input);
1246 if (GetAbort() != TSelector::kContinue) return kFALSE;
1247
1248 TChain *chain = NULL;
1249 if (fRawReader && (chain = fRawReader->GetChain())) {
1250 // Proof mode
1251 if (gProof) {
4b71572b 1252 gProof->AddInput(this);
975320a0 1253 if (!fESDOutput.IsValid()) {
1254 fESDOutput.SetProtocol("root",kTRUE);
1255 fESDOutput.SetHost(gSystem->HostName());
1256 fESDOutput.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
1257 }
1258 AliInfo(Form("Output file with ESDs is %s",fESDOutput.GetUrl()));
1259 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",fESDOutput.GetUrl()));
1260 gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
4b71572b 1261 chain->SetProof();
1262 chain->Process("AliReconstruction");
1263 }
1264 else {
1265 chain->Process(this);
1266 }
1267 }
1268 else {
1269 Begin(NULL);
1270 if (GetAbort() != TSelector::kContinue) return kFALSE;
1271 SlaveBegin(NULL);
1272 if (GetAbort() != TSelector::kContinue) return kFALSE;
1273 //******* The loop over events
44e45fac 1274 AliInfo("Starting looping over events");
4b71572b 1275 Int_t iEvent = 0;
1276 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1277 (fRawReader && fRawReader->NextEvent())) {
1278 if (!ProcessEvent(iEvent)) {
930e6e3e 1279 Abort("ProcessEvent",TSelector::kAbortFile);
1280 return kFALSE;
4b71572b 1281 }
1282 iEvent++;
1283 }
1284 SlaveTerminate();
1285 if (GetAbort() != TSelector::kContinue) return kFALSE;
1286 Terminate();
1287 if (GetAbort() != TSelector::kContinue) return kFALSE;
21a3aa09 1288 }
21a3aa09 1289
1290 return kTRUE;
1291}
1292
1293//_____________________________________________________________________________
4b71572b 1294void AliReconstruction::InitRawReader(const char* input)
21a3aa09 1295{
21a3aa09 1296 AliCodeTimerAuto("");
1297
4b71572b 1298 // Init raw-reader and
21a3aa09 1299 // set the input in case of raw data
4b71572b 1300 if (input) fRawInput = input;
1301 fRawReader = AliRawReader::Create(fRawInput.Data());
b58710ef 1302 if (!fRawReader)
21a3aa09 1303 AliInfo("Reconstruction will run over digits");
e0027792 1304
35042093 1305 if (!fEquipIdMap.IsNull() && fRawReader)
1306 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1307
cd0b062e 1308 if (!fUseHLTData.IsNull()) {
1309 // create the RawReaderHLT which performs redirection of HLT input data for
1310 // the specified detectors
1311 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1312 if (pRawReader) {
1313 fParentRawReader=fRawReader;
1314 fRawReader=pRawReader;
1315 } else {
1316 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1317 }
1318 }
4b71572b 1319 AliSysInfo::AddStamp("CreateRawReader");
1320}
cd0b062e 1321
4b71572b 1322//_____________________________________________________________________________
1323void AliReconstruction::InitRun(const char* input)
1324{
1325 // Initialization of raw-reader,
1326 // run number, CDB etc.
1327 AliCodeTimerAuto("");
1328 AliSysInfo::AddStamp("Start");
1329
002c9d1b 1330 // Initialize raw-reader if any
4b71572b 1331 InitRawReader(input);
596a855f 1332
ec92bee0 1333 // Initialize the CDB storage
795e4a22 1334 InitCDB();
ec92bee0 1335
6bae477a 1336 // Set run number in CDBManager (if it is not already set by the user)
4b71572b 1337 if (!SetRunNumberFromData()) {
1338 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1339 return;
1340 }
002c9d1b 1341
795e4a22 1342 // Set CDB lock: from now on it is forbidden to reset the run number
1343 // or the default storage or to activate any further storage!
1344 SetCDBLock();
1345
002c9d1b 1346}
1347
1348//_____________________________________________________________________________
1349void AliReconstruction::Begin(TTree *)
1350{
1351 // Initialize AlReconstruction before
1352 // going into the event loop
1353 // Should follow the TSelector convention
1354 // i.e. initialize only the object on the client side
db4aeca1 1355 AliCodeTimerAuto("");
1356
b4fef0d2 1357 AliReconstruction *reco = NULL;
002c9d1b 1358 if (fInput) {
8fb1f1dc 1359 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
002c9d1b 1360 *this = *reco;
002c9d1b 1361 }
1362 AliSysInfo::AddStamp("ReadInputInBegin");
1363 }
1364
6bae477a 1365 // Import ideal TGeo geometry and apply misalignment
1366 if (!gGeoManager) {
1367 TString geom(gSystem->DirName(fGAliceFileName));
1368 geom += "/geometry.root";
98e303d9 1369 AliGeomManager::LoadGeometry(geom.Data());
4b71572b 1370 if (!gGeoManager) {
1371 Abort("LoadGeometry", TSelector::kAbortProcess);
1372 return;
1373 }
281270d3 1374 AliSysInfo::AddStamp("LoadGeom");
ff5970a3 1375 TString detsToCheck=fRunLocalReconstruction;
4b71572b 1376 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1377 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1378 return;
1379 }
281270d3 1380 AliSysInfo::AddStamp("CheckGeom");
6bae477a 1381 }
8e245d15 1382
4b71572b 1383 if (!MisalignGeometry(fLoadAlignData)) {
1384 Abort("MisalignGeometry", TSelector::kAbortProcess);
1385 return;
1386 }
1387 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
281270d3 1388 AliSysInfo::AddStamp("MisalignGeom");
6bae477a 1389
8cb26cdf 1390 if (!InitGRP()) {
1391 Abort("InitGRP", TSelector::kAbortProcess);
1392 return;
1393 }
1394 AliSysInfo::AddStamp("InitGRP");
1395
4b71572b 1396 if (!LoadCDB()) {
1397 Abort("LoadCDB", TSelector::kAbortProcess);
1398 return;
1399 }
1400 AliSysInfo::AddStamp("LoadCDB");
325aa76f 1401
a6dd87ad 1402 if (!LoadTriggerScalersCDB()) {
1403 Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1404 return;
1405 }
1406 AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1407
1408
7e88424f 1409 // Read the reconstruction parameters from OCDB
1410 if (!InitRecoParams()) {
002c9d1b 1411 AliWarning("Not all detectors have correct RecoParam objects initialized");
4b71572b 1412 }
1413 AliSysInfo::AddStamp("InitRecoParams");
1414
fd2b273c 1415 if (fInput && gProof) {
b4fef0d2 1416 if (reco) *reco = *this;
fd2b273c 1417
1418 gProof->AddInputData(gGeoManager,kTRUE);
002c9d1b 1419 gGeoManager = NULL;
fd2b273c 1420 gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
002c9d1b 1421 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
f7a1cc68 1422 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
ead7b391 1423 magFieldMap->SetName("MagneticFieldMap");
fd2b273c 1424 gProof->AddInputData(magFieldMap,kTRUE);
002c9d1b 1425 }
4b71572b 1426
1427}
1428
1429//_____________________________________________________________________________
1430void AliReconstruction::SlaveBegin(TTree*)
1431{
1432 // Initialization related to run-loader,
1433 // vertexer, trackers, recontructors
1434 // In proof mode it is executed on the slave
1435 AliCodeTimerAuto("");
1436
db4aeca1 1437 TProofOutputFile *outProofFile = NULL;
ead7b391 1438 if (fInput) {
db4aeca1 1439 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1440 *this = *reco;
1441 }
4b71572b 1442 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1443 gGeoManager = tgeo;
1444 AliGeomManager::SetGeometry(tgeo);
7e88424f 1445 }
281270d3 1446 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1447 Int_t runNumber = -1;
1448 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1449 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1450 man->SetCacheFlag(kTRUE);
1451 man->SetLock(kTRUE);
1452 man->Print();
1453 }
4b71572b 1454 }
ead7b391 1455 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
f7a1cc68 1456 TGeoGlobalMagField::Instance()->SetField(map);
4b71572b 1457 }
db4aeca1 1458 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1459 outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
1460 outProofFile->SetOutputFileName(outputFileName->GetTitle());
1461 fOutput->Add(outProofFile);
4b71572b 1462 }
002c9d1b 1463 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
7e88424f 1464 }
325aa76f 1465
4b71572b 1466 // get the run loader
1467 if (!InitRunLoader()) {
1468 Abort("InitRunLoader", TSelector::kAbortProcess);
1469 return;
1470 }
1471 AliSysInfo::AddStamp("LoadLoader");
1472
325aa76f 1473 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
2257f27e 1474
f08fc9f5 1475 // get trackers
b8cd5251 1476 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
4b71572b 1477 Abort("CreateTrackers", TSelector::kAbortProcess);
1478 return;
1479 }
1480 AliSysInfo::AddStamp("CreateTrackers");
24f7a148 1481
36711aa4 1482 // create the ESD output file and tree
db4aeca1 1483 if (!outProofFile) {
1484 ffile = TFile::Open("AliESDs.root", "RECREATE");
1485 ffile->SetCompressionLevel(2);
1486 if (!ffile->IsOpen()) {
1487 Abort("OpenESDFile", TSelector::kAbortProcess);
1488 return;
1489 }
1490 }
1491 else {
1492 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1493 Abort(Form("Problems opening output PROOF file: %s/%s",
1494 outProofFile->GetDir(), outProofFile->GetFileName()),
1495 TSelector::kAbortProcess);
1496 return;
1497 }
596a855f 1498 }
46698ae4 1499
21a3aa09 1500 ftree = new TTree("esdTree", "Tree with ESD objects");
1501 fesd = new AliESDEvent();
1502 fesd->CreateStdContent();
32ba9c61 1503
1504 fesd->WriteToTree(ftree);
1d99986f 1505 if (fWriteESDfriend) {
32ba9c61 1506 // careful:
1507 // Since we add the branch manually we must
1508 // book and add it after WriteToTree
1509 // otherwise it is created twice,
1510 // once via writetotree and once here.
1511 // The case for AliESDfriend is now
1512 // caught also in AlIESDEvent::WriteToTree but
1513 // be careful when changing the name (AliESDfriend is not
1514 // a TNamed so we had to hardwire it)
21a3aa09 1515 fesdf = new AliESDfriend();
1516 TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
46698ae4 1517 br->SetFile("AliESDfriends.root");
21a3aa09 1518 fesd->AddObject(fesdf);
1d99986f 1519 }
f9604a22 1520 ftree->GetUserInfo()->Add(fesd);
1521
1522 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1523 fhltesd = new AliESDEvent();
1524 fhltesd->CreateStdContent();
7491aea6 1525
1526 // read the ESD template from CDB
1527 // HLT is allowed to put non-std content to its ESD, the non-std
1528 // objects need to be created before invocation of WriteToTree in
1529 // order to create all branches. Initialization is done from an
1530 // ESD layout template in CDB
1531 AliCDBManager* man = AliCDBManager::Instance();
1532 AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1533 AliCDBEntry* hltESDConfig=NULL;
1534 if (man->GetId(hltESDConfigPath)!=NULL &&
1535 (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1536 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1537 if (pESDLayout) {
1538 // init all internal variables from the list of objects
1539 pESDLayout->GetStdContent();
1540
1541 // copy content and create non-std objects
1542 *fhltesd=*pESDLayout;
1543 fhltesd->Reset();
1544 } else {
1545 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1546 hltESDConfigPath.GetPath().Data()));
1547 }
1548 }
1549
f9604a22 1550 fhltesd->WriteToTree(fhlttree);
1551 fhlttree->GetUserInfo()->Add(fhltesd);
5728d3d5 1552
ac4a7581 1553 ProcInfo_t procInfo;
1554 gSystem->GetProcInfo(&procInfo);
1555 AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
8661738e 1556
325aa76f 1557 //QA
930e6e3e 1558 //Initialize the QA and start of cycle
f1c1204d 1559 if (fRunQA || fRunGlobalQA)
1560 InitQA() ;
aa3c69a9 1561
7167ae53 1562 //Initialize the Plane Efficiency framework
1563 if (fRunPlaneEff && !InitPlaneEff()) {
4b71572b 1564 Abort("InitPlaneEff", TSelector::kAbortProcess);
1565 return;
7167ae53 1566 }
aa3c69a9 1567
14dd053c 1568 if (strcmp(gProgName,"alieve") == 0)
1569 fRunAliEVE = InitAliEVE();
1570
4b71572b 1571 return;
21a3aa09 1572}
1573
1574//_____________________________________________________________________________
4b71572b 1575Bool_t AliReconstruction::Process(Long64_t entry)
1576{
1577 // run the reconstruction over a single entry
1578 // from the chain with raw data
1579 AliCodeTimerAuto("");
1580
1581 TTree *currTree = fChain->GetTree();
33314186 1582 AliRawVEvent *event = NULL;
4b71572b 1583 currTree->SetBranchAddress("rawevent",&event);
1584 currTree->GetEntry(entry);
1585 fRawReader = new AliRawReaderRoot(event);
1586 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1587 delete fRawReader;
1588 fRawReader = NULL;
1589 delete event;
1590
1591 return fStatus;
1592}
1593
1594//_____________________________________________________________________________
1595void AliReconstruction::Init(TTree *tree)
1596{
1597 if (tree == 0) {
1598 AliError("The input tree is not found!");
1599 return;
1600 }
1601 fChain = tree;
1602}
1603
1604//_____________________________________________________________________________
1605Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
21a3aa09 1606{
1607 // run the reconstruction over a single event
1608 // The event loop is steered in Run method
1609
1610 AliCodeTimerAuto("");
1611
1612 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1613 fRunLoader->SetEventNumber(iEvent);
1614 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1615 iEvent, iEvent);
21a3aa09 1616 fRunLoader->TreeE()->Fill();
4b71572b 1617 if (fRawReader && fRawReader->UseAutoSaveESD())
1618 fRunLoader->TreeE()->AutoSave("SaveSelf");
21a3aa09 1619 }
1620
1621 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
21a3aa09 1622 return kTRUE;
1623 }
1624
1625 AliInfo(Form("processing event %d", iEvent));
aa3c69a9 1626
16447f18 1627 fRunLoader->GetEvent(iEvent);
1628
7e88424f 1629 // Fill Event-info object
1630 GetEventInfo();
77ba28ba 1631 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
48f5e52d 1632 AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
7e88424f 1633
a00021a7 1634 // Set the reco-params
1635 {
1636 TString detStr = fLoadCDB;
ac4a7581 1637 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
a00021a7 1638 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1639 AliReconstructor *reconstructor = GetReconstructor(iDet);
1640 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
57acd2d2 1641 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1642 reconstructor->SetRecoParam(par);
42ec5d3d 1643 reconstructor->SetEventInfo(&fEventInfo);
57acd2d2 1644 if (fRunQA) {
eca4fa66 1645 AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
6252ceeb 1646 AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
57acd2d2 1647 }
a00021a7 1648 }
1649 }
1650 }
1651
ca13fb87 1652 // QA on single raw
57acd2d2 1653 if (fRunQA) {
eca4fa66 1654 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1655 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
57acd2d2 1656 }
d506c543 1657 // local single event reconstruction
b26c3770 1658 if (!fRunLocalReconstruction.IsNull()) {
d506c543 1659 TString detectors=fRunLocalReconstruction;
a441bf51 1660 // run HLT event reconstruction first
d506c543 1661 // ;-( IsSelected changes the string
1662 if (IsSelected("HLT", detectors) &&
1663 !RunLocalEventReconstruction("HLT")) {
4b71572b 1664 if (fStopOnError) {CleanUp(); return kFALSE;}
a441bf51 1665 }
1666 detectors=fRunLocalReconstruction;
1667 detectors.ReplaceAll("HLT", "");
1668 if (!RunLocalEventReconstruction(detectors)) {
4b71572b 1669 if (fStopOnError) {CleanUp(); return kFALSE;}
b26c3770 1670 }
1671 }
1672
21a3aa09 1673 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1674 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1675 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1676 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 1677
d6ee376f 1678 // Set magnetic field from the tracker
21a3aa09 1679 fesd->SetMagneticField(AliTracker::GetBz());
1680 fhltesd->SetMagneticField(AliTracker::GetBz());
596a855f 1681
71f6cda4 1682 // Set most probable pt, for B=0 tracking
9257a1bd 1683 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
ac4a7581 1684 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
71f6cda4 1685 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
46698ae4 1686
2e3550da 1687 // Fill raw-data error log into the ESD
21a3aa09 1688 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1689
2257f27e 1690 // vertex finder
1691 if (fRunVertexFinder) {
4b71572b 1692 if (!RunVertexFinder(fesd)) {
1693 if (fStopOnError) {CleanUp(); return kFALSE;}
2257f27e 1694 }
1695 }
1696
58e8dc31 1697 // For Plane Efficiency: run the SPD trackleter
1698 if (fRunPlaneEff && fSPDTrackleter) {
1699 if (!RunSPDTrackleting(fesd)) {
1700 if (fStopOnError) {CleanUp(); return kFALSE;}
1701 }
1702 }
1703
e66fbafb 1704 // Muon tracking
b8cd5251 1705 if (!fRunTracking.IsNull()) {
e66fbafb 1706 if (fRunMuonTracking) {
21a3aa09 1707 if (!RunMuonTracking(fesd)) {
4b71572b 1708 if (fStopOnError) {CleanUp(); return kFALSE;}
24f7a148 1709 }
596a855f 1710 }
1711 }
1712
e66fbafb 1713 // barrel tracking
1714 if (!fRunTracking.IsNull()) {
4b71572b 1715 if (!RunTracking(fesd)) {
1716 if (fStopOnError) {CleanUp(); return kFALSE;}
e66fbafb 1717 }
1718 }
21c573b7 1719
596a855f 1720 // fill ESD
1721 if (!fFillESD.IsNull()) {
d506c543 1722 TString detectors=fFillESD;
f6806ad3 1723 // run HLT first and on hltesd
d506c543 1724 // ;-( IsSelected changes the string
1725 if (IsSelected("HLT", detectors) &&
1726 !FillESD(fhltesd, "HLT")) {
4b71572b 1727 if (fStopOnError) {CleanUp(); return kFALSE;}
f6806ad3 1728 }
1729 detectors=fFillESD;
d5105682 1730 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1731 if (detectors.Contains("ALL")) {
1732 detectors="";
ac4a7581 1733 for (Int_t idet=0; idet<kNDetectors; ++idet){
d5105682 1734 detectors += fgkDetectorName[idet];
1735 detectors += " ";
1736 }
1737 }
f6806ad3 1738 detectors.ReplaceAll("HLT", "");
1739 if (!FillESD(fesd, detectors)) {
4b71572b 1740 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 1741 }
1742 }
a5fa6165 1743
001397cd 1744 // fill Event header information from the RawEventHeader
21a3aa09 1745 if (fRawReader){FillRawEventHeaderESD(fesd);}
63314086 1746 if (fRawReader){FillRawEventHeaderESD(fhltesd);}
596a855f 1747
1748 // combined PID
21a3aa09 1749 AliESDpid::MakePID(fesd);
596a855f 1750
b647652d 1751 if (fFillTriggerESD) {
4b71572b 1752 if (!FillTriggerESD(fesd)) {
1753 if (fStopOnError) {CleanUp(); return kFALSE;}
b647652d 1754 }
1755 }
1756
21a3aa09 1757 ffile->cd();
a6ee503a 1758
3c3709c4 1759 //
67be5c77 1760 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1761 //
21a3aa09 1762 const Int_t ntracks = fesd->GetNumberOfTracks();
1763 const Double_t kBz = fesd->GetMagneticField();
3c3709c4 1764 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1765
1766 TObjArray trkArray;
1767 UShort_t *selectedIdx=new UShort_t[ntracks];
1768
1769 for (Int_t itrack=0; itrack<ntracks; itrack++){
98a50ff3 1770 const Double_t kMaxStep = 1; //max step over the material
3c3709c4 1771 Bool_t ok;
1772
21a3aa09 1773 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1774 if (!track) continue;
1775
1776 AliExternalTrackParam *tpcTrack =
1777 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1778 ok = kFALSE;
1779 if (tpcTrack)
1780 ok = AliTracker::
e92d2a64 1781 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
43c9dae1 1782
3c3709c4 1783 if (ok) {
1784 Int_t n=trkArray.GetEntriesFast();
1785 selectedIdx[n]=track->GetID();
1786 trkArray.AddLast(tpcTrack);
1787 }
1788
3d65e645 1789 //Tracks refitted by ITS should already be at the SPD vertex
1790 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1791
1792 AliTracker::
e92d2a64 1793 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
3d65e645 1794 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
3c3709c4 1795
3c3709c4 1796 }
1797
1798 //
1799 // Improve the reconstructed primary vertex position using the tracks
1800 //
59224b2b 1801 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1802 if(fesd->GetPrimaryVertexSPD()) {
1803 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1804 if(vtitle.Contains("cosmics")) {
1805 runVertexFinderTracks=kFALSE;
1806 }
c060d7fe 1807 }
a00021a7 1808
1809 if (runVertexFinderTracks) {
3c3709c4 1810 // TPC + ITS primary vertex
f09c879d 1811 ftVertexer->SetITSMode();
f2a195c1 1812 ftVertexer->SetConstraintOff();
a00021a7 1813 // get cuts for vertexer from AliGRPRecoParam
1814 if (grpRecoParam) {
1815 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1816 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1817 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1818 ftVertexer->SetCuts(cutsVertexer);
1819 delete [] cutsVertexer; cutsVertexer = NULL;
f2a195c1 1820 if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
1821 ftVertexer->SetVtxStart(fDiamondProfile);
43c9dae1 1822 }
21a3aa09 1823 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 1824 if (pvtx) {
1825 if (pvtx->GetStatus()) {
c264b61b 1826 fesd->SetPrimaryVertexTracks(pvtx);
3c3709c4 1827 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 1828 AliESDtrack *t = fesd->GetTrack(i);
3d65e645 1829 t->RelateToVertex(pvtx, kBz, kVeryBig);
3c3709c4 1830 }
1831 }
1832 }
1833
1834 // TPC-only primary vertex
f09c879d 1835 ftVertexer->SetTPCMode();
f2a195c1 1836 ftVertexer->SetConstraintOff();
a00021a7 1837 // get cuts for vertexer from AliGRPRecoParam
1838 if (grpRecoParam) {
1839 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1840 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1841 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1842 ftVertexer->SetCuts(cutsVertexer);
1843 delete [] cutsVertexer; cutsVertexer = NULL;
f2a195c1 1844 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
1845 ftVertexer->SetVtxStart(fDiamondProfileTPC);
43c9dae1 1846 }
21a3aa09 1847 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 1848 if (pvtx) {
1849 if (pvtx->GetStatus()) {
21a3aa09 1850 fesd->SetPrimaryVertexTPC(pvtx);
3d65e645 1851 for (Int_t i=0; i<ntracks; i++) {
1852 AliESDtrack *t = fesd->GetTrack(i);
1853 t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
3c3709c4 1854 }
1855 }
1856 }
1857
1858 }
1859 delete[] selectedIdx;
1860
21a3aa09 1861 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
17c86e90 1862
c5e3e5d1 1863
d1683eef 1864 if (fRunV0Finder) {
1865 // V0 finding
1866 AliV0vertexer vtxer;
21a3aa09 1867 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 1868
d1683eef 1869 if (fRunCascadeFinder) {
1870 // Cascade finding
1871 AliCascadeVertexer cvtxer;
21a3aa09 1872 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 1873 }
5e4ff34d 1874 }
1875
596a855f 1876 // write ESD
21a3aa09 1877 if (fCleanESD) CleanESD(fesd);
854c6476 1878
57acd2d2 1879 if (fRunQA) {
eca4fa66 1880 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1881 AliQAManager::QAManager()->RunOneEvent(fesd) ;
57acd2d2 1882 }
bea94759 1883 if (fRunGlobalQA) {
eca4fa66 1884 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
57acd2d2 1885 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
4e25ac79 1886 if (qadm && fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
1887 qadm->Exec(AliQAv1::kESDS, fesd);
b03591ab 1888 }
854c6476 1889
1d99986f 1890 if (fWriteESDfriend) {
b090e6a3 1891 // fesdf->~AliESDfriend();
1892 // new (fesdf) AliESDfriend(); // Reset...
21a3aa09 1893 fesd->GetESDfriend(fesdf);
1d99986f 1894 }
21a3aa09 1895 ftree->Fill();
500d54ab 1896
2d91a353 1897 // Auto-save the ESD tree in case of prompt reco @P2
be103ac8 1898 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2d91a353 1899 ftree->AutoSave("SaveSelf");
be103ac8 1900 TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1901 if (friendfile) friendfile->Save();
1902 }
2d91a353 1903
500d54ab 1904 // write HLT ESD
21a3aa09 1905 fhlttree->Fill();
1d99986f 1906
14dd053c 1907 // call AliEVE
1908 if (fRunAliEVE) RunAliEVE();
1909
21a3aa09 1910 fesd->Reset();
1911 fhltesd->Reset();
5728d3d5 1912 if (fWriteESDfriend) {
21a3aa09 1913 fesdf->~AliESDfriend();
1914 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 1915 }
a5fa6165 1916
ac4a7581 1917 ProcInfo_t procInfo;
1918 gSystem->GetProcInfo(&procInfo);
1919 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
a5fa6165 1920
ca13fb87 1921 fEventInfo.Reset();
ac4a7581 1922 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
42ec5d3d 1923 if (fReconstructor[iDet]) {
a00021a7 1924 fReconstructor[iDet]->SetRecoParam(NULL);
42ec5d3d 1925 fReconstructor[iDet]->SetEventInfo(NULL);
1926 }
1f26f3e7 1927 if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
ca13fb87 1928 }
1929
53c8f690 1930 if (fRunQA || fRunGlobalQA)
eca4fa66 1931 AliQAManager::QAManager()->Increment() ;
53c8f690 1932
ca13fb87 1933 return kTRUE;
21a3aa09 1934}
1935
21a3aa09 1936//_____________________________________________________________________________
4b71572b 1937void AliReconstruction::SlaveTerminate()
21a3aa09 1938{
4b71572b 1939 // Finalize the run on the slave side
21a3aa09 1940 // Called after the exit
1941 // from the event loop
1942 AliCodeTimerAuto("");
1943
1944 if (fIsNewRunLoader) { // galice.root didn't exist
1945 fRunLoader->WriteHeader("OVERWRITE");
1946 fRunLoader->CdGAFile();
1947 fRunLoader->Write(0, TObject::kOverwrite);
1948 }
1949
f747912b 1950 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1951 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1952
1953 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1954 cdbMapCopy->SetOwner(1);
1955 cdbMapCopy->SetName("cdbMap");
1956 TIter iter(cdbMap->GetTable());
1957
1958 TPair* pair = 0;
1959 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1960 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1961 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1962 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1963 }
1964
1965 TList *cdbListCopy = new TList();
1966 cdbListCopy->SetOwner(1);
1967 cdbListCopy->SetName("cdbList");
1968
1969 TIter iter2(cdbList);
1970
b940cb9b 1971 AliCDBId* id=0;
e84c88f5 1972 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1973 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1974 }
1975
21a3aa09 1976 ftree->GetUserInfo()->Add(cdbMapCopy);
1977 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1978
46698ae4 1979
21a3aa09 1980 ffile->cd();
aa3c69a9 1981
a9c0e6db 1982 if (fWriteESDfriend)
21a3aa09 1983 ftree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1984 // we want to have only one tree version number
21a3aa09 1985 ftree->Write(ftree->GetName(),TObject::kOverwrite);
63314086 1986 fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
f3a97c86 1987
a7a1e1c7 1988// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1989 if (fRunPlaneEff && !FinishPlaneEff()) {
1990 AliWarning("Finish PlaneEff evaluation failed");
1991 }
1992
930e6e3e 1993 // End of cycle for the in-loop
57acd2d2 1994 if (fRunQA)
eca4fa66 1995 AliQAManager::QAManager()->EndOfCycle() ;
57acd2d2 1996
930e6e3e 1997 if (fRunGlobalQA) {
eca4fa66 1998 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
4b71572b 1999 if (qadm) {
4e25ac79 2000 if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS)))
2001 qadm->EndOfCycle(AliQAv1::kRECPOINTS);
2002 if (fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
2003 qadm->EndOfCycle(AliQAv1::kESDS);
4b71572b 2004 qadm->Finish();
2005 }
a7807689 2006 }
87da0921 2007
2008 if (fRunQA || fRunGlobalQA) {
2009 if (fInput) {
2010 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
2011 TString qaOutputFile = outputFileName->GetTitle();
2012 qaOutputFile.ReplaceAll(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()),
2013 Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
2014 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
2015 qaProofFile->SetOutputFileName(qaOutputFile.Data());
2016 fOutput->Add(qaProofFile);
2017 MergeQA(qaProofFile->GetFileName());
2018 }
2019 }
2020 else {
2021 MergeQA();
2022 }
2023 }
2024
4b71572b 2025 gROOT->cd();
2026 CleanUp();
2027}
2028
2029//_____________________________________________________________________________
2030void AliReconstruction::Terminate()
2031{
f3a97c86 2032 // Create tags for the events in the ESD tree (the ESD tree is always present)
2033 // In case of empty events the tags will contain dummy values
4b71572b 2034 AliCodeTimerAuto("");
2035
e6d66370 2036 // Do not call the ESD tag creator in case of PROOF-based reconstruction
2037 if (!fInput) {
2038 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2039 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2040 }
e84c88f5 2041
795e4a22 2042 // Cleanup of CDB manager: cache and active storages!
2043 AliCDBManager::Instance()->ClearCache();
596a855f 2044}
2045
b26c3770 2046//_____________________________________________________________________________
2047Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2048{
2049// run the local reconstruction
aa3c69a9 2050
0f88822a 2051 static Int_t eventNr=0;
87932dab 2052 AliCodeTimerAuto("")
b26c3770 2053
2054 TString detStr = detectors;
ac4a7581 2055 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b26c3770 2056 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2057 AliReconstructor* reconstructor = GetReconstructor(iDet);
2058 if (!reconstructor) continue;
2059 AliLoader* loader = fLoader[iDet];
f6806ad3 2060 // Matthias April 2008: temporary fix to run HLT reconstruction
2061 // although the HLT loader is missing
2062 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
2063 if (fRawReader) {
44ed7a66 2064 reconstructor->Reconstruct(fRawReader, NULL);
f6806ad3 2065 } else {
44ed7a66 2066 TTree* dummy=NULL;
2067 reconstructor->Reconstruct(dummy, NULL);
f6806ad3 2068 }
2069 continue;
2070 }
d76c31f4 2071 if (!loader) {
2072 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2073 continue;
2074 }
b26c3770 2075 // conversion of digits
2076 if (fRawReader && reconstructor->HasDigitConversion()) {
2077 AliInfo(Form("converting raw data digits into root objects for %s",
2078 fgkDetectorName[iDet]));
30bbd491 2079// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2080// fgkDetectorName[iDet]));
b26c3770 2081 loader->LoadDigits("update");
2082 loader->CleanDigits();
2083 loader->MakeDigitsContainer();
2084 TTree* digitsTree = loader->TreeD();
2085 reconstructor->ConvertDigits(fRawReader, digitsTree);
2086 loader->WriteDigits("OVERWRITE");
2087 loader->UnloadDigits();
b26c3770 2088 }
b26c3770 2089 // local reconstruction
b26c3770 2090 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
30bbd491 2091 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 2092 loader->LoadRecPoints("update");
2093 loader->CleanRecPoints();
2094 loader->MakeRecPointsContainer();
2095 TTree* clustersTree = loader->TreeR();
2096 if (fRawReader && !reconstructor->HasDigitConversion()) {
2097 reconstructor->Reconstruct(fRawReader, clustersTree);
2098 } else {
2099 loader->LoadDigits("read");
2100 TTree* digitsTree = loader->TreeD();
2101 if (!digitsTree) {
44ed7a66 2102 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2103 if (fStopOnError) return kFALSE;
b26c3770 2104 } else {
44ed7a66 2105 reconstructor->Reconstruct(digitsTree, clustersTree);
2106 if (fRunQA) {
eca4fa66 2107 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2108 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
44ed7a66 2109 }
b26c3770 2110 }
2111 loader->UnloadDigits();
2112 }
57acd2d2 2113 if (fRunQA) {
eca4fa66 2114 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2115 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
57acd2d2 2116 }
eca4fa66 2117 loader->WriteRecPoints("OVERWRITE");
2118 loader->UnloadRecPoints();
2119 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
a00021a7 2120 }
2121 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
b26c3770 2122 AliError(Form("the following detectors were not found: %s",
2123 detStr.Data()));
2124 if (fStopOnError) return kFALSE;
2125 }
0f88822a 2126 eventNr++;
b26c3770 2127 return kTRUE;
2128}
58e8dc31 2129//_____________________________________________________________________________
2130Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2131{
2132// run the SPD trackleting (for SPD efficiency purpouses)
2133
2134 AliCodeTimerAuto("")
2135
2136 Double_t vtxPos[3] = {0, 0, 0};
2137 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2138/*
2139 TArrayF mcVertex(3);
2140 // if(MC)
2141 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2142 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2143 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2144 }
2145*/
2146 const AliESDVertex *vertex = esd->GetVertex();
2147 if(!vertex){
2148 AliWarning("Vertex not found");
2149 return kFALSE;
2150 }
2151 vertex->GetXYZ(vtxPos);
2152 vertex->GetSigmaXYZ(vtxErr);
2153 if (fSPDTrackleter) {
2154 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2155
2156 // load clusters
2157 fLoader[0]->LoadRecPoints("read");
2158 TTree* tree = fLoader[0]->TreeR();
2159 if (!tree) {
2160 AliError("Can't get the ITS cluster tree");
2161 return kFALSE;
2162 }
2163 fSPDTrackleter->LoadClusters(tree);
2164 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2165 // run trackleting
2166 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2167 AliError("AliITSTrackleterSPDEff Clusters2Tracks failed");
2168 // fLoader[0]->UnloadRecPoints();
2169 return kFALSE;
2170 }
2171//fSPDTrackleter->UnloadRecPoints();
2172 } else {
2173 AliWarning("SPDTrackleter not available");
2174 return kFALSE;
2175 }
2176 return kTRUE;
2177}
b26c3770 2178
596a855f 2179//_____________________________________________________________________________
af885e0f 2180Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 2181{
2182// run the barrel tracking
2183
87932dab 2184 AliCodeTimerAuto("")
030b532d 2185
92bffc4d 2186 AliVertexer *vertexer = CreateVertexer();
2187 if (!vertexer) return kFALSE;
2188
2189 AliInfo("running the ITS vertex finder");
2257f27e 2190 AliESDVertex* vertex = NULL;
92bffc4d 2191 if (fLoader[0]) {
2192 fLoader[0]->LoadRecPoints();
2193 TTree* cltree = fLoader[0]->TreeR();
2194 if (cltree) {
2195 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2196 vertex = vertexer->FindVertexForCurrentEvent(cltree);
308c2f7c 2197 }
2198 else {
92bffc4d 2199 AliError("Can't get the ITS cluster tree");
308c2f7c 2200 }
92bffc4d 2201 fLoader[0]->UnloadRecPoints();
2257f27e 2202 }
92bffc4d 2203 else {
2204 AliError("Can't get the ITS loader");
2205 }
2206 if(!vertex){
2207 AliWarning("Vertex not found");
2208 vertex = new AliESDVertex();
2209 vertex->SetName("default");
2210 }
2211 else {
2212 vertex->SetName("reconstructed");
2257f27e 2213 }
92bffc4d 2214
2215 Double_t vtxPos[3];
2216 Double_t vtxErr[3];
2217 vertex->GetXYZ(vtxPos);
2218 vertex->GetSigmaXYZ(vtxErr);
2219
06cc9d95 2220 esd->SetPrimaryVertexSPD(vertex);
73c51de2 2221 AliESDVertex *vpileup = NULL;
2222 Int_t novertices = 0;
2223 vpileup = vertexer->GetAllVertices(novertices);
2224 if(novertices>1){
2225 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2226 }
32e449be 2227 // if SPD multiplicity has been determined, it is stored in the ESD
92bffc4d 2228 AliMultiplicity *mult = vertexer->GetMultiplicity();
32e449be 2229 if(mult)esd->SetMultiplicity(mult);
2230
ac4a7581 2231 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2232 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2233 }
2257f27e 2234 delete vertex;
2235
92bffc4d 2236 delete vertexer;
2237
2257f27e 2238 return kTRUE;
2239}
2240
1f46a9ae 2241//_____________________________________________________________________________
af885e0f 2242Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 2243{
2244// run the HLT barrel tracking
2245
87932dab 2246 AliCodeTimerAuto("")
1f46a9ae 2247
2248 if (!fRunLoader) {
2249 AliError("Missing runLoader!");
2250 return kFALSE;
2251 }
2252
2253 AliInfo("running HLT tracking");
2254
2255 // Get a pointer to the HLT reconstructor
ac4a7581 2256 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
1f46a9ae 2257 if (!reconstructor) return kFALSE;
2258
2259 // TPC + ITS
2260 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2261 TString detName = fgkDetectorName[iDet];
2262 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2263 reconstructor->SetOption(detName.Data());
d76c31f4 2264 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 2265 if (!tracker) {
2266 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2267 if (fStopOnError) return kFALSE;
9dcc06e1 2268 continue;
1f46a9ae 2269 }
2270 Double_t vtxPos[3];
2271 Double_t vtxErr[3]={0.005,0.005,0.010};
2272 const AliESDVertex *vertex = esd->GetVertex();
2273 vertex->GetXYZ(vtxPos);
2274 tracker->SetVertex(vtxPos,vtxErr);
2275 if(iDet != 1) {
2276 fLoader[iDet]->LoadRecPoints("read");
2277 TTree* tree = fLoader[iDet]->TreeR();
2278 if (!tree) {
2279 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2280 return kFALSE;
2281 }
2282 tracker->LoadClusters(tree);
2283 }
2284 if (tracker->Clusters2Tracks(esd) != 0) {
2285 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2286 return kFALSE;
2287 }
2288 if(iDet != 1) {
2289 tracker->UnloadClusters();
2290 }
2291 delete tracker;
2292 }
2293
1f46a9ae 2294 return kTRUE;
2295}
2296
e66fbafb 2297//_____________________________________________________________________________
af885e0f 2298Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 2299{
2300// run the muon spectrometer tracking
2301
87932dab 2302 AliCodeTimerAuto("")
e66fbafb 2303
2304 if (!fRunLoader) {
2305 AliError("Missing runLoader!");
2306 return kFALSE;
2307 }
2308 Int_t iDet = 7; // for MUON
2309
2310 AliInfo("is running...");
2311
2312 // Get a pointer to the MUON reconstructor
2313 AliReconstructor *reconstructor = GetReconstructor(iDet);
2314 if (!reconstructor) return kFALSE;
2315
2316
2317 TString detName = fgkDetectorName[iDet];
2318 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 2319 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 2320 if (!tracker) {
2321 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2322 return kFALSE;
2323 }
2324
e66fbafb 2325 // read RecPoints
761350a6 2326 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 2327
761350a6 2328 tracker->LoadClusters(fLoader[iDet]->TreeR());
2329
2330 Int_t rv = tracker->Clusters2Tracks(esd);
2331
761350a6 2332 if ( rv )
2333 {
e66fbafb 2334 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2335 return kFALSE;
2336 }
761350a6 2337
e66fbafb 2338 fLoader[iDet]->UnloadRecPoints();
2339
c1954ee5 2340 tracker->UnloadClusters();
2341
e66fbafb 2342 delete tracker;
2343
e66fbafb 2344 return kTRUE;
2345}
2346
2347
2257f27e 2348//_____________________________________________________________________________
af885e0f 2349Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 2350{
2351// run the barrel tracking
0f88822a 2352 static Int_t eventNr=0;
87932dab 2353 AliCodeTimerAuto("")
24f7a148 2354
815c2b38 2355 AliInfo("running tracking");
596a855f 2356
1f26f3e7 2357 // Set the event info which is used
2358 // by the trackers in order to obtain
2359 // information about read-out detectors,
2360 // trigger etc.
2361 AliDebug(1, "Setting event info");
2362 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2363 if (!fTracker[iDet]) continue;
2364 fTracker[iDet]->SetEventInfo(&fEventInfo);
2365 }
2366
91b876d1 2367 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 2368 if (fReconstructor[11] && fLoader[11]) {
2369 fLoader[11]->LoadRecPoints("READ");
2370 TTree *treeR = fLoader[11]->TreeR();
89916438 2371 if (treeR) {
2372 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2373 }
d76c31f4 2374 }
91b876d1 2375
b8cd5251 2376 // pass 1: TPC + ITS inwards
2377 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2378 if (!fTracker[iDet]) continue;
2379 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 2380
b8cd5251 2381 // load clusters
2382 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2383 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 2384 TTree* tree = fLoader[iDet]->TreeR();
2385 if (!tree) {
2386 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 2387 return kFALSE;
2388 }
b8cd5251 2389 fTracker[iDet]->LoadClusters(tree);
6efecea1 2390 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2391 // run tracking
2392 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2393 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 2394 return kFALSE;
2395 }
878e1fe1 2396 // preliminary PID in TPC needed by the ITS tracker
2397 if (iDet == 1) {
b26c3770 2398 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 2399 AliESDpid::MakePID(esd);
0f88822a 2400 }
6efecea1 2401 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 2402 }
596a855f 2403
b8cd5251 2404 // pass 2: ALL backwards
aa3c69a9 2405
ac4a7581 2406 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2407 if (!fTracker[iDet]) continue;
2408 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2409
2410 // load clusters
2411 if (iDet > 1) { // all except ITS, TPC
2412 TTree* tree = NULL;
7b61cd9c 2413 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2414 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 2415 tree = fLoader[iDet]->TreeR();
b8cd5251 2416 if (!tree) {
eca4fa66 2417 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2418 return kFALSE;
24f7a148 2419 }
0f88822a 2420 fTracker[iDet]->LoadClusters(tree);
6efecea1 2421 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2422 }
24f7a148 2423
b8cd5251 2424 // run tracking
283f39c6 2425 if (iDet>1) // start filling residuals for the "outer" detectors
eca4fa66 2426 if (fRunGlobalQA) {
2427 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2428 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2429 if (arr) {
0a349581 2430 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2431 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
c9526f68 2432 if ( elem && (! elem->At(0)) ) {
2433 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2434 if (qadm) qadm->InitRecPointsForTracker() ;
2435 }
2436 }
eca4fa66 2437 }
b8cd5251 2438 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2439 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 2440 // return kFALSE;
b8cd5251 2441 }
24f7a148 2442
b8cd5251 2443 // unload clusters
6e65648b 2444 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
b8cd5251 2445 fTracker[iDet]->UnloadClusters();
7b61cd9c 2446 fLoader[iDet]->UnloadRecPoints();
b8cd5251 2447 }
8f37df88 2448 // updated PID in TPC needed by the ITS tracker -MI
2449 if (iDet == 1) {
8f37df88 2450 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2451 AliESDpid::MakePID(esd);
2452 }
6efecea1 2453 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 2454 }
283f39c6 2455 //stop filling residuals for the "outer" detectors
57acd2d2 2456 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
596a855f 2457
b8cd5251 2458 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 2459
b8cd5251 2460 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2461 if (!fTracker[iDet]) continue;
2462 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 2463
b8cd5251 2464 // run tracking
283f39c6 2465 if (iDet<2) // start filling residuals for TPC and ITS
eca4fa66 2466 if (fRunGlobalQA) {
2467 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2468 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2469 if (arr) {
0a349581 2470 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2471 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
c9526f68 2472 if ( elem && (! elem->At(0)) ) {
2473 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2474 if (qadm) qadm->InitRecPointsForTracker() ;
2475 }
2476 }
eca4fa66 2477 }
2478
b8cd5251 2479 if (fTracker[iDet]->RefitInward(esd) != 0) {
2480 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 2481 // return kFALSE;
b8cd5251 2482 }
db2368d0 2483 // run postprocessing
2484 if (fTracker[iDet]->PostProcess(esd) != 0) {
2485 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2486 // return kFALSE;
2487 }
6efecea1 2488 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
6e65648b 2489 }
2490
2491 // write space-points to the ESD in case alignment data output
2492 // is switched on
2493 if (fWriteAlignmentData)
2494 WriteAlignmentData(esd);
2495
2496 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2497 if (!fTracker[iDet]) continue;
b8cd5251 2498 // unload clusters
2499 fTracker[iDet]->UnloadClusters();
6efecea1 2500 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 2501 fLoader[iDet]->UnloadRecPoints();
6efecea1 2502 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 2503 }
283f39c6 2504 // stop filling residuals for TPC and ITS
57acd2d2 2505 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
854c6476 2506
0f88822a 2507 eventNr++;
596a855f 2508 return kTRUE;
2509}
2510
d64bd07d 2511//_____________________________________________________________________________
2512Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2513 //
2514 // Remove the data which are not needed for the physics analysis.
2515 //
2516
d64bd07d 2517 Int_t nTracks=esd->GetNumberOfTracks();
18571674 2518 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 2519 AliInfo
2520 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 2521
18571674 2522 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 2523 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 2524
7f68891d 2525 nTracks=esd->GetNumberOfTracks();
18571674 2526 nV0s=esd->GetNumberOfV0s();
cf37fd88 2527 AliInfo
ae5d5566 2528 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 2529
7f68891d 2530 return rc;
d64bd07d 2531}
2532
596a855f 2533//_____________________________________________________________________________
af885e0f 2534Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 2535{
2536// fill the event summary data
2537
87932dab 2538 AliCodeTimerAuto("")
0f88822a 2539 static Int_t eventNr=0;
596a855f 2540 TString detStr = detectors;
abe0c04e 2541
ac4a7581 2542 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
abe0c04e 2543 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 2544 AliReconstructor* reconstructor = GetReconstructor(iDet);
2545 if (!reconstructor) continue;
4b71572b 2546 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2547 TTree* clustersTree = NULL;
2548 if (fLoader[iDet]) {
2549 fLoader[iDet]->LoadRecPoints("read");
2550 clustersTree = fLoader[iDet]->TreeR();
2551 if (!clustersTree) {
2552 AliError(Form("Can't get the %s clusters tree",
2553 fgkDetectorName[iDet]));
2554 if (fStopOnError) return kFALSE;
2555 }
2556 }
2557 if (fRawReader && !reconstructor->HasDigitConversion()) {
2558 reconstructor->FillESD(fRawReader, clustersTree, esd);
2559 } else {
2560 TTree* digitsTree = NULL;
d76c31f4 2561 if (fLoader[iDet]) {
4b71572b 2562 fLoader[iDet]->LoadDigits("read");
2563 digitsTree = fLoader[iDet]->TreeD();
2564 if (!digitsTree) {
2565 AliError(Form("Can't get the %s digits tree",
b26c3770 2566 fgkDetectorName[iDet]));
2567 if (fStopOnError) return kFALSE;
2568 }
2569 }
4b71572b 2570 reconstructor->FillESD(digitsTree, clustersTree, esd);
2571 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2572 }
2573 if (fLoader[iDet]) {
2574 fLoader[iDet]->UnloadRecPoints();
596a855f 2575 }
2576 }
2577
2578 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 2579 AliError(Form("the following detectors were not found: %s",
2580 detStr.Data()));
596a855f 2581 if (fStopOnError) return kFALSE;
2582 }
6efecea1 2583 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 2584 eventNr++;
596a855f 2585 return kTRUE;
2586}
2587
b647652d 2588//_____________________________________________________________________________
af885e0f 2589Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 2590{
2591 // Reads the trigger decision which is
2592 // stored in Trigger.root file and fills
2593 // the corresponding esd entries
2594
87932dab 2595 AliCodeTimerAuto("")
2596
b647652d 2597 AliInfo("Filling trigger information into the ESD");
2598
2599 if (fRawReader) {
2600 AliCTPRawStream input(fRawReader);
2601 if (!input.Next()) {
7e88424f 2602 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
b647652d 2603 }
2604 else {
7e88424f 2605 if (esd->GetTriggerMask() != input.GetClassMask())
2606 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2607 input.GetClassMask(),esd->GetTriggerMask()));
2608 if (esd->GetOrbitNumber() != input.GetOrbitID())
2609 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2610 input.GetOrbitID(),esd->GetOrbitNumber()));
2611 if (esd->GetBunchCrossNumber() != input.GetBCID())
2612 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2613 input.GetBCID(),esd->GetBunchCrossNumber()));
e61ed4b1 2614 AliESDHeader* esdheader = esd->GetHeader();
2615 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
2616 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
2617 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
a6dd87ad 2618 // IR
2619 UInt_t orbit=input.GetOrbitID();
2620 for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
2621 if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
2622 esdheader->AddTriggerIR(input.GetIR(i));
2623 }
b647652d 2624 }
b024fd7f 2625 }
522fdd91 2626 //Scalers
82ebedd6 2627 //fRunScalers->Print();
2628 if(fRunScalers && fRunScalers->CheckRunScalers()){
a6dd87ad 2629 AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
82ebedd6 2630 //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
522fdd91 2631 AliESDHeader* esdheader = fesd->GetHeader();
2632 for(Int_t i=0;i<50;i++){
82ebedd6 2633 if((1<<i) & esd->GetTriggerMask()){
6863d231 2634 AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
82ebedd6 2635 if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
522fdd91 2636 }
2637 }
2638 }
b647652d 2639 return kTRUE;
2640}
001397cd 2641//_____________________________________________________________________________
af885e0f 2642Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 2643{
2644 //
2645 // Filling information from RawReader Header
2646 //
2647
151bea4e 2648 if (!fRawReader) return kFALSE;
2649
001397cd 2650 AliInfo("Filling information from RawReader Header");
151bea4e 2651
2652 esd->SetBunchCrossNumber(fRawReader->GetBCID());
2653 esd->SetOrbitNumber(fRawReader->GetOrbitID());
2654 esd->SetPeriodNumber(fRawReader->GetPeriod());
2655
2656 esd->SetTimeStamp(fRawReader->GetTimestamp());
2657 esd->SetEventType(fRawReader->GetType());
001397cd 2658
2659 return kTRUE;
2660}
2661
2662
596a855f 2663//_____________________________________________________________________________
2664Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2665{
2666// check whether detName is contained in detectors
2667// if yes, it is removed from detectors
2668
2669 // check if all detectors are selected
2670 if ((detectors.CompareTo("ALL") == 0) ||
2671 detectors.BeginsWith("ALL ") ||
2672 detectors.EndsWith(" ALL") ||
2673 detectors.Contains(" ALL ")) {
2674 detectors = "ALL";
2675 return kTRUE;
2676 }
2677
2678 // search for the given detector
2679 Bool_t result = kFALSE;
2680 if ((detectors.CompareTo(detName) == 0) ||
2681 detectors.BeginsWith(detName+" ") ||
2682 detectors.EndsWith(" "+detName) ||
2683 detectors.Contains(" "+detName+" ")) {
2684 detectors.ReplaceAll(detName, "");
2685 result = kTRUE;
2686 }
2687
2688 // clean up the detectors string
2689 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2690 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2691 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2692
2693 return result;
2694}
e583c30d 2695
f08fc9f5 2696//_____________________________________________________________________________
2697Bool_t AliReconstruction::InitRunLoader()
2698{
2699// get or create the run loader
2700
2701 if (gAlice) delete gAlice;
2702 gAlice = NULL;
2703
b26c3770 2704 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2705 // load all base libraries to get the loader classes
2706 TString libs = gSystem->GetLibraries();
ac4a7581 2707 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b26c3770 2708 TString detName = fgkDetectorName[iDet];
2709 if (detName == "HLT") continue;
2710 if (libs.Contains("lib" + detName + "base.so")) continue;
2711 gSystem->Load("lib" + detName + "base.so");
2712 }
f08fc9f5 2713 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2714 if (!fRunLoader) {
2715 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2716 CleanUp();
2717 return kFALSE;
2718 }
325aa76f 2719
b26c3770 2720 fRunLoader->CdGAFile();
325aa76f 2721 fRunLoader->LoadgAlice();
f08fc9f5 2722
6cae184e 2723 //PH This is a temporary fix to give access to the kinematics
2724 //PH that is needed for the labels of ITS clusters
f2ee4290 2725 fRunLoader->LoadHeader();
6cae184e 2726 fRunLoader->LoadKinematics();
2727
f08fc9f5 2728 } else { // galice.root does not exist
2729 if (!fRawReader) {
2730 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
f08fc9f5 2731 }
2732 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2733 AliConfig::GetDefaultEventFolderName(),
2734 "recreate");
2735 if (!fRunLoader) {
2736 AliError(Form("could not create run loader in file %s",
2737 fGAliceFileName.Data()));
2738 CleanUp();
2739 return kFALSE;
2740 }
21a3aa09 2741 fIsNewRunLoader = kTRUE;
f08fc9f5 2742 fRunLoader->MakeTree("E");
21a3aa09 2743
973388c2 2744 if (fNumberOfEventsPerFile > 0)
2745 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2746 else
21a3aa09 2747 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
f08fc9f5 2748 }
2749
2750 return kTRUE;
2751}
2752
c757bafd 2753//_____________________________________________________________________________
b8cd5251 2754AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 2755{
f08fc9f5 2756// get the reconstructor object and the loader for a detector
c757bafd 2757
7e88424f 2758 if (fReconstructor[iDet]) {
2759 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2760 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2761 fReconstructor[iDet]->SetRecoParam(par);
42ec5d3d 2762 fReconstructor[iDet]->SetRunInfo(fRunInfo);
7e88424f 2763 }
2764 return fReconstructor[iDet];
2765 }
b8cd5251 2766
2767 // load the reconstructor object
2768 TPluginManager* pluginManager = gROOT->GetPluginManager();
2769 TString detName = fgkDetectorName[iDet];
2770 TString recName = "Ali" + detName + "Reconstructor";
f0999a9a 2771
2772 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
b8cd5251 2773
b8cd5251 2774 AliReconstructor* reconstructor = NULL;
2775 // first check if a plugin is defined for the reconstructor
2776 TPluginHandler* pluginHandler =
2777 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 2778 // if not, add a plugin for it
2779 if (!pluginHandler) {
b8cd5251 2780 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 2781 TString libs = gSystem->GetLibraries();
2782 if (libs.Contains("lib" + detName + "base.so") ||
2783 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 2784 pluginManager->AddHandler("AliReconstructor", detName,
2785 recName, detName + "rec", recName + "()");
2786 } else {
2787 pluginManager->AddHandler("AliReconstructor", detName,
2788 recName, detName, recName + "()");
c757bafd 2789 }
b8cd5251 2790 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2791 }
2792 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2793 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 2794 }
b8cd5251 2795 if (reconstructor) {
2796 TObject* obj = fOptions.FindObject(detName.Data());
2797 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 2798 reconstructor->Init();
b8cd5251 2799 fReconstructor[iDet] = reconstructor;
2800 }
2801
f08fc9f5 2802 // get or create the loader
2803 if (detName != "HLT") {
2804 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2805 if (!fLoader[iDet]) {
2806 AliConfig::Instance()
2807 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2808 detName, detName);
2809 // first check if a plugin is defined for the loader
bb0901a4 2810 pluginHandler =
f08fc9f5 2811 pluginManager->FindHandler("AliLoader", detName);
2812 // if not, add a plugin for it
2813 if (!pluginHandler) {
2814 TString loaderName = "Ali" + detName + "Loader";
2815 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2816 pluginManager->AddHandler("AliLoader", detName,
2817 loaderName, detName + "base",
2818 loaderName + "(const char*, TFolder*)");
2819 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2820 }
2821 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2822 fLoader[iDet] =
2823 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2824 fRunLoader->GetEventFolder());
2825 }
2826 if (!fLoader[iDet]) { // use default loader
2827 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2828 }
2829 if (!fLoader[iDet]) {
2830 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2831 if (fStopOnError) return NULL;
f08fc9f5 2832 } else {
2833 fRunLoader->AddLoader(fLoader[iDet]);
2834 fRunLoader->CdGAFile();
2835 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2836 fRunLoader->Write(0, TObject::kOverwrite);
2837 }
2838 }
2839 }
2840
7e88424f 2841 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2842 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2843 reconstructor->SetRecoParam(par);
42ec5d3d 2844 reconstructor->SetRunInfo(fRunInfo);
7e88424f 2845 }
b8cd5251 2846 return reconstructor;
c757bafd 2847}
2848
2257f27e 2849//_____________________________________________________________________________
92bffc4d 2850AliVertexer* AliReconstruction::CreateVertexer()
2257f27e 2851{
2852// create the vertexer
92bffc4d 2853// Please note that the caller is the owner of the
2854// vertexer
2257f27e 2855
92bffc4d 2856 AliVertexer* vertexer = NULL;
b8cd5251 2857 AliReconstructor* itsReconstructor = GetReconstructor(0);
5ec10f5d 2858 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || fRunTracking.Contains("ITS"))) {
92bffc4d 2859 vertexer = itsReconstructor->CreateVertexer();
2257f27e 2860 }
92bffc4d 2861 if (!vertexer) {
815c2b38 2862 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2863 }
2864
92bffc4d 2865 return vertexer;
2257f27e 2866}
2867
24f7a148 2868//_____________________________________________________________________________
b8cd5251 2869Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2870{
f08fc9f5 2871// create the trackers
44e45fac 2872 AliInfo("Creating trackers");
24f7a148 2873
b8cd5251 2874 TString detStr = detectors;
ac4a7581 2875 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2876 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2877 AliReconstructor* reconstructor = GetReconstructor(iDet);
2878 if (!reconstructor) continue;
2879 TString detName = fgkDetectorName[iDet];
1f46a9ae 2880 if (detName == "HLT") {
2881 fRunHLTTracking = kTRUE;
2882 continue;
2883 }
e66fbafb 2884 if (detName == "MUON") {
2885 fRunMuonTracking = kTRUE;
2886 continue;
2887 }
2888
f08fc9f5 2889
d76c31f4 2890 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2891 if (!fTracker[iDet] && (iDet < 7)) {
2892 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2893 if (fStopOnError) return kFALSE;
2894 }
6efecea1 2895 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2896 }
2897
24f7a148 2898 return kTRUE;
2899}
2900
e583c30d 2901//_____________________________________________________________________________
4b71572b 2902void AliReconstruction::CleanUp()
e583c30d 2903{
2904// delete trackers and the run loader and close and delete the file
2905
ac4a7581 2906 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2907 delete fReconstructor[iDet];
2908 fReconstructor[iDet] = NULL;
2909 fLoader[iDet] = NULL;
2910 delete fTracker[iDet];
2911 fTracker[iDet] = NULL;
2912 }
4b71572b 2913 delete fRunInfo;
7e88424f 2914 fRunInfo = NULL;
2915
58e8dc31 2916 delete fSPDTrackleter;
2917 fSPDTrackleter = NULL;
2918
4b71572b 2919 delete ftVertexer;
21a3aa09 2920 ftVertexer = NULL;
795e4a22 2921
e583c30d 2922 delete fRunLoader;
2923 fRunLoader = NULL;
b649205a 2924 delete fRawReader;
2925 fRawReader = NULL;
4b71572b 2926 delete fParentRawReader;
cd0b062e 2927 fParentRawReader=NULL;
e583c30d 2928
4b71572b 2929 if (ffile) {
2930 ffile->Close();
2931 delete ffile;
2932 ffile = NULL;
24f7a148 2933 }
87da0921 2934
bf76b847 2935 if (AliQAManager::QAManager())
2936 AliQAManager::QAManager()->ShowQA() ;
eca4fa66 2937 AliQAManager::Destroy() ;
2938
87da0921 2939 TGeoGlobalMagField::Instance()->SetField(NULL);
24f7a148 2940}
f3a97c86 2941
af885e0f 2942void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2943{
2944 // Write space-points which are then used in the alignment procedures
6e65648b 2945 // For the moment only ITS, TPC, TRD and TOF
98937d93 2946
98937d93 2947 Int_t ntracks = esd->GetNumberOfTracks();
2948 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2949 {
2950 AliESDtrack *track = esd->GetTrack(itrack);
2951 Int_t nsp = 0;
ef7253ac 2952 Int_t idx[200];
76741755 2953 for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
81aa7a0d 2954 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
6e65648b 2955 nsp += track->GetNcls(iDet);
2956
2957 if (iDet==0) { // ITS "extra" clusters
2958 track->GetClusters(iDet,idx);
2959 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
2960 }
2961 }
2962
98937d93 2963 if (nsp) {
2964 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2965 track->SetTrackPointArray(sp);
2966 Int_t isptrack = 0;
81aa7a0d 2967 for (Int_t iDet = 5; iDet >= 0; iDet--) {
98937d93 2968 AliTracker *tracker = fTracker[iDet];
2969 if (!tracker) continue;
6e65648b 2970 Int_t nspdet = track->GetClusters(iDet,idx);
2971
2972 if (iDet==0) // ITS "extra" clusters
2973 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
2974
98937d93 2975 if (nspdet <= 0) continue;
98937d93 2976 AliTrackPoint p;
2977 Int_t isp = 0;
2978 Int_t isp2 = 0;
4ed6fb1c 2979 while (isp2 < nspdet) {
f3c6e4c9 2980 Bool_t isvalid=kTRUE;
2981
2982 Int_t index=idx[isp++];
2983 if (index < 0) continue;
2984
c12b6e44 2985 TString dets = fgkDetectorName[iDet];
2986 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2987 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2988 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2989 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
f3c6e4c9 2990 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
48ce48d1 2991 } else {
f3c6e4c9 2992 isvalid = tracker->GetTrackPoint(index,p);
48ce48d1 2993 }
2994 isp2++;
98937d93 2995 if (!isvalid) continue;
eb2d90b9 2996 if (iDet==0 && (isp-1)>=6) p.SetExtra();
f3c6e4c9 2997 sp->AddPoint(isptrack,&p); isptrack++;
98937d93 2998 }
98937d93 2999 }
3000 }
3001 }
98937d93 3002}
2e3550da 3003
3004//_____________________________________________________________________________
af885e0f 3005void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 3006{
3007 // The method reads the raw-data error log
3008 // accumulated within the rawReader.
3009 // It extracts the raw-data errors related to
3010 // the current event and stores them into
3011 // a TClonesArray inside the esd object.
3012
3013 if (!fRawReader) return;
3014
3015 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3016
3017 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3018 if (!log) continue;
3019 if (iEvent != log->GetEventNumber()) continue;
3020
3021 esd->AddRawDataErrorLog(log);
3022 }
3023
3024}
46698ae4 3025
8661738e 3026//_____________________________________________________________________________
3027void AliReconstruction::CheckQA()
3028{
3029// check the QA of SIM for this run and remove the detectors
3030// with status Fatal
3031
57acd2d2 3032// TString newRunLocalReconstruction ;
3033// TString newRunTracking ;
3034// TString newFillESD ;
3035//
4e25ac79 3036// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3037// TString detName(AliQAv1::GetDetName(iDet)) ;
3038// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3039// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
57acd2d2 3040// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
3041// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3042// } else {
4e25ac79 3043// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 3044// fRunLocalReconstruction.Contains("ALL") ) {
3045// newRunLocalReconstruction += detName ;
3046// newRunLocalReconstruction += " " ;
3047// }
4e25ac79 3048// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 3049// fRunTracking.Contains("ALL") ) {
3050// newRunTracking += detName ;
3051// newRunTracking += " " ;
3052// }
4e25ac79 3053// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 3054// fFillESD.Contains("ALL") ) {
3055// newFillESD += detName ;
3056// newFillESD += " " ;
3057// }
3058// }
3059// }
3060// fRunLocalReconstruction = newRunLocalReconstruction ;
3061// fRunTracking = newRunTracking ;
3062// fFillESD = newFillESD ;
a5fa6165 3063}
5b188f2f 3064
3065//_____________________________________________________________________________
3066Int_t AliReconstruction::GetDetIndex(const char* detector)
3067{
3068 // return the detector index corresponding to detector
3069 Int_t index = -1 ;
ac4a7581 3070 for (index = 0; index < kNDetectors ; index++) {
5b188f2f 3071 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3072 break ;
3073 }
3074 return index ;
3075}
7167ae53 3076//_____________________________________________________________________________
3077Bool_t AliReconstruction::FinishPlaneEff() {
3078 //
3079 // Here execute all the necessary operationis, at the end of the tracking phase,
d7f8fd68 3080 // in case that evaluation of PlaneEfficiencies was required for some detector.
3081 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
7167ae53 3082 //
3083 // This Preliminary version works only FOR ITS !!!!!
3084 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3085 //
3086 // Input: none
d7f8fd68 3087 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
7167ae53 3088 //
3089 Bool_t ret=kFALSE;
58e8dc31 3090 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
d7f8fd68 3091 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
7167ae53 3092 //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
58e8dc31 3093 if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
d7f8fd68 3094 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3095 TString name=planeeff->GetName();
3096 name+=".root";
3097 TFile* pefile = TFile::Open(name, "RECREATE");
3098 ret=(Bool_t)planeeff->Write();
3099 pefile->Close();
5fbd4fd6 3100 if(planeeff->GetCreateHistos()) {
d7f8fd68 3101 TString hname=planeeff->GetName();
3102 hname+="Histo.root";
3103 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
5fbd4fd6 3104 }
3105 }
58e8dc31 3106 if(fSPDTrackleter) {
3107 AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3108 TString name="AliITSPlaneEffSPDtracklet.root";
3109 TFile* pefile = TFile::Open(name, "RECREATE");
3110 ret=(Bool_t)planeeff->Write();
3111 pefile->Close();
3112 AliESDEvent *dummy=NULL;
3113 ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3114 }
7167ae53 3115 }
3116 return ret;
3117}
3118//_____________________________________________________________________________
3119Bool_t AliReconstruction::InitPlaneEff() {
3120//
3121 // Here execute all the necessary operations, before of the tracking phase,
3122 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
58e8dc31 3123 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
7167ae53 3124 // which should be updated/recalculated.
3125 //
3126 // This Preliminary version will work only FOR ITS !!!!!
3127 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3128 //
3129 // Input: none
3130 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3131 //
58e8dc31 3132 AliWarning(Form("Implementation of this method not yet completed !! Method return kTRUE"));
3133
3134 fSPDTrackleter = NULL;
3135 AliReconstructor* itsReconstructor = GetReconstructor(0);
3136 if (itsReconstructor) {
3137 fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3138 }
3139 if (fSPDTrackleter) {
3140 AliInfo("Trackleter for SPD has been created");
3141 }
3142
7167ae53 3143 return kTRUE;
7520312d 3144}
14dd053c 3145
3146//_____________________________________________________________________________
3147Bool_t AliReconstruction::InitAliEVE()
3148{
3149 // This method should be called only in case
3150 // AliReconstruction is run
3151 // within the alieve environment.
3152 // It will initialize AliEVE in a way
3153 // so that it can visualize event processed
3154 // by AliReconstruction.
3155 // The return flag shows whenever the
3156 // AliEVE initialization was successful or not.
3157
3158 TString macroStr;
3159 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3160 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3161 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3162
6a840f1e 3163 gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
de33999e 3164 gROOT->ProcessLine("alieve_online_init()");
14dd053c 3165
3166 return kTRUE;
3167}
3168
3169//_____________________________________________________________________________
3170void AliReconstruction::RunAliEVE()
3171{
3172 // Runs AliEVE visualisation of
3173 // the current event.
3174 // Should be executed only after
3175 // successful initialization of AliEVE.
3176
3177 AliInfo("Running AliEVE...");
519975fe 3178 gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
14dd053c 3179 gSystem->Run();
3180}
ce43afbe 3181
3182//_____________________________________________________________________________
3183Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3184{
3185 // Allows to run QA for a selected set of detectors
44ed7a66 3186 // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
ce43afbe 3187 // all selected detectors run the same selected tasks
3188
3189 if (!detAndAction.Contains(":")) {
3190 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3191 fRunQA = kFALSE ;
3192 return kFALSE ;
3193 }
3194 Int_t colon = detAndAction.Index(":") ;
3195 fQADetectors = detAndAction(0, colon) ;
3196 if (fQADetectors.Contains("ALL") )
3197 fQADetectors = fFillESD ;
e84c88f5 3198 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
ce43afbe 3199 if (fQATasks.Contains("ALL") ) {
44ed7a66 3200 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
ce43afbe 3201 } else {
3202 fQATasks.ToUpper() ;
3203 TString tempo("") ;
3204 if ( fQATasks.Contains("RAW") )
4e25ac79 3205 tempo = Form("%d ", AliQAv1::kRAWS) ;
44ed7a66 3206 if ( fQATasks.Contains("DIGIT") )
3207 tempo += Form("%d ", AliQAv1::kDIGITSR) ;
ce43afbe 3208 if ( fQATasks.Contains("RECPOINT") )
4e25ac79 3209 tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
ce43afbe 3210 if ( fQATasks.Contains("ESD") )
4e25ac79 3211 tempo += Form("%d ", AliQAv1::kESDS) ;
ce43afbe 3212 fQATasks = tempo ;
3213 if (fQATasks.IsNull()) {
3214 AliInfo("No QA requested\n") ;
3215 fRunQA = kFALSE ;
3216 return kTRUE ;
3217 }
3218 }
3219 TString tempo(fQATasks) ;
4e25ac79 3220 tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
44ed7a66 3221 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
4e25ac79 3222 tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3223 tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
ce43afbe 3224 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3225 fRunQA = kTRUE ;
3226 return kTRUE;
3227}
3228
7e88424f 3229//_____________________________________________________________________________
3230Bool_t AliReconstruction::InitRecoParams()
3231{
3232 // The method accesses OCDB and retrieves all
3233 // the available reco-param objects from there.
3234
3235 Bool_t isOK = kTRUE;
3236
8b26452d 3237 if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
3238 AliInfo("Using custom GRP reconstruction parameters");
3239 }
3240 else {
3241 AliInfo("Loading GRP reconstruction parameter objects");
3242
3243 AliCDBPath path("GRP","Calib","RecoParam");
3244 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3245 if(!entry){
3246 AliWarning("Couldn't find GRP RecoParam entry in OCDB");
3247 isOK = kFALSE;
3248 }
3249 else {
3250 TObject *recoParamObj = entry->GetObject();
3251 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3252 // GRP has a normal TobjArray of AliDetectorRecoParam objects
3253 // Registering them in AliRecoParam
3254 fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
3255 }
3256 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3257 // GRP has only onse set of reco parameters
3258 // Registering it in AliRecoParam
3259 AliInfo("Single set of GRP reconstruction parameters found");
3260 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3261 fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3262 }
3263 else {
3264 AliError("No valid GRP RecoParam object found in the OCDB");
3265 isOK = kFALSE;
3266 }
3267 entry->SetOwner(0);
3268 }
3269 }
3270
7d566c20 3271 TString detStr = fLoadCDB;
ac4a7581 3272 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
7e88424f 3273
7d566c20 3274 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3275
7e88424f 3276 if (fRecoParam.GetDetRecoParamArray(iDet)) {
3277 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3278 continue;
3279 }
3280
ac232c75 3281 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
7e88424f 3282
3283 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3284 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3285 if(!entry){
3286 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3287 isOK = kFALSE;
3288 }
3289 else {
3290 TObject *recoParamObj = entry->GetObject();
3291 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3292 // The detector has a normal TobjArray of AliDetectorRecoParam objects
3293 // Registering them in AliRecoParam
3294 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3295 }
3296 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3297 // The detector has only onse set of reco parameters
3298 // Registering it in AliRecoParam
ac232c75 3299 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
7e88424f 3300 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3301 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3302 }
3303 else {
3304 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3305 isOK = kFALSE;
3306 }
3307 entry->SetOwner(0);
f168abba 3308 // FIX ME: We have to disable the unloading of reco-param CDB
3309 // entries because QA framework is using them. Has to be fix in
3310 // a way that the QA takes the objects already constructed in
3311 // this method.
3312 // AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
7e88424f 3313 }
3314 }
3315
e30a9b4d 3316 if (AliDebugLevel() > 0) fRecoParam.Print();
ac232c75 3317
7e88424f 3318 return isOK;
3319}
3320
3321//_____________________________________________________________________________
3322Bool_t AliReconstruction::GetEventInfo()
3323{
3324 // Fill the event info object
3325 // ...
3326 AliCodeTimerAuto("")
3327
3328 AliCentralTrigger *aCTP = NULL;
3329 if (fRawReader) {
3330 fEventInfo.SetEventType(fRawReader->GetType());
3331
3332 ULong64_t mask = fRawReader->GetClassMask();
3333 fEventInfo.SetTriggerMask(mask);
3334 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3335 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3336
3337 aCTP = new AliCentralTrigger();
3338 TString configstr("");
3339 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3340 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3341 delete aCTP;
3342 return kFALSE;
3343 }
3344 aCTP->SetClassMask(mask);
3345 aCTP->SetClusterMask(clmask);
3346 }
3347 else {
3348 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3349
3350 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3351 aCTP = fRunLoader->GetTrigger();
3352 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
e61ed4b1 3353 // get inputs from actp - just get
3354 AliESDHeader* esdheader = fesd->GetHeader();
3355 esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
3356 esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
3357 esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
7e88424f 3358 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
3359 }
3360 else {
3361 AliWarning("No trigger can be loaded! The trigger information will not be used!");
3362 return kFALSE;
3363 }
3364 }
3365
3366 AliTriggerConfiguration *config = aCTP->GetConfiguration();
3367 if (!config) {
3368 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3369 if (fRawReader) delete aCTP;
3370 return kFALSE;
3371 }
3372
a0c2cf2d 3373 UChar_t clustmask = 0;
7e88424f 3374 TString trclasses;
3375 ULong64_t trmask = fEventInfo.GetTriggerMask();
3376 const TObjArray& classesArray = config->GetClasses();
3377 Int_t nclasses = classesArray.GetEntriesFast();
3378 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3379 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3380 if (trclass) {
a4b0683d 3381 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
7e88424f 3382 fesd->SetTriggerClass(trclass->GetName(),trindex);
8a933107 3383 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
e61ed4b1 3384 if (trmask & (1ull << trindex)) {
7e88424f 3385 trclasses += " ";
3386 trclasses += trclass->GetName();
3387 trclasses += " ";
a0c2cf2d 3388 clustmask |= trclass->GetCluster()->GetClusterMask();
7e88424f 3389 }
3390 }
3391 }
3392 fEventInfo.SetTriggerClasses(trclasses);
3393
a0c2cf2d 3394 // Set the information in ESD
3395 fesd->SetTriggerMask(trmask);
3396 fesd->SetTriggerCluster(clustmask);
3397
7e88424f 3398 if (!aCTP->CheckTriggeredDetectors()) {
3399 if (fRawReader) delete aCTP;
3400 return kFALSE;
3401 }
3402
3403 if (fRawReader) delete aCTP;
3404
3405 // We have to fill also the HLT decision here!!
3406 // ...
3407
3408 return kTRUE;
3409}
3410
3411const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
3412{
3413 // Match the detector list found in the rec.C or the default 'ALL'
3414 // to the list found in the GRP (stored there by the shuttle PP which
3415 // gets the information from ECS)
3416 static TString resultList;
3417 TString detList = detectorList;
3418
3419 resultList = "";
3420
3421 for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
3422 if ((detectorMask >> iDet) & 0x1) {
3423 TString det = AliDAQ::OfflineModuleName(iDet);
3424 if ((detList.CompareTo("ALL") == 0) ||
a101e1dd 3425 ((detList.BeginsWith("ALL ") ||
3426 detList.EndsWith(" ALL") ||
3427 detList.Contains(" ALL ")) &&
3428 !(detList.BeginsWith("-"+det+" ") ||
3429 detList.EndsWith(" -"+det) ||
3430 detList.Contains(" -"+det+" "))) ||
7e88424f 3431 (detList.CompareTo(det) == 0) ||
a101e1dd 3432 detList.BeginsWith(det+" ") ||
3433 detList.EndsWith(" "+det) ||
7e88424f 3434 detList.Contains( " "+det+" " )) {
3435 if (!resultList.EndsWith(det + " ")) {
3436 resultList += det;
3437 resultList += " ";
3438 }
3439 }
3440 }
3441 }
3442
3443 // HLT
3444 if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
3445 TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
3446 if ((detList.CompareTo("ALL") == 0) ||
a101e1dd 3447 ((detList.BeginsWith("ALL ") ||
3448 detList.EndsWith(" ALL") ||
3449 detList.Contains(" ALL ")) &&
3450 !(detList.BeginsWith("-"+hltDet+" ") ||
3451 detList.EndsWith(" -"+hltDet) ||
3452 detList.Contains(" -"+hltDet+" "))) ||
7e88424f 3453 (detList.CompareTo(hltDet) == 0) ||
a101e1dd 3454 detList.BeginsWith(hltDet+" ") ||
3455 detList.EndsWith(" "+hltDet) ||
7e88424f 3456 detList.Contains( " "+hltDet+" " )) {
3457 resultList += hltDet;
3458 }
3459 }
3460
3461 return resultList.Data();
3462
3463}
4b71572b 3464
3465//______________________________________________________________________________
3466void AliReconstruction::Abort(const char *method, EAbort what)
3467{
3468 // Abort processing. If what = kAbortProcess, the Process() loop will be
3469 // aborted. If what = kAbortFile, the current file in a chain will be
3470 // aborted and the processing will continue with the next file, if there
3471 // is no next file then Process() will be aborted. Abort() can also be
3472 // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
3473 // the SlaveTerminate() and Terminate() are always called. The abort flag
3474 // can be checked in these methods using GetAbort().
3475 //
3476 // The method is overwritten in AliReconstruction for better handling of
3477 // reco specific errors
3478
3479 if (!fStopOnError) return;
3480
3481 CleanUp();
3482
3483 TString whyMess = method;
3484 whyMess += " failed! Aborting...";
3485
3486 AliError(whyMess.Data());
3487
3488 fAbort = what;
3489 TString mess = "Abort";
3490 if (fAbort == kAbortProcess)
3491 mess = "AbortProcess";
3492 else if (fAbort == kAbortFile)
3493 mess = "AbortFile";
3494
3495 Info(mess, whyMess.Data());
3496}
3497