Copy constructor,=operator, reset added (Plamen)
[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
596a855f 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
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
024cf675 521//_____________________________________________________________________________
f1c1204d 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
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
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
652//_____________________________________________________________________________
f1c1204d 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}
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
761//_____________________________________________________________________________
795e4a22 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
769//_____________________________________________________________________________
6bae477a 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
efd2085e 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
848//_____________________________________________________________________________
975320a0 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
857//_____________________________________________________________________________
efd2085e 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
596a855f 867//_____________________________________________________________________________
7e88424f 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
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
1170//_____________________________________________________________________________
4b71572b 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
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) ;
57acd2d2 1584 }
a00021a7 1585 }
1586 }
1587 }
1588
ca13fb87 1589 // QA on single raw
57acd2d2 1590 if (fRunQA) {
eca4fa66 1591 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1592 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
57acd2d2 1593 }
d506c543 1594 // local single event reconstruction
b26c3770 1595 if (!fRunLocalReconstruction.IsNull()) {
d506c543 1596 TString detectors=fRunLocalReconstruction;
a441bf51 1597 // run HLT event reconstruction first
d506c543 1598 // ;-( IsSelected changes the string
1599 if (IsSelected("HLT", detectors) &&
1600 !RunLocalEventReconstruction("HLT")) {
4b71572b 1601 if (fStopOnError) {CleanUp(); return kFALSE;}
a441bf51 1602 }
1603 detectors=fRunLocalReconstruction;
1604 detectors.ReplaceAll("HLT", "");
1605 if (!RunLocalEventReconstruction(detectors)) {
4b71572b 1606 if (fStopOnError) {CleanUp(); return kFALSE;}
b26c3770 1607 }
1608 }
1609
21a3aa09 1610 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1611 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1612 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1613 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 1614
d6ee376f 1615 // Set magnetic field from the tracker
21a3aa09 1616 fesd->SetMagneticField(AliTracker::GetBz());
1617 fhltesd->SetMagneticField(AliTracker::GetBz());
596a855f 1618
71f6cda4 1619 // Set most probable pt, for B=0 tracking
9257a1bd 1620 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
ac4a7581 1621 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
71f6cda4 1622 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
46698ae4 1623
2e3550da 1624 // Fill raw-data error log into the ESD
21a3aa09 1625 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2e3550da 1626
2257f27e 1627 // vertex finder
1628 if (fRunVertexFinder) {
4b71572b 1629 if (!RunVertexFinder(fesd)) {
1630 if (fStopOnError) {CleanUp(); return kFALSE;}
2257f27e 1631 }
1632 }
1633
58e8dc31 1634 // For Plane Efficiency: run the SPD trackleter
1635 if (fRunPlaneEff && fSPDTrackleter) {
1636 if (!RunSPDTrackleting(fesd)) {
1637 if (fStopOnError) {CleanUp(); return kFALSE;}
1638 }
1639 }
1640
e66fbafb 1641 // Muon tracking
b8cd5251 1642 if (!fRunTracking.IsNull()) {
e66fbafb 1643 if (fRunMuonTracking) {
21a3aa09 1644 if (!RunMuonTracking(fesd)) {
4b71572b 1645 if (fStopOnError) {CleanUp(); return kFALSE;}
24f7a148 1646 }
596a855f 1647 }
1648 }
1649
e66fbafb 1650 // barrel tracking
1651 if (!fRunTracking.IsNull()) {
4b71572b 1652 if (!RunTracking(fesd)) {
1653 if (fStopOnError) {CleanUp(); return kFALSE;}
e66fbafb 1654 }
1655 }
21c573b7 1656
596a855f 1657 // fill ESD
1658 if (!fFillESD.IsNull()) {
d506c543 1659 TString detectors=fFillESD;
f6806ad3 1660 // run HLT first and on hltesd
d506c543 1661 // ;-( IsSelected changes the string
1662 if (IsSelected("HLT", detectors) &&
1663 !FillESD(fhltesd, "HLT")) {
4b71572b 1664 if (fStopOnError) {CleanUp(); return kFALSE;}
f6806ad3 1665 }
1666 detectors=fFillESD;
d5105682 1667 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1668 if (detectors.Contains("ALL")) {
1669 detectors="";
ac4a7581 1670 for (Int_t idet=0; idet<kNDetectors; ++idet){
d5105682 1671 detectors += fgkDetectorName[idet];
1672 detectors += " ";
1673 }
1674 }
f6806ad3 1675 detectors.ReplaceAll("HLT", "");
1676 if (!FillESD(fesd, detectors)) {
4b71572b 1677 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 1678 }
1679 }
a5fa6165 1680
001397cd 1681 // fill Event header information from the RawEventHeader
21a3aa09 1682 if (fRawReader){FillRawEventHeaderESD(fesd);}
596a855f 1683
1684 // combined PID
21a3aa09 1685 AliESDpid::MakePID(fesd);
596a855f 1686
b647652d 1687 if (fFillTriggerESD) {
4b71572b 1688 if (!FillTriggerESD(fesd)) {
1689 if (fStopOnError) {CleanUp(); return kFALSE;}
b647652d 1690 }
1691 }
1692
21a3aa09 1693 ffile->cd();
a6ee503a 1694
3c3709c4 1695 //
67be5c77 1696 // Propagate track to the beam pipe (if not already done by ITS)
3c3709c4 1697 //
21a3aa09 1698 const Int_t ntracks = fesd->GetNumberOfTracks();
1699 const Double_t kBz = fesd->GetMagneticField();
3c3709c4 1700 const Double_t kRadius = 2.8; //something less than the beam pipe radius
1701
1702 TObjArray trkArray;
1703 UShort_t *selectedIdx=new UShort_t[ntracks];
1704
1705 for (Int_t itrack=0; itrack<ntracks; itrack++){
98a50ff3 1706 const Double_t kMaxStep = 1; //max step over the material
3c3709c4 1707 Bool_t ok;
1708
21a3aa09 1709 AliESDtrack *track = fesd->GetTrack(itrack);
3c3709c4 1710 if (!track) continue;
1711
1712 AliExternalTrackParam *tpcTrack =
1713 (AliExternalTrackParam *)track->GetTPCInnerParam();
bcabd6af 1714 ok = kFALSE;
1715 if (tpcTrack)
1716 ok = AliTracker::
e92d2a64 1717 PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
43c9dae1 1718
3c3709c4 1719 if (ok) {
1720 Int_t n=trkArray.GetEntriesFast();
1721 selectedIdx[n]=track->GetID();
1722 trkArray.AddLast(tpcTrack);
1723 }
1724
3d65e645 1725 //Tracks refitted by ITS should already be at the SPD vertex
1726 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1727
1728 AliTracker::
e92d2a64 1729 PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
3d65e645 1730 track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
3c3709c4 1731
3c3709c4 1732 }
1733
1734 //
1735 // Improve the reconstructed primary vertex position using the tracks
1736 //
59224b2b 1737 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1738 if(fesd->GetPrimaryVertexSPD()) {
1739 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1740 if(vtitle.Contains("cosmics")) {
1741 runVertexFinderTracks=kFALSE;
1742 }
c060d7fe 1743 }
a00021a7 1744
1745 if (runVertexFinderTracks) {
3c3709c4 1746 // TPC + ITS primary vertex
f09c879d 1747 ftVertexer->SetITSMode();
f2a195c1 1748 ftVertexer->SetConstraintOff();
a00021a7 1749 // get cuts for vertexer from AliGRPRecoParam
1750 if (grpRecoParam) {
1751 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1752 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1753 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1754 ftVertexer->SetCuts(cutsVertexer);
1755 delete [] cutsVertexer; cutsVertexer = NULL;
f2a195c1 1756 if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
1757 ftVertexer->SetVtxStart(fDiamondProfile);
43c9dae1 1758 }
21a3aa09 1759 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
3c3709c4 1760 if (pvtx) {
1761 if (pvtx->GetStatus()) {
c264b61b 1762 fesd->SetPrimaryVertexTracks(pvtx);
3c3709c4 1763 for (Int_t i=0; i<ntracks; i++) {
21a3aa09 1764 AliESDtrack *t = fesd->GetTrack(i);
3d65e645 1765 t->RelateToVertex(pvtx, kBz, kVeryBig);
3c3709c4 1766 }
1767 }
1768 }
1769
1770 // TPC-only primary vertex
f09c879d 1771 ftVertexer->SetTPCMode();
f2a195c1 1772 ftVertexer->SetConstraintOff();
a00021a7 1773 // get cuts for vertexer from AliGRPRecoParam
1774 if (grpRecoParam) {
1775 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1776 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1777 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1778 ftVertexer->SetCuts(cutsVertexer);
1779 delete [] cutsVertexer; cutsVertexer = NULL;
f2a195c1 1780 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
1781 ftVertexer->SetVtxStart(fDiamondProfileTPC);
43c9dae1 1782 }
21a3aa09 1783 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
3c3709c4 1784 if (pvtx) {
1785 if (pvtx->GetStatus()) {
21a3aa09 1786 fesd->SetPrimaryVertexTPC(pvtx);
3d65e645 1787 for (Int_t i=0; i<ntracks; i++) {
1788 AliESDtrack *t = fesd->GetTrack(i);
1789 t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
3c3709c4 1790 }
1791 }
1792 }
1793
1794 }
1795 delete[] selectedIdx;
1796
21a3aa09 1797 if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
17c86e90 1798
c5e3e5d1 1799
d1683eef 1800 if (fRunV0Finder) {
1801 // V0 finding
1802 AliV0vertexer vtxer;
21a3aa09 1803 vtxer.Tracks2V0vertices(fesd);
5e4ff34d 1804
d1683eef 1805 if (fRunCascadeFinder) {
1806 // Cascade finding
1807 AliCascadeVertexer cvtxer;
21a3aa09 1808 cvtxer.V0sTracks2CascadeVertices(fesd);
d1683eef 1809 }
5e4ff34d 1810 }
1811
596a855f 1812 // write ESD
21a3aa09 1813 if (fCleanESD) CleanESD(fesd);
854c6476 1814
57acd2d2 1815 if (fRunQA) {
eca4fa66 1816 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1817 AliQAManager::QAManager()->RunOneEvent(fesd) ;
57acd2d2 1818 }
bea94759 1819 if (fRunGlobalQA) {
eca4fa66 1820 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
57acd2d2 1821 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
4e25ac79 1822 if (qadm && fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
1823 qadm->Exec(AliQAv1::kESDS, fesd);
b03591ab 1824 }
854c6476 1825
1d99986f 1826 if (fWriteESDfriend) {
b090e6a3 1827 // fesdf->~AliESDfriend();
1828 // new (fesdf) AliESDfriend(); // Reset...
21a3aa09 1829 fesd->GetESDfriend(fesdf);
1d99986f 1830 }
21a3aa09 1831 ftree->Fill();
500d54ab 1832
2d91a353 1833 // Auto-save the ESD tree in case of prompt reco @P2
be103ac8 1834 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2d91a353 1835 ftree->AutoSave("SaveSelf");
be103ac8 1836 TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1837 if (friendfile) friendfile->Save();
1838 }
2d91a353 1839
500d54ab 1840 // write HLT ESD
21a3aa09 1841 fhlttree->Fill();
1d99986f 1842
14dd053c 1843 // call AliEVE
1844 if (fRunAliEVE) RunAliEVE();
1845
21a3aa09 1846 fesd->Reset();
1847 fhltesd->Reset();
5728d3d5 1848 if (fWriteESDfriend) {
21a3aa09 1849 fesdf->~AliESDfriend();
1850 new (fesdf) AliESDfriend(); // Reset...
5728d3d5 1851 }
a5fa6165 1852
ac4a7581 1853 ProcInfo_t procInfo;
1854 gSystem->GetProcInfo(&procInfo);
1855 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
a5fa6165 1856
ca13fb87 1857 fEventInfo.Reset();
ac4a7581 1858 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
ca13fb87 1859 if (fReconstructor[iDet])
a00021a7 1860 fReconstructor[iDet]->SetRecoParam(NULL);
ca13fb87 1861 }
1862
53c8f690 1863 if (fRunQA || fRunGlobalQA)
eca4fa66 1864 AliQAManager::QAManager()->Increment() ;
53c8f690 1865
ca13fb87 1866 return kTRUE;
21a3aa09 1867}
1868
1869//_____________________________________________________________________________
4b71572b 1870void AliReconstruction::SlaveTerminate()
21a3aa09 1871{
4b71572b 1872 // Finalize the run on the slave side
21a3aa09 1873 // Called after the exit
1874 // from the event loop
1875 AliCodeTimerAuto("");
1876
1877 if (fIsNewRunLoader) { // galice.root didn't exist
1878 fRunLoader->WriteHeader("OVERWRITE");
1879 fRunLoader->CdGAFile();
1880 fRunLoader->Write(0, TObject::kOverwrite);
1881 }
1882
f747912b 1883 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1884 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1885
1886 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1887 cdbMapCopy->SetOwner(1);
1888 cdbMapCopy->SetName("cdbMap");
1889 TIter iter(cdbMap->GetTable());
1890
1891 TPair* pair = 0;
1892 while((pair = dynamic_cast<TPair*> (iter.Next()))){
1893 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1894 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1895 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1896 }
1897
1898 TList *cdbListCopy = new TList();
1899 cdbListCopy->SetOwner(1);
1900 cdbListCopy->SetName("cdbList");
1901
1902 TIter iter2(cdbList);
1903
b940cb9b 1904 AliCDBId* id=0;
e84c88f5 1905 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
a4970db9 1906 cdbListCopy->Add(new TObjString(id->ToString().Data()));
f747912b 1907 }
1908
21a3aa09 1909 ftree->GetUserInfo()->Add(cdbMapCopy);
1910 ftree->GetUserInfo()->Add(cdbListCopy);
abe0c04e 1911
46698ae4 1912
21a3aa09 1913 ffile->cd();
aa3c69a9 1914
a9c0e6db 1915 if (fWriteESDfriend)
21a3aa09 1916 ftree->SetBranchStatus("ESDfriend*",0);
562dd0b4 1917 // we want to have only one tree version number
21a3aa09 1918 ftree->Write(ftree->GetName(),TObject::kOverwrite);
1919 fhlttree->Write();
f3a97c86 1920
a7a1e1c7 1921// Finish with Plane Efficiency evaluation: before of CleanUp !!!
1922 if (fRunPlaneEff && !FinishPlaneEff()) {
1923 AliWarning("Finish PlaneEff evaluation failed");
1924 }
1925
930e6e3e 1926 // End of cycle for the in-loop
57acd2d2 1927 if (fRunQA)
eca4fa66 1928 AliQAManager::QAManager()->EndOfCycle() ;
57acd2d2 1929
930e6e3e 1930 if (fRunGlobalQA) {
eca4fa66 1931 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
4b71572b 1932 if (qadm) {
4e25ac79 1933 if (fQATasks.Contains(Form("%d", AliQAv1::kRECPOINTS)))
1934 qadm->EndOfCycle(AliQAv1::kRECPOINTS);
1935 if (fQATasks.Contains(Form("%d", AliQAv1::kESDS)))
1936 qadm->EndOfCycle(AliQAv1::kESDS);
4b71572b 1937 qadm->Finish();
1938 }
a7807689 1939 }
87da0921 1940
1941 if (fRunQA || fRunGlobalQA) {
1942 if (fInput) {
1943 if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1944 TString qaOutputFile = outputFileName->GetTitle();
1945 qaOutputFile.ReplaceAll(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()),
1946 Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
1947 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",AliQAv1::GetQADataFileName()));
1948 qaProofFile->SetOutputFileName(qaOutputFile.Data());
1949 fOutput->Add(qaProofFile);
1950 MergeQA(qaProofFile->GetFileName());
1951 }
1952 }
1953 else {
1954 MergeQA();
1955 }
1956 }
1957
4b71572b 1958 gROOT->cd();
1959 CleanUp();
1960}
1961
1962//_____________________________________________________________________________
1963void AliReconstruction::Terminate()
1964{
f3a97c86 1965 // Create tags for the events in the ESD tree (the ESD tree is always present)
1966 // In case of empty events the tags will contain dummy values
4b71572b 1967 AliCodeTimerAuto("");
1968
e6d66370 1969 // Do not call the ESD tag creator in case of PROOF-based reconstruction
1970 if (!fInput) {
1971 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
1972 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
1973 }
e84c88f5 1974
795e4a22 1975 // Cleanup of CDB manager: cache and active storages!
1976 AliCDBManager::Instance()->ClearCache();
596a855f 1977}
1978
1979//_____________________________________________________________________________
b26c3770 1980Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1981{
1982// run the local reconstruction
aa3c69a9 1983
0f88822a 1984 static Int_t eventNr=0;
87932dab 1985 AliCodeTimerAuto("")
b26c3770 1986
1987 TString detStr = detectors;
ac4a7581 1988 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b26c3770 1989 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1990 AliReconstructor* reconstructor = GetReconstructor(iDet);
1991 if (!reconstructor) continue;
1992 AliLoader* loader = fLoader[iDet];
f6806ad3 1993 // Matthias April 2008: temporary fix to run HLT reconstruction
1994 // although the HLT loader is missing
1995 if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1996 if (fRawReader) {
44ed7a66 1997 reconstructor->Reconstruct(fRawReader, NULL);
f6806ad3 1998 } else {
44ed7a66 1999 TTree* dummy=NULL;
2000 reconstructor->Reconstruct(dummy, NULL);
f6806ad3 2001 }
2002 continue;
2003 }
d76c31f4 2004 if (!loader) {
2005 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2006 continue;
2007 }
b26c3770 2008 // conversion of digits
2009 if (fRawReader && reconstructor->HasDigitConversion()) {
2010 AliInfo(Form("converting raw data digits into root objects for %s",
2011 fgkDetectorName[iDet]));
30bbd491 2012// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2013// fgkDetectorName[iDet]));
b26c3770 2014 loader->LoadDigits("update");
2015 loader->CleanDigits();
2016 loader->MakeDigitsContainer();
2017 TTree* digitsTree = loader->TreeD();
2018 reconstructor->ConvertDigits(fRawReader, digitsTree);
2019 loader->WriteDigits("OVERWRITE");
2020 loader->UnloadDigits();
b26c3770 2021 }
b26c3770 2022 // local reconstruction
b26c3770 2023 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
30bbd491 2024 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 2025 loader->LoadRecPoints("update");
2026 loader->CleanRecPoints();
2027 loader->MakeRecPointsContainer();
2028 TTree* clustersTree = loader->TreeR();
2029 if (fRawReader && !reconstructor->HasDigitConversion()) {
2030 reconstructor->Reconstruct(fRawReader, clustersTree);
2031 } else {
2032 loader->LoadDigits("read");
2033 TTree* digitsTree = loader->TreeD();
2034 if (!digitsTree) {
44ed7a66 2035 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2036 if (fStopOnError) return kFALSE;
b26c3770 2037 } else {
44ed7a66 2038 reconstructor->Reconstruct(digitsTree, clustersTree);
2039 if (fRunQA) {
eca4fa66 2040 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2041 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
44ed7a66 2042 }
b26c3770 2043 }
2044 loader->UnloadDigits();
2045 }
57acd2d2 2046 if (fRunQA) {
eca4fa66 2047 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2048 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
57acd2d2 2049 }
eca4fa66 2050 loader->WriteRecPoints("OVERWRITE");
2051 loader->UnloadRecPoints();
2052 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
a00021a7 2053 }
2054 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
b26c3770 2055 AliError(Form("the following detectors were not found: %s",
2056 detStr.Data()));
2057 if (fStopOnError) return kFALSE;
2058 }
0f88822a 2059 eventNr++;
b26c3770 2060 return kTRUE;
2061}
58e8dc31 2062//_____________________________________________________________________________
2063Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2064{
2065// run the SPD trackleting (for SPD efficiency purpouses)
2066
2067 AliCodeTimerAuto("")
2068
2069 Double_t vtxPos[3] = {0, 0, 0};
2070 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2071/*
2072 TArrayF mcVertex(3);
2073 // if(MC)
2074 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2075 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2076 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2077 }
2078*/
2079 const AliESDVertex *vertex = esd->GetVertex();
2080 if(!vertex){
2081 AliWarning("Vertex not found");
2082 return kFALSE;
2083 }
2084 vertex->GetXYZ(vtxPos);
2085 vertex->GetSigmaXYZ(vtxErr);
2086 if (fSPDTrackleter) {
2087 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2088
2089 // load clusters
2090 fLoader[0]->LoadRecPoints("read");
2091 TTree* tree = fLoader[0]->TreeR();
2092 if (!tree) {
2093 AliError("Can't get the ITS cluster tree");
2094 return kFALSE;
2095 }
2096 fSPDTrackleter->LoadClusters(tree);
2097 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2098 // run trackleting
2099 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2100 AliError("AliITSTrackleterSPDEff Clusters2Tracks failed");
2101 // fLoader[0]->UnloadRecPoints();
2102 return kFALSE;
2103 }
2104//fSPDTrackleter->UnloadRecPoints();
2105 } else {
2106 AliWarning("SPDTrackleter not available");
2107 return kFALSE;
2108 }
2109 return kTRUE;
2110}
b26c3770 2111
2112//_____________________________________________________________________________
af885e0f 2113Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 2114{
2115// run the barrel tracking
2116
87932dab 2117 AliCodeTimerAuto("")
030b532d 2118
92bffc4d 2119 AliVertexer *vertexer = CreateVertexer();
2120 if (!vertexer) return kFALSE;
2121
2122 AliInfo("running the ITS vertex finder");
2257f27e 2123 AliESDVertex* vertex = NULL;
92bffc4d 2124 if (fLoader[0]) {
2125 fLoader[0]->LoadRecPoints();
2126 TTree* cltree = fLoader[0]->TreeR();
2127 if (cltree) {
2128 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2129 vertex = vertexer->FindVertexForCurrentEvent(cltree);
308c2f7c 2130 }
2131 else {
92bffc4d 2132 AliError("Can't get the ITS cluster tree");
308c2f7c 2133 }
92bffc4d 2134 fLoader[0]->UnloadRecPoints();
2257f27e 2135 }
92bffc4d 2136 else {
2137 AliError("Can't get the ITS loader");
2138 }
2139 if(!vertex){
2140 AliWarning("Vertex not found");
2141 vertex = new AliESDVertex();
2142 vertex->SetName("default");
2143 }
2144 else {
2145 vertex->SetName("reconstructed");
2257f27e 2146 }
92bffc4d 2147
2148 Double_t vtxPos[3];
2149 Double_t vtxErr[3];
2150 vertex->GetXYZ(vtxPos);
2151 vertex->GetSigmaXYZ(vtxErr);
2152
06cc9d95 2153 esd->SetPrimaryVertexSPD(vertex);
73c51de2 2154 AliESDVertex *vpileup = NULL;
2155 Int_t novertices = 0;
2156 vpileup = vertexer->GetAllVertices(novertices);
2157 if(novertices>1){
2158 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2159 }
32e449be 2160 // if SPD multiplicity has been determined, it is stored in the ESD
92bffc4d 2161 AliMultiplicity *mult = vertexer->GetMultiplicity();
32e449be 2162 if(mult)esd->SetMultiplicity(mult);
2163
ac4a7581 2164 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2165 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2166 }
2257f27e 2167 delete vertex;
2168
92bffc4d 2169 delete vertexer;
2170
2257f27e 2171 return kTRUE;
2172}
2173
2174//_____________________________________________________________________________
af885e0f 2175Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 2176{
2177// run the HLT barrel tracking
2178
87932dab 2179 AliCodeTimerAuto("")
1f46a9ae 2180
2181 if (!fRunLoader) {
2182 AliError("Missing runLoader!");
2183 return kFALSE;
2184 }
2185
2186 AliInfo("running HLT tracking");
2187
2188 // Get a pointer to the HLT reconstructor
ac4a7581 2189 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
1f46a9ae 2190 if (!reconstructor) return kFALSE;
2191
2192 // TPC + ITS
2193 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2194 TString detName = fgkDetectorName[iDet];
2195 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2196 reconstructor->SetOption(detName.Data());
d76c31f4 2197 AliTracker *tracker = reconstructor->CreateTracker();
1f46a9ae 2198 if (!tracker) {
2199 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2200 if (fStopOnError) return kFALSE;
9dcc06e1 2201 continue;
1f46a9ae 2202 }
2203 Double_t vtxPos[3];
2204 Double_t vtxErr[3]={0.005,0.005,0.010};
2205 const AliESDVertex *vertex = esd->GetVertex();
2206 vertex->GetXYZ(vtxPos);
2207 tracker->SetVertex(vtxPos,vtxErr);
2208 if(iDet != 1) {
2209 fLoader[iDet]->LoadRecPoints("read");
2210 TTree* tree = fLoader[iDet]->TreeR();
2211 if (!tree) {
2212 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2213 return kFALSE;
2214 }
2215 tracker->LoadClusters(tree);
2216 }
2217 if (tracker->Clusters2Tracks(esd) != 0) {
2218 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2219 return kFALSE;
2220 }
2221 if(iDet != 1) {
2222 tracker->UnloadClusters();
2223 }
2224 delete tracker;
2225 }
2226
1f46a9ae 2227 return kTRUE;
2228}
2229
2230//_____________________________________________________________________________
af885e0f 2231Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 2232{
2233// run the muon spectrometer tracking
2234
87932dab 2235 AliCodeTimerAuto("")
e66fbafb 2236
2237 if (!fRunLoader) {
2238 AliError("Missing runLoader!");
2239 return kFALSE;
2240 }
2241 Int_t iDet = 7; // for MUON
2242
2243 AliInfo("is running...");
2244
2245 // Get a pointer to the MUON reconstructor
2246 AliReconstructor *reconstructor = GetReconstructor(iDet);
2247 if (!reconstructor) return kFALSE;
2248
2249
2250 TString detName = fgkDetectorName[iDet];
2251 AliDebug(1, Form("%s tracking", detName.Data()));
d76c31f4 2252 AliTracker *tracker = reconstructor->CreateTracker();
e66fbafb 2253 if (!tracker) {
2254 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2255 return kFALSE;
2256 }
2257
e66fbafb 2258 // read RecPoints
761350a6 2259 fLoader[iDet]->LoadRecPoints("read");
c1954ee5 2260
761350a6 2261 tracker->LoadClusters(fLoader[iDet]->TreeR());
2262
2263 Int_t rv = tracker->Clusters2Tracks(esd);
2264
761350a6 2265 if ( rv )
2266 {
e66fbafb 2267 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2268 return kFALSE;
2269 }
761350a6 2270
e66fbafb 2271 fLoader[iDet]->UnloadRecPoints();
2272
c1954ee5 2273 tracker->UnloadClusters();
2274
e66fbafb 2275 delete tracker;
2276
e66fbafb 2277 return kTRUE;
2278}
2279
2280
2281//_____________________________________________________________________________
af885e0f 2282Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 2283{
2284// run the barrel tracking
0f88822a 2285 static Int_t eventNr=0;
87932dab 2286 AliCodeTimerAuto("")
24f7a148 2287
815c2b38 2288 AliInfo("running tracking");
596a855f 2289
eca4fa66 2290
91b876d1 2291 //Fill the ESD with the T0 info (will be used by the TOF)
d76c31f4 2292 if (fReconstructor[11] && fLoader[11]) {
2293 fLoader[11]->LoadRecPoints("READ");
2294 TTree *treeR = fLoader[11]->TreeR();
89916438 2295 if (treeR) {
2296 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2297 }
d76c31f4 2298 }
91b876d1 2299
b8cd5251 2300 // pass 1: TPC + ITS inwards
2301 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2302 if (!fTracker[iDet]) continue;
2303 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 2304
b8cd5251 2305 // load clusters
2306 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2307 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
b8cd5251 2308 TTree* tree = fLoader[iDet]->TreeR();
2309 if (!tree) {
2310 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 2311 return kFALSE;
2312 }
b8cd5251 2313 fTracker[iDet]->LoadClusters(tree);
6efecea1 2314 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2315 // run tracking
2316 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2317 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 2318 return kFALSE;
2319 }
878e1fe1 2320 // preliminary PID in TPC needed by the ITS tracker
2321 if (iDet == 1) {
b26c3770 2322 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 2323 AliESDpid::MakePID(esd);
0f88822a 2324 }
6efecea1 2325 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
b8cd5251 2326 }
596a855f 2327
b8cd5251 2328 // pass 2: ALL backwards
aa3c69a9 2329
ac4a7581 2330 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2331 if (!fTracker[iDet]) continue;
2332 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2333
2334 // load clusters
2335 if (iDet > 1) { // all except ITS, TPC
2336 TTree* tree = NULL;
7b61cd9c 2337 fLoader[iDet]->LoadRecPoints("read");
6efecea1 2338 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
7b61cd9c 2339 tree = fLoader[iDet]->TreeR();
b8cd5251 2340 if (!tree) {
eca4fa66 2341 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2342 return kFALSE;
24f7a148 2343 }
0f88822a 2344 fTracker[iDet]->LoadClusters(tree);
6efecea1 2345 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
b8cd5251 2346 }
24f7a148 2347
b8cd5251 2348 // run tracking
283f39c6 2349 if (iDet>1) // start filling residuals for the "outer" detectors
eca4fa66 2350 if (fRunGlobalQA) {
2351 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2352 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2353 if (arr) {
2354 TObjArray * elem = arr[fRecoParam.GetEventSpecie()];
2355 if ( elem && (! elem->At(0)) ) {
2356 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2357 if (qadm) qadm->InitRecPointsForTracker() ;
2358 }
2359 }
eca4fa66 2360 }
b8cd5251 2361 if (fTracker[iDet]->PropagateBack(esd) != 0) {
2362 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 2363 // return kFALSE;
b8cd5251 2364 }
24f7a148 2365
b8cd5251 2366 // unload clusters
6e65648b 2367 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
b8cd5251 2368 fTracker[iDet]->UnloadClusters();
7b61cd9c 2369 fLoader[iDet]->UnloadRecPoints();
b8cd5251 2370 }
8f37df88 2371 // updated PID in TPC needed by the ITS tracker -MI
2372 if (iDet == 1) {
8f37df88 2373 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2374 AliESDpid::MakePID(esd);
2375 }
6efecea1 2376 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
b8cd5251 2377 }
283f39c6 2378 //stop filling residuals for the "outer" detectors
57acd2d2 2379 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
596a855f 2380
b8cd5251 2381 // pass 3: TRD + TPC + ITS refit inwards
aa3c69a9 2382
b8cd5251 2383 for (Int_t iDet = 2; iDet >= 0; iDet--) {
2384 if (!fTracker[iDet]) continue;
2385 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 2386
b8cd5251 2387 // run tracking
283f39c6 2388 if (iDet<2) // start filling residuals for TPC and ITS
eca4fa66 2389 if (fRunGlobalQA) {
2390 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2391 TObjArray ** arr = AliTracker::GetResidualsArray() ;
c9526f68 2392 if (arr) {
2393 TObjArray * elem = arr[fRecoParam.GetEventSpecie()];
2394 if ( elem && (! elem->At(0)) ) {
2395 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2396 if (qadm) qadm->InitRecPointsForTracker() ;
2397 }
2398 }
eca4fa66 2399 }
2400
b8cd5251 2401 if (fTracker[iDet]->RefitInward(esd) != 0) {
2402 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 2403 // return kFALSE;
b8cd5251 2404 }
db2368d0 2405 // run postprocessing
2406 if (fTracker[iDet]->PostProcess(esd) != 0) {
2407 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2408 // return kFALSE;
2409 }
6efecea1 2410 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
6e65648b 2411 }
2412
2413 // write space-points to the ESD in case alignment data output
2414 // is switched on
2415 if (fWriteAlignmentData)
2416 WriteAlignmentData(esd);
2417
2418 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2419 if (!fTracker[iDet]) continue;
b8cd5251 2420 // unload clusters
2421 fTracker[iDet]->UnloadClusters();
6efecea1 2422 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
b8cd5251 2423 fLoader[iDet]->UnloadRecPoints();
6efecea1 2424 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
b8cd5251 2425 }
283f39c6 2426 // stop filling residuals for TPC and ITS
57acd2d2 2427 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
854c6476 2428
0f88822a 2429 eventNr++;
596a855f 2430 return kTRUE;
2431}
2432
2433//_____________________________________________________________________________
d64bd07d 2434Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2435 //
2436 // Remove the data which are not needed for the physics analysis.
2437 //
2438
d64bd07d 2439 Int_t nTracks=esd->GetNumberOfTracks();
18571674 2440 Int_t nV0s=esd->GetNumberOfV0s();
cf37fd88 2441 AliInfo
2442 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
d64bd07d 2443
18571674 2444 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
7f68891d 2445 Bool_t rc=esd->Clean(cleanPars);
d64bd07d 2446
7f68891d 2447 nTracks=esd->GetNumberOfTracks();
18571674 2448 nV0s=esd->GetNumberOfV0s();
cf37fd88 2449 AliInfo
ae5d5566 2450 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
d64bd07d 2451
7f68891d 2452 return rc;
d64bd07d 2453}
2454
2455//_____________________________________________________________________________
af885e0f 2456Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 2457{
2458// fill the event summary data
2459
87932dab 2460 AliCodeTimerAuto("")
0f88822a 2461 static Int_t eventNr=0;
596a855f 2462 TString detStr = detectors;
abe0c04e 2463
ac4a7581 2464 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
abe0c04e 2465 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
b8cd5251 2466 AliReconstructor* reconstructor = GetReconstructor(iDet);
2467 if (!reconstructor) continue;
4b71572b 2468 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2469 TTree* clustersTree = NULL;
2470 if (fLoader[iDet]) {
2471 fLoader[iDet]->LoadRecPoints("read");
2472 clustersTree = fLoader[iDet]->TreeR();
2473 if (!clustersTree) {
2474 AliError(Form("Can't get the %s clusters tree",
2475 fgkDetectorName[iDet]));
2476 if (fStopOnError) return kFALSE;
2477 }
2478 }
2479 if (fRawReader && !reconstructor->HasDigitConversion()) {
2480 reconstructor->FillESD(fRawReader, clustersTree, esd);
2481 } else {
2482 TTree* digitsTree = NULL;
d76c31f4 2483 if (fLoader[iDet]) {
4b71572b 2484 fLoader[iDet]->LoadDigits("read");
2485 digitsTree = fLoader[iDet]->TreeD();
2486 if (!digitsTree) {
2487 AliError(Form("Can't get the %s digits tree",
b26c3770 2488 fgkDetectorName[iDet]));
2489 if (fStopOnError) return kFALSE;
2490 }
2491 }
4b71572b 2492 reconstructor->FillESD(digitsTree, clustersTree, esd);
2493 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2494 }
2495 if (fLoader[iDet]) {
2496 fLoader[iDet]->UnloadRecPoints();
596a855f 2497 }
2498 }
2499
2500 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 2501 AliError(Form("the following detectors were not found: %s",
2502 detStr.Data()));
596a855f 2503 if (fStopOnError) return kFALSE;
2504 }
6efecea1 2505 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
0f88822a 2506 eventNr++;
596a855f 2507 return kTRUE;
2508}
2509
b647652d 2510//_____________________________________________________________________________
af885e0f 2511Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 2512{
2513 // Reads the trigger decision which is
2514 // stored in Trigger.root file and fills
2515 // the corresponding esd entries
2516
87932dab 2517 AliCodeTimerAuto("")
2518
b647652d 2519 AliInfo("Filling trigger information into the ESD");
2520
2521 if (fRawReader) {
2522 AliCTPRawStream input(fRawReader);
2523 if (!input.Next()) {
7e88424f 2524 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
b647652d 2525 }
2526 else {
7e88424f 2527 if (esd->GetTriggerMask() != input.GetClassMask())
2528 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2529 input.GetClassMask(),esd->GetTriggerMask()));
2530 if (esd->GetOrbitNumber() != input.GetOrbitID())
2531 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2532 input.GetOrbitID(),esd->GetOrbitNumber()));
2533 if (esd->GetBunchCrossNumber() != input.GetBCID())
2534 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2535 input.GetBCID(),esd->GetBunchCrossNumber()));
e61ed4b1 2536 AliESDHeader* esdheader = esd->GetHeader();
2537 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
2538 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
2539 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
b647652d 2540 }
b024fd7f 2541
e61ed4b1 2542 // Here one has to add the filling interaction records
b024fd7f 2543 }
b647652d 2544 return kTRUE;
2545}
596a855f 2546
001397cd 2547
2548
2549
2550
2551//_____________________________________________________________________________
af885e0f 2552Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 2553{
2554 //
2555 // Filling information from RawReader Header
2556 //
2557
151bea4e 2558 if (!fRawReader) return kFALSE;
2559
001397cd 2560 AliInfo("Filling information from RawReader Header");
151bea4e 2561
2562 esd->SetBunchCrossNumber(fRawReader->GetBCID());
2563 esd->SetOrbitNumber(fRawReader->GetOrbitID());
2564 esd->SetPeriodNumber(fRawReader->GetPeriod());
2565
2566 esd->SetTimeStamp(fRawReader->GetTimestamp());
2567 esd->SetEventType(fRawReader->GetType());
001397cd 2568
2569 return kTRUE;
2570}
2571
2572
596a855f 2573//_____________________________________________________________________________
2574Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2575{
2576// check whether detName is contained in detectors
2577// if yes, it is removed from detectors
2578
2579 // check if all detectors are selected
2580 if ((detectors.CompareTo("ALL") == 0) ||
2581 detectors.BeginsWith("ALL ") ||
2582 detectors.EndsWith(" ALL") ||
2583 detectors.Contains(" ALL ")) {
2584 detectors = "ALL";
2585 return kTRUE;
2586 }
2587
2588 // search for the given detector
2589 Bool_t result = kFALSE;
2590 if ((detectors.CompareTo(detName) == 0) ||
2591 detectors.BeginsWith(detName+" ") ||
2592 detectors.EndsWith(" "+detName) ||
2593 detectors.Contains(" "+detName+" ")) {
2594 detectors.ReplaceAll(detName, "");
2595 result = kTRUE;
2596 }
2597
2598 // clean up the detectors string
2599 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
2600 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2601 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2602
2603 return result;
2604}
e583c30d 2605
2606//_____________________________________________________________________________
f08fc9f5 2607Bool_t AliReconstruction::InitRunLoader()
2608{
2609// get or create the run loader
2610
2611 if (gAlice) delete gAlice;
2612 gAlice = NULL;
2613
b26c3770 2614 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2615 // load all base libraries to get the loader classes
2616 TString libs = gSystem->GetLibraries();
ac4a7581 2617 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b26c3770 2618 TString detName = fgkDetectorName[iDet];
2619 if (detName == "HLT") continue;
2620 if (libs.Contains("lib" + detName + "base.so")) continue;
2621 gSystem->Load("lib" + detName + "base.so");
2622 }
f08fc9f5 2623 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2624 if (!fRunLoader) {
2625 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2626 CleanUp();
2627 return kFALSE;
2628 }
325aa76f 2629
b26c3770 2630 fRunLoader->CdGAFile();
325aa76f 2631 fRunLoader->LoadgAlice();
f08fc9f5 2632
6cae184e 2633 //PH This is a temporary fix to give access to the kinematics
2634 //PH that is needed for the labels of ITS clusters
f2ee4290 2635 fRunLoader->LoadHeader();
6cae184e 2636 fRunLoader->LoadKinematics();
2637
f08fc9f5 2638 } else { // galice.root does not exist
2639 if (!fRawReader) {
2640 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
f08fc9f5 2641 }
2642 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2643 AliConfig::GetDefaultEventFolderName(),
2644 "recreate");
2645 if (!fRunLoader) {
2646 AliError(Form("could not create run loader in file %s",
2647 fGAliceFileName.Data()));
2648 CleanUp();
2649 return kFALSE;
2650 }
21a3aa09 2651 fIsNewRunLoader = kTRUE;
f08fc9f5 2652 fRunLoader->MakeTree("E");
21a3aa09 2653
973388c2 2654 if (fNumberOfEventsPerFile > 0)
2655 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2656 else
21a3aa09 2657 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
f08fc9f5 2658 }
2659
2660 return kTRUE;
2661}
2662
2663//_____________________________________________________________________________
b8cd5251 2664AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 2665{
f08fc9f5 2666// get the reconstructor object and the loader for a detector
c757bafd 2667
7e88424f 2668 if (fReconstructor[iDet]) {
2669 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2670 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2671 fReconstructor[iDet]->SetRecoParam(par);
2672 }
2673 return fReconstructor[iDet];
2674 }
b8cd5251 2675
2676 // load the reconstructor object
2677 TPluginManager* pluginManager = gROOT->GetPluginManager();
2678 TString detName = fgkDetectorName[iDet];
2679 TString recName = "Ali" + detName + "Reconstructor";
f0999a9a 2680
2681 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
b8cd5251 2682
b8cd5251 2683 AliReconstructor* reconstructor = NULL;
2684 // first check if a plugin is defined for the reconstructor
2685 TPluginHandler* pluginHandler =
2686 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 2687 // if not, add a plugin for it
2688 if (!pluginHandler) {
b8cd5251 2689 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 2690 TString libs = gSystem->GetLibraries();
2691 if (libs.Contains("lib" + detName + "base.so") ||
2692 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 2693 pluginManager->AddHandler("AliReconstructor", detName,
2694 recName, detName + "rec", recName + "()");
2695 } else {
2696 pluginManager->AddHandler("AliReconstructor", detName,
2697 recName, detName, recName + "()");
c757bafd 2698 }
b8cd5251 2699 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2700 }
2701 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2702 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 2703 }
b8cd5251 2704 if (reconstructor) {
2705 TObject* obj = fOptions.FindObject(detName.Data());
2706 if (obj) reconstructor->SetOption(obj->GetTitle());
d76c31f4 2707 reconstructor->Init();
b8cd5251 2708 fReconstructor[iDet] = reconstructor;
2709 }
2710
f08fc9f5 2711 // get or create the loader
2712 if (detName != "HLT") {
2713 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2714 if (!fLoader[iDet]) {
2715 AliConfig::Instance()
2716 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2717 detName, detName);
2718 // first check if a plugin is defined for the loader
bb0901a4 2719 pluginHandler =
f08fc9f5 2720 pluginManager->FindHandler("AliLoader", detName);
2721 // if not, add a plugin for it
2722 if (!pluginHandler) {
2723 TString loaderName = "Ali" + detName + "Loader";
2724 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2725 pluginManager->AddHandler("AliLoader", detName,
2726 loaderName, detName + "base",
2727 loaderName + "(const char*, TFolder*)");
2728 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2729 }
2730 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2731 fLoader[iDet] =
2732 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2733 fRunLoader->GetEventFolder());
2734 }
2735 if (!fLoader[iDet]) { // use default loader
2736 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2737 }
2738 if (!fLoader[iDet]) {
2739 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 2740 if (fStopOnError) return NULL;
f08fc9f5 2741 } else {
2742 fRunLoader->AddLoader(fLoader[iDet]);
2743 fRunLoader->CdGAFile();
2744 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2745 fRunLoader->Write(0, TObject::kOverwrite);
2746 }
2747 }
2748 }
2749
7e88424f 2750 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2751 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2752 reconstructor->SetRecoParam(par);
2753 }
b8cd5251 2754 return reconstructor;
c757bafd 2755}
2756
2757//_____________________________________________________________________________
92bffc4d 2758AliVertexer* AliReconstruction::CreateVertexer()
2257f27e 2759{
2760// create the vertexer
92bffc4d 2761// Please note that the caller is the owner of the
2762// vertexer
2257f27e 2763
92bffc4d 2764 AliVertexer* vertexer = NULL;
b8cd5251 2765 AliReconstructor* itsReconstructor = GetReconstructor(0);
70d06e85 2766 if (itsReconstructor && (fRunLocalReconstruction.Contains("ITS"))) {
92bffc4d 2767 vertexer = itsReconstructor->CreateVertexer();
2257f27e 2768 }
92bffc4d 2769 if (!vertexer) {
815c2b38 2770 AliWarning("couldn't create a vertexer for ITS");
2257f27e 2771 }
2772
92bffc4d 2773 return vertexer;
2257f27e 2774}
2775
2776//_____________________________________________________________________________
b8cd5251 2777Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 2778{
f08fc9f5 2779// create the trackers
44e45fac 2780 AliInfo("Creating trackers");
24f7a148 2781
b8cd5251 2782 TString detStr = detectors;
ac4a7581 2783 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2784 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2785 AliReconstructor* reconstructor = GetReconstructor(iDet);
2786 if (!reconstructor) continue;
2787 TString detName = fgkDetectorName[iDet];
1f46a9ae 2788 if (detName == "HLT") {
2789 fRunHLTTracking = kTRUE;
2790 continue;
2791 }
e66fbafb 2792 if (detName == "MUON") {
2793 fRunMuonTracking = kTRUE;
2794 continue;
2795 }
2796
f08fc9f5 2797
d76c31f4 2798 fTracker[iDet] = reconstructor->CreateTracker();
f08fc9f5 2799 if (!fTracker[iDet] && (iDet < 7)) {
2800 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 2801 if (fStopOnError) return kFALSE;
2802 }
6efecea1 2803 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
8250d5f5 2804 }
2805
24f7a148 2806 return kTRUE;
2807}
2808
2809//_____________________________________________________________________________
4b71572b 2810void AliReconstruction::CleanUp()
e583c30d 2811{
2812// delete trackers and the run loader and close and delete the file
2813
ac4a7581 2814 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
b8cd5251 2815 delete fReconstructor[iDet];
2816 fReconstructor[iDet] = NULL;
2817 fLoader[iDet] = NULL;
2818 delete fTracker[iDet];
2819 fTracker[iDet] = NULL;
2820 }
4b71572b 2821 delete fRunInfo;
7e88424f 2822 fRunInfo = NULL;
2823
58e8dc31 2824 delete fSPDTrackleter;
2825 fSPDTrackleter = NULL;
2826
4b71572b 2827 delete ftVertexer;
21a3aa09 2828 ftVertexer = NULL;
795e4a22 2829
e583c30d 2830 delete fRunLoader;
2831 fRunLoader = NULL;
b649205a 2832 delete fRawReader;
2833 fRawReader = NULL;
4b71572b 2834 delete fParentRawReader;
cd0b062e 2835 fParentRawReader=NULL;
e583c30d 2836
4b71572b 2837 if (ffile) {
2838 ffile->Close();
2839 delete ffile;
2840 ffile = NULL;
24f7a148 2841 }
87da0921 2842
bf76b847 2843 if (AliQAManager::QAManager())
2844 AliQAManager::QAManager()->ShowQA() ;
eca4fa66 2845 AliQAManager::Destroy() ;
2846
87da0921 2847 TGeoGlobalMagField::Instance()->SetField(NULL);
24f7a148 2848}
f3a97c86 2849
af885e0f 2850void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2851{
2852 // Write space-points which are then used in the alignment procedures
6e65648b 2853 // For the moment only ITS, TPC, TRD and TOF
98937d93 2854
98937d93 2855 Int_t ntracks = esd->GetNumberOfTracks();
2856 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2857 {
2858 AliESDtrack *track = esd->GetTrack(itrack);
2859 Int_t nsp = 0;
ef7253ac 2860 Int_t idx[200];
76741755 2861 for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
81aa7a0d 2862 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
6e65648b 2863 nsp += track->GetNcls(iDet);
2864
2865 if (iDet==0) { // ITS "extra" clusters
2866 track->GetClusters(iDet,idx);
2867 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
2868 }
2869 }
2870
98937d93 2871 if (nsp) {
2872 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2873 track->SetTrackPointArray(sp);
2874 Int_t isptrack = 0;
81aa7a0d 2875 for (Int_t iDet = 5; iDet >= 0; iDet--) {
98937d93 2876 AliTracker *tracker = fTracker[iDet];
2877 if (!tracker) continue;
6e65648b 2878 Int_t nspdet = track->GetClusters(iDet,idx);
2879
2880 if (iDet==0) // ITS "extra" clusters
2881 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
2882
98937d93 2883 if (nspdet <= 0) continue;
98937d93 2884 AliTrackPoint p;
2885 Int_t isp = 0;
2886 Int_t isp2 = 0;
4ed6fb1c 2887 while (isp2 < nspdet) {
f3c6e4c9 2888 Bool_t isvalid=kTRUE;
2889
2890 Int_t index=idx[isp++];
2891 if (index < 0) continue;
2892
c12b6e44 2893 TString dets = fgkDetectorName[iDet];
2894 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2895 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2896 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2897 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
f3c6e4c9 2898 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
48ce48d1 2899 } else {
f3c6e4c9 2900 isvalid = tracker->GetTrackPoint(index,p);
48ce48d1 2901 }
2902 isp2++;
98937d93 2903 if (!isvalid) continue;
eb2d90b9 2904 if (iDet==0 && (isp-1)>=6) p.SetExtra();
f3c6e4c9 2905 sp->AddPoint(isptrack,&p); isptrack++;
98937d93 2906 }
98937d93 2907 }
2908 }
2909 }
98937d93 2910}
2e3550da 2911
2912//_____________________________________________________________________________
af885e0f 2913void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 2914{
2915 // The method reads the raw-data error log
2916 // accumulated within the rawReader.
2917 // It extracts the raw-data errors related to
2918 // the current event and stores them into
2919 // a TClonesArray inside the esd object.
2920
2921 if (!fRawReader) return;
2922
2923 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2924
2925 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2926 if (!log) continue;
2927 if (iEvent != log->GetEventNumber()) continue;
2928
2929 esd->AddRawDataErrorLog(log);
2930 }
2931
2932}
46698ae4 2933
7e963665 2934//_____________________________________________________________________________
8661738e 2935void AliReconstruction::CheckQA()
2936{
2937// check the QA of SIM for this run and remove the detectors
2938// with status Fatal
2939
57acd2d2 2940// TString newRunLocalReconstruction ;
2941// TString newRunTracking ;
2942// TString newFillESD ;
2943//
4e25ac79 2944// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
2945// TString detName(AliQAv1::GetDetName(iDet)) ;
2946// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
2947// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
57acd2d2 2948// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
2949// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
2950// } else {
4e25ac79 2951// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 2952// fRunLocalReconstruction.Contains("ALL") ) {
2953// newRunLocalReconstruction += detName ;
2954// newRunLocalReconstruction += " " ;
2955// }
4e25ac79 2956// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 2957// fRunTracking.Contains("ALL") ) {
2958// newRunTracking += detName ;
2959// newRunTracking += " " ;
2960// }
4e25ac79 2961// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
57acd2d2 2962// fFillESD.Contains("ALL") ) {
2963// newFillESD += detName ;
2964// newFillESD += " " ;
2965// }
2966// }
2967// }
2968// fRunLocalReconstruction = newRunLocalReconstruction ;
2969// fRunTracking = newRunTracking ;
2970// fFillESD = newFillESD ;
a5fa6165 2971}
5b188f2f 2972
2973//_____________________________________________________________________________
2974Int_t AliReconstruction::GetDetIndex(const char* detector)
2975{
2976 // return the detector index corresponding to detector
2977 Int_t index = -1 ;
ac4a7581 2978 for (index = 0; index < kNDetectors ; index++) {
5b188f2f 2979 if ( strcmp(detector, fgkDet