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