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