]> git.uio.no Git - u/mrichter/AliRoot.git/blame - STEER/AliReconstruction.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
New functions needed for effective removal of splitted track (M.Ivanov)
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
CommitLineData
596a855f 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. //
c71de921 29// //
30// If the input to the reconstruction are not simulated digits but raw data, //
31// this can be specified by an argument of the Run method or by the method //
32// //
33// rec.SetInput("..."); //
34// //
35// The input formats and the corresponding argument are: //
36// - DDL raw data files: directory name, ends with "/" //
37// - raw data root file: root file name, extension ".root" //
38// - raw data DATE file: DATE file name, any other non-empty string //
39// - MC root files : empty string, default //
40// //
b26c3770 41// By default all events are reconstructed. The reconstruction can be //
42// limited to a range of events by giving the index of the first and the //
43// last event as an argument to the Run method or by calling //
44// //
45// rec.SetEventRange(..., ...); //
46// //
47// The index -1 (default) can be used for the last event to indicate no //
48// upper limit of the event range. //
49// //
973388c2 50// In case of raw-data reconstruction the user can modify the default //
51// number of events per digits/clusters/tracks file. In case the option //
52// is not used the number is set 1. In case the user provides 0, than //
53// the number of events is equal to the number of events inside the //
54// raw-data file (i.e. one digits/clusters/tracks file): //
55// //
56// rec.SetNumberOfEventsPerFile(...); //
57// //
58// //
596a855f 59// The name of the galice file can be changed from the default //
e583c30d 60// "galice.root" by passing it as argument to the AliReconstruction //
61// constructor or by //
596a855f 62// //
63// rec.SetGAliceFile("..."); //
64// //
59697224 65// The local reconstruction can be switched on or off for individual //
66// detectors by //
596a855f 67// //
59697224 68// rec.SetRunLocalReconstruction("..."); //
596a855f 69// //
70// The argument is a (case sensitive) string with the names of the //
71// detectors separated by a space. The special string "ALL" selects all //
72// available detectors. This is the default. //
73// //
c71de921 74// The reconstruction of the primary vertex position can be switched off by //
75// //
76// rec.SetRunVertexFinder(kFALSE); //
77// //
b8cd5251 78// The tracking and the creation of ESD tracks can be switched on for //
79// selected detectors by //
596a855f 80// //
b8cd5251 81// rec.SetRunTracking("..."); //
596a855f 82// //
c84a5e9e 83// Uniform/nonuniform field tracking switches (default: uniform field) //
84// //
1d99986f 85// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
c84a5e9e 86// //
596a855f 87// The filling of additional ESD information can be steered by //
88// //
89// rec.SetFillESD("..."); //
90// //
b8cd5251 91// Again, for both methods the string specifies the list of detectors. //
92// The default is "ALL". //
93// //
94// The call of the shortcut method //
95// //
96// rec.SetRunReconstruction("..."); //
97// //
98// is equivalent to calling SetRunLocalReconstruction, SetRunTracking and //
99// SetFillESD with the same detector selecting string as argument. //
596a855f 100// //
c71de921 101// The reconstruction requires digits or raw data as input. For the creation //
102// of digits and raw data have a look at the class AliSimulation. //
596a855f 103// //
24f7a148 104// For debug purposes the method SetCheckPointLevel can be used. If the //
105// argument is greater than 0, files with ESD events will be written after //
106// selected steps of the reconstruction for each event: //
107// level 1: after tracking and after filling of ESD (final) //
108// level 2: in addition after each tracking step //
109// level 3: in addition after the filling of ESD for each detector //
110// If a final check point file exists for an event, this event will be //
111// skipped in the reconstruction. The tracking and the filling of ESD for //
112// a detector will be skipped as well, if the corresponding check point //
113// file exists. The ESD event will then be loaded from the file instead. //
114// //
596a855f 115///////////////////////////////////////////////////////////////////////////////
116
024a7e64 117#include <TArrayF.h>
118#include <TFile.h>
119#include <TSystem.h>
120#include <TROOT.h>
121#include <TPluginManager.h>
3103d196 122#include <TGeoManager.h>
2bdb9d38 123#include <TLorentzVector.h>
596a855f 124
125#include "AliReconstruction.h"
87932dab 126#include "AliCodeTimer.h"
b8cd5251 127#include "AliReconstructor.h"
815c2b38 128#include "AliLog.h"
596a855f 129#include "AliRunLoader.h"
130#include "AliRun.h"
b649205a 131#include "AliRawReaderFile.h"
132#include "AliRawReaderDate.h"
133#include "AliRawReaderRoot.h"
001397cd 134#include "AliRawEventHeaderBase.h"
af885e0f 135#include "AliESDEvent.h"
faffd83e 136#include "AliESDMuonTrack.h"
1d99986f 137#include "AliESDfriend.h"
2257f27e 138#include "AliESDVertex.h"
faffd83e 139#include "AliESDcascade.h"
140#include "AliESDkink.h"
141#include "AliESDtrack.h"
142#include "AliESDCaloCluster.h"
32e449be 143#include "AliMultiplicity.h"
c84a5e9e 144#include "AliTracker.h"
2257f27e 145#include "AliVertexer.h"
c5e3e5d1 146#include "AliVertexerTracks.h"
5e4ff34d 147#include "AliV0vertexer.h"
148#include "AliCascadeVertexer.h"
596a855f 149#include "AliHeader.h"
150#include "AliGenEventHeader.h"
b26c3770 151#include "AliPID.h"
596a855f 152#include "AliESDpid.h"
ff8bb5ae 153#include "AliESDtrack.h"
f3a97c86 154
08e1a23e 155#include "AliESDTagCreator.h"
a1069ee1 156#include "AliAODTagCreator.h"
f3a97c86 157
25be1e5c 158#include "AliGeomManager.h"
98937d93 159#include "AliTrackPointArray.h"
b0314964 160#include "AliCDBManager.h"
6bae477a 161#include "AliCDBEntry.h"
162#include "AliAlignObj.h"
f3a97c86 163
b647652d 164#include "AliCentralTrigger.h"
165#include "AliCTPRawStream.h"
166
f29f1726 167#include "AliAODEvent.h"
168#include "AliAODHeader.h"
169#include "AliAODTrack.h"
170#include "AliAODVertex.h"
171#include "AliAODCluster.h"
172
a5fa6165 173#include "AliQualAssDataMaker.h"
f29f1726 174
596a855f 175ClassImp(AliReconstruction)
176
177
c757bafd 178//_____________________________________________________________________________
b384f8a4 179const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
c757bafd 180
596a855f 181//_____________________________________________________________________________
024cf675 182AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri,
e583c30d 183 const char* name, const char* title) :
184 TNamed(name, title),
185
c84a5e9e 186 fUniformField(kTRUE),
2257f27e 187 fRunVertexFinder(kTRUE),
1f46a9ae 188 fRunHLTTracking(kFALSE),
e66fbafb 189 fRunMuonTracking(kFALSE),
1d99986f 190 fStopOnError(kFALSE),
191 fWriteAlignmentData(kFALSE),
d64bd07d 192 fCleanESD(kTRUE),
1d99986f 193 fWriteESDfriend(kFALSE),
a7807689 194 fWriteAOD(kFALSE),
b647652d 195 fFillTriggerESD(kTRUE),
1d99986f 196
197 fRunLocalReconstruction("ALL"),
b8cd5251 198 fRunTracking("ALL"),
e583c30d 199 fFillESD("ALL"),
200 fGAliceFileName(gAliceFilename),
b649205a 201 fInput(""),
35042093 202 fEquipIdMap(""),
b26c3770 203 fFirstEvent(0),
204 fLastEvent(-1),
973388c2 205 fNumberOfEventsPerFile(1),
24f7a148 206 fCheckPointLevel(0),
b8cd5251 207 fOptions(),
6bae477a 208 fLoadAlignFromCDB(kTRUE),
209 fLoadAlignData("ALL"),
46698ae4 210 fESDPar(""),
e583c30d 211
212 fRunLoader(NULL),
b649205a 213 fRawReader(NULL),
b8cd5251 214
98937d93 215 fVertexer(NULL),
9178838a 216 fDiamondProfile(NULL),
98937d93 217
6bae477a 218 fAlignObjArray(NULL),
ec92bee0 219 fCDBUri(cdbUri),
00aa02d5 220 fRemoteCDBUri(""),
ec92bee0 221 fSpecCDBUri()
596a855f 222{
223// create reconstruction object with default parameters
b8cd5251 224
225 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
226 fReconstructor[iDet] = NULL;
227 fLoader[iDet] = NULL;
228 fTracker[iDet] = NULL;
d101408a 229 fQualAssDataMaker[iDet] = NULL;
b8cd5251 230 }
e47c4c2e 231 AliPID pid;
596a855f 232}
233
234//_____________________________________________________________________________
235AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
e583c30d 236 TNamed(rec),
237
c84a5e9e 238 fUniformField(rec.fUniformField),
2257f27e 239 fRunVertexFinder(rec.fRunVertexFinder),
1f46a9ae 240 fRunHLTTracking(rec.fRunHLTTracking),
e66fbafb 241 fRunMuonTracking(rec.fRunMuonTracking),
1d99986f 242 fStopOnError(rec.fStopOnError),
243 fWriteAlignmentData(rec.fWriteAlignmentData),
d64bd07d 244 fCleanESD(rec.fCleanESD),
1d99986f 245 fWriteESDfriend(rec.fWriteESDfriend),
a7807689 246 fWriteAOD(rec.fWriteAOD),
b647652d 247 fFillTriggerESD(rec.fFillTriggerESD),
1d99986f 248
249 fRunLocalReconstruction(rec.fRunLocalReconstruction),
e583c30d 250 fRunTracking(rec.fRunTracking),
251 fFillESD(rec.fFillESD),
252 fGAliceFileName(rec.fGAliceFileName),
b649205a 253 fInput(rec.fInput),
35042093 254 fEquipIdMap(rec.fEquipIdMap),
b26c3770 255 fFirstEvent(rec.fFirstEvent),
256 fLastEvent(rec.fLastEvent),
973388c2 257 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
24f7a148 258 fCheckPointLevel(0),
b8cd5251 259 fOptions(),
6bae477a 260 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
261 fLoadAlignData(rec.fLoadAlignData),
46698ae4 262 fESDPar(rec.fESDPar),
e583c30d 263
264 fRunLoader(NULL),
b649205a 265 fRawReader(NULL),
b8cd5251 266
98937d93 267 fVertexer(NULL),
9178838a 268 fDiamondProfile(NULL),
98937d93 269
6bae477a 270 fAlignObjArray(rec.fAlignObjArray),
ec92bee0 271 fCDBUri(rec.fCDBUri),
00aa02d5 272 fRemoteCDBUri(rec.fRemoteCDBUri),
ec92bee0 273 fSpecCDBUri()
596a855f 274{
275// copy constructor
276
ec92bee0 277 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
efd2085e 278 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
279 }
b8cd5251 280 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
281 fReconstructor[iDet] = NULL;
282 fLoader[iDet] = NULL;
283 fTracker[iDet] = NULL;
d101408a 284 fQualAssDataMaker[iDet] = NULL;
b8cd5251 285 }
ec92bee0 286 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
287 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
288 }
596a855f 289}
290
291//_____________________________________________________________________________
292AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
293{
294// assignment operator
295
296 this->~AliReconstruction();
297 new(this) AliReconstruction(rec);
298 return *this;
299}
300
301//_____________________________________________________________________________
302AliReconstruction::~AliReconstruction()
303{
304// clean up
305
e583c30d 306 CleanUp();
efd2085e 307 fOptions.Delete();
ec92bee0 308 fSpecCDBUri.Delete();
87932dab 309
310 AliCodeTimer::Instance()->Print();
596a855f 311}
312
024cf675 313//_____________________________________________________________________________
314void AliReconstruction::InitCDBStorage()
315{
316// activate a default CDB storage
317// First check if we have any CDB storage set, because it is used
318// to retrieve the calibration and alignment constants
319
320 AliCDBManager* man = AliCDBManager::Instance();
ec92bee0 321 if (man->IsDefaultStorageSet())
024cf675 322 {
323 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 324 AliWarning("Default CDB storage has been already set !");
325 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
024cf675 326 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 327 fCDBUri = "";
328 }
329 else {
b8ec52f6 330 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
331 AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
332 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
ec92bee0 333 man->SetDefaultStorage(fCDBUri);
334 }
335
00aa02d5 336 // Remote storage (the Grid storage) is used if it is activated
337 // and if the object is not found in the default storage
338 if (man->IsRemoteStorageSet())
339 {
340 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
341 AliWarning("Remote CDB storage has been already set !");
342 AliWarning(Form("Ignoring the remote storage declared in AliReconstruction: %s",fRemoteCDBUri.Data()));
343 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
344 fRemoteCDBUri = "";
345 }
346 else {
347 AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
348 AliDebug(2, Form("Remote CDB storage is set to: %s",fRemoteCDBUri.Data()));
349 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
350 man->SetRemoteStorage(fRemoteCDBUri);
351 }
352
ec92bee0 353 // Now activate the detector specific CDB storage locations
c3a7b59a 354 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
355 TObject* obj = fSpecCDBUri[i];
356 if (!obj) continue;
b8ec52f6 357 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
358 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
359 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
c3a7b59a 360 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
ec92bee0 361 }
727d0766 362 man->Print();
024cf675 363}
364
365//_____________________________________________________________________________
366void AliReconstruction::SetDefaultStorage(const char* uri) {
ec92bee0 367// Store the desired default CDB storage location
368// Activate it later within the Run() method
024cf675 369
ec92bee0 370 fCDBUri = uri;
024cf675 371
372}
373
374//_____________________________________________________________________________
00aa02d5 375void AliReconstruction::SetRemoteStorage(const char* uri) {
376// Store the desired remote CDB storage location
377// Activate it later within the Run() method
378// Remote storage (the Grid storage) is used if it is activated
379// and if the object is not found in the default storage
380
381 fRemoteCDBUri = uri;
382
383}
384
385//_____________________________________________________________________________
c3a7b59a 386void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
ec92bee0 387// Store a detector-specific CDB storage location
388// Activate it later within the Run() method
024cf675 389
c3a7b59a 390 AliCDBPath aPath(calibType);
391 if(!aPath.IsValid()){
392 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
393 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
394 if(!strcmp(calibType, fgkDetectorName[iDet])) {
395 aPath.SetPath(Form("%s/*", calibType));
396 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
397 break;
398 }
399 }
400 if(!aPath.IsValid()){
401 AliError(Form("Not a valid path or detector: %s", calibType));
402 return;
403 }
404 }
405
53dd3c3d 406// // check that calibType refers to a "valid" detector name
407// Bool_t isDetector = kFALSE;
408// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
409// TString detName = fgkDetectorName[iDet];
410// if(aPath.GetLevel0() == detName) {
411// isDetector = kTRUE;
412// break;
413// }
414// }
415//
416// if(!isDetector) {
417// AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
418// return;
419// }
c3a7b59a 420
421 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
ec92bee0 422 if (obj) fSpecCDBUri.Remove(obj);
c3a7b59a 423 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
024cf675 424
425}
426
46698ae4 427
428
429
6bae477a 430//_____________________________________________________________________________
431Bool_t AliReconstruction::SetRunNumber()
432{
433 // The method is called in Run() in order
434 // to set a correct run number.
435 // In case of raw data reconstruction the
436 // run number is taken from the raw data header
437
438 if(AliCDBManager::Instance()->GetRun() < 0) {
439 if (!fRunLoader) {
440 AliError("No run loader is found !");
441 return kFALSE;
442 }
443 // read run number from gAlice
ec92bee0 444 if(fRunLoader->GetAliRun())
445 AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
446 else {
447 if(fRawReader) {
448 if(fRawReader->NextEvent()) {
449 AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
450 fRawReader->RewindEvents();
451 }
452 else {
453 AliError("No raw-data events found !");
454 return kFALSE;
455 }
456 }
457 else {
458 AliError("Neither gAlice nor RawReader objects are found !");
459 return kFALSE;
460 }
461 }
462 AliInfo(Form("CDB Run number: %d",AliCDBManager::Instance()->GetRun()));
6bae477a 463 }
464 return kTRUE;
465}
466
6bae477a 467//_____________________________________________________________________________
468Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
469{
470 // Read the alignment objects from CDB.
471 // Each detector is supposed to have the
472 // alignment objects in DET/Align/Data CDB path.
473 // All the detector objects are then collected,
474 // sorted by geometry level (starting from ALIC) and
475 // then applied to the TGeo geometry.
476 // Finally an overlaps check is performed.
477
478 // Load alignment data from CDB and fill fAlignObjArray
479 if(fLoadAlignFromCDB){
6bae477a 480
25be1e5c 481 TString detStr = detectors;
482 TString loadAlObjsListOfDets = "";
483
484 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
485 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
486 loadAlObjsListOfDets += fgkDetectorName[iDet];
487 loadAlObjsListOfDets += " ";
488 } // end loop over detectors
53dd3c3d 489 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
98e303d9 490 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
25be1e5c 491 }else{
492 // Check if the array with alignment objects was
493 // provided by the user. If yes, apply the objects
494 // to the present TGeo geometry
495 if (fAlignObjArray) {
496 if (gGeoManager && gGeoManager->IsClosed()) {
98e303d9 497 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
25be1e5c 498 AliError("The misalignment of one or more volumes failed!"
499 "Compare the list of simulated detectors and the list of detector alignment data!");
500 return kFALSE;
501 }
502 }
503 else {
504 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
6bae477a 505 return kFALSE;
506 }
507 }
6bae477a 508 }
25be1e5c 509
8e245d15 510 delete fAlignObjArray; fAlignObjArray=0;
a03b0371 511
6bae477a 512 return kTRUE;
513}
596a855f 514
515//_____________________________________________________________________________
516void AliReconstruction::SetGAliceFile(const char* fileName)
517{
518// set the name of the galice file
519
520 fGAliceFileName = fileName;
521}
522
efd2085e 523//_____________________________________________________________________________
524void AliReconstruction::SetOption(const char* detector, const char* option)
525{
526// set options for the reconstruction of a detector
527
528 TObject* obj = fOptions.FindObject(detector);
529 if (obj) fOptions.Remove(obj);
530 fOptions.Add(new TNamed(detector, option));
531}
532
596a855f 533
534//_____________________________________________________________________________
4a33489c 535Bool_t AliReconstruction::Run(const char* input)
596a855f 536{
537// run the reconstruction
538
87932dab 539 AliCodeTimerAuto("")
540
b649205a 541 // set the input
542 if (!input) input = fInput.Data();
543 TString fileName(input);
544 if (fileName.EndsWith("/")) {
545 fRawReader = new AliRawReaderFile(fileName);
546 } else if (fileName.EndsWith(".root")) {
547 fRawReader = new AliRawReaderRoot(fileName);
548 } else if (!fileName.IsNull()) {
549 fRawReader = new AliRawReaderDate(fileName);
550 fRawReader->SelectEvents(7);
551 }
35042093 552 if (!fEquipIdMap.IsNull() && fRawReader)
553 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
554
b649205a 555
f08fc9f5 556 // get the run loader
557 if (!InitRunLoader()) return kFALSE;
596a855f 558
ec92bee0 559 // Initialize the CDB storage
560 InitCDBStorage();
561
6bae477a 562 // Set run number in CDBManager (if it is not already set by the user)
563 if (!SetRunNumber()) if (fStopOnError) return kFALSE;
564
565 // Import ideal TGeo geometry and apply misalignment
566 if (!gGeoManager) {
567 TString geom(gSystem->DirName(fGAliceFileName));
568 geom += "/geometry.root";
98e303d9 569 AliGeomManager::LoadGeometry(geom.Data());
6bae477a 570 if (!gGeoManager) if (fStopOnError) return kFALSE;
571 }
8e245d15 572
573 AliCDBManager* man = AliCDBManager::Instance();
6bae477a 574 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
575
596a855f 576 // local reconstruction
59697224 577 if (!fRunLocalReconstruction.IsNull()) {
578 if (!RunLocalReconstruction(fRunLocalReconstruction)) {
e583c30d 579 if (fStopOnError) {CleanUp(); return kFALSE;}
596a855f 580 }
581 }
b26c3770 582// if (!fRunVertexFinder && fRunTracking.IsNull() &&
583// fFillESD.IsNull()) return kTRUE;
2257f27e 584
585 // get vertexer
586 if (fRunVertexFinder && !CreateVertexer()) {
587 if (fStopOnError) {
588 CleanUp();
589 return kFALSE;
590 }
591 }
596a855f 592
f08fc9f5 593 // get trackers
b8cd5251 594 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
24f7a148 595 if (fStopOnError) {
596 CleanUp();
597 return kFALSE;
598 }
596a855f 599 }
24f7a148 600
b26c3770 601 // get the possibly already existing ESD file and tree
af885e0f 602 AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
b26c3770 603 TFile* fileOld = NULL;
1f46a9ae 604 TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
b26c3770 605 if (!gSystem->AccessPathName("AliESDs.root")){
606 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
607 fileOld = TFile::Open("AliESDs.old.root");
608 if (fileOld && fileOld->IsOpen()) {
609 treeOld = (TTree*) fileOld->Get("esdTree");
46698ae4 610 if (treeOld)esd->ReadFromTree(treeOld);
1f46a9ae 611 hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
46698ae4 612 if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld);
b26c3770 613 }
614 }
615
36711aa4 616 // create the ESD output file and tree
596a855f 617 TFile* file = TFile::Open("AliESDs.root", "RECREATE");
46698ae4 618 file->SetCompressionLevel(2);
596a855f 619 if (!file->IsOpen()) {
815c2b38 620 AliError("opening AliESDs.root failed");
b26c3770 621 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
596a855f 622 }
46698ae4 623
36711aa4 624 TTree* tree = new TTree("esdTree", "Tree with ESD objects");
af885e0f 625 esd = new AliESDEvent();
46698ae4 626 esd->CreateStdContent();
627 esd->WriteToTree(tree);
628
1f46a9ae 629 TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
af885e0f 630 hltesd = new AliESDEvent();
46698ae4 631 hltesd->CreateStdContent();
632 hltesd->WriteToTree(hlttree);
633
634 /* CKB Why?
1f46a9ae 635 delete esd; delete hltesd;
636 esd = NULL; hltesd = NULL;
46698ae4 637 */
500d54ab 638 // create the branch with ESD additions
5728d3d5 639
640
641
46698ae4 642 AliESDfriend *esdf = 0;
1d99986f 643 if (fWriteESDfriend) {
46698ae4 644 esdf = new AliESDfriend();
645 TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf);
646 br->SetFile("AliESDfriends.root");
647 esd->AddObject(esdf);
1d99986f 648 }
5728d3d5 649
46698ae4 650
17c86e90 651 // Get the diamond profile from OCDB
652 AliCDBEntry* entry = AliCDBManager::Instance()
653 ->Get("GRP/Calib/MeanVertex");
654
655 if(entry) {
656 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
657 } else {
658 AliError("No diamond profile found in OCDB!");
659 }
660
20e5681c 661 AliVertexerTracks tVertexer(AliTracker::GetBz());
9178838a 662 if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
c5e3e5d1 663
596a855f 664 // loop over events
a5fa6165 665
b649205a 666 if (fRawReader) fRawReader->RewindEvents();
a5fa6165 667 TString detStr(fFillESD) ;
668
669// initialises quality assurance for ESDs
670 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
671 if (!IsSelected(fgkDetectorName[iDet], detStr))
672 continue;
673 AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
674 if (!qadm)
675 continue;
676 qadm->Init(AliQualAss::kESDS) ;
677 }
f08fc9f5 678
95cee32f 679 ProcInfo_t ProcInfo;
680 gSystem->GetProcInfo(&ProcInfo);
681 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
596a855f 682 for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
b26c3770 683 if (fRawReader) fRawReader->NextEvent();
4a33489c 684 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
b26c3770 685 // copy old ESD to the new one
686 if (treeOld) {
46698ae4 687 esd->ReadFromTree(treeOld);
b26c3770 688 treeOld->GetEntry(iEvent);
689 }
690 tree->Fill();
1f46a9ae 691 if (hlttreeOld) {
46698ae4 692 esd->ReadFromTree(hlttreeOld);
1f46a9ae 693 hlttreeOld->GetEntry(iEvent);
694 }
695 hlttree->Fill();
b26c3770 696 continue;
697 }
46698ae4 698
815c2b38 699 AliInfo(Form("processing event %d", iEvent));
596a855f 700 fRunLoader->GetEvent(iEvent);
24f7a148 701
bb0901a4 702 char aFileName[256];
703 sprintf(aFileName, "ESD_%d.%d_final.root",
f08fc9f5 704 fRunLoader->GetHeader()->GetRun(),
705 fRunLoader->GetHeader()->GetEventNrInRun());
bb0901a4 706 if (!gSystem->AccessPathName(aFileName)) continue;
24f7a148 707
b26c3770 708 // local reconstruction
709 if (!fRunLocalReconstruction.IsNull()) {
710 if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
711 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
712 }
713 }
714
46698ae4 715
f08fc9f5 716 esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1f46a9ae 717 hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
31fd97b2 718 esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
719 hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
46698ae4 720
d6ee376f 721 // Set magnetic field from the tracker
722 esd->SetMagneticField(AliTracker::GetBz());
723 hltesd->SetMagneticField(AliTracker::GetBz());
596a855f 724
46698ae4 725
726
2e3550da 727 // Fill raw-data error log into the ESD
728 if (fRawReader) FillRawDataErrorLog(iEvent,esd);
729
2257f27e 730 // vertex finder
731 if (fRunVertexFinder) {
732 if (!ReadESD(esd, "vertex")) {
733 if (!RunVertexFinder(esd)) {
b26c3770 734 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
2257f27e 735 }
736 if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
737 }
738 }
739
1f46a9ae 740 // HLT tracking
741 if (!fRunTracking.IsNull()) {
742 if (fRunHLTTracking) {
743 hltesd->SetVertex(esd->GetVertex());
744 if (!RunHLTTracking(hltesd)) {
745 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
746 }
747 }
748 }
749
e66fbafb 750 // Muon tracking
b8cd5251 751 if (!fRunTracking.IsNull()) {
e66fbafb 752 if (fRunMuonTracking) {
761350a6 753 if (!RunMuonTracking(esd)) {
b26c3770 754 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
24f7a148 755 }
596a855f 756 }
757 }
758
e66fbafb 759 // barrel tracking
760 if (!fRunTracking.IsNull()) {
21c573b7 761 if (!ReadESD(esd, "tracking")) {
762 if (!RunTracking(esd)) {
763 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
e66fbafb 764 }
21c573b7 765 if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
e66fbafb 766 }
767 }
21c573b7 768
596a855f 769 // fill ESD
770 if (!fFillESD.IsNull()) {
771 if (!FillESD(esd, fFillESD)) {
b26c3770 772 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
596a855f 773 }
774 }
a5fa6165 775
776 if (!fFillESD.IsNull())
777 RunQualAss(fFillESD.Data(), esd);
778
001397cd 779 // fill Event header information from the RawEventHeader
780 if (fRawReader){FillRawEventHeaderESD(esd);}
596a855f 781
782 // combined PID
783 AliESDpid::MakePID(esd);
24f7a148 784 if (fCheckPointLevel > 1) WriteESD(esd, "PID");
596a855f 785
b647652d 786 if (fFillTriggerESD) {
787 if (!ReadESD(esd, "trigger")) {
788 if (!FillTriggerESD(esd)) {
789 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
790 }
791 if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
792 }
793 }
794
a03cd2e0 795 //Try to improve the reconstructed primary vertex position using the tracks
c060d7fe 796 AliESDVertex *pvtx=0;
797 Bool_t dovertex=kTRUE;
798 TObject* obj = fOptions.FindObject("ITS");
799 if (obj) {
800 TString optITS = obj->GetTitle();
801 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
802 dovertex=kFALSE;
803 }
804 if(dovertex) pvtx=tVertexer.FindPrimaryVertex(esd);
17c86e90 805 if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
806
a03cd2e0 807 if (pvtx)
808 if (pvtx->GetStatus()) {
809 // Store the improved primary vertex
810 esd->SetPrimaryVertex(pvtx);
811 // Propagate the tracks to the DCA to the improved primary vertex
812 Double_t somethingbig = 777.;
813 Double_t bz = esd->GetMagneticField();
814 Int_t nt=esd->GetNumberOfTracks();
815 while (nt--) {
816 AliESDtrack *t = esd->GetTrack(nt);
817 t->RelateToVertex(pvtx, bz, somethingbig);
818 }
819 }
c5e3e5d1 820
5e4ff34d 821 {
822 // V0 finding
823 AliV0vertexer vtxer;
824 vtxer.Tracks2V0vertices(esd);
825
826 // Cascade finding
827 AliCascadeVertexer cvtxer;
828 cvtxer.V0sTracks2CascadeVertices(esd);
829 }
830
596a855f 831 // write ESD
d64bd07d 832 if (fCleanESD) CleanESD(esd);
1d99986f 833 if (fWriteESDfriend) {
99f99e0e 834 esdf->~AliESDfriend();
46698ae4 835 new (esdf) AliESDfriend(); // Reset...
836 esd->GetESDfriend(esdf);
1d99986f 837 }
500d54ab 838 tree->Fill();
839
840 // write HLT ESD
841 hlttree->Fill();
1d99986f 842
f3a97c86 843 if (fCheckPointLevel > 0) WriteESD(esd, "final");
46698ae4 844 esd->Reset();
845 hltesd->Reset();
5728d3d5 846 if (fWriteESDfriend) {
99f99e0e 847 esdf->~AliESDfriend();
5728d3d5 848 new (esdf) AliESDfriend(); // Reset...
849 }
46698ae4 850 // esdf->Reset();
851 // delete esdf; esdf = 0;
a5fa6165 852 // ESD QA
853
95cee32f 854 gSystem->GetProcInfo(&ProcInfo);
855 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
a5fa6165 856 }
857
858 detStr = fFillESD ;
859 // write quality assurance ESDs data (one entry for all events)
860 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
861 if (!IsSelected(fgkDetectorName[iDet], detStr))
862 continue;
863 AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
864 if (!qadm)
865 continue;
866 qadm->Finish(AliQualAss::kESDS) ;
867 }
5728d3d5 868
46698ae4 869 tree->GetUserInfo()->Add(esd);
870 hlttree->GetUserInfo()->Add(hltesd);
871
872
873
874 if(fESDPar.Contains("ESD.par")){
875 AliInfo("Attaching ESD.par to Tree");
876 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
877 tree->GetUserInfo()->Add(fn);
596a855f 878 }
879
46698ae4 880
36711aa4 881 file->cd();
a9c0e6db 882 if (fWriteESDfriend)
883 tree->SetBranchStatus("ESDfriend*",0);
36711aa4 884 tree->Write();
1f46a9ae 885 hlttree->Write();
f3a97c86 886
a7807689 887 if (fWriteAOD) {
f29f1726 888 TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
889 ESDFile2AODFile(file, aodFile);
890 aodFile->Close();
a7807689 891 }
892
46698ae4 893 gROOT->cd();
151e0c96 894 CleanUp(file, fileOld);
895
f3a97c86 896 // Create tags for the events in the ESD tree (the ESD tree is always present)
897 // In case of empty events the tags will contain dummy values
08e1a23e 898 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
899 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent);
a1069ee1 900 if (fWriteAOD) {
901 AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
902 aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent);
903 }
596a855f 904
905 return kTRUE;
906}
907
908
909//_____________________________________________________________________________
59697224 910Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
596a855f 911{
59697224 912// run the local reconstruction
596a855f 913
87932dab 914 AliCodeTimerAuto("")
030b532d 915
8e245d15 916 AliCDBManager* man = AliCDBManager::Instance();
917 Bool_t origCache = man->GetCacheFlag();
918
596a855f 919 TString detStr = detectors;
b8cd5251 920 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
921 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
922 AliReconstructor* reconstructor = GetReconstructor(iDet);
923 if (!reconstructor) continue;
b26c3770 924 if (reconstructor->HasLocalReconstruction()) continue;
b8cd5251 925
87932dab 926 AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b8cd5251 927 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 928
929 AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
8e245d15 930 AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
931
932 man->SetCacheFlag(kTRUE);
933 TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
934 man->GetAll(calibPath); // entries are cached!
935
87932dab 936 AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
937
b8cd5251 938 if (fRawReader) {
939 fRawReader->RewindEvents();
940 reconstructor->Reconstruct(fRunLoader, fRawReader);
941 } else {
942 reconstructor->Reconstruct(fRunLoader);
596a855f 943 }
87932dab 944
945 AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
8e245d15 946
947 // unload calibration data
98e303d9 948 man->UnloadFromCache(calibPath);
949 //man->ClearCache();
596a855f 950 }
951
8e245d15 952 man->SetCacheFlag(origCache);
953
596a855f 954 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 955 AliError(Form("the following detectors were not found: %s",
956 detStr.Data()));
596a855f 957 if (fStopOnError) return kFALSE;
958 }
959
960 return kTRUE;
961}
962
b26c3770 963//_____________________________________________________________________________
964Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
965{
966// run the local reconstruction
967
87932dab 968 AliCodeTimerAuto("")
b26c3770 969
970 TString detStr = detectors;
971 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
972 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
973 AliReconstructor* reconstructor = GetReconstructor(iDet);
974 if (!reconstructor) continue;
975 AliLoader* loader = fLoader[iDet];
976
977 // conversion of digits
978 if (fRawReader && reconstructor->HasDigitConversion()) {
979 AliInfo(Form("converting raw data digits into root objects for %s",
980 fgkDetectorName[iDet]));
87932dab 981 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
982 fgkDetectorName[iDet]));
b26c3770 983 loader->LoadDigits("update");
984 loader->CleanDigits();
985 loader->MakeDigitsContainer();
986 TTree* digitsTree = loader->TreeD();
987 reconstructor->ConvertDigits(fRawReader, digitsTree);
988 loader->WriteDigits("OVERWRITE");
989 loader->UnloadDigits();
b26c3770 990 }
991
992 // local reconstruction
993 if (!reconstructor->HasLocalReconstruction()) continue;
994 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
87932dab 995 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
b26c3770 996 loader->LoadRecPoints("update");
997 loader->CleanRecPoints();
998 loader->MakeRecPointsContainer();
999 TTree* clustersTree = loader->TreeR();
1000 if (fRawReader && !reconstructor->HasDigitConversion()) {
1001 reconstructor->Reconstruct(fRawReader, clustersTree);
1002 } else {
1003 loader->LoadDigits("read");
1004 TTree* digitsTree = loader->TreeD();
1005 if (!digitsTree) {
1006 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1007 if (fStopOnError) return kFALSE;
1008 } else {
1009 reconstructor->Reconstruct(digitsTree, clustersTree);
1010 }
1011 loader->UnloadDigits();
1012 }
1013 loader->WriteRecPoints("OVERWRITE");
1014 loader->UnloadRecPoints();
b26c3770 1015 }
1016
1017 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1018 AliError(Form("the following detectors were not found: %s",
1019 detStr.Data()));
1020 if (fStopOnError) return kFALSE;
1021 }
5f8272e1 1022
b26c3770 1023 return kTRUE;
1024}
1025
596a855f 1026//_____________________________________________________________________________
af885e0f 1027Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
596a855f 1028{
1029// run the barrel tracking
1030
87932dab 1031 AliCodeTimerAuto("")
030b532d 1032
2257f27e 1033 AliESDVertex* vertex = NULL;
1034 Double_t vtxPos[3] = {0, 0, 0};
1035 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1036 TArrayF mcVertex(3);
a6b0b91b 1037 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1038 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1039 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1040 }
2257f27e 1041
b8cd5251 1042 if (fVertexer) {
17c86e90 1043 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
815c2b38 1044 AliInfo("running the ITS vertex finder");
b26c3770 1045 if (fLoader[0]) fLoader[0]->LoadRecPoints();
b8cd5251 1046 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
b26c3770 1047 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
2257f27e 1048 if(!vertex){
815c2b38 1049 AliWarning("Vertex not found");
c710f220 1050 vertex = new AliESDVertex();
d1a50cb5 1051 vertex->SetName("default");
2257f27e 1052 }
1053 else {
d1a50cb5 1054 vertex->SetName("reconstructed");
2257f27e 1055 }
1056
1057 } else {
815c2b38 1058 AliInfo("getting the primary vertex from MC");
2257f27e 1059 vertex = new AliESDVertex(vtxPos, vtxErr);
1060 }
1061
1062 if (vertex) {
1063 vertex->GetXYZ(vtxPos);
1064 vertex->GetSigmaXYZ(vtxErr);
1065 } else {
815c2b38 1066 AliWarning("no vertex reconstructed");
2257f27e 1067 vertex = new AliESDVertex(vtxPos, vtxErr);
1068 }
1069 esd->SetVertex(vertex);
32e449be 1070 // if SPD multiplicity has been determined, it is stored in the ESD
25be1e5c 1071 AliMultiplicity *mult = fVertexer->GetMultiplicity();
32e449be 1072 if(mult)esd->SetMultiplicity(mult);
1073
b8cd5251 1074 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1075 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1076 }
2257f27e 1077 delete vertex;
1078
2257f27e 1079 return kTRUE;
1080}
1081
1f46a9ae 1082//_____________________________________________________________________________
af885e0f 1083Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1f46a9ae 1084{
1085// run the HLT barrel tracking
1086
87932dab 1087 AliCodeTimerAuto("")
1f46a9ae 1088
1089 if (!fRunLoader) {
1090 AliError("Missing runLoader!");
1091 return kFALSE;
1092 }
1093
1094 AliInfo("running HLT tracking");
1095
1096 // Get a pointer to the HLT reconstructor
1097 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1098 if (!reconstructor) return kFALSE;
1099
1100 // TPC + ITS
1101 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1102 TString detName = fgkDetectorName[iDet];
1103 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1104 reconstructor->SetOption(detName.Data());
1105 AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
1106 if (!tracker) {
1107 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1108 if (fStopOnError) return kFALSE;
9dcc06e1 1109 continue;
1f46a9ae 1110 }
1111 Double_t vtxPos[3];
1112 Double_t vtxErr[3]={0.005,0.005,0.010};
1113 const AliESDVertex *vertex = esd->GetVertex();
1114 vertex->GetXYZ(vtxPos);
1115 tracker->SetVertex(vtxPos,vtxErr);
1116 if(iDet != 1) {
1117 fLoader[iDet]->LoadRecPoints("read");
1118 TTree* tree = fLoader[iDet]->TreeR();
1119 if (!tree) {
1120 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1121 return kFALSE;
1122 }
1123 tracker->LoadClusters(tree);
1124 }
1125 if (tracker->Clusters2Tracks(esd) != 0) {
1126 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1127 return kFALSE;
1128 }
1129 if(iDet != 1) {
1130 tracker->UnloadClusters();
1131 }
1132 delete tracker;
1133 }
1134
1f46a9ae 1135 return kTRUE;
1136}
1137
e66fbafb 1138//_____________________________________________________________________________
af885e0f 1139Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
e66fbafb 1140{
1141// run the muon spectrometer tracking
1142
87932dab 1143 AliCodeTimerAuto("")
e66fbafb 1144
1145 if (!fRunLoader) {
1146 AliError("Missing runLoader!");
1147 return kFALSE;
1148 }
1149 Int_t iDet = 7; // for MUON
1150
1151 AliInfo("is running...");
1152
1153 // Get a pointer to the MUON reconstructor
1154 AliReconstructor *reconstructor = GetReconstructor(iDet);
1155 if (!reconstructor) return kFALSE;
1156
1157
1158 TString detName = fgkDetectorName[iDet];
1159 AliDebug(1, Form("%s tracking", detName.Data()));
1160 AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
1161 if (!tracker) {
1162 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1163 return kFALSE;
1164 }
1165
1166 // create Tracks
1167 fLoader[iDet]->LoadTracks("update");
1168 fLoader[iDet]->CleanTracks();
1169 fLoader[iDet]->MakeTracksContainer();
1170
1171 // read RecPoints
761350a6 1172 fLoader[iDet]->LoadRecPoints("read");
1173 tracker->LoadClusters(fLoader[iDet]->TreeR());
1174
1175 Int_t rv = tracker->Clusters2Tracks(esd);
1176
1177 fLoader[iDet]->UnloadRecPoints();
1178
1179 if ( rv )
1180 {
e66fbafb 1181 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1182 return kFALSE;
1183 }
761350a6 1184
1185 tracker->UnloadClusters();
1186
e66fbafb 1187 fLoader[iDet]->UnloadRecPoints();
1188
1189 fLoader[iDet]->WriteTracks("OVERWRITE");
1190 fLoader[iDet]->UnloadTracks();
1191
1192 delete tracker;
1193
e66fbafb 1194 return kTRUE;
1195}
1196
1197
2257f27e 1198//_____________________________________________________________________________
af885e0f 1199Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2257f27e 1200{
1201// run the barrel tracking
1202
87932dab 1203 AliCodeTimerAuto("")
24f7a148 1204
815c2b38 1205 AliInfo("running tracking");
596a855f 1206
91b876d1 1207 //Fill the ESD with the T0 info (will be used by the TOF)
1f4331b3 1208 if (fReconstructor[11])
1209 GetReconstructor(11)->FillESD(fRunLoader, esd);
91b876d1 1210
b8cd5251 1211 // pass 1: TPC + ITS inwards
1212 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1213 if (!fTracker[iDet]) continue;
1214 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
24f7a148 1215
b8cd5251 1216 // load clusters
1217 fLoader[iDet]->LoadRecPoints("read");
1218 TTree* tree = fLoader[iDet]->TreeR();
1219 if (!tree) {
1220 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1221 return kFALSE;
1222 }
b8cd5251 1223 fTracker[iDet]->LoadClusters(tree);
1224
1225 // run tracking
1226 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1227 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
24f7a148 1228 return kFALSE;
1229 }
b8cd5251 1230 if (fCheckPointLevel > 1) {
1231 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1232 }
878e1fe1 1233 // preliminary PID in TPC needed by the ITS tracker
1234 if (iDet == 1) {
1235 GetReconstructor(1)->FillESD(fRunLoader, esd);
b26c3770 1236 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
878e1fe1 1237 AliESDpid::MakePID(esd);
1238 }
b8cd5251 1239 }
596a855f 1240
b8cd5251 1241 // pass 2: ALL backwards
1242 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1243 if (!fTracker[iDet]) continue;
1244 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1245
1246 // load clusters
1247 if (iDet > 1) { // all except ITS, TPC
1248 TTree* tree = NULL;
7b61cd9c 1249 fLoader[iDet]->LoadRecPoints("read");
1250 tree = fLoader[iDet]->TreeR();
b8cd5251 1251 if (!tree) {
1252 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
24f7a148 1253 return kFALSE;
1254 }
b8cd5251 1255 fTracker[iDet]->LoadClusters(tree);
1256 }
24f7a148 1257
b8cd5251 1258 // run tracking
1259 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1260 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
49dfd67a 1261 // return kFALSE;
b8cd5251 1262 }
1263 if (fCheckPointLevel > 1) {
1264 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1265 }
24f7a148 1266
b8cd5251 1267 // unload clusters
1268 if (iDet > 2) { // all except ITS, TPC, TRD
1269 fTracker[iDet]->UnloadClusters();
7b61cd9c 1270 fLoader[iDet]->UnloadRecPoints();
b8cd5251 1271 }
8f37df88 1272 // updated PID in TPC needed by the ITS tracker -MI
1273 if (iDet == 1) {
1274 GetReconstructor(1)->FillESD(fRunLoader, esd);
1275 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1276 AliESDpid::MakePID(esd);
1277 }
b8cd5251 1278 }
596a855f 1279
98937d93 1280 // write space-points to the ESD in case alignment data output
1281 // is switched on
1282 if (fWriteAlignmentData)
1283 WriteAlignmentData(esd);
1284
b8cd5251 1285 // pass 3: TRD + TPC + ITS refit inwards
1286 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1287 if (!fTracker[iDet]) continue;
1288 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
596a855f 1289
b8cd5251 1290 // run tracking
1291 if (fTracker[iDet]->RefitInward(esd) != 0) {
1292 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
49dfd67a 1293 // return kFALSE;
b8cd5251 1294 }
1295 if (fCheckPointLevel > 1) {
1296 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1297 }
596a855f 1298
b8cd5251 1299 // unload clusters
1300 fTracker[iDet]->UnloadClusters();
1301 fLoader[iDet]->UnloadRecPoints();
1302 }
ff8bb5ae 1303 //
1304 // Propagate track to the vertex - if not done by ITS
1305 //
1306 Int_t ntracks = esd->GetNumberOfTracks();
1307 for (Int_t itrack=0; itrack<ntracks; itrack++){
1308 const Double_t kRadius = 3; // beam pipe radius
1309 const Double_t kMaxStep = 5; // max step
1310 const Double_t kMaxD = 123456; // max distance to prim vertex
1311 Double_t fieldZ = AliTracker::GetBz(); //
1312 AliESDtrack * track = esd->GetTrack(itrack);
1313 if (!track) continue;
1314 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
a7265806 1315 AliTracker::PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
ff8bb5ae 1316 track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
1317 }
1318
596a855f 1319 return kTRUE;
1320}
1321
d64bd07d 1322//_____________________________________________________________________________
1323Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1324 //
1325 // Remove the data which are not needed for the physics analysis.
1326 //
1327
1328 AliInfo("Cleaning the ESD...");
1329
1330 const AliESDVertex *vertex=esd->GetVertex();
1331 Double_t vz=vertex->GetZv();
1332
1333 Int_t nTracks=esd->GetNumberOfTracks();
1334 for (Int_t i=0; i<nTracks; i++) {
1335 AliESDtrack *track=esd->GetTrack(i);
1336
1337 Float_t xy,z; track->GetImpactParameters(xy,z);
1338 if (TMath::Abs(xy) < 50.) continue;
1339 if (vertex->GetStatus())
1340 if (TMath::Abs(vz-z) < 5.) continue;
1341
1342 esd->RemoveTrack(i);
1343 }
1344
1345 return kTRUE;
1346}
1347
596a855f 1348//_____________________________________________________________________________
af885e0f 1349Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
596a855f 1350{
1351// fill the event summary data
1352
87932dab 1353 AliCodeTimerAuto("")
030b532d 1354
596a855f 1355 TString detStr = detectors;
b8cd5251 1356 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1357 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1358 AliReconstructor* reconstructor = GetReconstructor(iDet);
1359 if (!reconstructor) continue;
1360
1361 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1362 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
b26c3770 1363 TTree* clustersTree = NULL;
1364 if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
1365 fLoader[iDet]->LoadRecPoints("read");
1366 clustersTree = fLoader[iDet]->TreeR();
1367 if (!clustersTree) {
1368 AliError(Form("Can't get the %s clusters tree",
1369 fgkDetectorName[iDet]));
1370 if (fStopOnError) return kFALSE;
1371 }
1372 }
1373 if (fRawReader && !reconstructor->HasDigitConversion()) {
1374 reconstructor->FillESD(fRawReader, clustersTree, esd);
1375 } else {
1376 TTree* digitsTree = NULL;
1377 if (fLoader[iDet]) {
1378 fLoader[iDet]->LoadDigits("read");
1379 digitsTree = fLoader[iDet]->TreeD();
1380 if (!digitsTree) {
1381 AliError(Form("Can't get the %s digits tree",
1382 fgkDetectorName[iDet]));
1383 if (fStopOnError) return kFALSE;
1384 }
1385 }
1386 reconstructor->FillESD(digitsTree, clustersTree, esd);
1387 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1388 }
1389 if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
1390 fLoader[iDet]->UnloadRecPoints();
1391 }
1392
b8cd5251 1393 if (fRawReader) {
1394 reconstructor->FillESD(fRunLoader, fRawReader, esd);
1395 } else {
1396 reconstructor->FillESD(fRunLoader, esd);
24f7a148 1397 }
b8cd5251 1398 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
596a855f 1399 }
1400 }
1401
1402 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
815c2b38 1403 AliError(Form("the following detectors were not found: %s",
1404 detStr.Data()));
596a855f 1405 if (fStopOnError) return kFALSE;
1406 }
1407
1408 return kTRUE;
1409}
1410
b647652d 1411//_____________________________________________________________________________
af885e0f 1412Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
b647652d 1413{
1414 // Reads the trigger decision which is
1415 // stored in Trigger.root file and fills
1416 // the corresponding esd entries
1417
87932dab 1418 AliCodeTimerAuto("")
1419
b647652d 1420 AliInfo("Filling trigger information into the ESD");
1421
1422 if (fRawReader) {
1423 AliCTPRawStream input(fRawReader);
1424 if (!input.Next()) {
1425 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1426 return kFALSE;
1427 }
1428 esd->SetTriggerMask(input.GetClassMask());
1429 esd->SetTriggerCluster(input.GetClusterMask());
1430 }
1431 else {
1432 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1433 if (runloader) {
1434 if (!runloader->LoadTrigger()) {
1435 AliCentralTrigger *aCTP = runloader->GetTrigger();
1436 esd->SetTriggerMask(aCTP->GetClassMask());
1437 esd->SetTriggerCluster(aCTP->GetClusterMask());
1438 }
1439 else {
1440 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1441 return kFALSE;
1442 }
1443 }
1444 else {
1445 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1446 return kFALSE;
1447 }
1448 }
1449
1450 return kTRUE;
1451}
596a855f 1452
001397cd 1453
1454
1455
1456
1457//_____________________________________________________________________________
af885e0f 1458Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
001397cd 1459{
1460 //
1461 // Filling information from RawReader Header
1462 //
1463
1464 AliInfo("Filling information from RawReader Header");
31fd97b2 1465 esd->SetBunchCrossNumber(0);
1466 esd->SetOrbitNumber(0);
9bcc1e45 1467 esd->SetPeriodNumber(0);
001397cd 1468 esd->SetTimeStamp(0);
1469 esd->SetEventType(0);
1470 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1471 if (eventHeader){
9bcc1e45 1472
1473 const UInt_t *id = eventHeader->GetP("Id");
1474 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1475 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1476 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1477
001397cd 1478 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
31fd97b2 1479 esd->SetEventType((eventHeader->Get("Type")));
001397cd 1480 }
1481
1482 return kTRUE;
1483}
1484
1485
596a855f 1486//_____________________________________________________________________________
1487Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
1488{
1489// check whether detName is contained in detectors
1490// if yes, it is removed from detectors
1491
1492 // check if all detectors are selected
1493 if ((detectors.CompareTo("ALL") == 0) ||
1494 detectors.BeginsWith("ALL ") ||
1495 detectors.EndsWith(" ALL") ||
1496 detectors.Contains(" ALL ")) {
1497 detectors = "ALL";
1498 return kTRUE;
1499 }
1500
1501 // search for the given detector
1502 Bool_t result = kFALSE;
1503 if ((detectors.CompareTo(detName) == 0) ||
1504 detectors.BeginsWith(detName+" ") ||
1505 detectors.EndsWith(" "+detName) ||
1506 detectors.Contains(" "+detName+" ")) {
1507 detectors.ReplaceAll(detName, "");
1508 result = kTRUE;
1509 }
1510
1511 // clean up the detectors string
1512 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1513 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1514 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1515
1516 return result;
1517}
e583c30d 1518
f08fc9f5 1519//_____________________________________________________________________________
1520Bool_t AliReconstruction::InitRunLoader()
1521{
1522// get or create the run loader
1523
1524 if (gAlice) delete gAlice;
1525 gAlice = NULL;
1526
b26c3770 1527 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
1528 // load all base libraries to get the loader classes
1529 TString libs = gSystem->GetLibraries();
1530 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1531 TString detName = fgkDetectorName[iDet];
1532 if (detName == "HLT") continue;
1533 if (libs.Contains("lib" + detName + "base.so")) continue;
1534 gSystem->Load("lib" + detName + "base.so");
1535 }
f08fc9f5 1536 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
1537 if (!fRunLoader) {
1538 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1539 CleanUp();
1540 return kFALSE;
1541 }
b26c3770 1542 fRunLoader->CdGAFile();
1543 if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
1544 if (fRunLoader->LoadgAlice() == 0) {
1545 gAlice = fRunLoader->GetAliRun();
c84a5e9e 1546 AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
b26c3770 1547 }
f08fc9f5 1548 }
1549 if (!gAlice && !fRawReader) {
1550 AliError(Form("no gAlice object found in file %s",
1551 fGAliceFileName.Data()));
1552 CleanUp();
1553 return kFALSE;
1554 }
1555
6cae184e 1556 //PH This is a temporary fix to give access to the kinematics
1557 //PH that is needed for the labels of ITS clusters
1558 fRunLoader->LoadKinematics();
1559
f08fc9f5 1560 } else { // galice.root does not exist
1561 if (!fRawReader) {
1562 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
1563 CleanUp();
1564 return kFALSE;
1565 }
1566 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
1567 AliConfig::GetDefaultEventFolderName(),
1568 "recreate");
1569 if (!fRunLoader) {
1570 AliError(Form("could not create run loader in file %s",
1571 fGAliceFileName.Data()));
1572 CleanUp();
1573 return kFALSE;
1574 }
1575 fRunLoader->MakeTree("E");
1576 Int_t iEvent = 0;
1577 while (fRawReader->NextEvent()) {
1578 fRunLoader->SetEventNumber(iEvent);
1579 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1580 iEvent, iEvent);
1581 fRunLoader->MakeTree("H");
1582 fRunLoader->TreeE()->Fill();
1583 iEvent++;
1584 }
1585 fRawReader->RewindEvents();
973388c2 1586 if (fNumberOfEventsPerFile > 0)
1587 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
1588 else
1589 fRunLoader->SetNumberOfEventsPerFile(iEvent);
f08fc9f5 1590 fRunLoader->WriteHeader("OVERWRITE");
1591 fRunLoader->CdGAFile();
1592 fRunLoader->Write(0, TObject::kOverwrite);
1593// AliTracker::SetFieldMap(???);
1594 }
1595
1596 return kTRUE;
1597}
1598
c757bafd 1599//_____________________________________________________________________________
b8cd5251 1600AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
c757bafd 1601{
f08fc9f5 1602// get the reconstructor object and the loader for a detector
c757bafd 1603
b8cd5251 1604 if (fReconstructor[iDet]) return fReconstructor[iDet];
1605
1606 // load the reconstructor object
1607 TPluginManager* pluginManager = gROOT->GetPluginManager();
1608 TString detName = fgkDetectorName[iDet];
1609 TString recName = "Ali" + detName + "Reconstructor";
f08fc9f5 1610 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
b8cd5251 1611
1612 if (detName == "HLT") {
1613 if (!gROOT->GetClass("AliLevel3")) {
4aa41877 1614 gSystem->Load("libAliHLTSrc.so");
1615 gSystem->Load("libAliHLTMisc.so");
1616 gSystem->Load("libAliHLTHough.so");
1617 gSystem->Load("libAliHLTComp.so");
b8cd5251 1618 }
1619 }
1620
1621 AliReconstructor* reconstructor = NULL;
1622 // first check if a plugin is defined for the reconstructor
1623 TPluginHandler* pluginHandler =
1624 pluginManager->FindHandler("AliReconstructor", detName);
f08fc9f5 1625 // if not, add a plugin for it
1626 if (!pluginHandler) {
b8cd5251 1627 AliDebug(1, Form("defining plugin for %s", recName.Data()));
b26c3770 1628 TString libs = gSystem->GetLibraries();
1629 if (libs.Contains("lib" + detName + "base.so") ||
1630 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
b8cd5251 1631 pluginManager->AddHandler("AliReconstructor", detName,
1632 recName, detName + "rec", recName + "()");
1633 } else {
1634 pluginManager->AddHandler("AliReconstructor", detName,
1635 recName, detName, recName + "()");
c757bafd 1636 }
b8cd5251 1637 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
1638 }
1639 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
1640 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
c757bafd 1641 }
b8cd5251 1642 if (reconstructor) {
1643 TObject* obj = fOptions.FindObject(detName.Data());
1644 if (obj) reconstructor->SetOption(obj->GetTitle());
b26c3770 1645 reconstructor->Init(fRunLoader);
b8cd5251 1646 fReconstructor[iDet] = reconstructor;
1647 }
1648
f08fc9f5 1649 // get or create the loader
1650 if (detName != "HLT") {
1651 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
1652 if (!fLoader[iDet]) {
1653 AliConfig::Instance()
1654 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
1655 detName, detName);
1656 // first check if a plugin is defined for the loader
bb0901a4 1657 pluginHandler =
f08fc9f5 1658 pluginManager->FindHandler("AliLoader", detName);
1659 // if not, add a plugin for it
1660 if (!pluginHandler) {
1661 TString loaderName = "Ali" + detName + "Loader";
1662 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
1663 pluginManager->AddHandler("AliLoader", detName,
1664 loaderName, detName + "base",
1665 loaderName + "(const char*, TFolder*)");
1666 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
1667 }
1668 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
1669 fLoader[iDet] =
1670 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
1671 fRunLoader->GetEventFolder());
1672 }
1673 if (!fLoader[iDet]) { // use default loader
1674 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
1675 }
1676 if (!fLoader[iDet]) {
1677 AliWarning(Form("couldn't get loader for %s", detName.Data()));
6667b602 1678 if (fStopOnError) return NULL;
f08fc9f5 1679 } else {
1680 fRunLoader->AddLoader(fLoader[iDet]);
1681 fRunLoader->CdGAFile();
1682 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
1683 fRunLoader->Write(0, TObject::kOverwrite);
1684 }
1685 }
1686 }
1687
b8cd5251 1688 return reconstructor;
c757bafd 1689}
1690
2257f27e 1691//_____________________________________________________________________________
1692Bool_t AliReconstruction::CreateVertexer()
1693{
1694// create the vertexer
1695
b8cd5251 1696 fVertexer = NULL;
1697 AliReconstructor* itsReconstructor = GetReconstructor(0);
59697224 1698 if (itsReconstructor) {
b8cd5251 1699 fVertexer = itsReconstructor->CreateVertexer(fRunLoader);
2257f27e 1700 }
b8cd5251 1701 if (!fVertexer) {
815c2b38 1702 AliWarning("couldn't create a vertexer for ITS");
2257f27e 1703 if (fStopOnError) return kFALSE;
1704 }
1705
1706 return kTRUE;
1707}
1708
24f7a148 1709//_____________________________________________________________________________
b8cd5251 1710Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
24f7a148 1711{
f08fc9f5 1712// create the trackers
24f7a148 1713
b8cd5251 1714 TString detStr = detectors;
1715 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1716 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1717 AliReconstructor* reconstructor = GetReconstructor(iDet);
1718 if (!reconstructor) continue;
1719 TString detName = fgkDetectorName[iDet];
1f46a9ae 1720 if (detName == "HLT") {
1721 fRunHLTTracking = kTRUE;
1722 continue;
1723 }
e66fbafb 1724 if (detName == "MUON") {
1725 fRunMuonTracking = kTRUE;
1726 continue;
1727 }
1728
f08fc9f5 1729
1730 fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
1731 if (!fTracker[iDet] && (iDet < 7)) {
1732 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
8250d5f5 1733 if (fStopOnError) return kFALSE;
1734 }
1735 }
1736
24f7a148 1737 return kTRUE;
1738}
1739
e583c30d 1740//_____________________________________________________________________________
b26c3770 1741void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
e583c30d 1742{
1743// delete trackers and the run loader and close and delete the file
1744
b8cd5251 1745 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1746 delete fReconstructor[iDet];
1747 fReconstructor[iDet] = NULL;
1748 fLoader[iDet] = NULL;
1749 delete fTracker[iDet];
1750 fTracker[iDet] = NULL;
d101408a 1751 delete fQualAssDataMaker[iDet];
1752 fQualAssDataMaker[iDet] = NULL;
b8cd5251 1753 }
1754 delete fVertexer;
1755 fVertexer = NULL;
9178838a 1756 delete fDiamondProfile;
1757 fDiamondProfile = NULL;
e583c30d 1758
1759 delete fRunLoader;
1760 fRunLoader = NULL;
b649205a 1761 delete fRawReader;
1762 fRawReader = NULL;
e583c30d 1763
1764 if (file) {
1765 file->Close();
1766 delete file;
1767 }
b26c3770 1768
1769 if (fileOld) {
1770 fileOld->Close();
1771 delete fileOld;
1772 gSystem->Unlink("AliESDs.old.root");
1773 }
e583c30d 1774}
24f7a148 1775
24f7a148 1776//_____________________________________________________________________________
af885e0f 1777
1778Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
24f7a148 1779{
1780// read the ESD event from a file
1781
1782 if (!esd) return kFALSE;
1783 char fileName[256];
1784 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 1785 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 1786 if (gSystem->AccessPathName(fileName)) return kFALSE;
1787
f3a97c86 1788 AliInfo(Form("reading ESD from file %s", fileName));
815c2b38 1789 AliDebug(1, Form("reading ESD from file %s", fileName));
24f7a148 1790 TFile* file = TFile::Open(fileName);
1791 if (!file || !file->IsOpen()) {
815c2b38 1792 AliError(Form("opening %s failed", fileName));
24f7a148 1793 delete file;
1794 return kFALSE;
1795 }
1796
1797 gROOT->cd();
1798 delete esd;
af885e0f 1799 esd = (AliESDEvent*) file->Get("ESD");
24f7a148 1800 file->Close();
1801 delete file;
1802 return kTRUE;
af885e0f 1803
24f7a148 1804}
1805
af885e0f 1806
1807
24f7a148 1808//_____________________________________________________________________________
af885e0f 1809void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
24f7a148 1810{
1811// write the ESD event to a file
1812
1813 if (!esd) return;
1814 char fileName[256];
1815 sprintf(fileName, "ESD_%d.%d_%s.root",
31fd97b2 1816 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
24f7a148 1817
815c2b38 1818 AliDebug(1, Form("writing ESD to file %s", fileName));
24f7a148 1819 TFile* file = TFile::Open(fileName, "recreate");
1820 if (!file || !file->IsOpen()) {
815c2b38 1821 AliError(Form("opening %s failed", fileName));
24f7a148 1822 } else {
1823 esd->Write("ESD");
1824 file->Close();
1825 }
1826 delete file;
1827}
f3a97c86 1828
1829
1830
1831
f3a97c86 1832
a7807689 1833//_____________________________________________________________________________
f29f1726 1834void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
a7807689 1835{
f29f1726 1836 // write all files from the given esd file to an aod file
85ba66b8 1837
f29f1726 1838 // create an AliAOD object
1839 AliAODEvent *aod = new AliAODEvent();
1840 aod->CreateStdContent();
1841
1842 // go to the file
1843 aodFile->cd();
1844
1845 // create the tree
b97637d4 1846 TTree *aodTree = new TTree("aodTree", "AliAOD tree");
f29f1726 1847 aodTree->Branch(aod->GetList());
1848
1849 // connect to ESD
1850 TTree *t = (TTree*) esdFile->Get("esdTree");
af885e0f 1851 AliESDEvent *esd = new AliESDEvent();
53ec9628 1852 esd->ReadFromTree(t);
f29f1726 1853
53ec9628 1854 Int_t nEvents = t->GetEntries();
f29f1726 1855
1856 // set arrays and pointers
1857 Float_t posF[3];
1858 Double_t pos[3];
1859 Double_t p[3];
1860 Double_t covVtx[6];
1861 Double_t covTr[21];
1862 Double_t pid[10];
1863
1864 // loop over events and fill them
1865 for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
53ec9628 1866 t->GetEntry(iEvent);
f29f1726 1867
1868 // Multiplicity information needed by the header (to be revised!)
1869 Int_t nTracks = esd->GetNumberOfTracks();
1870 Int_t nPosTracks = 0;
1871 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
b97637d4 1872 if (esd->GetTrack(iTrack)->Charge()> 0) nPosTracks++;
f29f1726 1873
85ba66b8 1874 // Access the header
1875 AliAODHeader *header = aod->GetHeader();
1876
1877 // fill the header
ade23daf 1878 header->SetRunNumber (esd->GetRunNumber() );
1879 header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
1880 header->SetOrbitNumber (esd->GetOrbitNumber() );
1881 header->SetPeriodNumber (esd->GetPeriodNumber() );
1882 header->SetTriggerMask (esd->GetTriggerMask() );
1883 header->SetTriggerCluster (esd->GetTriggerCluster() );
1884 header->SetEventType (esd->GetEventType() );
1885 header->SetMagneticField (esd->GetMagneticField() );
1886 header->SetZDCN1Energy (esd->GetZDCN1Energy() );
1887 header->SetZDCP1Energy (esd->GetZDCP1Energy() );
1888 header->SetZDCN2Energy (esd->GetZDCN2Energy() );
1889 header->SetZDCP2Energy (esd->GetZDCP2Energy() );
1890 header->SetZDCEMEnergy (esd->GetZDCEMEnergy() );
a1d4139d 1891 header->SetRefMultiplicity (nTracks);
1892 header->SetRefMultiplicityPos(nPosTracks);
1893 header->SetRefMultiplicityNeg(nTracks - nPosTracks);
1894 header->SetMuonMagFieldScale(-999.); // FIXME
1895 header->SetCentrality(-999.); // FIXME
f29f1726 1896
1897 Int_t nV0s = esd->GetNumberOfV0s();
1898 Int_t nCascades = esd->GetNumberOfCascades();
1899 Int_t nKinks = esd->GetNumberOfKinks();
1900 Int_t nVertices = nV0s + nCascades + nKinks;
1901
1902 aod->ResetStd(nTracks, nVertices);
1903 AliAODTrack *aodTrack;
1904
f29f1726 1905 // Array to take into account the tracks already added to the AOD
1906 Bool_t * usedTrack = NULL;
1907 if (nTracks>0) {
1908 usedTrack = new Bool_t[nTracks];
1909 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
1910 }
1911 // Array to take into account the V0s already added to the AOD
1912 Bool_t * usedV0 = NULL;
1913 if (nV0s>0) {
1914 usedV0 = new Bool_t[nV0s];
1915 for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
1916 }
1917 // Array to take into account the kinks already added to the AOD
1918 Bool_t * usedKink = NULL;
1919 if (nKinks>0) {
1920 usedKink = new Bool_t[nKinks];
1921 for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
1922 }
1923
1924 // Access to the AOD container of vertices
1925 TClonesArray &vertices = *(aod->GetVertices());
1926 Int_t jVertices=0;
1927
1928 // Access to the AOD container of tracks
1929 TClonesArray &tracks = *(aod->GetTracks());
1930 Int_t jTracks=0;
1931
1932 // Add primary vertex. The primary tracks will be defined
1933 // after the loops on the composite objects (V0, cascades, kinks)
1934 const AliESDVertex *vtx = esd->GetPrimaryVertex();
1935
1936 vtx->GetXYZ(pos); // position
1937 vtx->GetCovMatrix(covVtx); //covariance matrix
1938
1939 AliAODVertex * primary = new(vertices[jVertices++])
02153d58 1940 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
f29f1726 1941
1942 // Create vertices starting from the most complex objects
1943
1944 // Cascades
1945 for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
1946 AliESDcascade *cascade = esd->GetCascade(nCascade);
1947
b8be8c7d 1948 cascade->GetXYZcascade(pos[0], pos[1], pos[2]); // Bo: bug correction
f29f1726 1949 cascade->GetPosCovXi(covVtx);
1950
1951 // Add the cascade vertex
1952 AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
1953 covVtx,
1954 cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
1955 primary,
02153d58 1956 nCascade,
f29f1726 1957 AliAODVertex::kCascade);
1958
1959 primary->AddDaughter(vcascade);
1960
1961 // Add the V0 from the cascade. The ESD class have to be optimized...
85ba66b8 1962 // Now we have to search for the corresponding V0 in the list of V0s
f29f1726 1963 // using the indeces of the positive and negative tracks
1964
1965 Int_t posFromV0 = cascade->GetPindex();
1966 Int_t negFromV0 = cascade->GetNindex();
1967
f29f1726 1968 AliESDv0 * v0 = 0x0;
1969 Int_t indV0 = -1;
1970
1971 for (Int_t iV0=0; iV0<nV0s; ++iV0) {
1972
1973 v0 = esd->GetV0(iV0);
1974 Int_t posV0 = v0->GetPindex();
1975 Int_t negV0 = v0->GetNindex();
1976
1977 if (posV0==posFromV0 && negV0==negFromV0) {
1978 indV0 = iV0;
1979 break;
1980 }
1981 }
1982
1983 AliAODVertex * vV0FromCascade = 0x0;
1984
1985 if (indV0>-1 && !usedV0[indV0] ) {
1986
1987 // the V0 exists in the array of V0s and is not used
1988
1989 usedV0[indV0] = kTRUE;
1990
1991 v0->GetXYZ(pos[0], pos[1], pos[2]);
1992 v0->GetPosCov(covVtx);
1993
1994 vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
1995 covVtx,
1996 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
1997 vcascade,
02153d58 1998 indV0,
f29f1726 1999 AliAODVertex::kV0);
2000 } else {
2001
2002 // the V0 doesn't exist in the array of V0s or was used
2003 cerr << "Error: event " << iEvent << " cascade " << nCascade
2004 << " The V0 " << indV0
2005 << " doesn't exist in the array of V0s or was used!" << endl;
2006
2007 cascade->GetXYZ(pos[0], pos[1], pos[2]);
2008 cascade->GetPosCov(covVtx);
2009
2010 vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
2011 covVtx,
2012 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2013 vcascade,
02153d58 2014 indV0,
f29f1726 2015 AliAODVertex::kV0);
2016 vcascade->AddDaughter(vV0FromCascade);
2017 }
2018
2019 // Add the positive tracks from the V0
2020
2021 if (! usedTrack[posFromV0]) {
2022
2023 usedTrack[posFromV0] = kTRUE;
2024
2025 AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
2026 esdTrack->GetPxPyPz(p);
2027 esdTrack->GetXYZ(pos);
2028 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2029 esdTrack->GetESDpid(pid);
2030
2031 vV0FromCascade->AddDaughter(aodTrack =
2032 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2033 esdTrack->GetLabel(),
2034 p,
2035 kTRUE,
2036 pos,
2037 kFALSE,
2038 covTr,
b97637d4 2039 (Short_t)esdTrack->Charge(),
f29f1726 2040 esdTrack->GetITSClusterMap(),
2041 pid,
2042 vV0FromCascade,
2043 kTRUE, // check if this is right
2044 kFALSE, // check if this is right
2045 AliAODTrack::kSecondary)
2046 );
2047 aodTrack->ConvertAliPIDtoAODPID();
2048 }
2049 else {
2050 cerr << "Error: event " << iEvent << " cascade " << nCascade
2051 << " track " << posFromV0 << " has already been used!" << endl;
2052 }
2053
2054 // Add the negative tracks from the V0
2055
2056 if (!usedTrack[negFromV0]) {
2057
2058 usedTrack[negFromV0] = kTRUE;
2059
2060 AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
2061 esdTrack->GetPxPyPz(p);
2062 esdTrack->GetXYZ(pos);
2063 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2064 esdTrack->GetESDpid(pid);
2065
2066 vV0FromCascade->AddDaughter(aodTrack =
2067 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2068 esdTrack->GetLabel(),
2069 p,
2070 kTRUE,
2071 pos,
2072 kFALSE,
2073 covTr,
b97637d4 2074 (Short_t)esdTrack->Charge(),
f29f1726 2075 esdTrack->GetITSClusterMap(),
2076 pid,
2077 vV0FromCascade,
2078 kTRUE, // check if this is right
2079 kFALSE, // check if this is right
2080 AliAODTrack::kSecondary)
2081 );
2082 aodTrack->ConvertAliPIDtoAODPID();
2083 }
2084 else {
2085 cerr << "Error: event " << iEvent << " cascade " << nCascade
2086 << " track " << negFromV0 << " has already been used!" << endl;
2087 }
2088
2089 // Add the bachelor track from the cascade
2090
2091 Int_t bachelor = cascade->GetBindex();
2092
2093 if(!usedTrack[bachelor]) {
2094
2095 usedTrack[bachelor] = kTRUE;
2096
2097 AliESDtrack *esdTrack = esd->GetTrack(bachelor);
2098 esdTrack->GetPxPyPz(p);
2099 esdTrack->GetXYZ(pos);
2100 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2101 esdTrack->GetESDpid(pid);
2102
2103 vcascade->AddDaughter(aodTrack =
2104 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2105 esdTrack->GetLabel(),
2106 p,
2107 kTRUE,
2108 pos,
2109 kFALSE,
2110 covTr,
b97637d4 2111 (Short_t)esdTrack->Charge(),
f29f1726 2112 esdTrack->GetITSClusterMap(),
2113 pid,
2114 vcascade,
2115 kTRUE, // check if this is right
2116 kFALSE, // check if this is right
2117 AliAODTrack::kSecondary)
2118 );
2119 aodTrack->ConvertAliPIDtoAODPID();
2120 }
2121 else {
2122 cerr << "Error: event " << iEvent << " cascade " << nCascade
2123 << " track " << bachelor << " has already been used!" << endl;
2124 }
2125
2126 // Add the primary track of the cascade (if any)
2127
2128 } // end of the loop on cascades
2129
2130 // V0s
2131
2132 for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
2133
2134 if (usedV0[nV0]) continue; // skip if aready added to the AOD
2135
2136 AliESDv0 *v0 = esd->GetV0(nV0);
2137
2138 v0->GetXYZ(pos[0], pos[1], pos[2]);
2139 v0->GetPosCov(covVtx);
2140
2141 AliAODVertex * vV0 =
2142 new(vertices[jVertices++]) AliAODVertex(pos,
2143 covVtx,
2144 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2145 primary,
02153d58 2146 nV0,
f29f1726 2147 AliAODVertex::kV0);
2148 primary->AddDaughter(vV0);
2149
2150 Int_t posFromV0 = v0->GetPindex();
2151 Int_t negFromV0 = v0->GetNindex();
2152
2153 // Add the positive tracks from the V0
2154
2155 if (!usedTrack[posFromV0]) {
2156
2157 usedTrack[posFromV0] = kTRUE;
2158
2159 AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
2160 esdTrack->GetPxPyPz(p);
2161 esdTrack->GetXYZ(pos);
2162 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2163 esdTrack->GetESDpid(pid);
2164
2165 vV0->AddDaughter(aodTrack =
2166 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2167 esdTrack->GetLabel(),
2168 p,
2169 kTRUE,
2170 pos,
2171 kFALSE,
2172 covTr,
b97637d4 2173 (Short_t)esdTrack->Charge(),
f29f1726 2174 esdTrack->GetITSClusterMap(),
2175 pid,
2176 vV0,
2177 kTRUE, // check if this is right
2178 kFALSE, // check if this is right
2179 AliAODTrack::kSecondary)
2180 );
2181 aodTrack->ConvertAliPIDtoAODPID();
2182 }
2183 else {
2184 cerr << "Error: event " << iEvent << " V0 " << nV0
2185 << " track " << posFromV0 << " has already been used!" << endl;
2186 }
a7807689 2187
f29f1726 2188 // Add the negative tracks from the V0
2189
2190 if (!usedTrack[negFromV0]) {
2191
2192 usedTrack[negFromV0] = kTRUE;
2193
2194 AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
2195 esdTrack->GetPxPyPz(p);
2196 esdTrack->GetXYZ(pos);
2197 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2198 esdTrack->GetESDpid(pid);
2199
2200 vV0->AddDaughter(aodTrack =
2201 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2202 esdTrack->GetLabel(),
2203 p,
2204 kTRUE,
2205 pos,
2206 kFALSE,
2207 covTr,
b97637d4 2208 (Short_t)esdTrack->Charge(),
f29f1726 2209 esdTrack->GetITSClusterMap(),
2210 pid,
2211 vV0,
2212 kTRUE, // check if this is right
2213 kFALSE, // check if this is right
2214 AliAODTrack::kSecondary)
2215 );
2216 aodTrack->ConvertAliPIDtoAODPID();
2217 }
2218 else {
2219 cerr << "Error: event " << iEvent << " V0 " << nV0
2220 << " track " << negFromV0 << " has already been used!" << endl;
2221 }
2222
2223 } // end of the loop on V0s
2224
2225 // Kinks: it is a big mess the access to the information in the kinks
2226 // The loop is on the tracks in order to find the mother and daugther of each kink
2227
2228
2229 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
2230
2231
2232 AliESDtrack * esdTrack = esd->GetTrack(iTrack);
2233
2234 Int_t ikink = esdTrack->GetKinkIndex(0);
2235
2236 if (ikink) {
2237 // Negative kink index: mother, positive: daughter
2238
2239 // Search for the second track of the kink
2240
2241 for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
2242
2243 AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
2244
2245 Int_t jkink = esdTrack1->GetKinkIndex(0);
2246
2247 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
2248
2249 // The two tracks are from the same kink
2250
2251 if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
2252
2253 Int_t imother = -1;
2254 Int_t idaughter = -1;
2255
2256 if (ikink<0 && jkink>0) {
2257
2258 imother = iTrack;
2259 idaughter = jTrack;
2260 }
2261 else if (ikink>0 && jkink<0) {
2262
2263 imother = jTrack;
2264 idaughter = iTrack;
2265 }
2266 else {
2267 cerr << "Error: Wrong combination of kink indexes: "
2268 << ikink << " " << jkink << endl;
2269 continue;
2270 }
2271
2272 // Add the mother track
2273
2274 AliAODTrack * mother = NULL;
2275
2276 if (!usedTrack[imother]) {
2277
2278 usedTrack[imother] = kTRUE;
2279
2280 AliESDtrack *esdTrack = esd->GetTrack(imother);
2281 esdTrack->GetPxPyPz(p);
2282 esdTrack->GetXYZ(pos);
2283 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2284 esdTrack->GetESDpid(pid);
2285
2286 mother =
2287 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2288 esdTrack->GetLabel(),
2289 p,
2290 kTRUE,
2291 pos,
2292 kFALSE,
2293 covTr,
b97637d4 2294 (Short_t)esdTrack->Charge(),
f29f1726 2295 esdTrack->GetITSClusterMap(),
2296 pid,
2297 primary,
2298 kTRUE, // check if this is right
2299 kTRUE, // check if this is right
2300 AliAODTrack::kPrimary);
2301 primary->AddDaughter(mother);
2302 mother->ConvertAliPIDtoAODPID();
2303 }
2304 else {
2305 cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
2306 << " track " << imother << " has already been used!" << endl;
2307 }
2308
2309 // Add the kink vertex
2310 AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
2311
2312 AliAODVertex * vkink =
2313 new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
2314 NULL,
2315 0.,
2316 mother,
02153d58 2317 esdTrack->GetID(), // This is the track ID of the mother's track!
f29f1726 2318 AliAODVertex::kKink);
2319 // Add the daughter track
2320
2321 AliAODTrack * daughter = NULL;
2322
2323 if (!usedTrack[idaughter]) {
2324
2325 usedTrack[idaughter] = kTRUE;
2326
2327 AliESDtrack *esdTrack = esd->GetTrack(idaughter);
2328 esdTrack->GetPxPyPz(p);
2329 esdTrack->GetXYZ(pos);
2330 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2331 esdTrack->GetESDpid(pid);
2332
2333 daughter =
2334 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2335 esdTrack->GetLabel(),
2336 p,
2337 kTRUE,
2338 pos,
2339 kFALSE,
2340 covTr,
b97637d4 2341 (Short_t)esdTrack->Charge(),
f29f1726 2342 esdTrack->GetITSClusterMap(),
2343 pid,
2344 vkink,
2345 kTRUE, // check if this is right
2346 kTRUE, // check if this is right
2347 AliAODTrack::kPrimary);
2348 vkink->AddDaughter(daughter);
2349 daughter->ConvertAliPIDtoAODPID();
2350 }
2351 else {
2352 cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
2353 << " track " << idaughter << " has already been used!" << endl;
2354 }
2355
2356
2357 }
2358 }
2359
2360 }
2361
2362 }
2363
2364
2365 // Tracks (primary and orphan)
2366
2367 for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
2368
2369
2370 if (usedTrack[nTrack]) continue;
2371
2372 AliESDtrack *esdTrack = esd->GetTrack(nTrack);
2373 esdTrack->GetPxPyPz(p);
2374 esdTrack->GetXYZ(pos);
2375 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2376 esdTrack->GetESDpid(pid);
2377
2378 Float_t impactXY, impactZ;
2379
2380 esdTrack->GetImpactParameters(impactXY,impactZ);
2381
2382 if (impactXY<3) {
2383 // track inside the beam pipe
2384
2385 primary->AddDaughter(aodTrack =
2386 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2387 esdTrack->GetLabel(),
2388 p,
2389 kTRUE,
2390 pos,
2391 kFALSE,
2392 covTr,
b97637d4 2393 (Short_t)esdTrack->Charge(),
f29f1726 2394 esdTrack->GetITSClusterMap(),
2395 pid,
2396 primary,
2397 kTRUE, // check if this is right
2398 kTRUE, // check if this is right
2399 AliAODTrack::kPrimary)
2400 );
2401 aodTrack->ConvertAliPIDtoAODPID();
2402 }
2403 else {
2404 // outside the beam pipe: orphan track
2405 aodTrack =
2406 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2407 esdTrack->GetLabel(),
2408 p,
2409 kTRUE,
2410 pos,
2411 kFALSE,
2412 covTr,
b97637d4 2413 (Short_t)esdTrack->Charge(),
f29f1726 2414 esdTrack->GetITSClusterMap(),
2415 pid,
2416 NULL,
2417 kFALSE, // check if this is right
2418 kFALSE, // check if this is right
2419 AliAODTrack::kOrphan);
2420 aodTrack->ConvertAliPIDtoAODPID();
2421 }
2422 } // end of loop on tracks
2423
2424 // muon tracks
2425 Int_t nMuTracks = esd->GetNumberOfMuonTracks();
2426 for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
2427
2428 AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);
2429 p[0] = esdMuTrack->Px();
2430 p[1] = esdMuTrack->Py();
2431 p[2] = esdMuTrack->Pz();
2432 pos[0] = primary->GetX();
2433 pos[1] = primary->GetY();
2434 pos[2] = primary->GetZ();
2435
2436 // has to be changed once the muon pid is provided by the ESD
2437 for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
2438
85ba66b8 2439 primary->AddDaughter(aodTrack =
f29f1726 2440 new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
2441 0, // no label provided
2442 p,
2443 kTRUE,
2444 pos,
2445 kFALSE,
2446 NULL, // no covariance matrix provided
b97637d4 2447 esdMuTrack->Charge(),
e704c7d4 2448 0, // ITSClusterMap is set below
f29f1726 2449 pid,
2450 primary,
85ba66b8 2451 kFALSE, // muon tracks are not used to fit the primary vtx
2452 kFALSE, // not used for vertex fit
f29f1726 2453 AliAODTrack::kPrimary)
2454 );
85ba66b8 2455
2456 aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
2457 Int_t track2Trigger = esdMuTrack->GetMatchTrigger();
2458 aodTrack->SetMatchTrigger(track2Trigger);
2459 if (track2Trigger)
2460 aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
2461 else
2462 aodTrack->SetChi2MatchTrigger(0.);
f29f1726 2463 }
2464
2465 // Access to the AOD container of clusters
2466 TClonesArray &clusters = *(aod->GetClusters());
2467 Int_t jClusters=0;
2468
2469 // Calo Clusters
2470 Int_t nClusters = esd->GetNumberOfCaloClusters();
2471
2472 for (Int_t iClust=0; iClust<nClusters; ++iClust) {
2473
2474 AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
2475
2476 Int_t id = cluster->GetID();
2477 Int_t label = -1;
53ec9628 2478 Float_t energy = cluster->E();
2479 cluster->GetPosition(posF);
f29f1726 2480 AliAODVertex *prodVertex = primary;
2481 AliAODTrack *primTrack = NULL;
2482 Char_t ttype=AliAODCluster::kUndef;
85ba66b8 2483
f29f1726 2484 if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
2485 else if (cluster->IsEMCAL()) {
85ba66b8 2486
f29f1726 2487 if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
2488 ttype = AliAODCluster::kEMCALPseudoCluster;
2489 else
2490 ttype = AliAODCluster::kEMCALClusterv1;
85ba66b8 2491
f29f1726 2492 }
85ba66b8 2493
f29f1726 2494 new(clusters[jClusters++]) AliAODCluster(id,
2495 label,
2496 energy,
2497 pos,
2498 NULL, // no covariance matrix provided
2499 NULL, // no pid for clusters provided
2500 prodVertex,
2501 primTrack,
2502 ttype);
85ba66b8 2503
f29f1726 2504 } // end of loop on calo clusters
85ba66b8 2505
2506 // tracklets
2507 const AliMultiplicity *mult = esd->GetMultiplicity();
2508 if (mult) {
2509 if (mult->GetNumberOfTracklets()>0) {
2510 aod->GetTracklets()->CreateContainer(mult->GetNumberOfTracklets());
2511
2512 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
2513 aod->GetTracklets()->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
2514 }
2515 }
2516 } else {
2517 Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
2518 }
2519
f29f1726 2520 delete [] usedTrack;
2521 delete [] usedV0;
2522 delete [] usedKink;
85ba66b8 2523
f29f1726 2524 // fill the tree for this event
2525 aodTree->Fill();
2526 } // end of event loop
85ba66b8 2527
f29f1726 2528 aodTree->GetUserInfo()->Add(aod);
85ba66b8 2529
f29f1726 2530 // close ESD file
2531 esdFile->Close();
85ba66b8 2532
f29f1726 2533 // write the tree to the specified file
2534 aodFile = aodTree->GetCurrentFile();
2535 aodFile->cd();
2536 aodTree->Write();
85ba66b8 2537
a7807689 2538 return;
2539}
2540
af885e0f 2541void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
98937d93 2542{
2543 // Write space-points which are then used in the alignment procedures
2544 // For the moment only ITS, TRD and TPC
2545
2546 // Load TOF clusters
d528ee75 2547 if (fTracker[3]){
2548 fLoader[3]->LoadRecPoints("read");
2549 TTree* tree = fLoader[3]->TreeR();
2550 if (!tree) {
2551 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2552 return;
2553 }
2554 fTracker[3]->LoadClusters(tree);
98937d93 2555 }
98937d93 2556 Int_t ntracks = esd->GetNumberOfTracks();
2557 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2558 {
2559 AliESDtrack *track = esd->GetTrack(itrack);
2560 Int_t nsp = 0;
ef7253ac 2561 Int_t idx[200];
98937d93 2562 for (Int_t iDet = 3; iDet >= 0; iDet--)
2563 nsp += track->GetNcls(iDet);
2564 if (nsp) {
2565 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2566 track->SetTrackPointArray(sp);
2567 Int_t isptrack = 0;
2568 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2569 AliTracker *tracker = fTracker[iDet];
2570 if (!tracker) continue;
2571 Int_t nspdet = track->GetNcls(iDet);
98937d93 2572 if (nspdet <= 0) continue;
2573 track->GetClusters(iDet,idx);
2574 AliTrackPoint p;
2575 Int_t isp = 0;
2576 Int_t isp2 = 0;
2577 while (isp < nspdet) {
2578 Bool_t isvalid = tracker->GetTrackPoint(idx[isp2],p); isp2++;
160db090 2579 const Int_t kNTPCmax = 159;
2580 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
98937d93 2581 if (!isvalid) continue;
2582 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2583 }
98937d93 2584 }
2585 }
2586 }
d528ee75 2587 if (fTracker[3]){
2588 fTracker[3]->UnloadClusters();
2589 fLoader[3]->UnloadRecPoints();
2590 }
98937d93 2591}
2e3550da 2592
2593//_____________________________________________________________________________
af885e0f 2594void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2e3550da 2595{
2596 // The method reads the raw-data error log
2597 // accumulated within the rawReader.
2598 // It extracts the raw-data errors related to
2599 // the current event and stores them into
2600 // a TClonesArray inside the esd object.
2601
2602 if (!fRawReader) return;
2603
2604 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2605
2606 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2607 if (!log) continue;
2608 if (iEvent != log->GetEventNumber()) continue;
2609
2610 esd->AddRawDataErrorLog(log);
2611 }
2612
2613}
46698ae4 2614
2615TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
b545009a 2616 // Dump a file content into a char in TNamed
46698ae4 2617 ifstream in;
2618 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2619 Int_t kBytes = (Int_t)in.tellg();
2620 printf("Size: %d \n",kBytes);
2621 TNamed *fn = 0;
2622 if(in.good()){
2623 char* memblock = new char [kBytes];
2624 in.seekg (0, ios::beg);
2625 in.read (memblock, kBytes);
2626 in.close();
2627 TString fData(memblock,kBytes);
2628 fn = new TNamed(fName,fData);
2629 printf("fData Size: %d \n",fData.Sizeof());
2630 printf("fName Size: %d \n",fName.Sizeof());
2631 printf("fn Size: %d \n",fn->Sizeof());
2632 delete[] memblock;
2633 }
2634 else{
2635 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2636 }
2637
2638 return fn;
2639}
2640
2641void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
46698ae4 2642 // This is not really needed in AliReconstruction at the moment
2643 // but can serve as a template
2644
2645 TList *fList = fTree->GetUserInfo();
2646 TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
2647 printf("fn Size: %d \n",fn->Sizeof());
2648
2649 TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
2650 const char* cdata = fn->GetTitle();
2651 printf("fTmp Size %d\n",fTmp.Sizeof());
2652
2653 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2654 printf("calculated size %d\n",size);
2655 ofstream out(fName.Data(),ios::out | ios::binary);
2656 out.write(cdata,size);
2657 out.close();
2658
2659}
2660
a5fa6165 2661//_____________________________________________________________________________
2662AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet)
2663{
2664// get the quality assurance data maker object and the loader for a detector
2665
2666 if (fQualAssDataMaker[iDet])
2667 return fQualAssDataMaker[iDet];
2668
2669 // load the QA data maker object
2670 TPluginManager* pluginManager = gROOT->GetPluginManager();
2671 TString detName = fgkDetectorName[iDet];
2672 TString qadmName = "Ali" + detName + "QualAssDataMaker";
2673 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
2674 return NULL;
2675
2676 AliQualAssDataMaker * qadm = NULL;
2677 // first check if a plugin is defined for the quality assurance data maker
2678 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
2679 // if not, add a plugin for it
2680 if (!pluginHandler) {
2681 AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2682 TString libs = gSystem->GetLibraries();
2683 if (libs.Contains("lib" + detName + "base.so") ||
2684 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2685 pluginManager->AddHandler("AliQualAssDataMaker", detName,
2686 qadmName, detName + "qadm", qadmName + "()");
2687 } else {
2688 pluginManager->AddHandler("AliQualAssDataMaker", detName,
2689 qadmName, detName, qadmName + "()");
2690 }
2691 pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
2692 }
2693 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2694 qadm = (AliQualAssDataMaker *) pluginHandler->ExecPlugin(0);
2695 }
2696 if (qadm) {
2697 // TObject* obj = fOptions.FindObject(detName.Data());
2698 // if (obj) reconstructor->SetOption(obj->GetTitle());
2699 fQualAssDataMaker[iDet] = qadm;
2700 }
2701
2702 // get or create the loader
2703 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2704 if (!fLoader[iDet]) {
2705 AliConfig::Instance()
2706 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2707 detName, detName);
2708 // first check if a plugin is defined for the loader
2709 pluginHandler =
2710 pluginManager->FindHandler("AliLoader", detName);
2711 // if not, add a plugin for it
2712 if (!pluginHandler) {
2713 TString loaderName = "Ali" + detName + "Loader";
2714 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2715 pluginManager->AddHandler("AliLoader", detName,
2716 loaderName, detName + "base",
2717 loaderName + "(const char*, TFolder*)");
2718 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2719 }
2720 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2721 fLoader[iDet] =
2722 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2723 fRunLoader->GetEventFolder());
2724 }
2725 if (!fLoader[iDet]) { // use default loader
2726 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2727 }
2728 if (!fLoader[iDet]) {
2729 AliWarning(Form("couldn't get loader for %s", detName.Data()));
2730 if (fStopOnError) return NULL;
2731 } else {
2732 fRunLoader->AddLoader(fLoader[iDet]);
2733 fRunLoader->CdGAFile();
2734 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2735 fRunLoader->Write(0, TObject::kOverwrite);
2736 }
2737 }
2738
2739 return qadm;
2740}
2741
2742//_____________________________________________________________________________
2743Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
2744{
2745 // run the Quality Assurance data producer
2746
2747 AliCodeTimerAuto("")
2748 TString detStr = detectors;
2749 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2750 if (!IsSelected(fgkDetectorName[iDet], detStr))
2751 continue;
2752 AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
2753 if (!qadm)
2754 continue;
2755 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2756 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2757
2758 qadm->SetData(esd) ;
2759 qadm->Exec(AliQualAss::kESDS) ;
2760
2761 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2762 }
2763 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2764 AliError(Form("the following detectors were not found: %s",
2765 detStr.Data()));
2766 if (fStopOnError)
2767 return kFALSE;
2768 }
2769
2770 return kTRUE;
2771}