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