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