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