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