New example task to configure different analysis to fill shower shape related plots
[u/mrichter/AliRoot.git] / STEER / STEER / AliReconstruction.cxx
... / ...
CommitLineData
1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
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. //
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// //
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// //
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// //
59// The name of the galice file can be changed from the default //
60// "galice.root" by passing it as argument to the AliReconstruction //
61// constructor or by //
62// //
63// rec.SetGAliceFile("..."); //
64// //
65// The local reconstruction can be switched on or off for individual //
66// detectors by //
67// //
68// rec.SetRunLocalReconstruction("..."); //
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// //
74// The reconstruction of the primary vertex position can be switched off by //
75// //
76// rec.SetRunVertexFinder(kFALSE); //
77// //
78// The tracking and the creation of ESD tracks can be switched on for //
79// selected detectors by //
80// //
81// rec.SetRunTracking("..."); //
82// //
83// Uniform/nonuniform field tracking switches (default: uniform field) //
84// //
85// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
86// //
87// The filling of additional ESD information can be steered by //
88// //
89// rec.SetFillESD("..."); //
90// //
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. //
100// //
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. //
103// //
104// The input data of a detector can be replaced by the corresponding HLT //
105// data by calling (usual detector string) //
106// SetUseHLTData("..."); //
107// //
108// //
109///////////////////////////////////////////////////////////////////////////////
110
111#include <TArrayD.h>
112#include <TArrayF.h>
113#include <TArrayS.h>
114#include <TChain.h>
115#include <TFile.h>
116#include <TGeoGlobalMagField.h>
117#include <TGeoManager.h>
118#include <TList.h>
119#include <TLorentzVector.h>
120#include <TMap.h>
121#include <TObjArray.h>
122#include <TPRegexp.h>
123#include <TParameter.h>
124#include <TPluginManager.h>
125#include <TProof.h>
126#include <TProofOutputFile.h>
127#include <TROOT.h>
128#include <TSystem.h>
129#include <THashTable.h>
130#include <TGrid.h>
131#include <TMessage.h>
132#include <TUrl.h>
133#include <TRandom.h>
134
135#include "AliAlignObj.h"
136#include "AliAnalysisManager.h"
137#include "AliAnalysisDataContainer.h"
138#include "AliCDBEntry.h"
139#include "AliCDBManager.h"
140#include "AliCDBStorage.h"
141#include "AliCTPRawStream.h"
142#include "AliCascadeVertexer.h"
143#include "AliCentralTrigger.h"
144#include "AliCodeTimer.h"
145#include "AliDAQ.h"
146#include "AliDetectorRecoParam.h"
147#include "AliESDCaloCells.h"
148#include "AliESDCaloCluster.h"
149#include "AliESDEvent.h"
150#include "AliESDMuonTrack.h"
151#include "AliESDPmdTrack.h"
152#include "AliESDTagCreator.h"
153#include "AliESDVertex.h"
154#include "AliESDcascade.h"
155#include "AliESDfriend.h"
156#include "AliESDkink.h"
157#include "AliESDpid.h"
158#include "AliESDtrack.h"
159#include "AliESDtrack.h"
160#include "AliEventInfo.h"
161#include "AliGRPObject.h"
162#include "AliGRPRecoParam.h"
163#include "AliGenEventHeader.h"
164#include "AliGeomManager.h"
165#include "AliGlobalQADataMaker.h"
166#include "AliHeader.h"
167#include "AliLog.h"
168#include "AliMagF.h"
169#include "AliMultiplicity.h"
170#include "AliPID.h"
171#include "AliPlaneEff.h"
172#include "AliQAv1.h"
173#include "AliQADataMakerRec.h"
174#include "AliQAManager.h"
175#include "AliRawVEvent.h"
176#include "AliRawEventHeaderBase.h"
177#include "AliRawHLTManager.h"
178#include "AliRawReaderDate.h"
179#include "AliRawReaderFile.h"
180#include "AliRawReaderRoot.h"
181#include "AliRecoInputHandler.h"
182#include "AliReconstruction.h"
183#include "AliReconstructor.h"
184#include "AliRun.h"
185#include "AliRunInfo.h"
186#include "AliRunLoader.h"
187#include "AliSysInfo.h" // memory snapshots
188#include "AliTrackPointArray.h"
189#include "AliTracker.h"
190#include "AliTriggerClass.h"
191#include "AliTriggerCluster.h"
192#include "AliTriggerIR.h"
193#include "AliTriggerConfiguration.h"
194#include "AliV0vertexer.h"
195#include "AliVertexer.h"
196#include "AliTrackleter.h"
197#include "AliVertexerTracks.h"
198#include "AliTriggerRunScalers.h"
199#include "AliCTPTimeParams.h"
200#include "AliESDHLTDecision.h"
201#include "AliTriggerInput.h"
202#include "AliLHCData.h"
203#include "ARVersion.h"
204#include <RVersion.h>
205#include <unistd.h>
206#include <sys/resource.h>
207ClassImp(AliReconstruction)
208
209//_____________________________________________________________________________
210const char* AliReconstruction::fgkStopEvFName = "_stopEvent_";
211const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
212// #ifdef MFT_UPGRADE
213// , "MFT"
214// #endif
215 , "MFT" // AU
216 , "HLT"
217};
218
219//_____________________________________________________________________________
220AliReconstruction::AliReconstruction(const char* gAliceFilename) :
221 TSelector(),
222 fRunVertexFinder(kTRUE),
223 fRunVertexFinderTracks(kTRUE),
224 fRunHLTTracking(kFALSE),
225 fRunMuonTracking(kFALSE),
226 fRunV0Finder(kTRUE),
227 fRunCascadeFinder(kTRUE),
228 fRunMultFinder(kTRUE),
229 fStopOnError(kTRUE),
230 fWriteAlignmentData(kFALSE),
231 fWriteESDfriend(kFALSE),
232 fFillTriggerESD(kTRUE),
233
234 fCleanESD(kTRUE),
235 fV0DCAmax(3.),
236 fV0CsPmin(0.),
237 fDmax(50.),
238 fZmax(50.),
239
240 fRunLocalReconstruction("ALL"),
241 fRunTracking("ALL"),
242 fFillESD("ALL"),
243 fDeleteRecPoints(""),
244 fDeleteDigits(""),
245 fLoadCDB(""),
246 fUseTrackingErrorsForAlignment(""),
247 fGAliceFileName(gAliceFilename),
248 fRawInput(""),
249 fESDOutput(""),
250 fProofOutputFileName(""),
251 fProofOutputLocation(""),
252 fProofOutputDataset(kFALSE),
253 fProofOutputArchive(""),
254 fEquipIdMap(""),
255 fFirstEvent(0),
256 fLastEvent(-1),
257 fNumberOfEventsPerFile((UInt_t)-1),
258 fFractionFriends(0.04),
259 fOptions(),
260 fLoadAlignFromCDB(kTRUE),
261 fLoadAlignData("ALL"),
262 fUseHLTData(),
263 fRunInfo(NULL),
264 fEventInfo(),
265 fRunScalers(NULL),
266 fCTPTimeParams(NULL),
267 fCTPTimeAlign(NULL),
268
269 fRunLoader(NULL),
270 fRawReader(NULL),
271 fParentRawReader(NULL),
272
273 fRecoParam(),
274
275 fSPDTrackleter(NULL),
276
277 fDiamondProfileSPD(NULL),
278 fDiamondProfile(NULL),
279 fDiamondProfileTPC(NULL),
280 fListOfCosmicTriggers(NULL),
281
282 fGRPData(NULL),
283
284 fAlignObjArray(NULL),
285 fCDBUri(),
286 fQARefUri(),
287 fSpecCDBUri(),
288 fInitCDBCalled(kFALSE),
289 fFromCDBSnapshot(kFALSE),
290 fSnapshotFileName(""),
291 fSetRunNumberFromDataCalled(kFALSE),
292 fQADetectors("ALL"),
293 fQATasks("ALL"),
294 fRunQA(kTRUE),
295 fRunGlobalQA(kTRUE),
296 fSameQACycle(kFALSE),
297 fInitQACalled(kFALSE),
298 fWriteQAExpertData(kTRUE),
299 fRunPlaneEff(kFALSE),
300
301 fesd(NULL),
302 fhltesd(NULL),
303 fesdf(NULL),
304 ffile(NULL),
305 ffileF(NULL),
306 ftree(NULL),
307 ftreeF(NULL),
308 fhlttree(NULL),
309 ftVertexer(NULL),
310 fIsNewRunLoader(kFALSE),
311 fRunAliEVE(kFALSE),
312 fChain(NULL),
313 fNall(0),
314 fNspecie(0),
315 fSspecie(0),
316 fNhighPt(0),
317 fShighPt(0),
318 fUpgradeModule(""),
319 fAnalysisMacro(),
320 fAnalysis(0),
321 fRecoHandler(0),
322 fDeclTriggerClasses(""),
323 fStopped(kFALSE),
324 fMaxRSS(0),
325 fMaxVMEM(0)
326{
327// create reconstruction object with default parameters
328 gGeoManager = NULL;
329
330 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
331 fReconstructor[iDet] = NULL;
332 fUpgradeMask[iDet]=kFALSE;
333 fLoader[iDet] = NULL;
334 fTracker[iDet] = NULL;
335 }
336 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
337 fQACycles[iDet] = 999999 ;
338 fQAWriteExpert[iDet] = kFALSE ;
339 }
340 fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
341
342 AliPID pid;
343}
344
345//_____________________________________________________________________________
346AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
347 TSelector(),
348 fRunVertexFinder(rec.fRunVertexFinder),
349 fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
350 fRunHLTTracking(rec.fRunHLTTracking),
351 fRunMuonTracking(rec.fRunMuonTracking),
352 fRunV0Finder(rec.fRunV0Finder),
353 fRunCascadeFinder(rec.fRunCascadeFinder),
354 fRunMultFinder(rec.fRunMultFinder),
355 fStopOnError(rec.fStopOnError),
356 fWriteAlignmentData(rec.fWriteAlignmentData),
357 fWriteESDfriend(rec.fWriteESDfriend),
358 fFillTriggerESD(rec.fFillTriggerESD),
359
360 fCleanESD(rec.fCleanESD),
361 fV0DCAmax(rec.fV0DCAmax),
362 fV0CsPmin(rec.fV0CsPmin),
363 fDmax(rec.fDmax),
364 fZmax(rec.fZmax),
365
366 fRunLocalReconstruction(rec.fRunLocalReconstruction),
367 fRunTracking(rec.fRunTracking),
368 fFillESD(rec.fFillESD),
369 fDeleteRecPoints(""),
370 fDeleteDigits(""),
371 fLoadCDB(rec.fLoadCDB),
372 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
373 fGAliceFileName(rec.fGAliceFileName),
374 fRawInput(rec.fRawInput),
375 fESDOutput(rec.fESDOutput),
376 fProofOutputFileName(rec.fProofOutputFileName),
377 fProofOutputLocation(rec.fProofOutputLocation),
378 fProofOutputDataset(rec.fProofOutputDataset),
379 fProofOutputArchive(rec.fProofOutputArchive),
380 fEquipIdMap(rec.fEquipIdMap),
381 fFirstEvent(rec.fFirstEvent),
382 fLastEvent(rec.fLastEvent),
383 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
384 fFractionFriends(rec.fFractionFriends),
385 fOptions(),
386 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
387 fLoadAlignData(rec.fLoadAlignData),
388 fUseHLTData(rec.fUseHLTData),
389 fRunInfo(NULL),
390 fEventInfo(),
391 fRunScalers(NULL),
392 fCTPTimeParams(NULL),
393 fCTPTimeAlign(NULL),
394
395 fRunLoader(NULL),
396 fRawReader(NULL),
397 fParentRawReader(NULL),
398
399 fRecoParam(rec.fRecoParam),
400
401 fSPDTrackleter(NULL),
402
403 fDiamondProfileSPD(rec.fDiamondProfileSPD),
404 fDiamondProfile(rec.fDiamondProfile),
405 fDiamondProfileTPC(rec.fDiamondProfileTPC),
406 fListOfCosmicTriggers(NULL),
407
408 fGRPData(NULL),
409
410 fAlignObjArray(rec.fAlignObjArray),
411 fCDBUri(rec.fCDBUri),
412 fQARefUri(rec.fQARefUri),
413 fSpecCDBUri(),
414 fInitCDBCalled(rec.fInitCDBCalled),
415 fFromCDBSnapshot(rec.fFromCDBSnapshot),
416 fSnapshotFileName(rec.fSnapshotFileName),
417 fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
418 fQADetectors(rec.fQADetectors),
419 fQATasks(rec.fQATasks),
420 fRunQA(rec.fRunQA),
421 fRunGlobalQA(rec.fRunGlobalQA),
422 fSameQACycle(rec.fSameQACycle),
423 fInitQACalled(rec.fInitQACalled),
424 fWriteQAExpertData(rec.fWriteQAExpertData),
425 fRunPlaneEff(rec.fRunPlaneEff),
426
427 fesd(NULL),
428 fhltesd(NULL),
429 fesdf(NULL),
430 ffile(NULL),
431 ffileF(NULL),
432 ftree(NULL),
433 ftreeF(NULL),
434 fhlttree(NULL),
435 ftVertexer(NULL),
436 fIsNewRunLoader(rec.fIsNewRunLoader),
437 fRunAliEVE(kFALSE),
438 fChain(NULL),
439 fNall(0),
440 fNspecie(0),
441 fSspecie(0),
442 fNhighPt(0),
443 fShighPt(0),
444 fUpgradeModule(""),
445 fAnalysisMacro(rec.fAnalysisMacro),
446 fAnalysis(0),
447 fRecoHandler(0),
448 fDeclTriggerClasses(rec.fDeclTriggerClasses),
449 fStopped(kFALSE),
450 fMaxRSS(0),
451 fMaxVMEM(0)
452{
453// copy constructor
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 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
459 fReconstructor[iDet] = NULL;
460 fUpgradeMask[iDet] = kFALSE;
461 fLoader[iDet] = NULL;
462 fTracker[iDet] = NULL;
463 }
464
465 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
466 fQACycles[iDet] = rec.fQACycles[iDet];
467 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
468 }
469
470 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
471 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
472 }
473
474 for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
475
476}
477
478//_____________________________________________________________________________
479AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
480{
481// assignment operator
482// Used in PROOF mode
483// Be very careful while modifing it!
484// Simple rules to follow:
485// for persistent data members - use their assignment operators
486// for non-persistent ones - do nothing or take the default values from constructor
487// TSelector members should not be touched
488 if(&rec == this) return *this;
489
490 fRunVertexFinder = rec.fRunVertexFinder;
491 fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
492 fRunHLTTracking = rec.fRunHLTTracking;
493 fRunMuonTracking = rec.fRunMuonTracking;
494 fRunV0Finder = rec.fRunV0Finder;
495 fRunCascadeFinder = rec.fRunCascadeFinder;
496 fRunMultFinder = rec.fRunMultFinder;
497 fStopOnError = rec.fStopOnError;
498 fWriteAlignmentData = rec.fWriteAlignmentData;
499 fWriteESDfriend = rec.fWriteESDfriend;
500 fFillTriggerESD = rec.fFillTriggerESD;
501
502 fCleanESD = rec.fCleanESD;
503 fV0DCAmax = rec.fV0DCAmax;
504 fV0CsPmin = rec.fV0CsPmin;
505 fDmax = rec.fDmax;
506 fZmax = rec.fZmax;
507
508 fRunLocalReconstruction = rec.fRunLocalReconstruction;
509 fRunTracking = rec.fRunTracking;
510 fFillESD = rec.fFillESD;
511 fDeleteRecPoints = rec.fDeleteRecPoints;
512 fDeleteDigits = rec.fDeleteDigits;
513 fLoadCDB = rec.fLoadCDB;
514 fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
515 fGAliceFileName = rec.fGAliceFileName;
516 fRawInput = rec.fRawInput;
517 fESDOutput = rec.fESDOutput;
518 fProofOutputFileName = rec.fProofOutputFileName;
519 fProofOutputLocation = rec.fProofOutputLocation;
520 fProofOutputDataset = rec.fProofOutputDataset;
521 fProofOutputArchive = rec.fProofOutputArchive;
522 fEquipIdMap = rec.fEquipIdMap;
523 fFirstEvent = rec.fFirstEvent;
524 fLastEvent = rec.fLastEvent;
525 fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
526 fFractionFriends = rec.fFractionFriends;
527
528 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
529 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
530 }
531
532 fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
533 fLoadAlignData = rec.fLoadAlignData;
534 fUseHLTData = rec.fUseHLTData;
535
536 delete fRunInfo; fRunInfo = NULL;
537 if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
538
539 fEventInfo = rec.fEventInfo;
540
541 delete fRunScalers; fRunScalers = NULL;
542 if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
543
544 delete fCTPTimeParams; fCTPTimeParams = NULL;
545 if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
546 delete fCTPTimeAlign; fCTPTimeAlign = NULL;
547 if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
548
549 fRunLoader = NULL;
550 fRawReader = NULL;
551 fParentRawReader = NULL;
552
553 fRecoParam = rec.fRecoParam;
554
555 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
556 fUpgradeMask[iDet] = kFALSE;
557 delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
558 delete fLoader[iDet]; fLoader[iDet] = NULL;
559 delete fTracker[iDet]; fTracker[iDet] = NULL;
560 }
561
562 for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
563 fQACycles[iDet] = rec.fQACycles[iDet];
564 fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
565 }
566
567 delete fSPDTrackleter; fSPDTrackleter = NULL;
568
569 delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
570 if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
571 delete fDiamondProfile; fDiamondProfile = NULL;
572 if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
573 delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
574 if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
575
576 delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
577 if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
578
579 delete fGRPData; fGRPData = NULL;
580 // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
581 if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
582
583 delete fAlignObjArray; fAlignObjArray = NULL;
584
585 fCDBUri = "";
586 fQARefUri = rec.fQARefUri;
587 fSpecCDBUri.Delete();
588 fInitCDBCalled = rec.fInitCDBCalled;
589 fFromCDBSnapshot = rec.fFromCDBSnapshot;
590 fSnapshotFileName = rec.fSnapshotFileName;
591 fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
592 fQADetectors = rec.fQADetectors;
593 fQATasks = rec.fQATasks;
594 fRunQA = rec.fRunQA;
595 fRunGlobalQA = rec.fRunGlobalQA;
596 fSameQACycle = rec.fSameQACycle;
597 fInitQACalled = rec.fInitQACalled;
598 fWriteQAExpertData = rec.fWriteQAExpertData;
599 fRunPlaneEff = rec.fRunPlaneEff;
600 for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
601 fesd = NULL;
602 fhltesd = NULL;
603 fesdf = NULL;
604 ffile = NULL;
605 ffileF = NULL;
606 ftree = NULL;
607 ftreeF = NULL;
608 fhlttree = NULL;
609 ftVertexer = NULL;
610 fIsNewRunLoader = rec.fIsNewRunLoader;
611 fRunAliEVE = kFALSE;
612 fChain = NULL;
613 fNall = 0;
614 fNspecie = 0;
615 fSspecie = 0;
616 fNhighPt = 0;
617 fShighPt = 0;
618 fUpgradeModule="";
619 fAnalysisMacro = rec.fAnalysisMacro;
620 fAnalysis = 0;
621 fRecoHandler = 0;
622 fDeclTriggerClasses = rec.fDeclTriggerClasses;
623
624 return *this;
625}
626
627//_____________________________________________________________________________
628AliReconstruction::~AliReconstruction()
629{
630// clean up
631
632 CleanUp();
633 if (fListOfCosmicTriggers) {
634 fListOfCosmicTriggers->Delete();
635 delete fListOfCosmicTriggers;
636 }
637 delete fGRPData;
638 delete fRunScalers;
639 delete fCTPTimeParams;
640 delete fCTPTimeAlign;
641 fOptions.Delete();
642 if (fAlignObjArray) {
643 fAlignObjArray->Delete();
644 delete fAlignObjArray;
645 }
646 fSpecCDBUri.Delete();
647
648 AliCodeTimer::Instance()->Print();
649}
650
651//_____________________________________________________________________________
652void AliReconstruction::InitQA()
653{
654 //Initialize the QA and start of cycle
655 AliCodeTimerAuto("",0);
656
657 if (fInitQACalled) return;
658 fInitQACalled = kTRUE;
659
660 if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
661
662
663 AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
664 if (fWriteQAExpertData)
665 qam->SetWriteExpert() ;
666
667 if (qam->IsDefaultStorageSet()) {
668 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
669 AliWarning("Default QA reference storage has been already set !");
670 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
671 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
672 fQARefUri = qam->GetDefaultStorage()->GetURI();
673 } else {
674 if (fQARefUri.Length() > 0) {
675 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
676 AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
677 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
678 } else {
679 fQARefUri="local://$ALICE_ROOT/QAref";
680 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
681 AliWarning("Default QA refeference storage not yet set !!!!");
682 AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
683 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
684
685 }
686 qam->SetDefaultStorage(fQARefUri);
687 }
688
689 if (fRunQA) {
690 qam->SetActiveDetectors(fQADetectors) ;
691 for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
692 qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
693 qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
694 }
695 if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
696 fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
697 qam->SetTasks(fQATasks) ;
698 qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
699 }
700 if (fRunGlobalQA) {
701 Bool_t sameCycle = kFALSE ;
702 AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
703 AliInfo(Form("Initializing the global QA data maker"));
704 if (IsInTasks(AliQAv1::kRECPOINTS)) {
705 qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
706 TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
707 AliTracker::SetResidualsArray(arr);
708 sameCycle = kTRUE ;
709 }
710 if (IsInTasks(AliQAv1::kESDS)) {
711 qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
712 qadm->Init(AliQAv1::kESDS);
713 }
714 }
715 AliSysInfo::AddStamp("InitQA") ;
716}
717
718//_____________________________________________________________________________
719void AliReconstruction::MergeQA(const char *fileName)
720{
721 //Initialize the QA and start of cycle
722 AliCodeTimerAuto("",0) ;
723 AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
724 AliSysInfo::AddStamp("MergeQA") ;
725}
726
727//_____________________________________________________________________________
728void AliReconstruction::InitCDB()
729{
730// activate a default CDB storage
731// First check if we have any CDB storage set, because it is used
732// to retrieve the calibration and alignment constants
733 AliCodeTimerAuto("",0);
734
735 if (fInitCDBCalled) return;
736 fInitCDBCalled = kTRUE;
737
738 AliCDBManager* man = AliCDBManager::Instance();
739 if (man->IsDefaultStorageSet())
740 {
741 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
742 AliWarning("Default CDB storage has been already set !");
743 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
744 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
745 fCDBUri = man->GetDefaultStorage()->GetURI();
746 }
747 else {
748 if (fCDBUri.Length() > 0)
749 {
750 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
751 AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
752 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
753 man->SetDefaultStorage(fCDBUri);
754 }
755 else if (!man->GetRaw()){
756 fCDBUri="local://$ALICE_ROOT/OCDB";
757 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
758 AliWarning("Default CDB storage not yet set !!!!");
759 AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
760 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
761 man->SetDefaultStorage(fCDBUri);
762 }
763 else {
764 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
765 AliWarning("Default storage will be set after setting the Run Number!!!");
766 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
767 }
768 }
769
770 // Now activate the detector specific CDB storage locations
771 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
772 TObject* obj = fSpecCDBUri[i];
773 if (!obj) continue;
774 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
775 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
776 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
777 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
778 }
779 AliSysInfo::AddStamp("InitCDB");
780}
781
782//_____________________________________________________________________________
783void AliReconstruction::SetCDBSnapshotMode(const char* snapshotFileName) {
784 AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName);
785}
786
787//_____________________________________________________________________________
788void AliReconstruction::SetDefaultStorage(const char* uri) {
789// Store the desired default CDB storage location
790// Activate it later within the Run() method
791
792 fCDBUri = uri;
793
794}
795
796//_____________________________________________________________________________
797void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
798 // Store the desired default CDB storage location
799 // Activate it later within the Run() method
800
801 fQARefUri = uri;
802 AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
803
804}
805//_____________________________________________________________________________
806void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
807// Store a detector-specific CDB storage location
808// Activate it later within the Run() method
809
810 AliCDBPath aPath(calibType);
811 if(!aPath.IsValid()){
812 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
813 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
814 if(!strcmp(calibType, fgkDetectorName[iDet])) {
815 aPath.SetPath(Form("%s/*", calibType));
816 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
817 break;
818 }
819 }
820 if(!aPath.IsValid()){
821 AliError(Form("Not a valid path or detector: %s", calibType));
822 return;
823 }
824 }
825
826// // check that calibType refers to a "valid" detector name
827// Bool_t isDetector = kFALSE;
828// for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
829// TString detName = fgkDetectorName[iDet];
830// if(aPath.GetLevel0() == detName) {
831// isDetector = kTRUE;
832// break;
833// }
834// }
835//
836// if(!isDetector) {
837// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
838// return;
839// }
840
841 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
842 if (obj) fSpecCDBUri.Remove(obj);
843 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
844
845}
846
847//_____________________________________________________________________________
848Bool_t AliReconstruction::SetRunNumberFromData()
849{
850 // The method is called in Run() in order
851 // to set a correct run number.
852 // In case of raw data reconstruction the
853 // run number is taken from the raw data header
854
855 if (fSetRunNumberFromDataCalled) return kTRUE;
856 fSetRunNumberFromDataCalled = kTRUE;
857
858 AliCDBManager* man = AliCDBManager::Instance();
859
860 if(fRawReader) {
861 if(fRawReader->NextEvent()) {
862 if(man->GetRun() > 0) {
863 AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
864 }
865 man->SetRun(fRawReader->GetRunNumber());
866 fRawReader->RewindEvents();
867 }
868 else {
869 if(man->GetRun() > 0) {
870 AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
871 }
872 else {
873 AliWarning("Neither raw events nor settings in AliCDBManager are found !");
874 return kFALSE;
875 }
876 }
877 }
878 else {
879 AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
880 if (!rl) {
881 AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
882 return kFALSE;
883 }
884 else {
885 rl->LoadHeader();
886 // read run number from gAlice
887 if(rl->GetHeader()) {
888 man->SetRun(rl->GetHeader()->GetRun());
889 rl->UnloadHeader();
890 delete rl;
891 }
892 else {
893 AliError("Neither run-loader header nor RawReader objects are found !");
894 delete rl;
895 return kFALSE;
896 }
897 }
898 }
899
900 man->Print();
901
902 return kTRUE;
903}
904
905//_____________________________________________________________________________
906void AliReconstruction::SetCDBLock() {
907 // Set CDB lock: from now on it is forbidden to reset the run number
908 // or the default storage or to activate any further storage!
909
910 AliCDBManager::Instance()->SetLock(1);
911}
912
913//_____________________________________________________________________________
914void AliReconstruction::MatchUpgradeDetector() {
915 // Translates detector name in a boolean.
916 // The boolean is used in GetReconstructor to load the
917 // upgrade reconstructor instead of the standard one.
918 for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
919 if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
920 }
921}
922//_____________________________________________________________________________
923Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
924{
925 // Read the alignment objects from CDB.
926 // Each detector is supposed to have the
927 // alignment objects in DET/Align/Data CDB path.
928 // All the detector objects are then collected,
929 // sorted by geometry level (starting from ALIC) and
930 // then applied to the TGeo geometry.
931 // Finally an overlaps check is performed.
932
933 // Load alignment data from CDB and fill fAlignObjArray
934 if(fLoadAlignFromCDB){
935
936 TString detStr = detectors;
937 TString loadAlObjsListOfDets = "";
938
939 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
940 if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
941 if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
942
943 if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
944 {
945 loadAlObjsListOfDets += fgkDetectorName[iDet];
946 loadAlObjsListOfDets += " ";
947 }
948 } // end loop over detectors
949
950 if(AliGeomManager::GetNalignable("GRP") != 0)
951 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
952 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
953 }else{
954 // Check if the array with alignment objects was
955 // provided by the user. If yes, apply the objects
956 // to the present TGeo geometry
957 if (fAlignObjArray) {
958 if (gGeoManager && gGeoManager->IsClosed()) {
959 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
960 AliError("The misalignment of one or more volumes failed!"
961 "Compare the list of simulated detectors and the list of detector alignment data!");
962 return kFALSE;
963 }
964 }
965 else {
966 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
967 return kFALSE;
968 }
969 }
970 }
971
972 if (fAlignObjArray) {
973 fAlignObjArray->Delete();
974 delete fAlignObjArray; fAlignObjArray=NULL;
975 }
976
977 return kTRUE;
978}
979
980//_____________________________________________________________________________
981void AliReconstruction::SetGAliceFile(const char* fileName)
982{
983// set the name of the galice file
984
985 fGAliceFileName = fileName;
986}
987
988//_____________________________________________________________________________
989void AliReconstruction::SetInput(const char* input)
990{
991 // In case the input string starts with 'mem://', we run in an online mode
992 // and AliRawReaderDateOnline object is created. In all other cases a raw-data
993 // file is assumed. One can give as an input:
994 // mem://: - events taken from DAQ monitoring libs online
995 // or
996 // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
997 if (input) fRawInput = input;
998}
999
1000//_____________________________________________________________________________
1001void AliReconstruction::SetOutput(const char* output)
1002{
1003 // Set the output ESD filename
1004 // 'output' is a normalt ROOT url
1005 // The method is used in case of raw-data reco with PROOF
1006 if (output) fESDOutput = output;
1007}
1008
1009//_____________________________________________________________________________
1010void AliReconstruction::SetOption(const char* detector, const char* option)
1011{
1012// set options for the reconstruction of a detector
1013
1014 TObject* obj = fOptions.FindObject(detector);
1015 if (obj) fOptions.Remove(obj);
1016 fOptions.Add(new TNamed(detector, option));
1017}
1018
1019//_____________________________________________________________________________
1020void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1021{
1022 // Set custom reconstruction parameters for a given detector
1023 // Single set of parameters for all the events
1024
1025 // First check if the reco-params are global
1026 if(!strcmp(detector, "GRP")) {
1027 par->SetAsDefault();
1028 fRecoParam.AddDetRecoParam(kNDetectors,par);
1029 return;
1030 }
1031
1032 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1033 if(!strcmp(detector, fgkDetectorName[iDet])) {
1034 par->SetAsDefault();
1035 fRecoParam.AddDetRecoParam(iDet,par);
1036 break;
1037 }
1038 }
1039
1040}
1041
1042//_____________________________________________________________________________
1043Bool_t AliReconstruction::InitGRP() {
1044 //------------------------------------
1045 // Initialization of the GRP entry
1046 //------------------------------------
1047 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1048
1049 if (entry) {
1050
1051 TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
1052
1053 if (m) {
1054 AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1055 m->Print();
1056 fGRPData = new AliGRPObject();
1057 fGRPData->ReadValuesFromMap(m);
1058 }
1059
1060 else {
1061 AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1062 fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
1063 entry->SetOwner(0);
1064 }
1065
1066 // FIX ME: The unloading of GRP entry is temporarily disabled
1067 // because ZDC and VZERO are using it in order to initialize
1068 // their reconstructor objects. In the future one has to think
1069 // of propagating AliRunInfo to the reconstructors.
1070 // AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1071 }
1072
1073 if (!fGRPData) {
1074 AliError("No GRP entry found in OCDB!");
1075 return kFALSE;
1076 }
1077
1078 TString lhcState = fGRPData->GetLHCState();
1079 if (lhcState==AliGRPObject::GetInvalidString()) {
1080 AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
1081 lhcState = "UNKNOWN";
1082 }
1083
1084 TString beamType = fGRPData->GetBeamType();
1085 if (beamType==AliGRPObject::GetInvalidString()) {
1086 AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
1087 beamType = "UNKNOWN";
1088 }
1089
1090 Float_t beamEnergy = fGRPData->GetBeamEnergy();
1091 if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
1092 AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
1093 beamEnergy = 0;
1094 }
1095
1096 TString runType = fGRPData->GetRunType();
1097 if (runType==AliGRPObject::GetInvalidString()) {
1098 AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
1099 runType = "UNKNOWN";
1100 }
1101
1102 Int_t activeDetectors = fGRPData->GetDetectorMask();
1103 if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
1104 AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
1105 activeDetectors = 1074790399;
1106 }
1107 AliDebug(1, Form("activeDetectors = %d", activeDetectors));
1108
1109 fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
1110 fRunInfo->Dump();
1111
1112
1113 // Process the list of active detectors
1114 if (activeDetectors) {
1115 UInt_t detMask = activeDetectors;
1116 AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1117 fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1118 AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1119 fRunTracking = MatchDetectorList(fRunTracking,detMask);
1120 fFillESD = MatchDetectorList(fFillESD,detMask);
1121 fQADetectors = MatchDetectorList(fQADetectors,detMask);
1122 fDeleteRecPoints = MatchDetectorList(fDeleteRecPoints,detMask);
1123 fDeleteDigits = MatchDetectorList(fDeleteDigits,detMask);
1124 fLoadCDB.Form("%s %s %s %s",
1125 fRunLocalReconstruction.Data(),
1126 fRunTracking.Data(),
1127 fFillESD.Data(),
1128 fQADetectors.Data());
1129 fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
1130 if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
1131 !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
1132 !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
1133 // switch off the vertexer
1134 AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
1135 fRunVertexFinder = kFALSE;
1136 fRunMultFinder = kFALSE;
1137 }
1138 if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1139 // switch off the reading of CTP raw-data payload
1140 if (fFillTriggerESD) {
1141 AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1142 fFillTriggerESD = kFALSE;
1143 }
1144 }
1145 }
1146
1147 AliInfo("===================================================================================");
1148 AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1149 AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1150 AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
1151 AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
1152 AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
1153 AliInfo("===================================================================================");
1154
1155 //*** Dealing with the magnetic field map
1156 if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
1157 if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
1158 AliInfo("ExpertMode!!! GRP information will be ignored !");
1159 AliInfo("ExpertMode!!! Running with the externally locked B field !");
1160 }
1161 else {
1162 AliInfo("Destroying existing B field instance!");
1163 delete TGeoGlobalMagField::Instance();
1164 }
1165 }
1166 if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
1167 // Construct the field map out of the information retrieved from GRP.
1168 Bool_t ok = kTRUE;
1169 // L3
1170 Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1171 if (l3Current == AliGRPObject::GetInvalidFloat()) {
1172 AliError("GRP/GRP/Data entry: missing value for the L3 current !");
1173 ok = kFALSE;
1174 }
1175
1176 Char_t l3Polarity = fGRPData->GetL3Polarity();
1177 if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1178 AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
1179 ok = kFALSE;
1180 }
1181
1182 // Dipole
1183 Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1184 if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1185 AliError("GRP/GRP/Data entry: missing value for the dipole current !");
1186 ok = kFALSE;
1187 }
1188
1189 Char_t diPolarity = fGRPData->GetDipolePolarity();
1190 if (diPolarity == AliGRPObject::GetInvalidChar()) {
1191 AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
1192 ok = kFALSE;
1193 }
1194
1195 // read special bits for the polarity convention and map type
1196 Int_t polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
1197 Bool_t uniformB = fGRPData->IsUniformBMap();
1198
1199 if (ok) {
1200 AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
1201 TMath::Abs(diCurrent) * (diPolarity ? -1:1),
1202 polConvention,uniformB,beamEnergy, beamType.Data());
1203 if (fld) {
1204 TGeoGlobalMagField::Instance()->SetField( fld );
1205 TGeoGlobalMagField::Instance()->Lock();
1206 AliInfo("Running with the B field constructed out of GRP !");
1207 }
1208 else AliFatal("Failed to create a B field map !");
1209 }
1210 else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1211 }
1212
1213 //*** Get the diamond profiles from OCDB
1214 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1215 if (entry) {
1216 fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1217 } else {
1218 AliError("No SPD diamond profile found in OCDB!");
1219 }
1220
1221 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1222 if (entry) {
1223 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1224 } else {
1225 AliError("No diamond profile found in OCDB!");
1226 }
1227
1228 entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1229 if (entry) {
1230 fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1231 } else {
1232 AliError("No TPC diamond profile found in OCDB!");
1233 }
1234
1235 entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1236 if (entry) {
1237 fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1238 entry->SetOwner(0);
1239 }
1240
1241 if (!fListOfCosmicTriggers) {
1242 AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1243 }
1244
1245 return kTRUE;
1246}
1247
1248//_____________________________________________________________________________
1249Bool_t AliReconstruction::LoadCDB()
1250{
1251 // Load CDB entries for all active detectors.
1252 // By default we load all the entries in <det>/Calib
1253 // folder.
1254
1255 AliCodeTimerAuto("",0);
1256
1257 AliCDBManager::Instance()->Get("GRP/CTP/Config");
1258
1259 AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
1260
1261 TString detStr = fLoadCDB;
1262 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1263 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1264 AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1265 AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
1266 }
1267
1268 // Temporary fix - one has to define the correct policy in order
1269 // to load the trigger OCDB entries only for the detectors that
1270 // in the trigger or that are needed in order to put correct
1271 // information in ESD
1272 AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
1273
1274 return kTRUE;
1275}
1276//_____________________________________________________________________________
1277Bool_t AliReconstruction::LoadTriggerScalersCDB()
1278{
1279 // Load CTP scalers from OCDB.
1280 // The scalers are checked for consistency.
1281
1282 AliCodeTimerAuto("",0);
1283
1284 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
1285
1286 if (entry) {
1287
1288 AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1289 fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1290 entry->SetOwner(0);
1291 if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
1292
1293 }
1294 return kTRUE;
1295}
1296//_____________________________________________________________________________
1297Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
1298{
1299 // Load CTP timing information (alignment)
1300 // from OCDB.
1301
1302 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
1303 if (!entry) return kFALSE;
1304
1305 AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
1306 fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
1307 entry->SetOwner(0);
1308
1309 AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
1310 if (!entry2) return kFALSE;
1311
1312 AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
1313 fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
1314 entry2->SetOwner(0);
1315
1316 return kTRUE;
1317}
1318
1319//_____________________________________________________________________________
1320Bool_t AliReconstruction::ReadIntensityInfoCDB()
1321{
1322 // Load LHC DIP data
1323 AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1324 AliCDBEntry* entryCTP = AliCDBManager::Instance()->Get("GRP/CTP/Config");
1325 //
1326 if (!entry || !entryCTP) {
1327 AliError(Form("Failed to extract CDB objects GRP/GRP/LHCData: %p or GRP/CTP/Config: %p",entry,entryCTP));
1328 return kFALSE;
1329 }
1330 // extract BC masks
1331 enum {kA,kB,kC,kE,kNMasks};
1332 AliTriggerConfiguration* conf = (AliTriggerConfiguration*)entryCTP->GetObject();
1333 const TObjArray& clArr = conf->GetClasses();
1334 TObjArray masks(kNMasks);
1335 TIter next(&clArr);
1336 AliTriggerClass* trClass = 0;
1337 int nFound = 0;
1338 masks.SetOwner(kFALSE);
1339 //
1340 while ( (trClass=(AliTriggerClass*)next()) ) {
1341 TString trName = trClass->GetName();
1342 int ind = trName.Index("-"); // prefix in front of A,B,C,E
1343 if (ind<1) continue; // anomaly
1344 //
1345 trName = trName.Data() + ind;
1346 AliTriggerBCMask* bcMask = trClass->GetBCMask();
1347 if (!bcMask) continue;
1348 UInt_t which = 0;
1349 if (trName.BeginsWith("-A-")) which |= 0x1<<kA;
1350 else if (trName.BeginsWith("-B-")) which |= 0x1<<kB;
1351 else if (trName.BeginsWith("-C-")) which |= 0x1<<kC;
1352 else if (trName.BeginsWith("-E-")) which |= 0x1<<kE;
1353 else if (trName.BeginsWith("-AC-")) which |= (0x1<<kA) | (0x1<<kC);
1354 else if (trName.BeginsWith("-CA-")) which |= (0x1<<kA) | (0x1<<kC);
1355 else { AliWarning(Form("Unknown trigger type %s\n",trClass->GetName())); continue;}
1356 //
1357 for (int ip=kNMasks;ip--;) {
1358 if ( !(which&(0x1<<ip)) || masks[ip] ) continue; // does not match or already done
1359 masks[ip] = (TObject*)bcMask;
1360 nFound++;
1361 }
1362 if (nFound==kNMasks) break;
1363 }
1364 //
1365 AliInfo("Reading mean bunch intensities from GRP/GRP/LHCData");
1366 AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1367 //
1368 for (int ib=2;ib--;) {
1369 double intI,intNI;
1370 if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI,&masks)>=0)) {
1371 fBeamInt[ib][0] = intI;
1372 fBeamInt[ib][1] = intNI;
1373 AliInfo(Form("Mean intensity for beam %d: Interacting:%.2e Non-Interacting:%.2e",ib,intI,intNI));
1374 }
1375 }
1376 return kTRUE;
1377 //
1378}
1379
1380
1381//_____________________________________________________________________________
1382Bool_t AliReconstruction::Run(const char* input)
1383{
1384 // Run Run Run
1385 AliCodeTimerAuto("",0);
1386
1387 InitRun(input);
1388 if (GetAbort() != TSelector::kContinue) return kFALSE;
1389
1390 TChain *chain = NULL;
1391 if (fRawReader && (chain = fRawReader->GetChain())) {
1392 Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
1393 // Proof mode
1394 if (gProof) {
1395 // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1396 gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
1397
1398 if (gGrid)
1399 gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1400
1401 TMessage::EnableSchemaEvolutionForAll(kTRUE);
1402 gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1403
1404 gProof->AddInput(this);
1405
1406 if (!ParseOutput()) return kFALSE;
1407
1408 gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
1409 chain->SetProof();
1410 chain->Process("AliReconstruction","",nEntries,fFirstEvent);
1411 }
1412 else {
1413 chain->Process(this,"",nEntries,fFirstEvent);
1414 }
1415 }
1416 else {
1417 Begin(NULL);
1418 if (GetAbort() != TSelector::kContinue) return kFALSE;
1419 SlaveBegin(NULL);
1420 if (GetAbort() != TSelector::kContinue) return kFALSE;
1421 //******* The loop over events
1422 AliInfo("Starting looping over events");
1423 Int_t iEvent = 0;
1424 while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1425 (fRawReader && fRawReader->NextEvent())) {
1426 //
1427 // check if process has enough resources
1428 if (!HasEnoughResources(iEvent)) break;
1429 if (!ProcessEvent(iEvent)) {
1430 Abort("ProcessEvent",TSelector::kAbortFile);
1431 return kFALSE;
1432 }
1433 iEvent++;
1434 }
1435 SlaveTerminate();
1436 if (GetAbort() != TSelector::kContinue) return kFALSE;
1437 Terminate();
1438 if (GetAbort() != TSelector::kContinue) return kFALSE;
1439 }
1440
1441 return kTRUE;
1442}
1443
1444//_____________________________________________________________________________
1445void AliReconstruction::InitRawReader(const char* input)
1446{
1447 // Init raw-reader and
1448 // set the input in case of raw data
1449
1450 AliCodeTimerAuto("",0);
1451
1452 if (input) fRawInput = input;
1453 fRawReader = AliRawReader::Create(fRawInput.Data());
1454 if (!fRawReader) {
1455 if (fRawInput.IsNull()) {
1456 AliInfo("Reconstruction will run over digits");
1457 }
1458 else {
1459 AliFatal("Can not create raw-data reader ! Exiting...");
1460 }
1461 }
1462
1463 if (!fEquipIdMap.IsNull() && fRawReader)
1464 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1465
1466 if (!fUseHLTData.IsNull()) {
1467 // create the RawReaderHLT which performs redirection of HLT input data for
1468 // the specified detectors
1469 AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1470 if (pRawReader) {
1471 fParentRawReader=fRawReader;
1472 fRawReader=pRawReader;
1473 } else {
1474 AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1475 }
1476 }
1477 AliSysInfo::AddStamp("CreateRawReader");
1478}
1479
1480//_____________________________________________________________________________
1481void AliReconstruction::InitRun(const char* input)
1482{
1483 // Initialization of raw-reader,
1484 // run number, CDB etc.
1485 AliCodeTimerAuto("",0);
1486 AliSysInfo::AddStamp("Start");
1487
1488 // Initialize raw-reader if any
1489 InitRawReader(input);
1490
1491 // Initialize the CDB storage
1492 InitCDB();
1493
1494 // Set run number in CDBManager (if it is not already set by the user)
1495 if (!SetRunNumberFromData()) {
1496 Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1497 return;
1498 }
1499
1500 if(fFromCDBSnapshot){
1501 AliDebug(2,"Initializing from a CDB snapshot");
1502 if(!AliCDBManager::Instance()->InitFromSnapshot(fSnapshotFileName.Data()))
1503 AliFatal("Was not able to initialize from the snapshot!");
1504 }
1505 // Set CDB lock: from now on it is forbidden to reset the run number
1506 // or the default storage or to activate any further storage!
1507 SetCDBLock();
1508
1509}
1510
1511//_____________________________________________________________________________
1512void AliReconstruction::Begin(TTree *)
1513{
1514 // Initialize AlReconstruction before
1515 // going into the event loop
1516 // Should follow the TSelector convention
1517 // i.e. initialize only the object on the client side
1518 AliCodeTimerAuto("",0);
1519
1520 AliReconstruction *reco = NULL;
1521 if (fInput) {
1522 if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1523 *this = *reco;
1524 }
1525 AliSysInfo::AddStamp("ReadInputInBegin");
1526 }
1527
1528 // Import ideal TGeo geometry and apply misalignment
1529 if (!gGeoManager) {
1530 TString geom(gSystem->DirName(fGAliceFileName));
1531 geom += "/geometry.root";
1532 AliGeomManager::LoadGeometry(geom.Data());
1533 if (!gGeoManager) {
1534 Abort("LoadGeometry", TSelector::kAbortProcess);
1535 return;
1536 }
1537 AliSysInfo::AddStamp("LoadGeom");
1538 TString detsToCheck=fRunLocalReconstruction;
1539 if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1540 Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1541 return;
1542 }
1543 AliSysInfo::AddStamp("CheckGeom");
1544 }
1545
1546 Bool_t toCDBSnapshot=kFALSE;
1547 TString snapshotFileOut(""); // we could use fSnapshotFileName if we are not interested
1548 // in reading from and writing to a snapshot file at the same time
1549 if(TString(gSystem->Getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
1550 toCDBSnapshot=kTRUE;
1551 //fFromCDBSnapshot=kFALSE;
1552 TString snapshotFile(gSystem->Getenv("OCDB_SNAPSHOT_FILENAME"));
1553 if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
1554 snapshotFileOut = snapshotFile;
1555 else
1556 snapshotFileOut="OCDB.root";
1557 }
1558
1559 if (!MisalignGeometry(fLoadAlignData)) {
1560 Abort("MisalignGeometry", TSelector::kAbortProcess);
1561 return;
1562 }
1563 AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1564 if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1565 AliSysInfo::AddStamp("MisalignGeom");
1566
1567 if (!InitGRP()) {
1568 Abort("InitGRP", TSelector::kAbortProcess);
1569 return;
1570 }
1571 AliSysInfo::AddStamp("InitGRP");
1572 if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1573
1574 if(!fFromCDBSnapshot){
1575 if (!LoadCDB()) {
1576 Abort("LoadCDB", TSelector::kAbortProcess);
1577 return;
1578 }
1579 AliSysInfo::AddStamp("LoadCDB");
1580 }
1581
1582 if (!LoadTriggerScalersCDB()) {
1583 Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1584 return;
1585 }
1586 AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1587
1588 if (!LoadCTPTimeParamsCDB()) {
1589 Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1590 return;
1591 }
1592 AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
1593
1594 if (!ReadIntensityInfoCDB()) {
1595 Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1596 return;
1597 }
1598 AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1599
1600 // Read the reconstruction parameters from OCDB
1601 if (!InitRecoParams()) {
1602 AliWarning("Not all detectors have correct RecoParam objects initialized");
1603 }
1604 AliSysInfo::AddStamp("InitRecoParams");
1605
1606 if(toCDBSnapshot)
1607 AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
1608 AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1609 AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1610
1611 if (fInput && gProof) {
1612 if (reco) *reco = *this;
1613
1614 gGeoManager->SetName("Geometry");
1615 gProof->AddInputData(gGeoManager,kTRUE);
1616 gGeoManager = NULL;
1617 gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
1618 fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1619 AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1620 magFieldMap->SetName("MagneticFieldMap");
1621 gProof->AddInputData(magFieldMap,kTRUE);
1622 if (fAnalysis) {
1623 fAnalysis->SetName("Analysis");
1624 gProof->AddInputData(fAnalysis,kTRUE);
1625 }
1626 }
1627
1628}
1629
1630//_____________________________________________________________________________
1631void AliReconstruction::SlaveBegin(TTree*)
1632{
1633 // Initialization related to run-loader,
1634 // vertexer, trackers, recontructors
1635 // In proof mode it is executed on the slave
1636 AliCodeTimerAuto("",0);
1637
1638 TProofOutputFile *outProofFile = NULL;
1639 if (fInput) {
1640 if (AliDebugLevel() > 0) fInput->Print();
1641 if (AliDebugLevel() > 10) fInput->Dump();
1642 if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1643 *this = *reco;
1644 }
1645 if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1646 gGeoManager = tgeo;
1647 AliGeomManager::SetGeometry(tgeo);
1648 }
1649 if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1650 Int_t runNumber = -1;
1651 if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1652 AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1653 man->SetCacheFlag(kTRUE);
1654 man->SetLock(kTRUE);
1655 man->Print();
1656 }
1657 }
1658 if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1659 AliMagF *newMap = new AliMagF(*map);
1660 if (!newMap->LoadParameterization()) {
1661 Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1662 return;
1663 }
1664 TGeoGlobalMagField::Instance()->SetField(newMap);
1665 TGeoGlobalMagField::Instance()->Lock();
1666 }
1667 if (!fAnalysis) {
1668 // Attempt to get the analysis manager from the input list
1669 fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
1670 if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
1671 }
1672 if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1673 fProofOutputFileName = outputFileName->GetTitle();
1674 if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1675 fProofOutputLocation = outputLocation->GetTitle();
1676 if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1677 fProofOutputDataset = kTRUE;
1678 if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1679 fProofOutputArchive = archiveList->GetTitle();
1680 if (!fProofOutputFileName.IsNull() &&
1681 !fProofOutputLocation.IsNull() &&
1682 fProofOutputArchive.IsNull()) {
1683 if (!fProofOutputDataset) {
1684 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1685 outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1686 }
1687 else {
1688 outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1689 }
1690 if (AliDebugLevel() > 0) outProofFile->Dump();
1691 fOutput->Add(outProofFile);
1692 }
1693 AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1694 }
1695 // Check if analysis was requested in the reconstruction event loop
1696 if (!fAnalysis) {
1697 // Attempt to connect in-memory singleton
1698 fAnalysis = AliAnalysisManager::GetAnalysisManager();
1699 if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
1700 // Check if an analysis macro was specified
1701 if (!fAnalysis && !fAnalysisMacro.IsNull()) {
1702 // Run specified analysis macro
1703 gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
1704 fAnalysis = AliAnalysisManager::GetAnalysisManager();
1705 if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
1706 else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====",
1707 fAnalysis->GetName(), fAnalysisMacro.Data()));
1708 }
1709 }
1710
1711 // get the run loader
1712 if (!InitRunLoader()) {
1713 Abort("InitRunLoader", TSelector::kAbortProcess);
1714 return;
1715 }
1716 AliSysInfo::AddStamp("LoadLoader");
1717
1718 ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1719
1720 // get trackers
1721 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1722 Abort("CreateTrackers", TSelector::kAbortProcess);
1723 return;
1724 }
1725 AliSysInfo::AddStamp("CreateTrackers");
1726
1727 // create the ESD output file and tree
1728 if (!outProofFile) {
1729 ffile = TFile::Open("AliESDs.root", "RECREATE");
1730 ffile->SetCompressionLevel(2);
1731 if (!ffile->IsOpen()) {
1732 Abort("OpenESDFile", TSelector::kAbortProcess);
1733 return;
1734 }
1735 }
1736 else {
1737 AliInfo(Form("Opening output PROOF file: %s/%s",
1738 outProofFile->GetDir(), outProofFile->GetFileName()));
1739 if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1740 Abort(Form("Problems opening output PROOF file: %s/%s",
1741 outProofFile->GetDir(), outProofFile->GetFileName()),
1742 TSelector::kAbortProcess);
1743 return;
1744 }
1745 }
1746
1747 ftree = new TTree("esdTree", "Tree with ESD objects");
1748 fesd = new AliESDEvent();
1749 fesd->CreateStdContent();
1750 // add a so far non-std object to the ESD, this will
1751 // become part of the std content
1752 fesd->AddObject(new AliESDHLTDecision);
1753
1754 fesd->WriteToTree(ftree);
1755 if (fWriteESDfriend) {
1756 ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
1757 ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
1758 fesdf = new AliESDfriend();
1759 ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
1760 fesd->AddObject(fesdf);
1761 ffile->cd();
1762 }
1763 ftree->GetUserInfo()->Add(fesd);
1764
1765 fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1766 fhltesd = new AliESDEvent();
1767 fhltesd->CreateStdContent();
1768 // read the ESD template from CDB
1769 // HLT is allowed to put non-std content to its ESD, the non-std
1770 // objects need to be created before invocation of WriteToTree in
1771 // order to create all branches. Initialization is done from an
1772 // ESD layout template in CDB
1773 AliCDBManager* man = AliCDBManager::Instance();
1774 AliCDBPath hltESDConfigPath("HLT/Calib/esdLayout");
1775 AliCDBEntry* hltESDConfig=NULL;
1776 if (man->GetId(hltESDConfigPath)!=NULL)
1777 hltESDConfig=man->Get(hltESDConfigPath);
1778 if (!hltESDConfig) {
1779 // try the alternative path
1780 // in Feb 2012 the object has been moved from ConfigHLT to Calib
1781 AliCDBPath hltESDConfigLegacyPath("HLT/ConfigHLT/esdLayout");
1782 AliInfo(Form("can not find HLT ESD config object in %s, trying legacy path %s",
1783 hltESDConfigPath.GetPath().Data(),
1784 hltESDConfigLegacyPath.GetPath().Data()));
1785 hltESDConfig=man->Get(hltESDConfigLegacyPath);
1786 }
1787 if (hltESDConfig) {
1788 AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1789 if (pESDLayout) {
1790 // init all internal variables from the list of objects
1791 pESDLayout->GetStdContent();
1792
1793 // copy content and create non-std objects
1794 *fhltesd=*pESDLayout;
1795 fhltesd->Reset();
1796 } else {
1797 AliError(Form("error setting hltEsd layout from %s: invalid object type",
1798 hltESDConfigPath.GetPath().Data()));
1799 }
1800 }
1801
1802 fhltesd->WriteToTree(fhlttree);
1803 fhlttree->GetUserInfo()->Add(fhltesd);
1804
1805 ProcInfo_t procInfo;
1806 gSystem->GetProcInfo(&procInfo);
1807 AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
1808
1809 //QA
1810 //Initialize the QA and start of cycle
1811 if (fRunQA || fRunGlobalQA)
1812 InitQA() ;
1813
1814 //Initialize the Plane Efficiency framework
1815 if (fRunPlaneEff && !InitPlaneEff()) {
1816 Abort("InitPlaneEff", TSelector::kAbortProcess);
1817 return;
1818 }
1819
1820 if (strcmp(gProgName,"alieve") == 0)
1821 fRunAliEVE = InitAliEVE();
1822 // If we have an analysis manager, connect the AliRecoInputHandler here
1823 if (fAnalysis) {
1824 if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
1825 AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
1826 \n ->Replacing with AliRecoInputHandler instance.");
1827 delete fAnalysis->GetInputEventHandler();
1828 }
1829 // Set the event and other data pointers
1830 fRecoHandler = new AliRecoInputHandler();
1831// fRecoHandler->Init(ftree, "LOCAL");
1832 fRecoHandler->SetEvent(fesd);
1833 fRecoHandler->SetESDfriend(fesdf);
1834 fRecoHandler->SetHLTEvent(fhltesd);
1835 fRecoHandler->SetHLTTree(fhlttree);
1836 fAnalysis->SetInputEventHandler(fRecoHandler);
1837 // Enter external loop mode
1838 fAnalysis->SetExternalLoop(kTRUE);
1839 // Initialize analysis
1840 fAnalysis->SlaveBegin(ftree);
1841 fAnalysis->StartAnalysis("local", (TTree*)0);
1842 // Connect ESD tree with the input container
1843 fAnalysis->GetCommonInputContainer()->SetData(ftree);
1844 }
1845 return;
1846}
1847
1848//_____________________________________________________________________________
1849Bool_t AliReconstruction::Process(Long64_t entry)
1850{
1851 // run the reconstruction over a single entry
1852 // from the chain with raw data
1853 AliCodeTimerAuto("",0);
1854
1855 TTree *currTree = fChain->GetTree();
1856 AliRawVEvent *event = NULL;
1857 currTree->SetBranchAddress("rawevent",&event);
1858 currTree->GetEntry(entry);
1859 fRawReader = new AliRawReaderRoot(event);
1860 // check if process has enough resources
1861 if (!HasEnoughResources(entry)) return kFALSE;
1862 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1863 delete fRawReader;
1864 fRawReader = NULL;
1865 delete event;
1866
1867 return fStatus;
1868}
1869
1870//_____________________________________________________________________________
1871void AliReconstruction::Init(TTree *tree)
1872{
1873 // Implementation of TSelector::Init()
1874 // method
1875 if (tree == 0) {
1876 AliError("The input tree is not found!");
1877 return;
1878 }
1879 fChain = tree;
1880}
1881
1882//_____________________________________________________________________________
1883Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1884{
1885 // run the reconstruction over a single event
1886 // The event loop is steered in Run method
1887
1888
1889 static Long_t oldMres=0;
1890 static Long_t oldMvir=0;
1891 static Float_t oldCPU=0;
1892 static Long_t aveDMres=0;
1893 static Long_t aveDMvir=0;
1894 static Float_t aveDCPU=0;
1895
1896 AliCodeTimerAuto("",0);
1897
1898 AliESDpid pid;
1899
1900 AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
1901
1902 if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1903 fRunLoader->SetEventNumber(iEvent);
1904 if (fRawReader)
1905 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1906 iEvent, iEvent);
1907 fRunLoader->TreeE()->Fill();
1908
1909 if (fRawReader && fRawReader->UseAutoSaveESD())
1910 fRunLoader->TreeE()->AutoSave("SaveSelf");
1911 }
1912
1913 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1914 return kTRUE;
1915 }
1916
1917
1918 fRunLoader->GetEvent(iEvent);
1919
1920 // Fill Event-info object
1921 GetEventInfo();
1922 fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
1923
1924 ProcInfo_t procInfo;
1925 if(iEvent==fFirstEvent) {
1926 gSystem->GetProcInfo(&procInfo);
1927 oldMres=procInfo.fMemResident;
1928 oldMvir=procInfo.fMemVirtual;
1929 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
1930 }
1931 AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
1932
1933 AliSysInfo::AddStamp(Form("StartReco_%d",iEvent), 0,0,iEvent);
1934
1935 // Set the reco-params
1936 {
1937 TString detStr = fLoadCDB;
1938 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1939 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1940 AliReconstructor *reconstructor = GetReconstructor(iDet);
1941 if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1942 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1943 reconstructor->SetRecoParam(par);
1944 reconstructor->GetPidSettings(&pid);
1945 reconstructor->SetEventInfo(&fEventInfo);
1946 if (fRunQA) {
1947 AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
1948 AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
1949 if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
1950 }
1951 }
1952 }
1953 //
1954 if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
1955 //
1956 if (fRunQA) {
1957 const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
1958 AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
1959 AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
1960 }
1961 }
1962
1963 // QA on single raw
1964 if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
1965 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1966 AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
1967 AliSysInfo::AddStamp(Form("RawQA_%d",iEvent), 0,0,iEvent);
1968 }
1969 // local single event reconstruction
1970 if (!fRunLocalReconstruction.IsNull()) {
1971 TString detectors=fRunLocalReconstruction;
1972 // run HLT event reconstruction first
1973 // ;-( IsSelected changes the string
1974 if (IsSelected("HLT", detectors) &&
1975 !RunLocalEventReconstruction("HLT")) {
1976 if (fStopOnError) {CleanUp(); return kFALSE;}
1977 }
1978 detectors=fRunLocalReconstruction;
1979 detectors.ReplaceAll("HLT", "");
1980 if (!RunLocalEventReconstruction(detectors)) {
1981 if (fStopOnError) {
1982 CleanUp();
1983 return kFALSE;
1984 }
1985 }
1986 }
1987
1988
1989 // fill Event header information from the RawEventHeader
1990 if (fRawReader){FillRawEventHeaderESD(fesd);}
1991 if (fRawReader){FillRawEventHeaderESD(fhltesd);}
1992
1993 fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1994 fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1995
1996 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1997 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1998 ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1999 ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
2000
2001 fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
2002 fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
2003
2004 fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
2005 fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
2006
2007 // Set magnetic field from the tracker
2008 fesd->SetMagneticField(AliTracker::GetBz());
2009 fhltesd->SetMagneticField(AliTracker::GetBz());
2010 //
2011 AliESDRun *esdRun,*esdRunH;
2012 esdRun = (AliESDRun*)fesd->GetESDRun();
2013 esdRunH = (AliESDRun*)fhltesd->GetESDRun();
2014 esdRun->SetBeamEnergyIsSqrtSHalfGeV();
2015 esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
2016 //
2017 for (int ib=2;ib--;) for (int it=2;it--;) {
2018 esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
2019 esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
2020 }
2021 //
2022 fesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2023 fesd->SetBeamType(fGRPData->GetBeamType().Data());
2024 fesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2025 fesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2026 fhltesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2027 fhltesd->SetBeamType(fGRPData->GetBeamType().Data());
2028 fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2029 fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2030 //
2031 AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2032 if (fld) { // set info needed for field initialization
2033 fesd->SetCurrentL3(fld->GetCurrentSol());
2034 fesd->SetCurrentDip(fld->GetCurrentDip());
2035 fesd->SetUniformBMap(fld->IsUniform());
2036 fesd->SetBInfoStored();
2037 //
2038 fhltesd->SetCurrentL3(fld->GetCurrentSol());
2039 fhltesd->SetCurrentDip(fld->GetCurrentDip());
2040 fhltesd->SetUniformBMap(fld->IsUniform());
2041 fhltesd->SetBInfoStored();
2042 }
2043 //
2044 // Set most probable pt, for B=0 tracking
2045 // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
2046 const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
2047 if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
2048
2049 // Fill raw-data error log into the ESD
2050 if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2051
2052 AliSysInfo::AddStamp(Form("FillHeadErrs_%d",iEvent), 0,0,iEvent);
2053
2054 // vertex finder
2055 if (fRunVertexFinder) {
2056 if (!RunVertexFinder(fesd)) {
2057 if (fStopOnError) {CleanUp(); return kFALSE;}
2058 }
2059 AliSysInfo::AddStamp(Form("VtxFinder_%d",iEvent), 0,0,iEvent);
2060 }
2061
2062 // For Plane Efficiency: run the SPD trackleter
2063 if (fRunPlaneEff && fSPDTrackleter) {
2064 if (!RunSPDTrackleting(fesd)) {
2065 if (fStopOnError) {CleanUp(); return kFALSE;}
2066 }
2067 AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
2068 }
2069
2070 // Muon tracking
2071 if (!fRunTracking.IsNull()) {
2072 if (fRunMuonTracking) {
2073 if (!RunMuonTracking(fesd)) {
2074 if (fStopOnError) {CleanUp(); return kFALSE;}
2075 }
2076 }
2077 AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);
2078 }
2079
2080 // barrel tracking
2081 if (!fRunTracking.IsNull()) {
2082 if (!RunTracking(fesd,pid)) {
2083 if (fStopOnError) {CleanUp(); return kFALSE;}
2084 }
2085 }
2086
2087 // fill ESD
2088 if (!fFillESD.IsNull()) {
2089 TString detectors=fFillESD;
2090 // run HLT first and on hltesd
2091 // ;-( IsSelected changes the string
2092 if (IsSelected("HLT", detectors) &&
2093 !FillESD(fhltesd, "HLT")) {
2094 if (fStopOnError) {CleanUp(); return kFALSE;}
2095 }
2096 detectors=fFillESD;
2097 // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
2098 if (detectors.Contains("ALL")) {
2099 detectors="";
2100 for (Int_t idet=0; idet<kNDetectors; ++idet){
2101 detectors += fgkDetectorName[idet];
2102 detectors += " ";
2103 }
2104 }
2105 detectors.ReplaceAll("HLT", "");
2106 if (!FillESD(fesd, detectors)) {
2107 if (fStopOnError) {CleanUp(); return kFALSE;}
2108 }
2109 }
2110
2111
2112 ffile->cd();
2113
2114 //
2115 // Propagate track to the beam pipe (if not already done by ITS)
2116 //
2117 const Int_t ntracks = fesd->GetNumberOfTracks();
2118 const Double_t kRadius = 2.8; //something less than the beam pipe radius
2119
2120 TObjArray trkArray;
2121 UShort_t selectedIdx[ntracks];
2122
2123 for (Int_t itrack=0; itrack<ntracks; itrack++){
2124 const Double_t kMaxStep = 1; //max step over the material
2125 Bool_t ok;
2126
2127 AliESDtrack *track = fesd->GetTrack(itrack);
2128 if (!track) continue;
2129
2130 AliExternalTrackParam *tpcTrack =
2131 (AliExternalTrackParam *)track->GetTPCInnerParam();
2132 ok = kFALSE;
2133 if (tpcTrack)
2134 ok = AliTracker::
2135 PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
2136
2137 if (ok) {
2138 Int_t n=trkArray.GetEntriesFast();
2139 selectedIdx[n]=track->GetID();
2140 trkArray.AddLast(tpcTrack);
2141 }
2142
2143 //Tracks refitted by ITS should already be at the SPD vertex
2144 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
2145
2146 AliTracker::
2147 PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
2148 Double_t x[3]; track->GetXYZ(x);
2149 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2150 track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
2151
2152 }
2153 AliSysInfo::AddStamp(Form("RelToSPDVtx_%d",iEvent), 0,0,iEvent);
2154 //
2155 // Improve the reconstructed primary vertex position using the tracks
2156 //
2157 Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
2158 if(fesd->GetPrimaryVertexSPD()) {
2159 TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
2160 if(vtitle.Contains("cosmics")) {
2161 runVertexFinderTracks=kFALSE;
2162 }
2163 }
2164
2165 if (runVertexFinderTracks) {
2166 // TPC + ITS primary vertex
2167 ftVertexer->SetITSMode();
2168 ftVertexer->SetConstraintOff();
2169 // get cuts for vertexer from AliGRPRecoParam
2170 Bool_t constrSPD=kFALSE;
2171 if (grpRecoParam) {
2172 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2173 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2174 grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
2175 ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2176 delete [] cutsVertexer; cutsVertexer = NULL;
2177 if(grpRecoParam->GetVertexerTracksConstraintITS()) {
2178 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
2179 ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
2180 }else{
2181 if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2182 ftVertexer->SetVtxStart(fDiamondProfileSPD);
2183 constrSPD=kTRUE;
2184 }
2185 }
2186 }
2187 }
2188 AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
2189 if (pvtx) {
2190 if(constrSPD){
2191 TString title=pvtx->GetTitle();
2192 title.Append("SPD");
2193 pvtx->SetTitle(title);
2194 }
2195 if (pvtx->GetStatus()) {
2196 fesd->SetPrimaryVertexTracks(pvtx);
2197 for (Int_t i=0; i<ntracks; i++) {
2198 AliESDtrack *t = fesd->GetTrack(i);
2199 Double_t x[3]; t->GetXYZ(x);
2200 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2201 t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
2202 }
2203 }
2204 delete pvtx; pvtx=NULL;
2205 }
2206 AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);
2207
2208 // TPC-only primary vertex
2209 ftVertexer->SetTPCMode();
2210 ftVertexer->SetConstraintOff();
2211 // get cuts for vertexer from AliGRPRecoParam
2212 if (grpRecoParam) {
2213 Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2214 Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2215 grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
2216 ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2217 delete [] cutsVertexer; cutsVertexer = NULL;
2218 if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) {
2219 if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
2220 }
2221 }
2222 pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
2223 if (pvtx) {
2224 if (pvtx->GetStatus()) {
2225 fesd->SetPrimaryVertexTPC(pvtx);
2226 for (Int_t i=0; i<ntracks; i++) {
2227 AliESDtrack *t = fesd->GetTrack(i);
2228 Double_t x[3]; t->GetXYZ(x);
2229 Double_t b[3]; AliTracker::GetBxByBz(x,b);
2230 t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
2231 }
2232 }
2233 delete pvtx; pvtx=NULL;
2234 }
2235 AliSysInfo::AddStamp(Form("VtxTPC_%d",iEvent), 0,0,iEvent);
2236
2237 }
2238
2239 if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2240 else fesd->SetDiamond(fDiamondProfileSPD);
2241
2242 if (fRunV0Finder) {
2243 // V0 finding
2244 AliV0vertexer vtxer;
2245 // get cuts for V0vertexer from AliGRPRecoParam
2246 if (grpRecoParam) {
2247 Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2248 Double_t cutsV0vertexer[nCutsV0vertexer];
2249 grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2250 vtxer.SetCuts(cutsV0vertexer);
2251 }
2252 vtxer.Tracks2V0vertices(fesd);
2253 AliSysInfo::AddStamp(Form("V0Finder_%d",iEvent), 0,0,iEvent);
2254
2255 if (fRunCascadeFinder) {
2256 // Cascade finding
2257 AliCascadeVertexer cvtxer;
2258 // get cuts for CascadeVertexer from AliGRPRecoParam
2259 if (grpRecoParam) {
2260 Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2261 Double_t cutsCascadeVertexer[nCutsCascadeVertexer];
2262 grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2263 cvtxer.SetCuts(cutsCascadeVertexer);
2264 }
2265 cvtxer.V0sTracks2CascadeVertices(fesd);
2266 AliSysInfo::AddStamp(Form("CascadeFinder_%d",iEvent), 0,0,iEvent);
2267 }
2268 }
2269
2270 // AdC+FN
2271 if (fReconstructor[3])
2272 GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
2273
2274 // combined PID
2275 pid.MakePID(fesd);
2276
2277 if (fFillTriggerESD) {
2278 if (!FillTriggerESD(fesd)) {
2279 if (fStopOnError) {CleanUp(); return kFALSE;}
2280 }
2281 }
2282 // Always fill scalers
2283 if (!FillTriggerScalers(fesd)) {
2284 if (fStopOnError) {CleanUp(); return kFALSE;}
2285 }
2286
2287 AliSysInfo::AddStamp(Form("FillVaria_%d",iEvent), 0,0,iEvent);
2288
2289 // write ESD
2290 UInt_t specie = fesd->GetEventSpecie();
2291 Bool_t keepAll = (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib);
2292 if (fCleanESD && (!keepAll) ) {
2293 CleanESD(fesd);
2294 AliSysInfo::AddStamp(Form("CleanESD_%d",iEvent), 0,0,iEvent);
2295 }
2296 //
2297 // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
2298 // tracks interpreted as primary, this step should be done in the very end, when full
2299 // ESD info is available (particulalry, V0s)
2300 // vertex finder
2301 if (fRunMultFinder) {
2302 if (!RunMultFinder(fesd)) {
2303 if (fStopOnError) {CleanUp(); return kFALSE;}
2304 }
2305 AliSysInfo::AddStamp(Form("MultFinder_%d",iEvent), 0,0,iEvent);
2306 }
2307
2308 if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
2309 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2310 AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
2311 AliSysInfo::AddStamp(Form("RunQA_%d",iEvent), 0,0,iEvent);
2312 }
2313 if (fRunGlobalQA) {
2314 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2315 if (qadm)
2316 qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2317 if (qadm && IsInTasks(AliQAv1::kESDS))
2318 qadm->Exec(AliQAv1::kESDS, fesd);
2319 AliSysInfo::AddStamp(Form("RunGlobQA_%d",iEvent), 0,0,iEvent);
2320 }
2321
2322 // copy HLT decision from HLTesd to esd
2323 // the most relevant information is stored in a reduced container in the esd,
2324 // while the full information can be found in the HLTesd
2325 TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2326 TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2327 if (pHLTSrc && pHLTTgt) {
2328 pHLTSrc->Copy(*pHLTTgt);
2329 }
2330 //
2331 // Perform analysis of this event if requested
2332 // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
2333 if (fAnalysis) {
2334 fRecoHandler->BeginEvent(iEvent);
2335 fAnalysis->ExecAnalysis();
2336 fRecoHandler->FinishEvent();
2337 AliSysInfo::AddStamp(Form("Analysis_%d",iEvent), 0,0,iEvent);
2338 }
2339 //
2340 if (fWriteESDfriend) {
2341 fesd->GetESDfriend(fesdf);
2342 AliSysInfo::AddStamp(Form("CreateFriend_%d",iEvent), 0,0,iEvent);
2343
2344 }
2345 //
2346 ftree->Fill();
2347 AliSysInfo::AddStamp(Form("ESDFill_%d",iEvent), 0,0,iEvent);
2348 //
2349 if (fWriteESDfriend) {
2350 WriteESDfriend();
2351 AliSysInfo::AddStamp(Form("WriteFriend_%d",iEvent), 0,0,iEvent);
2352 }
2353 //
2354 //
2355 // Auto-save the ESD tree in case of prompt reco @P2
2356 if (fRawReader && fRawReader->UseAutoSaveESD()) {
2357 ftree->AutoSave("SaveSelf");
2358 if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
2359 }
2360 // write HLT ESD
2361 fhlttree->Fill();
2362
2363 // call AliEVE
2364 if (fRunAliEVE) RunAliEVE();
2365 //
2366 fesd->Reset();
2367 fhltesd->Reset();
2368 if (fWriteESDfriend) {
2369 fesdf->~AliESDfriend();
2370 new (fesdf) AliESDfriend(); // Reset...
2371 }
2372
2373 gSystem->GetProcInfo(&procInfo);
2374 Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
2375 Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
2376 Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
2377 aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
2378 aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
2379 aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
2380 AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
2381 iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
2382 oldMres=procInfo.fMemResident;
2383 oldMvir=procInfo.fMemVirtual;
2384 oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2385
2386 fEventInfo.Reset();
2387 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2388 if (fReconstructor[iDet]) {
2389 fReconstructor[iDet]->SetRecoParam(NULL);
2390 fReconstructor[iDet]->SetEventInfo(NULL);
2391 }
2392 if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
2393 }
2394
2395 if (fRunQA || fRunGlobalQA)
2396 AliQAManager::QAManager()->Increment() ;
2397
2398 DeleteRecPoints(fDeleteRecPoints);
2399 DeleteDigits(fDeleteDigits);
2400 //
2401 return kTRUE;
2402}
2403
2404//_____________________________________________________________________________
2405void AliReconstruction::SlaveTerminate()
2406{
2407 // Finalize the run on the slave side
2408 // Called after the exit
2409 // from the event loop
2410 AliCodeTimerAuto("",0);
2411 // If analysis was done during reconstruction, we need to call SlaveTerminate for it
2412 if (fAnalysis) {
2413 fAnalysis->PackOutput(fOutput);
2414 fAnalysis->SetSkipTerminate(kTRUE);
2415 fAnalysis->Terminate();
2416 }
2417
2418 if (fIsNewRunLoader) { // galice.root didn't exist
2419 fRunLoader->WriteHeader("OVERWRITE");
2420 fRunLoader->WriteTrigger("OVERWRITE");
2421 fRunLoader->CdGAFile();
2422 fRunLoader->Write(0, TObject::kOverwrite);
2423 }
2424
2425 const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
2426 const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
2427
2428 TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2429 cdbMapCopy->SetOwner(1);
2430 cdbMapCopy->SetName("cdbMap");
2431 TIter iter(cdbMap->GetTable());
2432
2433 TPair* pair = 0;
2434 while((pair = dynamic_cast<TPair*> (iter.Next()))){
2435 TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
2436 TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2437 if (keyStr && valStr)
2438 cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
2439 }
2440
2441 TList *cdbListCopy = new TList();
2442 cdbListCopy->SetOwner(1);
2443 cdbListCopy->SetName("cdbList");
2444
2445 TIter iter2(cdbList);
2446
2447 AliCDBId* id=0;
2448 while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
2449 cdbListCopy->Add(new TObjString(id->ToString().Data()));
2450 }
2451
2452 ftree->GetUserInfo()->Add(cdbMapCopy);
2453 ftree->GetUserInfo()->Add(cdbListCopy);
2454
2455 // Add the AliRoot version that created this file
2456 TString sVersion("aliroot ");
2457 sVersion += ALIROOT_SVN_BRANCH;
2458 sVersion += ":";
2459 sVersion += ALIROOT_SVN_REVISION;
2460 sVersion += "; root ";
2461 sVersion += ROOT_SVN_BRANCH;
2462 sVersion += ":";
2463 sVersion += ROOT_SVN_REVISION;
2464 sVersion += "; metadata ";
2465 sVersion += gSystem->Getenv("PRODUCTION_METADATA");
2466
2467
2468 TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
2469 ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
2470
2471 ffile->cd();
2472
2473 // we want to have only one tree version number
2474 ftree->Write(ftree->GetName(),TObject::kOverwrite);
2475 fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2476
2477 if (fWriteESDfriend) {
2478 ffileF->cd();
2479 ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2480 }
2481
2482// Finish with Plane Efficiency evaluation: before of CleanUp !!!
2483 if (fRunPlaneEff && !FinishPlaneEff()) {
2484 AliWarning("Finish PlaneEff evaluation failed");
2485 }
2486
2487 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2488 if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
2489 }
2490 // End of cycle for the in-loop
2491
2492 if (fRunQA || fRunGlobalQA) {
2493 AliQAManager::QAManager()->EndOfCycle() ;
2494 if (fInput &&
2495 !fProofOutputLocation.IsNull() &&
2496 fProofOutputArchive.IsNull() &&
2497 !fProofOutputDataset) {
2498 TString qaOutputFile(Form("%sMerged.%s.Data.root",
2499 fProofOutputLocation.Data(),
2500 AliQAv1::GetQADataFileName()));
2501 TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2502 AliQAv1::GetQADataFileName()));
2503 qaProofFile->SetOutputFileName(qaOutputFile.Data());
2504 if (AliDebugLevel() > 0) qaProofFile->Dump();
2505 fOutput->Add(qaProofFile);
2506 MergeQA(qaProofFile->GetFileName());
2507 }
2508 else {
2509 MergeQA();
2510 }
2511 }
2512
2513 gROOT->cd();
2514 CleanUp();
2515
2516 if (fInput) {
2517 if (!fProofOutputFileName.IsNull() &&
2518 !fProofOutputLocation.IsNull() &&
2519 fProofOutputDataset &&
2520 !fProofOutputArchive.IsNull()) {
2521 TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2522 "DROV",
2523 fProofOutputLocation.Data());
2524 if (AliDebugLevel() > 0) zipProofFile->Dump();
2525 fOutput->Add(zipProofFile);
2526 TString fileList(fProofOutputArchive.Data());
2527 fileList.ReplaceAll(","," ");
2528 TString command;
2529#if ROOT_SVN_REVISION >= 30174
2530 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2531#else
2532 command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2533#endif
2534 AliInfo(Form("Executing: %s",command.Data()));
2535 gSystem->Exec(command.Data());
2536 }
2537 }
2538}
2539
2540//_____________________________________________________________________________
2541void AliReconstruction::Terminate()
2542{
2543 // Create tags for the events in the ESD tree (the ESD tree is always present)
2544 // In case of empty events the tags will contain dummy values
2545 AliCodeTimerAuto("",0);
2546
2547 // Do not call the ESD tag creator in case of PROOF-based reconstruction
2548 if (!fInput) {
2549 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2550 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2551 delete esdtagCreator;
2552 }
2553
2554 // Cleanup of CDB manager: cache and active storages!
2555 AliCDBManager::Instance()->ClearCache();
2556}
2557
2558//_____________________________________________________________________________
2559Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2560{
2561// run the local reconstruction
2562
2563 static Int_t eventNr=0;
2564 AliCodeTimerAuto("",0)
2565
2566 TString detStr = detectors;
2567 // execute HLT reconstruction first since other detector reconstruction
2568 // might depend on HLT data
2569 // key 'HLT' is removed from detStr by IsSelected
2570 if (!IsSelected("HLT", detStr)) {
2571 AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2572 if (reconstructor) {
2573 // there is no AliLoader for HLT, see
2574 // https://savannah.cern.ch/bugs/?35473
2575 AliInfo("running reconstruction for HLT");
2576 if (fRawReader) {
2577 AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
2578 reconstructor->Reconstruct(fRawReader, NULL);
2579 }
2580 else {
2581 AliInfo("reconstructor->Reconstruct(dummy, NULL)");
2582 TTree* dummy=NULL;
2583 reconstructor->Reconstruct(dummy, NULL);
2584 }
2585 }
2586 AliSysInfo::AddStamp(Form("LRecHLT_%d",eventNr), -1,1,eventNr);
2587 }
2588
2589 AliInfo(Form("kNDetectors = %d",kNDetectors));
2590
2591 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2592 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2593 AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
2594 AliReconstructor* reconstructor = GetReconstructor(iDet);
2595 if (!reconstructor) continue;
2596 AliLoader* loader = fLoader[iDet];
2597 if (!loader) {
2598 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2599 continue;
2600 }
2601 // conversion of digits
2602 if (fRawReader && reconstructor->HasDigitConversion()) {
2603 AliInfo(Form("converting raw data digits into root objects for %s",
2604 fgkDetectorName[iDet]));
2605// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2606// fgkDetectorName[iDet]),0);
2607 loader->LoadDigits("update");
2608 loader->CleanDigits();
2609 loader->MakeDigitsContainer();
2610 TTree* digitsTree = loader->TreeD();
2611 reconstructor->ConvertDigits(fRawReader, digitsTree);
2612 loader->WriteDigits("OVERWRITE");
2613 loader->UnloadDigits();
2614 }
2615 // local reconstruction
2616 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2617 //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2618 AliDebug(1, "Loading Rec Points");
2619 loader->LoadRecPoints("update");
2620 AliDebug(1, "Cleaning Rec Points");
2621 loader->CleanRecPoints();
2622 AliDebug(1, "Making Rec Points Container");
2623 loader->MakeRecPointsContainer();
2624 TTree* clustersTree = loader->TreeR();
2625 if (fRawReader && !reconstructor->HasDigitConversion()) {
2626 reconstructor->Reconstruct(fRawReader, clustersTree);
2627 }
2628 else {
2629 AliDebug(1, "Loading Digits");
2630 loader->LoadDigits("read");
2631 TTree* digitsTree = loader->TreeD();
2632 AliDebug(1, Form("Digits Tree = %p",digitsTree));
2633 if (!digitsTree) {
2634 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2635 if (fStopOnError)
2636 return kFALSE;
2637 }
2638 else {
2639 AliDebug(1, "Digits -> Clusters");
2640 reconstructor->Reconstruct(digitsTree, clustersTree);
2641 if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2642 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2643 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
2644 }
2645 }
2646 loader->UnloadDigits();
2647 }
2648 if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2649 AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2650 AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
2651 }
2652 loader->WriteRecPoints("OVERWRITE");
2653 loader->UnloadRecPoints();
2654 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2655 }
2656 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
2657 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2658 AliError(Form("the following detectors were not found: %s",
2659 detStr.Data()));
2660 if (fStopOnError)
2661 return kFALSE;
2662 }
2663 eventNr++;
2664 return kTRUE;
2665}
2666//_____________________________________________________________________________
2667Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2668{
2669// run the SPD trackleting (for SPD efficiency purpouses)
2670
2671 AliCodeTimerAuto("",0)
2672
2673 Double_t vtxPos[3] = {0, 0, 0};
2674 Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2675/*
2676 TArrayF m
2677/
2678cVertex(3);
2679 // if(MC)
2680 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2681 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2682 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2683 }
2684*/
2685 const AliESDVertex *vertex = esd->GetVertex();
2686 if(!vertex){
2687 AliWarning("Vertex not found");
2688 return kFALSE;
2689 }
2690 vertex->GetXYZ(vtxPos);
2691 vertex->GetSigmaXYZ(vtxErr);
2692 if (fSPDTrackleter) {
2693 AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2694
2695 // load clusters
2696 fLoader[0]->LoadRecPoints("read");
2697 TTree* tree = fLoader[0]->TreeR();
2698 if (!tree) {
2699 AliError("Can't get the ITS cluster tree");
2700 return kFALSE;
2701 }
2702 fSPDTrackleter->LoadClusters(tree);
2703 fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2704 // run trackleting
2705 if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2706 AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
2707 // fLoader[0]->UnloadRecPoints();
2708 return kFALSE;
2709 }
2710//fSPDTrackleter->UnloadRecPoints();
2711 } else {
2712 AliWarning("SPDTrackleter not available");
2713 return kFALSE;
2714 }
2715 return kTRUE;
2716}
2717
2718//_____________________________________________________________________________
2719Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2720{
2721// run the barrel tracking
2722
2723 AliCodeTimerAuto("",0)
2724
2725 AliVertexer *vertexer = CreateVertexer();
2726 if (!vertexer) return kFALSE;
2727
2728 AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2729 AliESDVertex* vertex = NULL;
2730 if (fLoader[0]) {
2731 fLoader[0]->LoadRecPoints();
2732 TTree* cltree = fLoader[0]->TreeR();
2733 if (cltree) {
2734 if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2735 vertex = vertexer->FindVertexForCurrentEvent(cltree);
2736 }
2737 else {
2738 AliError("Can't get the ITS cluster tree");
2739 }
2740 fLoader[0]->UnloadRecPoints();
2741 }
2742 else {
2743 AliError("Can't get the ITS loader");
2744 }
2745 if(!vertex){
2746 AliWarning("Vertex not found");
2747 vertex = new AliESDVertex();
2748 vertex->SetName("default");
2749 }
2750 else {
2751 vertex->SetName("reconstructed");
2752 }
2753
2754 Double_t vtxPos[3];
2755 Double_t vtxErr[3];
2756 vertex->GetXYZ(vtxPos);
2757 vertex->GetSigmaXYZ(vtxErr);
2758
2759 esd->SetPrimaryVertexSPD(vertex);
2760 AliESDVertex *vpileup = NULL;
2761 Int_t novertices = 0;
2762 vpileup = vertexer->GetAllVertices(novertices);
2763 if(novertices>1){
2764 for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2765 }
2766 /*
2767 // if SPD multiplicity has been determined, it is stored in the ESD
2768 AliMultiplicity *mult = vertexer->GetMultiplicity();
2769 if(mult)esd->SetMultiplicity(mult);
2770 */
2771 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2772 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2773 }
2774 delete vertex;
2775
2776 delete vertexer;
2777
2778 return kTRUE;
2779}
2780
2781//_____________________________________________________________________________
2782Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2783{
2784 // run the trackleter for multiplicity study
2785
2786 AliCodeTimerAuto("",0)
2787
2788 AliTrackleter *trackleter = CreateMultFinder();
2789 if (!trackleter) return kFALSE;
2790
2791 AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2792
2793 if (fLoader[0]) {
2794 fLoader[0]->LoadRecPoints();
2795 TTree* cltree = fLoader[0]->TreeR();
2796 if (cltree) {
2797 trackleter->Reconstruct(esd,cltree);
2798 AliMultiplicity *mult = trackleter->GetMultiplicity();
2799 if(mult) esd->SetMultiplicity(mult);
2800 }
2801 else {
2802 AliError("Can't get the ITS cluster tree");
2803 }
2804 fLoader[0]->UnloadRecPoints();
2805 }
2806 else {
2807 AliError("Can't get the ITS loader");
2808 }
2809
2810 delete trackleter;
2811
2812 return kTRUE;
2813}
2814
2815//_____________________________________________________________________________
2816Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
2817{
2818// run the HLT barrel tracking
2819
2820 AliCodeTimerAuto("",0)
2821
2822 if (!fRunLoader) {
2823 AliError("Missing runLoader!");
2824 return kFALSE;
2825 }
2826
2827 AliInfo("running HLT tracking");
2828
2829 // Get a pointer to the HLT reconstructor
2830 AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
2831 if (!reconstructor) return kFALSE;
2832
2833 // TPC + ITS
2834 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2835 TString detName = fgkDetectorName[iDet];
2836 AliDebug(1, Form("%s HLT tracking", detName.Data()));
2837 reconstructor->SetOption(detName.Data());
2838 AliTracker *tracker = reconstructor->CreateTracker();
2839 if (!tracker) {
2840 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2841 if (fStopOnError) return kFALSE;
2842 continue;
2843 }
2844 Double_t vtxPos[3];
2845 Double_t vtxErr[3]={0.005,0.005,0.010};
2846 const AliESDVertex *vertex = esd->GetVertex();
2847 vertex->GetXYZ(vtxPos);
2848 tracker->SetVertex(vtxPos,vtxErr);
2849 if(iDet != 1) {
2850 fLoader[iDet]->LoadRecPoints("read");
2851 TTree* tree = fLoader[iDet]->TreeR();
2852 if (!tree) {
2853 AliError(Form("Can't get the %s cluster tree", detName.Data()));
2854 return kFALSE;
2855 }
2856 tracker->LoadClusters(tree);
2857 }
2858 if (tracker->Clusters2Tracks(esd) != 0) {
2859 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2860 return kFALSE;
2861 }
2862 if(iDet != 1) {
2863 tracker->UnloadClusters();
2864 }
2865 delete tracker;
2866 }
2867
2868 return kTRUE;
2869}
2870
2871//_____________________________________________________________________________
2872Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2873{
2874// run the muon spectrometer tracking
2875
2876 AliCodeTimerAuto("",0)
2877
2878 if (!fRunLoader) {
2879 AliError("Missing runLoader!");
2880 return kFALSE;
2881 }
2882 Int_t iDet = GetDetIndex("MUON"); // for MUON
2883
2884 // Get a pointer to the MUON reconstructor
2885 AliReconstructor *reconstructor = GetReconstructor(iDet);
2886 if (!reconstructor) return kFALSE;
2887
2888
2889 TString detName = fgkDetectorName[iDet];
2890 AliDebug(1, Form("%s tracking", detName.Data()));
2891 AliTracker *tracker = reconstructor->CreateTracker();
2892 if (!tracker) {
2893 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2894 return kFALSE;
2895 }
2896
2897 // read RecPoints
2898 fLoader[iDet]->LoadRecPoints("read");
2899
2900 tracker->LoadClusters(fLoader[iDet]->TreeR());
2901
2902 Int_t rv = tracker->Clusters2Tracks(esd);
2903
2904 fLoader[iDet]->UnloadRecPoints();
2905
2906 tracker->UnloadClusters();
2907
2908 if ( rv )
2909 {
2910 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2911 return kFALSE;
2912 }
2913
2914 return kTRUE;
2915}
2916
2917
2918//_____________________________________________________________________________
2919Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
2920{
2921// run the barrel tracking
2922 static Int_t eventNr=0;
2923 AliCodeTimerAuto("",0)
2924
2925 AliInfo("running tracking");
2926
2927 // Set the event info which is used
2928 // by the trackers in order to obtain
2929 // information about read-out detectors,
2930 // trigger etc.
2931 AliDebug(1, "Setting event info");
2932 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2933 if (!fTracker[iDet]) continue;
2934 fTracker[iDet]->SetEventInfo(&fEventInfo);
2935 }
2936
2937 //Fill the ESD with the T0 info (will be used by the TOF)
2938 if (fReconstructor[11] && fLoader[11]) {
2939 fLoader[11]->LoadRecPoints("READ");
2940 TTree *treeR = fLoader[11]->TreeR();
2941 if (treeR) {
2942 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2943 }
2944 }
2945
2946 // pass 1: TPC + ITS inwards
2947 for (Int_t iDet = 1; iDet >= 0; iDet--) {
2948 if (!fTracker[iDet]) continue;
2949 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2950
2951 // load clusters
2952 fLoader[iDet]->LoadRecPoints("read");
2953 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2954 TTree* tree = fLoader[iDet]->TreeR();
2955 if (!tree) {
2956 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2957 return kFALSE;
2958 }
2959 fTracker[iDet]->LoadClusters(tree);
2960 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2961 // run tracking
2962 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2963 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2964 return kFALSE;
2965 }
2966 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2967 // preliminary PID in TPC needed by the ITS tracker
2968 if (iDet == 1) {
2969 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2970 PID.MakePID(esd,kTRUE);
2971 AliSysInfo::AddStamp(Form("MakePID0%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
2972 }
2973 }
2974
2975 // pass 2: ALL backwards
2976
2977 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2978 if (!fTracker[iDet]) continue;
2979 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2980
2981 // load clusters
2982 if (iDet > 1) { // all except ITS, TPC
2983 TTree* tree = NULL;
2984 fLoader[iDet]->LoadRecPoints("read");
2985 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2986 tree = fLoader[iDet]->TreeR();
2987 if (!tree) {
2988 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2989 return kFALSE;
2990 }
2991 fTracker[iDet]->LoadClusters(tree);
2992 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2993 }
2994
2995 // run tracking
2996 if (iDet>1) // start filling residuals for the "outer" detectors
2997 if (fRunGlobalQA) {
2998 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2999 TObjArray ** arr = AliTracker::GetResidualsArray() ;
3000 if (arr) {
3001 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3002 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3003 if ( elem && (! elem->At(0)) ) {
3004 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3005 if (qadm) qadm->InitRecPointsForTracker() ;
3006 }
3007 }
3008 // AliSysInfo::AddStamp(Form("QAInitResid%s_%d",fgkDetectorName[iDet],eventNr), iDet,0, eventNr);
3009 }
3010 if (fTracker[iDet]->PropagateBack(esd) != 0) {
3011 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
3012 // return kFALSE;
3013 }
3014 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3015
3016 // unload clusters
3017 if (iDet > 3) { // all except ITS, TPC, TRD and TOF
3018 fTracker[iDet]->UnloadClusters();
3019 fLoader[iDet]->UnloadRecPoints();
3020 }
3021 // updated PID in TPC needed by the ITS tracker -MI
3022 if (iDet == 1) {
3023 //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
3024 //AliESDpid::MakePID(esd);
3025 PID.MakePID(esd,kTRUE);
3026 AliSysInfo::AddStamp(Form("MakePID1%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
3027 }
3028
3029 }
3030 //stop filling residuals for the "outer" detectors
3031 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
3032
3033 // pass 3: TRD + TPC + ITS refit inwards
3034
3035 for (Int_t iDet = 2; iDet >= 0; iDet--) {
3036 if (!fTracker[iDet]) continue;
3037 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
3038
3039 // run tracking
3040 if (iDet<2) // start filling residuals for TPC and ITS
3041 if (fRunGlobalQA) {
3042 AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
3043 TObjArray ** arr = AliTracker::GetResidualsArray() ;
3044 if (arr) {
3045 AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3046 TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3047 if ( elem && (! elem->At(0)) ) {
3048 AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3049 if (qadm) qadm->InitRecPointsForTracker() ;
3050 }
3051 }
3052 }
3053
3054 if (fTracker[iDet]->RefitInward(esd) != 0) {
3055 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
3056 // return kFALSE;
3057 }
3058 // run postprocessing
3059 if (fTracker[iDet]->PostProcess(esd) != 0) {
3060 AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
3061 // return kFALSE;
3062 }
3063 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3064 }
3065
3066 // write space-points to the ESD in case alignment data output
3067 // is switched on
3068 if (fWriteAlignmentData) {
3069 WriteAlignmentData(esd);
3070 AliSysInfo::AddStamp(Form("WrtAlignData_%d",eventNr), 0,0, eventNr);
3071 }
3072
3073 for (Int_t iDet = 3; iDet >= 0; iDet--) {
3074 if (!fTracker[iDet]) continue;
3075 // unload clusters
3076 fTracker[iDet]->UnloadClusters();
3077 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
3078 fLoader[iDet]->UnloadRecPoints();
3079 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
3080 }
3081 // stop filling residuals for TPC and ITS
3082 if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
3083
3084 eventNr++;
3085 return kTRUE;
3086}
3087
3088//_____________________________________________________________________________
3089Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
3090 //
3091 // Remove the data which are not needed for the physics analysis.
3092 //
3093
3094 Int_t nTracks=esd->GetNumberOfTracks();
3095 Int_t nV0s=esd->GetNumberOfV0s();
3096 AliInfo
3097 (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
3098
3099 Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
3100 Bool_t rc=esd->Clean(cleanPars);
3101
3102 nTracks=esd->GetNumberOfTracks();
3103 nV0s=esd->GetNumberOfV0s();
3104 AliInfo
3105 (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
3106
3107 return rc;
3108}
3109
3110//_____________________________________________________________________________
3111Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
3112{
3113// fill the event summary data
3114
3115 AliCodeTimerAuto("",0)
3116 static Int_t eventNr=0;
3117 TString detStr = detectors;
3118
3119 AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
3120 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3121 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3122 AliReconstructor* reconstructor = GetReconstructor(iDet);
3123 if (!reconstructor) continue;
3124 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
3125 TTree* clustersTree = NULL;
3126 if (fLoader[iDet]) {
3127 fLoader[iDet]->LoadRecPoints("read");
3128 clustersTree = fLoader[iDet]->TreeR();
3129 if (!clustersTree) {
3130 AliError(Form("Can't get the %s clusters tree",
3131 fgkDetectorName[iDet]));
3132 if (fStopOnError) return kFALSE;
3133 }
3134 }
3135 if (fRawReader && !reconstructor->HasDigitConversion()) {
3136 reconstructor->FillESD(fRawReader, clustersTree, esd);
3137 } else {
3138 TTree* digitsTree = NULL;
3139 if (fLoader[iDet]) {
3140 fLoader[iDet]->LoadDigits("read");
3141 digitsTree = fLoader[iDet]->TreeD();
3142 if (!digitsTree) {
3143 AliError(Form("Can't get the %s digits tree",
3144 fgkDetectorName[iDet]));
3145 if (fStopOnError) return kFALSE;
3146 }
3147 }
3148 reconstructor->FillESD(digitsTree, clustersTree, esd);
3149 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
3150 }
3151 if (fLoader[iDet]) {
3152 fLoader[iDet]->UnloadRecPoints();
3153 }
3154 }
3155
3156 if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
3157 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
3158 AliError(Form("the following detectors were not found: %s",
3159 detStr.Data()));
3160 if (fStopOnError) return kFALSE;
3161 }
3162 AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
3163 eventNr++;
3164 return kTRUE;
3165}
3166
3167//_____________________________________________________________________________
3168Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
3169{
3170 // Reads the trigger decision which is
3171 // stored in Trigger.root file and fills
3172 // the corresponding esd entries
3173
3174 AliCodeTimerAuto("",0)
3175
3176 AliInfo("Filling trigger information into the ESD");
3177
3178 if (fRawReader) {
3179 AliCTPRawStream input(fRawReader);
3180 if (!input.Next()) {
3181 AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
3182 }
3183 else {
3184 if (esd->GetTriggerMask() != input.GetClassMask())
3185 AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
3186 input.GetClassMask(),esd->GetTriggerMask()));
3187 if (esd->GetOrbitNumber() != input.GetOrbitID())
3188 AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
3189 input.GetOrbitID(),esd->GetOrbitNumber()));
3190 if (esd->GetBunchCrossNumber() != input.GetBCID())
3191 AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
3192 input.GetBCID(),esd->GetBunchCrossNumber()));
3193 AliESDHeader* esdheader = esd->GetHeader();
3194 esdheader->SetL0TriggerInputs(input.GetL0Inputs());
3195 esdheader->SetL1TriggerInputs(input.GetL1Inputs());
3196 esdheader->SetL2TriggerInputs(input.GetL2Inputs());
3197 // IR
3198 // UInt_t orbit=input.GetOrbitID();
3199 for(Int_t i=0 ; i<input.GetNIRs() ; i++ ) {
3200 esdheader->AddTriggerIR(input.GetIR(i));
3201 }
3202 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3203 if (rlCTP) {
3204 rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
3205 rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
3206 rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
3207 }
3208 }
3209 if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
3210 }
3211 return kTRUE;
3212}
3213//_____________________________________________________________________________
3214Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
3215{
3216 //Scalers
3217 //fRunScalers->Print();
3218 if(fRunScalers && fRunScalers->CheckRunScalers()){
3219 AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
3220 //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
3221 AliESDHeader* esdheader = fesd->GetHeader();
3222 for(Int_t i=0;i<50;i++){
3223 if((1ull<<i) & esd->GetTriggerMask()){
3224 AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
3225 if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
3226 }
3227 }
3228 const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
3229 const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
3230 if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
3231 if (scalrecRun) esdheader->SetTriggerScalersDeltaRun(scalrecRun);
3232 }
3233 return kTRUE;
3234}
3235//_____________________________________________________________________________
3236Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
3237{
3238 //
3239 // Filling information from RawReader Header
3240 //
3241
3242 if (!fRawReader) return kFALSE;
3243
3244 AliInfo("Filling information from RawReader Header");
3245
3246 esd->SetBunchCrossNumber(fRawReader->GetBCID());
3247 esd->SetOrbitNumber(fRawReader->GetOrbitID());
3248 esd->SetPeriodNumber(fRawReader->GetPeriod());
3249
3250 esd->SetTimeStamp(fRawReader->GetTimestamp());
3251 esd->SetEventType(fRawReader->GetType());
3252
3253 return kTRUE;
3254}
3255
3256
3257//_____________________________________________________________________________
3258Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
3259{
3260// check whether detName is contained in detectors
3261// if yes, it is removed from detectors
3262
3263 // check if all detectors are selected
3264 if ((detectors.CompareTo("ALL") == 0) ||
3265 detectors.BeginsWith("ALL ") ||
3266 detectors.EndsWith(" ALL") ||
3267 detectors.Contains(" ALL ")) {
3268 detectors = "ALL";
3269 return kTRUE;
3270 }
3271
3272 // search for the given detector
3273 Bool_t result = kFALSE;
3274 if ((detectors.CompareTo(detName) == 0) ||
3275 detectors.BeginsWith(detName+" ") ||
3276 detectors.EndsWith(" "+detName) ||
3277 detectors.Contains(" "+detName+" ")) {
3278 detectors.ReplaceAll(detName, "");
3279 result = kTRUE;
3280 }
3281
3282 // clean up the detectors string
3283 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
3284 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
3285 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
3286
3287 return result;
3288}
3289
3290//_____________________________________________________________________________
3291Bool_t AliReconstruction::InitRunLoader()
3292{
3293// get or create the run loader
3294
3295 if (gAlice) delete gAlice;
3296 gAlice = NULL;
3297
3298 TFile *gafile = TFile::Open(fGAliceFileName.Data());
3299 // if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
3300 if (gafile) { // galice.root exists
3301 gafile->Close();
3302 delete gafile;
3303
3304 // load all base libraries to get the loader classes
3305 TString libs = gSystem->GetLibraries();
3306 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3307 TString detName = fgkDetectorName[iDet];
3308 if (detName == "HLT") continue;
3309 if (libs.Contains("lib" + detName + "base.so")) continue;
3310 gSystem->Load("lib" + detName + "base.so");
3311 }
3312 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
3313 if (!fRunLoader) {
3314 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
3315 CleanUp();
3316 return kFALSE;
3317 }
3318
3319 fRunLoader->CdGAFile();
3320 fRunLoader->LoadgAlice();
3321
3322 //PH This is a temporary fix to give access to the kinematics
3323 //PH that is needed for the labels of ITS clusters
3324 fRunLoader->LoadHeader();
3325 fRunLoader->LoadKinematics();
3326
3327 } else { // galice.root does not exist
3328 if (!fRawReader) {
3329 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
3330 }
3331 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
3332 AliConfig::GetDefaultEventFolderName(),
3333 "recreate");
3334 if (!fRunLoader) {
3335 AliError(Form("could not create run loader in file %s",
3336 fGAliceFileName.Data()));
3337 CleanUp();
3338 return kFALSE;
3339 }
3340 fIsNewRunLoader = kTRUE;
3341 fRunLoader->MakeTree("E");
3342 fRunLoader->MakeTree("GG");
3343
3344 if (fNumberOfEventsPerFile > 0)
3345 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
3346 else
3347 fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
3348 }
3349
3350 return kTRUE;
3351}
3352
3353//_____________________________________________________________________________
3354AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
3355{
3356// get the reconstructor object and the loader for a detector
3357
3358 if (fReconstructor[iDet]) {
3359 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3360 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3361 fReconstructor[iDet]->SetRecoParam(par);
3362 fReconstructor[iDet]->SetRunInfo(fRunInfo);
3363 }
3364 return fReconstructor[iDet];
3365 }
3366
3367 // load the reconstructor object
3368 TPluginManager* pluginManager = gROOT->GetPluginManager();
3369 TString detName = fgkDetectorName[iDet];
3370 TString recName = "Ali" + detName + "Reconstructor";
3371
3372 if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
3373
3374 AliReconstructor* reconstructor = NULL;
3375 // first check if a plugin is defined for the reconstructor
3376 TPluginHandler* pluginHandler =
3377 pluginManager->FindHandler("AliReconstructor", detName);
3378 // if not, add a plugin for it
3379 if (!pluginHandler) {
3380 AliDebug(1, Form("defining plugin for %s", recName.Data()));
3381 TString libs = gSystem->GetLibraries();
3382 if (libs.Contains("lib" + detName + "base.so") ||
3383 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
3384 pluginManager->AddHandler("AliReconstructor", detName,
3385 recName, detName + "rec", recName + "()");
3386 } else {
3387 pluginManager->AddHandler("AliReconstructor", detName,
3388 recName, detName, recName + "()");
3389 }
3390 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
3391 }
3392 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3393 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
3394 }
3395
3396 // check if the upgrade reconstructor should be used instead of the standard one
3397 if(fUpgradeMask[iDet]) {
3398 if(reconstructor) delete reconstructor;
3399 TClass *cl = new TClass(Form("Ali%sUpgradeReconstructor",fgkDetectorName[iDet]));
3400 reconstructor = (AliReconstructor*)(cl->New());
3401 }
3402
3403 if (reconstructor) {
3404 TObject* obj = fOptions.FindObject(detName.Data());
3405 if (obj) reconstructor->SetOption(obj->GetTitle());
3406 reconstructor->SetRunInfo(fRunInfo);
3407 reconstructor->Init();
3408 fReconstructor[iDet] = reconstructor;
3409 }
3410
3411 // get or create the loader
3412 if (detName != "HLT") {
3413 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
3414 if (!fLoader[iDet]) {
3415 AliConfig::Instance()
3416 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
3417 detName, detName);
3418 // first check if a plugin is defined for the loader
3419 pluginHandler =
3420 pluginManager->FindHandler("AliLoader", detName);
3421 // if not, add a plugin for it
3422 if (!pluginHandler) {
3423 TString loaderName = "Ali" + detName + "Loader";
3424 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
3425 pluginManager->AddHandler("AliLoader", detName,
3426 loaderName, detName + "base",
3427 loaderName + "(const char*, TFolder*)");
3428 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
3429 }
3430 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3431 fLoader[iDet] =
3432 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
3433 fRunLoader->GetEventFolder());
3434 }
3435 if (!fLoader[iDet]) { // use default loader
3436 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
3437 }
3438 if (!fLoader[iDet]) {
3439 AliWarning(Form("couldn't get loader for %s", detName.Data()));
3440 if (fStopOnError) return NULL;
3441 } else {
3442 fRunLoader->AddLoader(fLoader[iDet]);
3443 fRunLoader->CdGAFile();
3444 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
3445 fRunLoader->Write(0, TObject::kOverwrite);
3446 }
3447 }
3448 }
3449
3450 if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3451 const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3452 if (reconstructor) {
3453 reconstructor->SetRecoParam(par);
3454 reconstructor->SetRunInfo(fRunInfo);
3455 }
3456 }
3457 return reconstructor;
3458}
3459
3460//_____________________________________________________________________________
3461AliVertexer* AliReconstruction::CreateVertexer()
3462{
3463// create the vertexer
3464// Please note that the caller is the owner of the
3465// vertexer
3466
3467 AliVertexer* vertexer = NULL;
3468 AliReconstructor* itsReconstructor = GetReconstructor(0);
3469 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3470 fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3471 vertexer = itsReconstructor->CreateVertexer();
3472 }
3473 if (!vertexer) {
3474 AliWarning("couldn't create a vertexer for ITS");
3475 }
3476
3477 return vertexer;
3478}
3479
3480//_____________________________________________________________________________
3481AliTrackleter* AliReconstruction::CreateMultFinder()
3482{
3483// create the ITS trackleter for mult. estimation
3484// Please note that the caller is the owner of the
3485// trackleter
3486
3487 AliTrackleter* trackleter = NULL;
3488 AliReconstructor* itsReconstructor = GetReconstructor(0);
3489 if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3490 fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3491 trackleter = itsReconstructor->CreateMultFinder();
3492 }
3493 else {
3494 AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
3495 fRunMultFinder = kFALSE;
3496 }
3497
3498 return trackleter;
3499}
3500
3501//_____________________________________________________________________________
3502Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
3503{
3504// create the trackers
3505 AliInfo("Creating trackers");
3506
3507 TString detStr = detectors;
3508 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3509 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3510 AliReconstructor* reconstructor = GetReconstructor(iDet);
3511 if (!reconstructor) continue;
3512 TString detName = fgkDetectorName[iDet];
3513 if (detName == "HLT") {
3514 fRunHLTTracking = kTRUE;
3515 continue;
3516 }
3517 if (detName == "MUON") {
3518 fRunMuonTracking = kTRUE;
3519 continue;
3520 }
3521
3522 fTracker[iDet] = reconstructor->CreateTracker();
3523 if (!fTracker[iDet] && (iDet < 7)) {
3524 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
3525 if (fStopOnError) return kFALSE;
3526 }
3527 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
3528 }
3529
3530 return kTRUE;
3531}
3532
3533//_____________________________________________________________________________
3534void AliReconstruction::CleanUp()
3535{
3536// delete trackers and the run loader and close and delete the file
3537/*
3538 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3539 delete fReconstructor[iDet];
3540 fReconstructor[iDet] = NULL;
3541 fLoader[iDet] = NULL;
3542 delete fTracker[iDet];
3543 fTracker[iDet] = NULL;
3544 }
3545*/
3546
3547 delete fRunInfo;
3548 fRunInfo = NULL;
3549
3550 delete fSPDTrackleter;
3551 fSPDTrackleter = NULL;
3552
3553 delete ftVertexer;
3554 ftVertexer = NULL;
3555
3556 delete fRunLoader;
3557 fRunLoader = NULL;
3558 delete fRawReader;
3559 fRawReader = NULL;
3560 delete fParentRawReader;
3561 fParentRawReader=NULL;
3562
3563 if (ffile) {
3564 ffile->Close();
3565 delete ffile;
3566 ffile = NULL;
3567 }
3568
3569 if (AliQAManager::QAManager())
3570 AliQAManager::QAManager()->ShowQA() ;
3571 // AliQAManager::Destroy() ;
3572 delete fAnalysis;
3573 fAnalysis = NULL;
3574}
3575
3576void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
3577{
3578 // Write space-points which are then used in the alignment procedures
3579 // For the moment only ITS, TPC, TRD and TOF
3580
3581 Int_t ntracks = esd->GetNumberOfTracks();
3582 for (Int_t itrack = 0; itrack < ntracks; itrack++)
3583 {
3584 AliESDtrack *track = esd->GetTrack(itrack);
3585 Int_t nsp = 0;
3586 Int_t idx[200];
3587 for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
3588 for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
3589 nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
3590
3591 if (iDet==GetDetIndex("ITS")) { // ITS "extra" clusters
3592 track->GetClusters(iDet,idx);
3593 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
3594 }
3595 }
3596
3597 if (nsp) {
3598 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
3599 track->SetTrackPointArray(sp);
3600 Int_t isptrack = 0;
3601 for (Int_t iDet = 5; iDet >= 0; iDet--) {
3602 AliTracker *tracker = fTracker[iDet];
3603 if (!tracker) continue;
3604 Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
3605
3606 if (iDet==GetDetIndex("ITS")) // ITS "extra" clusters
3607 for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
3608
3609 if (nspdet <= 0) continue;
3610 AliTrackPoint p;
3611 Int_t isp = 0;
3612 Int_t isp2 = 0;
3613 while (isp2 < nspdet) {
3614 Bool_t isvalid=kTRUE;
3615
3616 Int_t index=idx[isp++];
3617 if (index < 0) continue;
3618
3619 TString dets = fgkDetectorName[iDet];
3620 if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
3621 fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
3622 fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
3623 fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
3624 isvalid = tracker->GetTrackPointTrackingError(index,p,track);
3625 } else {
3626 isvalid = tracker->GetTrackPoint(index,p);
3627 }
3628 isp2++;
3629 if (!isvalid) continue;
3630 if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
3631 sp->AddPoint(isptrack,&p); isptrack++;
3632 }
3633 }
3634 }
3635 }
3636}
3637
3638//_____________________________________________________________________________
3639void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
3640{
3641 // The method reads the raw-data error log
3642 // accumulated within the rawReader.
3643 // It extracts the raw-data errors related to
3644 // the current event and stores them into
3645 // a TClonesArray inside the esd object.
3646
3647 if (!fRawReader) return;
3648
3649 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3650
3651 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3652 if (!log) continue;
3653 if (iEvent != log->GetEventNumber()) continue;
3654
3655 esd->AddRawDataErrorLog(log);
3656 }
3657
3658}
3659
3660//_____________________________________________________________________________
3661// void AliReconstruction::CheckQA()
3662// {
3663// check the QA of SIM for this run and remove the detectors
3664// with status Fatal
3665
3666// TString newRunLocalReconstruction ;
3667// TString newRunTracking ;
3668// TString newFillESD ;
3669//
3670// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3671// TString detName(AliQAv1::GetDetName(iDet)) ;
3672// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3673// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
3674// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
3675// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3676// } else {
3677// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
3678// fRunLocalReconstruction.Contains("ALL") ) {
3679// newRunLocalReconstruction += detName ;
3680// newRunLocalReconstruction += " " ;
3681// }
3682// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
3683// fRunTracking.Contains("ALL") ) {
3684// newRunTracking += detName ;
3685// newRunTracking += " " ;
3686// }
3687// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
3688// fFillESD.Contains("ALL") ) {
3689// newFillESD += detName ;
3690// newFillESD += " " ;
3691// }
3692// }
3693// }
3694// fRunLocalReconstruction = newRunLocalReconstruction ;
3695// fRunTracking = newRunTracking ;
3696// fFillESD = newFillESD ;
3697// }
3698
3699//_____________________________________________________________________________
3700Int_t AliReconstruction::GetDetIndex(const char* detector)
3701{
3702 // return the detector index corresponding to detector
3703 Int_t index = -1 ;
3704 for (index = 0; index < kNDetectors ; index++) {
3705 if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3706 break ;
3707 }
3708 return index ;
3709}
3710//_____________________________________________________________________________
3711Bool_t AliReconstruction::FinishPlaneEff() {
3712 //
3713 // Here execute all the necessary operationis, at the end of the tracking phase,
3714 // in case that evaluation of PlaneEfficiencies was required for some detector.
3715 // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
3716 //
3717 // This Preliminary version works only FOR ITS !!!!!
3718 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3719 //
3720 // Input: none
3721 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3722 //
3723 Bool_t ret=kFALSE;
3724 TString detStr = fLoadCDB;
3725 //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
3726 for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
3727 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3728 if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
3729 AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3730 TString name=planeeff->GetName();
3731 name+=".root";
3732 TFile* pefile = TFile::Open(name, "RECREATE");
3733 ret=(Bool_t)planeeff->Write();
3734 pefile->Close();
3735 if(planeeff->GetCreateHistos()) {
3736 TString hname=planeeff->GetName();
3737 hname+="Histo.root";
3738 ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
3739 }
3740 }
3741 if(fSPDTrackleter) {
3742 AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3743 TString name="AliITSPlaneEffSPDtracklet.root";
3744 TFile* pefile = TFile::Open(name, "RECREATE");
3745 ret=(Bool_t)planeeff->Write();
3746 pefile->Close();
3747 AliESDEvent *dummy=NULL;
3748 ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3749 }
3750 }
3751 return ret;
3752}
3753//_____________________________________________________________________________
3754Bool_t AliReconstruction::InitPlaneEff() {
3755//
3756 // Here execute all the necessary operations, before of the tracking phase,
3757 // for the evaluation of PlaneEfficiencies, in case required for some detectors.
3758 // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
3759 // which should be updated/recalculated.
3760 //
3761 // This Preliminary version will work only FOR ITS !!!!!
3762 // other detectors (TOF,TRD, etc. have to develop their specific codes)
3763 //
3764 // Input: none
3765 // Return: kTRUE if all operations have been done properly, kFALSE otherwise
3766 //
3767
3768 fSPDTrackleter = NULL;
3769 TString detStr = fLoadCDB;
3770 if (IsSelected(fgkDetectorName[0], detStr)) {
3771 AliReconstructor* itsReconstructor = GetReconstructor(0);
3772 if (itsReconstructor) {
3773 fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3774 }
3775 if (fSPDTrackleter) {
3776 AliInfo("Trackleter for SPD has been created");
3777 }
3778 }
3779 return kTRUE;
3780}
3781
3782//_____________________________________________________________________________
3783Bool_t AliReconstruction::InitAliEVE()
3784{
3785 // This method should be called only in case
3786 // AliReconstruction is run
3787 // within the alieve environment.
3788 // It will initialize AliEVE in a way
3789 // so that it can visualize event processed
3790 // by AliReconstruction.
3791 // The return flag shows whenever the
3792 // AliEVE initialization was successful or not.
3793
3794 TString macroStr(gSystem->Getenv("ALIEVE_ONLINE_MACRO"));
3795
3796 if (macroStr.IsNull())
3797 macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3798
3799 AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3800
3801 if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3802
3803 gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
3804 gROOT->ProcessLine("alieve_online_init()");
3805
3806 return kTRUE;
3807}
3808
3809//_____________________________________________________________________________
3810void AliReconstruction::RunAliEVE()
3811{
3812 // Runs AliEVE visualisation of
3813 // the current event.
3814 // Should be executed only after
3815 // successful initialization of AliEVE.
3816
3817 AliInfo("Running AliEVE...");
3818 gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
3819 gSystem->Run();
3820}
3821
3822//_____________________________________________________________________________
3823Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3824{
3825 // Allows to run QA for a selected set of detectors
3826 // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
3827 // all selected detectors run the same selected tasks
3828
3829 if (!detAndAction.Contains(":")) {
3830 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3831 fRunQA = kFALSE ;
3832 return kFALSE ;
3833 }
3834 Int_t colon = detAndAction.Index(":") ;
3835 fQADetectors = detAndAction(0, colon) ;
3836 fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
3837 if (fQATasks.Contains("ALL") ) {
3838 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
3839 } else {
3840 fQATasks.ToUpper() ;
3841 TString tempo("") ;
3842 if ( fQATasks.Contains("RAW") )
3843 tempo = Form("%d ", AliQAv1::kRAWS) ;
3844 if ( fQATasks.Contains("DIGIT") )
3845 tempo += Form("%d ", AliQAv1::kDIGITSR) ;
3846 if ( fQATasks.Contains("RECPOINT") )
3847 tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
3848 if ( fQATasks.Contains("ESD") )
3849 tempo += Form("%d ", AliQAv1::kESDS) ;
3850 fQATasks = tempo ;
3851 if (fQATasks.IsNull()) {
3852 AliInfo("No QA requested\n") ;
3853 fRunQA = kFALSE ;
3854 return kTRUE ;
3855 }
3856 }
3857 TString tempo(fQATasks) ;
3858 tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
3859 tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
3860 tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3861 tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
3862 AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3863 fRunQA = kTRUE ;
3864 return kTRUE;
3865}
3866
3867//_____________________________________________________________________________
3868Bool_t AliReconstruction::InitRecoParams()
3869{
3870 // The method accesses OCDB and retrieves all
3871 // the available reco-param objects from there.
3872
3873 Bool_t isOK = kTRUE;
3874
3875 if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
3876 AliInfo("Using custom GRP reconstruction parameters");
3877 }
3878 else {
3879 AliInfo("Loading GRP reconstruction parameter objects");
3880
3881 AliCDBPath path("GRP","Calib","RecoParam");
3882 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3883 if(!entry){
3884 AliWarning("Couldn't find GRP RecoParam entry in OCDB");
3885 isOK = kFALSE;
3886 }
3887 else {
3888 TObject *recoParamObj = entry->GetObject();
3889 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3890 // GRP has a normal TobjArray of AliDetectorRecoParam objects
3891 // Registering them in AliRecoParam
3892 fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
3893 }
3894 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3895 // GRP has only onse set of reco parameters
3896 // Registering it in AliRecoParam
3897 AliInfo("Single set of GRP reconstruction parameters found");
3898 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3899 fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3900 }
3901 else {
3902 AliError("No valid GRP RecoParam object found in the OCDB");
3903 isOK = kFALSE;
3904 }
3905 entry->SetOwner(0);
3906 }
3907 }
3908
3909 TString detStr = fLoadCDB;
3910 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3911
3912 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3913
3914 if (fRecoParam.GetDetRecoParamArray(iDet)) {
3915 AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3916 continue;
3917 }
3918
3919 AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
3920
3921 AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3922 AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3923 if(!entry){
3924 AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3925 isOK = kFALSE;
3926 }
3927 else {
3928 TObject *recoParamObj = entry->GetObject();
3929 if (dynamic_cast<TObjArray*>(recoParamObj)) {
3930 // The detector has a normal TobjArray of AliDetectorRecoParam objects
3931 // Registering them in AliRecoParam
3932 fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3933 }
3934 else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3935 // The detector has only onse set of reco parameters
3936 // Registering it in AliRecoParam
3937 AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
3938 dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3939 fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3940 }
3941 else {
3942 AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3943 isOK = kFALSE;
3944 }
3945 entry->SetOwner(0);
3946 // FIX ME: We have to disable the unloading of reco-param CDB
3947 // entries because QA framework is using them. Has to be fix in
3948 // a way that the QA takes the objects already constructed in
3949 // this method.
3950 // AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
3951 }
3952 }
3953
3954 if (AliDebugLevel() > 0) fRecoParam.Print();
3955
3956 return isOK;
3957}
3958
3959//_____________________________________________________________________________
3960Bool_t AliReconstruction::GetEventInfo()
3961{
3962 // Fill the event info object
3963 // ...
3964 AliCodeTimerAuto("",0)
3965
3966 AliCentralTrigger *aCTP = NULL;
3967 if (fRawReader) {
3968 fEventInfo.SetEventType(fRawReader->GetType());
3969
3970 ULong64_t mask = fRawReader->GetClassMask();
3971 fEventInfo.SetTriggerMask(mask);
3972 UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3973 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3974
3975 aCTP = new AliCentralTrigger();
3976 TString configstr("");
3977 if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3978 AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3979 delete aCTP;
3980 return kFALSE;
3981 }
3982 aCTP->SetClassMask(mask);
3983 aCTP->SetClusterMask(clmask);
3984
3985 AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3986 if (rlCTP) {
3987 rlCTP->SetClassMask(mask);
3988 rlCTP->SetClusterMask(clmask);
3989 }
3990 }
3991 else {
3992 fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3993
3994 if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3995 aCTP = fRunLoader->GetTrigger();
3996 fEventInfo.SetTriggerMask(aCTP->GetClassMask());
3997 // get inputs from actp - just get
3998 AliESDHeader* esdheader = fesd->GetHeader();
3999 esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
4000 esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
4001 esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
4002 fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
4003 }
4004 else {
4005 AliWarning("No trigger can be loaded! The trigger information will not be used!");
4006 return kFALSE;
4007 }
4008 }
4009
4010 AliTriggerConfiguration *config = aCTP->GetConfiguration();
4011 if (!config) {
4012 AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
4013 if (fRawReader) delete aCTP;
4014 return kFALSE;
4015 }
4016
4017 UChar_t clustmask = 0;
4018 TString trclasses;
4019 ULong64_t trmask = fEventInfo.GetTriggerMask();
4020 const TObjArray& classesArray = config->GetClasses();
4021 Int_t nclasses = classesArray.GetEntriesFast();
4022 for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
4023 AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
4024 if (trclass && trclass->GetMask()>0) {
4025 Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
4026 fesd->SetTriggerClass(trclass->GetName(),trindex);
4027 if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
4028 if (trmask & (1ull << trindex)) {
4029 trclasses += " ";
4030 trclasses += trclass->GetName();
4031 trclasses += " ";
4032 clustmask |= trclass->GetCluster()->GetClusterMask();
4033 }
4034 }
4035 }
4036 fEventInfo.SetTriggerClasses(trclasses);
4037 // Now put the declared trigger classes (not present in the run)
4038 // to 0/false in the event selection
4039 if (!fDeclTriggerClasses.IsNull()) {
4040 TObjArray *tokens = fDeclTriggerClasses.Tokenize(" ");
4041 Int_t ntokens = tokens->GetEntriesFast();
4042 for (Int_t itoken = 0; itoken < ntokens; ++itoken) {
4043 if (fRawReader) fRawReader->LoadTriggerClass((((TObjString*)tokens->At(itoken))->String()).Data(),-1);
4044 }
4045 delete tokens;
4046 }
4047
4048 // Write names of active trigger inputs in ESD Header
4049 const TObjArray& inputsArray = config->GetInputs();
4050 Int_t ninputs = inputsArray.GetEntriesFast();
4051 for( Int_t iinput=0; iinput < ninputs; iinput++ ) {
4052 AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
4053 if (trginput && trginput->GetMask()>0) {
4054 Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
4055 AliESDHeader* headeresd = fesd->GetHeader();
4056 Int_t trglevel = (Int_t)trginput->GetLevel();
4057 if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
4058 if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
4059 if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
4060 }
4061 }
4062
4063 // Set the information in ESD
4064 fesd->SetTriggerMask(trmask);
4065 fesd->SetTriggerCluster(clustmask);
4066
4067 if (!aCTP->CheckTriggeredDetectors()) {
4068 if (fRawReader) delete aCTP;
4069 return kFALSE;
4070 }
4071
4072 if (fRawReader) delete aCTP;
4073
4074 // We have to fill also the HLT decision here!!
4075 // ...
4076
4077 return kTRUE;
4078}
4079
4080const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
4081{
4082 // Match the detector list found in the rec.C or the default 'ALL'
4083 // to the list found in the GRP (stored there by the shuttle PP which
4084 // gets the information from ECS)
4085 static TString resultList;
4086 TString detList = detectorList;
4087
4088 resultList = "";
4089
4090 for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
4091 if ((detectorMask >> iDet) & 0x1) {
4092 TString det = AliDAQ::OfflineModuleName(iDet);
4093 if ((detList.CompareTo("ALL") == 0) ||
4094 ((detList.BeginsWith("ALL ") ||
4095 detList.EndsWith(" ALL") ||
4096 detList.Contains(" ALL ")) &&
4097 !(detList.BeginsWith("-"+det+" ") ||
4098 detList.EndsWith(" -"+det) ||
4099 detList.Contains(" -"+det+" "))) ||
4100 (detList.CompareTo(det) == 0) ||
4101 detList.BeginsWith(det+" ") ||
4102 detList.EndsWith(" "+det) ||
4103 detList.Contains( " "+det+" " )) {
4104 if (!resultList.EndsWith(det + " ")) {
4105 resultList += det;
4106 resultList += " ";
4107 }
4108 }
4109 }
4110 }
4111
4112 // HLT
4113 if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
4114 TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
4115 if ((detList.CompareTo("ALL") == 0) ||
4116 ((detList.BeginsWith("ALL ") ||
4117 detList.EndsWith(" ALL") ||
4118 detList.Contains(" ALL ")) &&
4119 !(detList.BeginsWith("-"+hltDet+" ") ||
4120 detList.EndsWith(" -"+hltDet) ||
4121 detList.Contains(" -"+hltDet+" "))) ||
4122 (detList.CompareTo(hltDet) == 0) ||
4123 detList.BeginsWith(hltDet+" ") ||
4124 detList.EndsWith(" "+hltDet) ||
4125 detList.Contains( " "+hltDet+" " )) {
4126 resultList += hltDet;
4127 }
4128 }
4129
4130 return resultList.Data();
4131
4132}
4133
4134//______________________________________________________________________________
4135void AliReconstruction::Abort(const char *method, EAbort what)
4136{
4137 // Abort processing. If what = kAbortProcess, the Process() loop will be
4138 // aborted. If what = kAbortFile, the current file in a chain will be
4139 // aborted and the processing will continue with the next file, if there
4140 // is no next file then Process() will be aborted. Abort() can also be
4141 // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
4142 // the SlaveTerminate() and Terminate() are always called. The abort flag
4143 // can be checked in these methods using GetAbort().
4144 //
4145 // The method is overwritten in AliReconstruction for better handling of
4146 // reco specific errors
4147
4148 if (!fStopOnError) return;
4149
4150 CleanUp();
4151
4152 TString whyMess = method;
4153 whyMess += " failed! Aborting...";
4154
4155 AliError(whyMess.Data());
4156
4157 fAbort = what;
4158 TString mess = "Abort";
4159 if (fAbort == kAbortProcess)
4160 mess = "AbortProcess";
4161 else if (fAbort == kAbortFile)
4162 mess = "AbortFile";
4163
4164 Info(mess.Data(), "%s", whyMess.Data());
4165}
4166
4167//______________________________________________________________________________
4168Bool_t AliReconstruction::ProcessEvent(void* event)
4169{
4170 // Method that is used in case the event loop
4171 // is steered from outside, for example by AMORE
4172 // 'event' is a pointer to the DATE event in the memory
4173
4174 if (fRawReader) delete fRawReader;
4175 fRawReader = new AliRawReaderDate(event);
4176 fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
4177 delete fRawReader;
4178 fRawReader = NULL;
4179
4180 return fStatus;
4181}
4182
4183//______________________________________________________________________________
4184Bool_t AliReconstruction::ParseOutput()
4185{
4186 // The method parses the output file
4187 // location string in order to steer
4188 // properly the selector
4189
4190 TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
4191 TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
4192
4193 if (re1.Match(fESDOutput) == 4) {
4194 // root archive with output files stored and regustered
4195 // in proof dataset
4196 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
4197 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
4198 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4199 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
4200 AliInfo(Form("%s files will be stored within %s in dataset %s",
4201 re1[2].Data(),
4202 re1[1].Data(),
4203 re1[3].Data()));
4204 }
4205 else if (re2.Match(fESDOutput) == 3) {
4206 // output file stored and registered
4207 // in proof dataset
4208 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
4209 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
4210 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4211 AliInfo(Form("%s will be stored in dataset %s",
4212 (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
4213 re2[2].Data()));
4214 }
4215 else {
4216 if (fESDOutput.IsNull()) {
4217 // Output location not given.
4218 // Assuming xrootd has been already started and
4219 // the output file has to be sent back
4220 // to the client machine
4221 TString esdUrl(Form("root://%s/%s/",
4222 TUrl(gSystem->HostName()).GetHostFQDN(),
4223 gSystem->pwd()));
4224 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
4225 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
4226 AliInfo(Form("AliESDs.root will be stored in %s",
4227 esdUrl.Data()));
4228 }
4229 else {
4230 // User specified an output location.
4231 // Ones has just to parse it here
4232 TUrl outputUrl(fESDOutput.Data());
4233 TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
4234 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
4235 TString outputLocation(outputUrl.GetUrl());
4236 outputLocation.ReplaceAll(outputFile.Data(),"");
4237 gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
4238 AliInfo(Form("%s will be stored in %s",
4239 outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
4240 outputLocation.Data()));
4241 }
4242 }
4243
4244 return kTRUE;
4245}
4246
4247//______________________________________________________________________________
4248Bool_t AliReconstruction::IsHighPt() const {
4249 // Selection of events containing "high" pT tracks
4250 // If at least one track is found within 1.5 and 100 GeV (pT)
4251 // that was reconstructed by both ITS and TPC, the event is accepted
4252
4253 // Track cuts
4254 const Double_t pTmin = 1.5;
4255 const Double_t pTmax = 100;
4256 ULong_t mask = 0;
4257 mask |= (AliESDtrack::kITSrefit);
4258 mask |= (AliESDtrack::kTPCrefit);
4259 const Double_t pTminCosmic = 5.;
4260 const Double_t pTmaxCosmic = 100;
4261 ULong_t maskCosmic = 0;
4262 Int_t cosmicCount=0;
4263 maskCosmic |= (AliESDtrack::kTPCrefit);
4264
4265 Bool_t isOK = kFALSE;
4266
4267 if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4268 // Check if this ia a physics event (code 7)
4269 Int_t ntrk = fesd->GetNumberOfTracks();
4270 for (Int_t itrk=0; itrk<ntrk; ++itrk) {
4271
4272 AliESDtrack * trk = fesd->GetTrack(itrk);
4273 if (trk
4274 && trk->Pt() > pTmin
4275 && trk->Pt() < pTmax
4276 && (trk->GetStatus() & mask) == mask ) {
4277
4278 isOK = kTRUE;
4279 break;
4280 }
4281 if (trk
4282 && trk->GetInnerParam()
4283 && trk->GetInnerParam()->Pt() > pTminCosmic
4284 && trk->GetInnerParam()->Pt() < pTmaxCosmic
4285 && (trk->GetStatus() & maskCosmic) == maskCosmic ) {
4286
4287 cosmicCount++;
4288 break;
4289 }
4290 }
4291 if (cosmicCount>1) isOK=kTRUE;
4292 }
4293 return isOK;
4294}
4295
4296//______________________________________________________________________________
4297Bool_t AliReconstruction::IsCosmicOrCalibSpecie() const {
4298 // Select cosmic or calibration events
4299
4300 Bool_t isOK = kFALSE;
4301
4302 if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4303 // Check if this ia a physics event (code 7)
4304
4305 UInt_t specie = fesd->GetEventSpecie();
4306 if (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib) {
4307 isOK = kTRUE;
4308 }
4309 }
4310 return isOK;
4311}
4312
4313//______________________________________________________________________________
4314void AliReconstruction::WriteESDfriend() {
4315 // Fill the ESD friend in the tree. The required fraction of ESD friends is stored
4316 // in fFractionFriends. We select events where we store the ESD friends according
4317 // to the following algorithm:
4318 // 1. Store all Cosmic or Calibration events within the required fraction
4319 // 2. Sample "high Pt" events within the remaining fraction after step 1.
4320 // 3. Sample randomly events if we still have remaining slot
4321
4322 fNall++;
4323 Bool_t isSelected = kFALSE;
4324 //
4325 // Store all friends for B field OFF
4326 if (TMath::Abs(AliTrackerBase::GetBz())<0.5) isSelected=kTRUE;
4327
4328 if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
4329 fNspecie++;
4330
4331 isSelected = kTRUE;
4332 fSspecie++;
4333 }
4334
4335 Double_t remainingFraction = fFractionFriends;
4336 remainingFraction -= ((Double_t)(fSspecie)/(Double_t)(fNall));
4337
4338 if (IsHighPt()) { // Selection of "high Pt" events
4339 fNhighPt++;
4340 Double_t curentHighPtFraction = ((Double_t)(fNhighPt+1))/((Double_t)(fNall+1));
4341 // "Bayesian" estimate supposing that without events all the events are of the required type
4342
4343 if (!isSelected) {
4344 Double_t rnd = gRandom->Rndm()*curentHighPtFraction;
4345 if (rnd<remainingFraction) {
4346 isSelected = kTRUE;
4347 fShighPt++;
4348 }
4349 }
4350 }
4351 remainingFraction -= ((Double_t)(fShighPt)/(Double_t)(fNall));
4352
4353 // Random selection to fill the remaining fraction (if any)
4354 if (!isSelected) {
4355 Double_t rnd = gRandom->Rndm();
4356 if (rnd<remainingFraction) {
4357 isSelected = kTRUE;
4358 }
4359 }
4360
4361 if (!isSelected) {
4362 fesdf->~AliESDfriend();
4363 new (fesdf) AliESDfriend(); // Reset...
4364 fesdf->SetSkipBit(kTRUE);
4365 }
4366 //
4367 ftreeF->Fill();
4368}
4369
4370//_________________________________________________________________
4371void AliReconstruction::DeleteDigits(const TString& detectors)
4372{
4373 // delete requested digit files produced at current event
4374 static int iEvent = 0;
4375 if (detectors.IsNull()) return;
4376 TString detStr = detectors;
4377 AliInfo(Form("Deleting Digits: %s",detectors.Data()));
4378
4379 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4380 gSystem->Exec(Form("if [ -e %s.Digits.root ]; then\nrm %s.Digits.root\nfi",
4381 fgkDetectorName[iDet],fgkDetectorName[iDet]));
4382 }
4383 AliSysInfo::AddStamp(Form("DelDigits_%d",iEvent), 0,0,iEvent);
4384 iEvent++;
4385}
4386
4387//_________________________________________________________________
4388void AliReconstruction::DeleteRecPoints(const TString& detectors)
4389{
4390 // delete requested recpoint files produced at current event
4391 static int iEvent = 0;
4392 if (detectors.IsNull()) return;
4393 TString detStr = detectors;
4394 AliInfo(Form("Deleting Recpoints: %s",detectors.Data()));
4395 //
4396 for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4397 gSystem->Exec(Form("if [ -e %s.RecPoints.root ]; then\nrm %s.RecPoints.root\nfi",
4398 fgkDetectorName[iDet],fgkDetectorName[iDet]));
4399 }
4400 AliSysInfo::AddStamp(Form("DelRecPoints_%d",iEvent), 0,0,iEvent);
4401 iEvent++;
4402}
4403
4404//_________________________________________________________________
4405void AliReconstruction::SetStopOnResourcesExcess(Int_t vRSS,Int_t vVMEM)
4406{
4407 // require checking the resources left and stopping on excess
4408 // if 0 : no check is done
4409 // if >0 : stop reconstruction if exceeds this value
4410 // if <0 : use as margin to system limits
4411 //
4412 const int kKB2MB = 1024;
4413 const int kInfMem = 9999999;
4414 //
4415 struct rlimit r;
4416 int pgSize = getpagesize();
4417 //
4418 if (vRSS>0) {
4419 fMaxRSS = vRSS;
4420 AliInfo(Form("Setting max. RSS usage to user value %d MB",fMaxRSS));
4421 }
4422 else if (vRSS<0) {
4423 getrlimit(RLIMIT_RSS,&r);
4424 fMaxRSS = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vRSS;
4425 AliInfo(Form("Setting max. RSS usage to system hard limit %d%s MB (%d margin)",fMaxRSS,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vRSS));
4426 }
4427 else {AliInfo("No check on RSS memory usage will be applied");}
4428 //
4429 if (vVMEM>0) {
4430 fMaxVMEM = vVMEM;
4431 AliInfo(Form("Setting max. VMEM usage to user value %d MB",fMaxVMEM));
4432 }
4433 else if (vVMEM<0) {
4434 getrlimit(RLIMIT_AS,&r);
4435 fMaxVMEM = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vVMEM;
4436 AliInfo(Form("Setting max. VMEM usage to system hard limit %d%s MB (%d margin)",fMaxVMEM,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vVMEM));
4437 }
4438 else {AliInfo("No check on RSS memory usage will be applied");}
4439 //
4440}
4441
4442//_________________________________________________________________
4443Bool_t AliReconstruction::HasEnoughResources(int ev)
4444{
4445 // check if process consumed more than allowed resources
4446 const int kKB2MB = 1024;
4447 Bool_t res = kTRUE;
4448 if (!fMaxRSS && !fMaxVMEM) return res;
4449 //
4450 ProcInfo_t procInfo;
4451 gSystem->GetProcInfo(&procInfo);
4452 if (procInfo.fMemResident/kKB2MB > fMaxRSS) res = kFALSE;
4453 if (procInfo.fMemVirtual/kKB2MB > fMaxVMEM) res = kFALSE;
4454 //
4455 if (!res) {
4456 AliInfo(Form("Job exceeded allowed limits: RSS:%d (%d) VMEM:%d (%d), will stop",
4457 int(procInfo.fMemResident/kKB2MB),fMaxRSS,
4458 int(procInfo.fMemVirtual/kKB2MB) ,fMaxVMEM));
4459 //
4460 gSystem->Exec(Form("if [ -e %s ]; then\nrm %s\nfi\necho %d > %s",fgkStopEvFName,fgkStopEvFName,ev,fgkStopEvFName));
4461 fStopped = kTRUE;
4462 }
4463 return res;
4464}