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