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