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