1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 ///////////////////////////////////////////////////////////////////////////////
20 // class for running the reconstruction //
22 // Clusters and tracks are created for all detectors and all events by //
25 // AliReconstruction rec; //
28 // The Run method returns kTRUE in case of successful execution. //
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 //
33 // rec.SetInput("..."); //
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 //
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 //
45 // rec.SetEventRange(..., ...); //
47 // The index -1 (default) can be used for the last event to indicate no //
48 // upper limit of the event range. //
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): //
56 // rec.SetNumberOfEventsPerFile(...); //
59 // The name of the galice file can be changed from the default //
60 // "galice.root" by passing it as argument to the AliReconstruction //
61 // constructor or by //
63 // rec.SetGAliceFile("..."); //
65 // The local reconstruction can be switched on or off for individual //
68 // rec.SetRunLocalReconstruction("..."); //
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. //
74 // The reconstruction of the primary vertex position can be switched off by //
76 // rec.SetRunVertexFinder(kFALSE); //
78 // The tracking and the creation of ESD tracks can be switched on for //
79 // selected detectors by //
81 // rec.SetRunTracking("..."); //
83 // Uniform/nonuniform field tracking switches (default: uniform field) //
85 // rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
87 // The filling of additional ESD information can be steered by //
89 // rec.SetFillESD("..."); //
91 // Again, for both methods the string specifies the list of detectors. //
92 // The default is "ALL". //
94 // The call of the shortcut method //
96 // rec.SetRunReconstruction("..."); //
98 // is equivalent to calling SetRunLocalReconstruction, SetRunTracking and //
99 // SetFillESD with the same detector selecting string as argument. //
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. //
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. //
115 ///////////////////////////////////////////////////////////////////////////////
121 #include <TPluginManager.h>
122 #include <TGeoManager.h>
123 #include <TLorentzVector.h>
125 #include "AliReconstruction.h"
126 #include "AliCodeTimer.h"
127 #include "AliReconstructor.h"
129 #include "AliRunLoader.h"
131 #include "AliRawReaderFile.h"
132 #include "AliRawReaderDate.h"
133 #include "AliRawReaderRoot.h"
134 #include "AliRawEventHeaderBase.h"
135 #include "AliESDEvent.h"
136 #include "AliESDMuonTrack.h"
137 #include "AliESDfriend.h"
138 #include "AliESDVertex.h"
139 #include "AliESDcascade.h"
140 #include "AliESDkink.h"
141 #include "AliESDtrack.h"
142 #include "AliESDCaloCluster.h"
143 #include "AliMultiplicity.h"
144 #include "AliTracker.h"
145 #include "AliVertexer.h"
146 #include "AliVertexerTracks.h"
147 #include "AliV0vertexer.h"
148 #include "AliCascadeVertexer.h"
149 #include "AliHeader.h"
150 #include "AliGenEventHeader.h"
152 #include "AliESDpid.h"
153 #include "AliESDtrack.h"
155 #include "AliESDTagCreator.h"
156 #include "AliAODTagCreator.h"
158 #include "AliGeomManager.h"
159 #include "AliTrackPointArray.h"
160 #include "AliCDBManager.h"
161 #include "AliCDBEntry.h"
162 #include "AliAlignObj.h"
164 #include "AliCentralTrigger.h"
165 #include "AliCTPRawStream.h"
167 #include "AliAODEvent.h"
168 #include "AliAODHeader.h"
169 #include "AliAODTrack.h"
170 #include "AliAODVertex.h"
171 #include "AliAODCluster.h"
173 #include "AliQADataMaker.h"
175 #include "AliSysInfo.h" // memory snapshots
178 ClassImp(AliReconstruction)
181 //_____________________________________________________________________________
182 const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
184 //_____________________________________________________________________________
185 AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri,
186 const char* name, const char* title) :
189 fUniformField(kTRUE),
190 fRunVertexFinder(kTRUE),
191 fRunHLTTracking(kFALSE),
192 fRunMuonTracking(kFALSE),
194 fRunCascadeFinder(kTRUE),
195 fStopOnError(kFALSE),
196 fWriteAlignmentData(kFALSE),
197 fWriteESDfriend(kFALSE),
199 fFillTriggerESD(kTRUE),
205 fRunLocalReconstruction("ALL"),
208 fUseTrackingErrorsForAlignment(""),
209 fGAliceFileName(gAliceFilename),
214 fNumberOfEventsPerFile(1),
217 fLoadAlignFromCDB(kTRUE),
218 fLoadAlignData("ALL"),
225 fDiamondProfile(NULL),
227 fAlignObjArray(NULL),
232 // create reconstruction object with default parameters
234 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
235 fReconstructor[iDet] = NULL;
236 fLoader[iDet] = NULL;
237 fTracker[iDet] = NULL;
238 fQADataMaker[iDet] = NULL;
239 fQACycles[iDet] = 999999;
244 //_____________________________________________________________________________
245 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
248 fUniformField(rec.fUniformField),
249 fRunVertexFinder(rec.fRunVertexFinder),
250 fRunHLTTracking(rec.fRunHLTTracking),
251 fRunMuonTracking(rec.fRunMuonTracking),
252 fRunV0Finder(rec.fRunV0Finder),
253 fRunCascadeFinder(rec.fRunCascadeFinder),
254 fStopOnError(rec.fStopOnError),
255 fWriteAlignmentData(rec.fWriteAlignmentData),
256 fWriteESDfriend(rec.fWriteESDfriend),
257 fWriteAOD(rec.fWriteAOD),
258 fFillTriggerESD(rec.fFillTriggerESD),
260 fCleanESD(rec.fCleanESD),
264 fRunLocalReconstruction(rec.fRunLocalReconstruction),
265 fRunTracking(rec.fRunTracking),
266 fFillESD(rec.fFillESD),
267 fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
268 fGAliceFileName(rec.fGAliceFileName),
270 fEquipIdMap(rec.fEquipIdMap),
271 fFirstEvent(rec.fFirstEvent),
272 fLastEvent(rec.fLastEvent),
273 fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
276 fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
277 fLoadAlignData(rec.fLoadAlignData),
278 fESDPar(rec.fESDPar),
284 fDiamondProfile(NULL),
286 fAlignObjArray(rec.fAlignObjArray),
287 fCDBUri(rec.fCDBUri),
288 fRemoteCDBUri(rec.fRemoteCDBUri),
293 for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
294 if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
296 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
297 fReconstructor[iDet] = NULL;
298 fLoader[iDet] = NULL;
299 fTracker[iDet] = NULL;
300 fQADataMaker[iDet] = NULL;
301 fQACycles[iDet] = rec.fQACycles[iDet];
303 for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
304 if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
308 //_____________________________________________________________________________
309 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
311 // assignment operator
313 this->~AliReconstruction();
314 new(this) AliReconstruction(rec);
318 //_____________________________________________________________________________
319 AliReconstruction::~AliReconstruction()
325 fSpecCDBUri.Delete();
327 AliCodeTimer::Instance()->Print();
330 //_____________________________________________________________________________
331 void AliReconstruction::InitCDBStorage()
333 // activate a default CDB storage
334 // First check if we have any CDB storage set, because it is used
335 // to retrieve the calibration and alignment constants
337 AliCDBManager* man = AliCDBManager::Instance();
338 if (man->IsDefaultStorageSet())
340 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
341 AliWarning("Default CDB storage has been already set !");
342 AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
343 AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
347 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
348 AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
349 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
350 man->SetDefaultStorage(fCDBUri);
353 // Remote storage (the Grid storage) is used if it is activated
354 // and if the object is not found in the default storage
356 // if (man->IsRemoteStorageSet())
358 // AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
359 // AliWarning("Remote CDB storage has been already set !");
360 // AliWarning(Form("Ignoring the remote storage declared in AliReconstruction: %s",fRemoteCDBUri.Data()));
361 // AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
362 // fRemoteCDBUri = "";
365 // AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
366 // AliDebug(2, Form("Remote CDB storage is set to: %s",fRemoteCDBUri.Data()));
367 // AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
368 // man->SetRemoteStorage(fRemoteCDBUri);
371 // Now activate the detector specific CDB storage locations
372 for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
373 TObject* obj = fSpecCDBUri[i];
375 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
376 AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
377 AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
378 man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
383 //_____________________________________________________________________________
384 void AliReconstruction::SetDefaultStorage(const char* uri) {
385 // Store the desired default CDB storage location
386 // Activate it later within the Run() method
392 //_____________________________________________________________________________
393 void AliReconstruction::SetRemoteStorage(const char* uri) {
394 // Store the desired remote CDB storage location
395 // Activate it later within the Run() method
396 // Remote storage (the Grid storage) is used if it is activated
397 // and if the object is not found in the default storage
403 //_____________________________________________________________________________
404 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
405 // Store a detector-specific CDB storage location
406 // Activate it later within the Run() method
408 AliCDBPath aPath(calibType);
409 if(!aPath.IsValid()){
410 // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
411 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
412 if(!strcmp(calibType, fgkDetectorName[iDet])) {
413 aPath.SetPath(Form("%s/*", calibType));
414 AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
418 if(!aPath.IsValid()){
419 AliError(Form("Not a valid path or detector: %s", calibType));
424 // // check that calibType refers to a "valid" detector name
425 // Bool_t isDetector = kFALSE;
426 // for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
427 // TString detName = fgkDetectorName[iDet];
428 // if(aPath.GetLevel0() == detName) {
429 // isDetector = kTRUE;
435 // AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
439 TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
440 if (obj) fSpecCDBUri.Remove(obj);
441 fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
448 //_____________________________________________________________________________
449 Bool_t AliReconstruction::SetRunNumber()
451 // The method is called in Run() in order
452 // to set a correct run number.
453 // In case of raw data reconstruction the
454 // run number is taken from the raw data header
456 if(AliCDBManager::Instance()->GetRun() < 0) {
458 AliError("No run loader is found !");
461 // read run number from gAlice
462 if(fRunLoader->GetAliRun())
463 AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
466 if(fRawReader->NextEvent()) {
467 AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
468 fRawReader->RewindEvents();
471 AliError("No raw-data events found !");
476 AliError("Neither gAlice nor RawReader objects are found !");
480 AliInfo(Form("CDB Run number: %d",AliCDBManager::Instance()->GetRun()));
485 //_____________________________________________________________________________
486 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
488 // Read the alignment objects from CDB.
489 // Each detector is supposed to have the
490 // alignment objects in DET/Align/Data CDB path.
491 // All the detector objects are then collected,
492 // sorted by geometry level (starting from ALIC) and
493 // then applied to the TGeo geometry.
494 // Finally an overlaps check is performed.
496 // Load alignment data from CDB and fill fAlignObjArray
497 if(fLoadAlignFromCDB){
499 TString detStr = detectors;
500 TString loadAlObjsListOfDets = "";
502 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
503 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
504 loadAlObjsListOfDets += fgkDetectorName[iDet];
505 loadAlObjsListOfDets += " ";
506 } // end loop over detectors
507 loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
508 AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
510 // Check if the array with alignment objects was
511 // provided by the user. If yes, apply the objects
512 // to the present TGeo geometry
513 if (fAlignObjArray) {
514 if (gGeoManager && gGeoManager->IsClosed()) {
515 if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
516 AliError("The misalignment of one or more volumes failed!"
517 "Compare the list of simulated detectors and the list of detector alignment data!");
522 AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
528 delete fAlignObjArray; fAlignObjArray=0;
533 //_____________________________________________________________________________
534 void AliReconstruction::SetGAliceFile(const char* fileName)
536 // set the name of the galice file
538 fGAliceFileName = fileName;
541 //_____________________________________________________________________________
542 void AliReconstruction::SetOption(const char* detector, const char* option)
544 // set options for the reconstruction of a detector
546 TObject* obj = fOptions.FindObject(detector);
547 if (obj) fOptions.Remove(obj);
548 fOptions.Add(new TNamed(detector, option));
552 //_____________________________________________________________________________
553 Bool_t AliReconstruction::Run(const char* input)
555 // run the reconstruction
560 if (!input) input = fInput.Data();
561 TString fileName(input);
562 if (fileName.EndsWith("/")) {
563 fRawReader = new AliRawReaderFile(fileName);
564 } else if (fileName.EndsWith(".root")) {
565 fRawReader = new AliRawReaderRoot(fileName);
566 } else if (!fileName.IsNull()) {
567 fRawReader = new AliRawReaderDate(fileName);
568 fRawReader->SelectEvents(7);
570 if (!fEquipIdMap.IsNull() && fRawReader)
571 fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
573 AliSysInfo::AddStamp("Start");
574 // get the run loader
575 if (!InitRunLoader()) return kFALSE;
576 AliSysInfo::AddStamp("LoadLoader");
578 // Initialize the CDB storage
580 AliSysInfo::AddStamp("LoadCDB");
582 // Set run number in CDBManager (if it is not already set by the user)
583 if (!SetRunNumber()) if (fStopOnError) return kFALSE;
585 // Import ideal TGeo geometry and apply misalignment
587 TString geom(gSystem->DirName(fGAliceFileName));
588 geom += "/geometry.root";
589 AliGeomManager::LoadGeometry(geom.Data());
590 if (!gGeoManager) if (fStopOnError) return kFALSE;
593 if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
594 AliSysInfo::AddStamp("LoadGeom");
596 // local reconstruction
597 if (!fRunLocalReconstruction.IsNull()) {
598 if (!RunLocalReconstruction(fRunLocalReconstruction)) {
599 if (fStopOnError) {CleanUp(); return kFALSE;}
602 // if (!fRunVertexFinder && fRunTracking.IsNull() &&
603 // fFillESD.IsNull()) return kTRUE;
606 if (fRunVertexFinder && !CreateVertexer()) {
612 AliSysInfo::AddStamp("Vertexer");
615 if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
621 AliSysInfo::AddStamp("LoadTrackers");
623 // get the possibly already existing ESD file and tree
624 AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
625 TFile* fileOld = NULL;
626 TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
627 if (!gSystem->AccessPathName("AliESDs.root")){
628 gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
629 fileOld = TFile::Open("AliESDs.old.root");
630 if (fileOld && fileOld->IsOpen()) {
631 treeOld = (TTree*) fileOld->Get("esdTree");
632 if (treeOld)esd->ReadFromTree(treeOld);
633 hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
634 if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld);
638 // create the ESD output file and tree
639 TFile* file = TFile::Open("AliESDs.root", "RECREATE");
640 file->SetCompressionLevel(2);
641 if (!file->IsOpen()) {
642 AliError("opening AliESDs.root failed");
643 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
646 TTree* tree = new TTree("esdTree", "Tree with ESD objects");
647 esd = new AliESDEvent();
648 esd->CreateStdContent();
649 esd->WriteToTree(tree);
651 TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
652 hltesd = new AliESDEvent();
653 hltesd->CreateStdContent();
654 hltesd->WriteToTree(hlttree);
657 delete esd; delete hltesd;
658 esd = NULL; hltesd = NULL;
660 // create the branch with ESD additions
664 AliESDfriend *esdf = 0;
665 if (fWriteESDfriend) {
666 esdf = new AliESDfriend();
667 TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf);
668 br->SetFile("AliESDfriends.root");
669 esd->AddObject(esdf);
673 // Get the diamond profile from OCDB
674 AliCDBEntry* entry = AliCDBManager::Instance()
675 ->Get("GRP/Calib/MeanVertex");
678 fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
680 AliError("No diamond profile found in OCDB!");
683 AliVertexerTracks tVertexer(AliTracker::GetBz());
684 if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
688 if (fRawReader) fRawReader->RewindEvents();
689 TString detStr(fFillESD) ;
692 gSystem->GetProcInfo(&ProcInfo);
693 AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
695 // checking the QA of previous steps
698 for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
699 if (fRawReader) fRawReader->NextEvent();
700 if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
701 // copy old ESD to the new one
703 esd->ReadFromTree(treeOld);
704 treeOld->GetEntry(iEvent);
708 esd->ReadFromTree(hlttreeOld);
709 hlttreeOld->GetEntry(iEvent);
715 AliInfo(Form("processing event %d", iEvent));
716 fRunLoader->GetEvent(iEvent);
719 sprintf(aFileName, "ESD_%d.%d_final.root",
720 fRunLoader->GetHeader()->GetRun(),
721 fRunLoader->GetHeader()->GetEventNrInRun());
722 if (!gSystem->AccessPathName(aFileName)) continue;
724 // local reconstruction
725 if (!fRunLocalReconstruction.IsNull()) {
726 if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
727 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
732 esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
733 hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
734 esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
735 hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
737 // Set magnetic field from the tracker
738 esd->SetMagneticField(AliTracker::GetBz());
739 hltesd->SetMagneticField(AliTracker::GetBz());
743 // Fill raw-data error log into the ESD
744 if (fRawReader) FillRawDataErrorLog(iEvent,esd);
747 if (fRunVertexFinder) {
748 if (!ReadESD(esd, "vertex")) {
749 if (!RunVertexFinder(esd)) {
750 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
752 if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
757 if (!fRunTracking.IsNull()) {
758 if (fRunHLTTracking) {
759 hltesd->SetVertex(esd->GetVertex());
760 if (!RunHLTTracking(hltesd)) {
761 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
767 if (!fRunTracking.IsNull()) {
768 if (fRunMuonTracking) {
769 if (!RunMuonTracking(esd)) {
770 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
776 if (!fRunTracking.IsNull()) {
777 if (!ReadESD(esd, "tracking")) {
778 if (!RunTracking(esd)) {
779 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
781 if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
786 if (!fFillESD.IsNull()) {
787 if (!FillESD(esd, fFillESD)) {
788 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
792 if (!fFillESD.IsNull())
793 RunQA(fFillESD.Data(), esd);
795 // fill Event header information from the RawEventHeader
796 if (fRawReader){FillRawEventHeaderESD(esd);}
799 AliESDpid::MakePID(esd);
800 if (fCheckPointLevel > 1) WriteESD(esd, "PID");
802 if (fFillTriggerESD) {
803 if (!ReadESD(esd, "trigger")) {
804 if (!FillTriggerESD(esd)) {
805 if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
807 if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
813 //Try to improve the reconstructed primary vertex position using the tracks
814 AliESDVertex *pvtx=0;
815 Bool_t dovertex=kTRUE;
816 TObject* obj = fOptions.FindObject("ITS");
818 TString optITS = obj->GetTitle();
819 if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
822 if(dovertex) pvtx=tVertexer.FindPrimaryVertex(esd);
823 if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
826 if (pvtx->GetStatus()) {
827 // Store the improved primary vertex
828 esd->SetPrimaryVertex(pvtx);
829 // Propagate the tracks to the DCA to the improved primary vertex
830 Double_t somethingbig = 777.;
831 Double_t bz = esd->GetMagneticField();
832 Int_t nt=esd->GetNumberOfTracks();
834 AliESDtrack *t = esd->GetTrack(nt);
835 t->RelateToVertex(pvtx, bz, somethingbig);
842 vtxer.Tracks2V0vertices(esd);
844 if (fRunCascadeFinder) {
846 AliCascadeVertexer cvtxer;
847 cvtxer.V0sTracks2CascadeVertices(esd);
852 if (fCleanESD) CleanESD(esd);
853 if (fWriteESDfriend) {
854 esdf->~AliESDfriend();
855 new (esdf) AliESDfriend(); // Reset...
856 esd->GetESDfriend(esdf);
863 if (fCheckPointLevel > 0) WriteESD(esd, "final");
866 if (fWriteESDfriend) {
867 esdf->~AliESDfriend();
868 new (esdf) AliESDfriend(); // Reset...
871 // delete esdf; esdf = 0;
874 gSystem->GetProcInfo(&ProcInfo);
875 AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
879 // write quality assurance ESDs data (one entry for all events)
880 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
881 if (!IsSelected(fgkDetectorName[iDet], detStr))
883 AliQADataMaker * qadm = GetQADataMaker(iDet);
885 qadm->EndOfCycle(AliQA::kRECPOINTS);
886 qadm->EndOfCycle(AliQA::kESDS);
887 qadm->Finish(AliQA::kRECPOINTS);
888 qadm->Finish(AliQA::kESDS) ;
891 tree->GetUserInfo()->Add(esd);
892 hlttree->GetUserInfo()->Add(hltesd);
896 if(fESDPar.Contains("ESD.par")){
897 AliInfo("Attaching ESD.par to Tree");
898 TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
899 tree->GetUserInfo()->Add(fn);
905 tree->SetBranchStatus("ESDfriend*",0);
906 // we want to have only one tree version number
907 tree->Write(tree->GetName(),TObject::kOverwrite);
911 TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
912 ESDFile2AODFile(file, aodFile);
917 CleanUp(file, fileOld);
919 // Create tags for the events in the ESD tree (the ESD tree is always present)
920 // In case of empty events the tags will contain dummy values
921 AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
922 esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent);
924 AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
925 aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent);
932 //_____________________________________________________________________________
933 Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
935 // run the local reconstruction
936 static Int_t eventNr=0;
939 // AliCDBManager* man = AliCDBManager::Instance();
940 // Bool_t origCache = man->GetCacheFlag();
942 // TString detStr = detectors;
943 // for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
944 // if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
945 // AliReconstructor* reconstructor = GetReconstructor(iDet);
946 // if (!reconstructor) continue;
947 // if (reconstructor->HasLocalReconstruction()) continue;
949 // AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
950 // AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
952 // AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
953 // AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
955 // man->SetCacheFlag(kTRUE);
956 // TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
957 // man->GetAll(calibPath); // entries are cached!
959 // AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
962 // fRawReader->RewindEvents();
963 // reconstructor->Reconstruct(fRunLoader, fRawReader);
965 // reconstructor->Reconstruct(fRunLoader);
968 // AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
969 // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
971 // // unload calibration data
972 // man->UnloadFromCache(calibPath);
973 // //man->ClearCache();
976 // man->SetCacheFlag(origCache);
978 // if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
979 // AliError(Form("the following detectors were not found: %s",
981 // if (fStopOnError) return kFALSE;
988 //_____________________________________________________________________________
989 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
991 // run the local reconstruction
992 static Int_t eventNr=0;
995 TString detStr = detectors;
996 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
997 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
998 AliReconstructor* reconstructor = GetReconstructor(iDet);
999 if (!reconstructor) continue;
1000 AliLoader* loader = fLoader[iDet];
1002 AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1006 // conversion of digits
1007 if (fRawReader && reconstructor->HasDigitConversion()) {
1008 AliInfo(Form("converting raw data digits into root objects for %s",
1009 fgkDetectorName[iDet]));
1010 AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1011 fgkDetectorName[iDet]));
1012 loader->LoadDigits("update");
1013 loader->CleanDigits();
1014 loader->MakeDigitsContainer();
1015 TTree* digitsTree = loader->TreeD();
1016 reconstructor->ConvertDigits(fRawReader, digitsTree);
1017 loader->WriteDigits("OVERWRITE");
1018 loader->UnloadDigits();
1021 // local reconstruction
1022 AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1023 AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1024 loader->LoadRecPoints("update");
1025 loader->CleanRecPoints();
1026 loader->MakeRecPointsContainer();
1027 TTree* clustersTree = loader->TreeR();
1028 if (fRawReader && !reconstructor->HasDigitConversion()) {
1029 reconstructor->Reconstruct(fRawReader, clustersTree);
1031 loader->LoadDigits("read");
1032 TTree* digitsTree = loader->TreeD();
1034 AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1035 if (fStopOnError) return kFALSE;
1037 reconstructor->Reconstruct(digitsTree, clustersTree);
1039 loader->UnloadDigits();
1042 AliQADataMaker * qadm = GetQADataMaker(iDet);
1044 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
1045 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
1047 if (qadm->IsCycleDone() ) {
1048 qadm->EndOfCycle(AliQA::kRECPOINTS) ;
1049 qadm->EndOfCycle(AliQA::kESDS) ;
1050 qadm->StartOfCycle(AliQA::kRECPOINTS) ;
1051 qadm->StartOfCycle(AliQA::kESDS, "same") ;
1053 qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1054 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
1057 loader->WriteRecPoints("OVERWRITE");
1058 loader->UnloadRecPoints();
1059 AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
1062 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1063 AliError(Form("the following detectors were not found: %s",
1065 if (fStopOnError) return kFALSE;
1071 //_____________________________________________________________________________
1072 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
1074 // run the barrel tracking
1076 AliCodeTimerAuto("")
1078 AliESDVertex* vertex = NULL;
1079 Double_t vtxPos[3] = {0, 0, 0};
1080 Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1081 TArrayF mcVertex(3);
1082 if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1083 fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1084 for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1088 if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1089 AliInfo("running the ITS vertex finder");
1090 if (fLoader[0]) fLoader[0]->LoadRecPoints();
1091 vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
1092 if (fLoader[0]) fLoader[0]->UnloadRecPoints();
1094 AliWarning("Vertex not found");
1095 vertex = new AliESDVertex();
1096 vertex->SetName("default");
1099 vertex->SetName("reconstructed");
1103 AliInfo("getting the primary vertex from MC");
1104 vertex = new AliESDVertex(vtxPos, vtxErr);
1108 vertex->GetXYZ(vtxPos);
1109 vertex->GetSigmaXYZ(vtxErr);
1111 AliWarning("no vertex reconstructed");
1112 vertex = new AliESDVertex(vtxPos, vtxErr);
1114 esd->SetVertex(vertex);
1115 // if SPD multiplicity has been determined, it is stored in the ESD
1116 AliMultiplicity *mult = fVertexer->GetMultiplicity();
1117 if(mult)esd->SetMultiplicity(mult);
1119 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1120 if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1127 //_____________________________________________________________________________
1128 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1130 // run the HLT barrel tracking
1132 AliCodeTimerAuto("")
1135 AliError("Missing runLoader!");
1139 AliInfo("running HLT tracking");
1141 // Get a pointer to the HLT reconstructor
1142 AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1143 if (!reconstructor) return kFALSE;
1146 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1147 TString detName = fgkDetectorName[iDet];
1148 AliDebug(1, Form("%s HLT tracking", detName.Data()));
1149 reconstructor->SetOption(detName.Data());
1150 AliTracker *tracker = reconstructor->CreateTracker();
1152 AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1153 if (fStopOnError) return kFALSE;
1157 Double_t vtxErr[3]={0.005,0.005,0.010};
1158 const AliESDVertex *vertex = esd->GetVertex();
1159 vertex->GetXYZ(vtxPos);
1160 tracker->SetVertex(vtxPos,vtxErr);
1162 fLoader[iDet]->LoadRecPoints("read");
1163 TTree* tree = fLoader[iDet]->TreeR();
1165 AliError(Form("Can't get the %s cluster tree", detName.Data()));
1168 tracker->LoadClusters(tree);
1170 if (tracker->Clusters2Tracks(esd) != 0) {
1171 AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1175 tracker->UnloadClusters();
1183 //_____________________________________________________________________________
1184 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
1186 // run the muon spectrometer tracking
1188 AliCodeTimerAuto("")
1191 AliError("Missing runLoader!");
1194 Int_t iDet = 7; // for MUON
1196 AliInfo("is running...");
1198 // Get a pointer to the MUON reconstructor
1199 AliReconstructor *reconstructor = GetReconstructor(iDet);
1200 if (!reconstructor) return kFALSE;
1203 TString detName = fgkDetectorName[iDet];
1204 AliDebug(1, Form("%s tracking", detName.Data()));
1205 AliTracker *tracker = reconstructor->CreateTracker();
1207 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1212 fLoader[iDet]->LoadTracks("update");
1213 fLoader[iDet]->CleanTracks();
1214 fLoader[iDet]->MakeTracksContainer();
1217 fLoader[iDet]->LoadRecPoints("read");
1218 tracker->LoadClusters(fLoader[iDet]->TreeR());
1220 Int_t rv = tracker->Clusters2Tracks(esd);
1222 fLoader[iDet]->UnloadRecPoints();
1226 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1230 tracker->UnloadClusters();
1232 fLoader[iDet]->UnloadRecPoints();
1234 fLoader[iDet]->WriteTracks("OVERWRITE");
1235 fLoader[iDet]->UnloadTracks();
1243 //_____________________________________________________________________________
1244 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
1246 // run the barrel tracking
1247 static Int_t eventNr=0;
1248 AliCodeTimerAuto("")
1250 AliInfo("running tracking");
1252 //Fill the ESD with the T0 info (will be used by the TOF)
1253 if (fReconstructor[11] && fLoader[11]) {
1254 fLoader[11]->LoadRecPoints("READ");
1255 TTree *treeR = fLoader[11]->TreeR();
1256 GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1259 // pass 1: TPC + ITS inwards
1260 for (Int_t iDet = 1; iDet >= 0; iDet--) {
1261 if (!fTracker[iDet]) continue;
1262 AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
1265 fLoader[iDet]->LoadRecPoints("read");
1266 AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
1267 TTree* tree = fLoader[iDet]->TreeR();
1269 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1272 fTracker[iDet]->LoadClusters(tree);
1273 AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1275 if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1276 AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1279 if (fCheckPointLevel > 1) {
1280 WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1282 // preliminary PID in TPC needed by the ITS tracker
1284 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1285 AliESDpid::MakePID(esd);
1287 AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
1290 // pass 2: ALL backwards
1291 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1292 if (!fTracker[iDet]) continue;
1293 AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1296 if (iDet > 1) { // all except ITS, TPC
1298 fLoader[iDet]->LoadRecPoints("read");
1299 AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
1300 tree = fLoader[iDet]->TreeR();
1302 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1305 fTracker[iDet]->LoadClusters(tree);
1306 AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1310 if (fTracker[iDet]->PropagateBack(esd) != 0) {
1311 AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
1314 if (fCheckPointLevel > 1) {
1315 WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1319 if (iDet > 2) { // all except ITS, TPC, TRD
1320 fTracker[iDet]->UnloadClusters();
1321 fLoader[iDet]->UnloadRecPoints();
1323 // updated PID in TPC needed by the ITS tracker -MI
1325 GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1326 AliESDpid::MakePID(esd);
1328 AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1331 // write space-points to the ESD in case alignment data output
1333 if (fWriteAlignmentData)
1334 WriteAlignmentData(esd);
1336 // pass 3: TRD + TPC + ITS refit inwards
1337 for (Int_t iDet = 2; iDet >= 0; iDet--) {
1338 if (!fTracker[iDet]) continue;
1339 AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
1342 if (fTracker[iDet]->RefitInward(esd) != 0) {
1343 AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
1346 if (fCheckPointLevel > 1) {
1347 WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1349 AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1351 fTracker[iDet]->UnloadClusters();
1352 AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
1353 fLoader[iDet]->UnloadRecPoints();
1354 AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
1357 // Propagate track to the vertex - if not done by ITS
1359 Int_t ntracks = esd->GetNumberOfTracks();
1360 for (Int_t itrack=0; itrack<ntracks; itrack++){
1361 const Double_t kRadius = 3; // beam pipe radius
1362 const Double_t kMaxStep = 5; // max step
1363 const Double_t kMaxD = 123456; // max distance to prim vertex
1364 Double_t fieldZ = AliTracker::GetBz(); //
1365 AliESDtrack * track = esd->GetTrack(itrack);
1366 if (!track) continue;
1367 if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1368 AliTracker::PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1369 track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
1375 //_____________________________________________________________________________
1376 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1378 // Remove the data which are not needed for the physics analysis.
1381 AliInfo("Cleaning the ESD...");
1382 Int_t nTracks=esd->GetNumberOfTracks();
1383 AliInfo(Form("Number of ESD tracks before cleaning %d",nTracks));
1385 Float_t cleanPars[]={fDmax,fZmax};
1386 Bool_t rc=esd->Clean(cleanPars);
1388 nTracks=esd->GetNumberOfTracks();
1389 AliInfo(Form("Number of ESD tracks after cleaning %d",nTracks));
1394 //_____________________________________________________________________________
1395 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
1397 // fill the event summary data
1399 AliCodeTimerAuto("")
1400 static Int_t eventNr=0;
1401 TString detStr = detectors;
1402 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1403 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1404 AliReconstructor* reconstructor = GetReconstructor(iDet);
1405 if (!reconstructor) continue;
1407 if (!ReadESD(esd, fgkDetectorName[iDet])) {
1408 AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
1409 TTree* clustersTree = NULL;
1410 if (fLoader[iDet]) {
1411 fLoader[iDet]->LoadRecPoints("read");
1412 clustersTree = fLoader[iDet]->TreeR();
1413 if (!clustersTree) {
1414 AliError(Form("Can't get the %s clusters tree",
1415 fgkDetectorName[iDet]));
1416 if (fStopOnError) return kFALSE;
1419 if (fRawReader && !reconstructor->HasDigitConversion()) {
1420 reconstructor->FillESD(fRawReader, clustersTree, esd);
1422 TTree* digitsTree = NULL;
1423 if (fLoader[iDet]) {
1424 fLoader[iDet]->LoadDigits("read");
1425 digitsTree = fLoader[iDet]->TreeD();
1427 AliError(Form("Can't get the %s digits tree",
1428 fgkDetectorName[iDet]));
1429 if (fStopOnError) return kFALSE;
1432 reconstructor->FillESD(digitsTree, clustersTree, esd);
1433 if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1435 if (fLoader[iDet]) {
1436 fLoader[iDet]->UnloadRecPoints();
1439 if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
1443 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1444 AliError(Form("the following detectors were not found: %s",
1446 if (fStopOnError) return kFALSE;
1448 AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
1453 //_____________________________________________________________________________
1454 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
1456 // Reads the trigger decision which is
1457 // stored in Trigger.root file and fills
1458 // the corresponding esd entries
1460 AliCodeTimerAuto("")
1462 AliInfo("Filling trigger information into the ESD");
1465 AliCTPRawStream input(fRawReader);
1466 if (!input.Next()) {
1467 AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1470 esd->SetTriggerMask(input.GetClassMask());
1471 esd->SetTriggerCluster(input.GetClusterMask());
1474 AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1476 if (!runloader->LoadTrigger()) {
1477 AliCentralTrigger *aCTP = runloader->GetTrigger();
1478 esd->SetTriggerMask(aCTP->GetClassMask());
1479 esd->SetTriggerCluster(aCTP->GetClusterMask());
1482 AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1487 AliError("No run loader is available! The trigger information is not stored in the ESD !");
1499 //_____________________________________________________________________________
1500 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
1503 // Filling information from RawReader Header
1506 AliInfo("Filling information from RawReader Header");
1507 esd->SetBunchCrossNumber(0);
1508 esd->SetOrbitNumber(0);
1509 esd->SetPeriodNumber(0);
1510 esd->SetTimeStamp(0);
1511 esd->SetEventType(0);
1512 const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1515 const UInt_t *id = eventHeader->GetP("Id");
1516 esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1517 esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1518 esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1520 esd->SetTimeStamp((eventHeader->Get("Timestamp")));
1521 esd->SetEventType((eventHeader->Get("Type")));
1528 //_____________________________________________________________________________
1529 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
1531 // check whether detName is contained in detectors
1532 // if yes, it is removed from detectors
1534 // check if all detectors are selected
1535 if ((detectors.CompareTo("ALL") == 0) ||
1536 detectors.BeginsWith("ALL ") ||
1537 detectors.EndsWith(" ALL") ||
1538 detectors.Contains(" ALL ")) {
1543 // search for the given detector
1544 Bool_t result = kFALSE;
1545 if ((detectors.CompareTo(detName) == 0) ||
1546 detectors.BeginsWith(detName+" ") ||
1547 detectors.EndsWith(" "+detName) ||
1548 detectors.Contains(" "+detName+" ")) {
1549 detectors.ReplaceAll(detName, "");
1553 // clean up the detectors string
1554 while (detectors.Contains(" ")) detectors.ReplaceAll(" ", " ");
1555 while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
1556 while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
1561 //_____________________________________________________________________________
1562 Bool_t AliReconstruction::InitRunLoader()
1564 // get or create the run loader
1566 if (gAlice) delete gAlice;
1569 if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
1570 // load all base libraries to get the loader classes
1571 TString libs = gSystem->GetLibraries();
1572 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1573 TString detName = fgkDetectorName[iDet];
1574 if (detName == "HLT") continue;
1575 if (libs.Contains("lib" + detName + "base.so")) continue;
1576 gSystem->Load("lib" + detName + "base.so");
1578 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
1580 AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
1584 fRunLoader->CdGAFile();
1585 if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
1586 if (fRunLoader->LoadgAlice() == 0) {
1587 gAlice = fRunLoader->GetAliRun();
1588 AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
1591 if (!gAlice && !fRawReader) {
1592 AliError(Form("no gAlice object found in file %s",
1593 fGAliceFileName.Data()));
1598 //PH This is a temporary fix to give access to the kinematics
1599 //PH that is needed for the labels of ITS clusters
1600 fRunLoader->LoadKinematics();
1602 } else { // galice.root does not exist
1604 AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
1608 fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
1609 AliConfig::GetDefaultEventFolderName(),
1612 AliError(Form("could not create run loader in file %s",
1613 fGAliceFileName.Data()));
1617 fRunLoader->MakeTree("E");
1619 while (fRawReader->NextEvent()) {
1620 fRunLoader->SetEventNumber(iEvent);
1621 fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1623 fRunLoader->MakeTree("H");
1624 fRunLoader->TreeE()->Fill();
1627 fRawReader->RewindEvents();
1628 if (fNumberOfEventsPerFile > 0)
1629 fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
1631 fRunLoader->SetNumberOfEventsPerFile(iEvent);
1632 fRunLoader->WriteHeader("OVERWRITE");
1633 fRunLoader->CdGAFile();
1634 fRunLoader->Write(0, TObject::kOverwrite);
1635 // AliTracker::SetFieldMap(???);
1641 //_____________________________________________________________________________
1642 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
1644 // get the reconstructor object and the loader for a detector
1646 if (fReconstructor[iDet]) return fReconstructor[iDet];
1648 // load the reconstructor object
1649 TPluginManager* pluginManager = gROOT->GetPluginManager();
1650 TString detName = fgkDetectorName[iDet];
1651 TString recName = "Ali" + detName + "Reconstructor";
1652 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
1654 AliReconstructor* reconstructor = NULL;
1655 // first check if a plugin is defined for the reconstructor
1656 TPluginHandler* pluginHandler =
1657 pluginManager->FindHandler("AliReconstructor", detName);
1658 // if not, add a plugin for it
1659 if (!pluginHandler) {
1660 AliDebug(1, Form("defining plugin for %s", recName.Data()));
1661 TString libs = gSystem->GetLibraries();
1662 if (libs.Contains("lib" + detName + "base.so") ||
1663 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
1664 pluginManager->AddHandler("AliReconstructor", detName,
1665 recName, detName + "rec", recName + "()");
1667 pluginManager->AddHandler("AliReconstructor", detName,
1668 recName, detName, recName + "()");
1670 pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
1672 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
1673 reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
1675 if (reconstructor) {
1676 TObject* obj = fOptions.FindObject(detName.Data());
1677 if (obj) reconstructor->SetOption(obj->GetTitle());
1678 reconstructor->Init();
1679 fReconstructor[iDet] = reconstructor;
1682 // get or create the loader
1683 if (detName != "HLT") {
1684 fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
1685 if (!fLoader[iDet]) {
1686 AliConfig::Instance()
1687 ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
1689 // first check if a plugin is defined for the loader
1691 pluginManager->FindHandler("AliLoader", detName);
1692 // if not, add a plugin for it
1693 if (!pluginHandler) {
1694 TString loaderName = "Ali" + detName + "Loader";
1695 AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
1696 pluginManager->AddHandler("AliLoader", detName,
1697 loaderName, detName + "base",
1698 loaderName + "(const char*, TFolder*)");
1699 pluginHandler = pluginManager->FindHandler("AliLoader", detName);
1701 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
1703 (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
1704 fRunLoader->GetEventFolder());
1706 if (!fLoader[iDet]) { // use default loader
1707 fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
1709 if (!fLoader[iDet]) {
1710 AliWarning(Form("couldn't get loader for %s", detName.Data()));
1711 if (fStopOnError) return NULL;
1713 fRunLoader->AddLoader(fLoader[iDet]);
1714 fRunLoader->CdGAFile();
1715 if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
1716 fRunLoader->Write(0, TObject::kOverwrite);
1721 return reconstructor;
1724 //_____________________________________________________________________________
1725 Bool_t AliReconstruction::CreateVertexer()
1727 // create the vertexer
1730 AliReconstructor* itsReconstructor = GetReconstructor(0);
1731 if (itsReconstructor) {
1732 fVertexer = itsReconstructor->CreateVertexer();
1735 AliWarning("couldn't create a vertexer for ITS");
1736 if (fStopOnError) return kFALSE;
1742 //_____________________________________________________________________________
1743 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
1745 // create the trackers
1747 TString detStr = detectors;
1748 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1749 if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1750 AliReconstructor* reconstructor = GetReconstructor(iDet);
1751 if (!reconstructor) continue;
1752 TString detName = fgkDetectorName[iDet];
1753 if (detName == "HLT") {
1754 fRunHLTTracking = kTRUE;
1757 if (detName == "MUON") {
1758 fRunMuonTracking = kTRUE;
1763 fTracker[iDet] = reconstructor->CreateTracker();
1764 if (!fTracker[iDet] && (iDet < 7)) {
1765 AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1766 if (fStopOnError) return kFALSE;
1768 AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
1774 //_____________________________________________________________________________
1775 void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
1777 // delete trackers and the run loader and close and delete the file
1779 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1780 delete fReconstructor[iDet];
1781 fReconstructor[iDet] = NULL;
1782 fLoader[iDet] = NULL;
1783 delete fTracker[iDet];
1784 fTracker[iDet] = NULL;
1785 delete fQADataMaker[iDet];
1786 fQADataMaker[iDet] = NULL;
1790 delete fDiamondProfile;
1791 fDiamondProfile = NULL;
1806 gSystem->Unlink("AliESDs.old.root");
1810 //_____________________________________________________________________________
1812 Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
1814 // read the ESD event from a file
1816 if (!esd) return kFALSE;
1818 sprintf(fileName, "ESD_%d.%d_%s.root",
1819 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
1820 if (gSystem->AccessPathName(fileName)) return kFALSE;
1822 AliInfo(Form("reading ESD from file %s", fileName));
1823 AliDebug(1, Form("reading ESD from file %s", fileName));
1824 TFile* file = TFile::Open(fileName);
1825 if (!file || !file->IsOpen()) {
1826 AliError(Form("opening %s failed", fileName));
1833 esd = (AliESDEvent*) file->Get("ESD");
1842 //_____________________________________________________________________________
1843 void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
1845 // write the ESD event to a file
1849 sprintf(fileName, "ESD_%d.%d_%s.root",
1850 esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
1852 AliDebug(1, Form("writing ESD to file %s", fileName));
1853 TFile* file = TFile::Open(fileName, "recreate");
1854 if (!file || !file->IsOpen()) {
1855 AliError(Form("opening %s failed", fileName));
1867 //_____________________________________________________________________________
1868 void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
1870 // write all files from the given esd file to an aod file
1872 // create an AliAOD object
1873 AliAODEvent *aod = new AliAODEvent();
1874 aod->CreateStdContent();
1880 TTree *aodTree = new TTree("aodTree", "AliAOD tree");
1881 aodTree->Branch(aod->GetList());
1884 TTree *t = (TTree*) esdFile->Get("esdTree");
1885 AliESDEvent *esd = new AliESDEvent();
1886 esd->ReadFromTree(t);
1888 Int_t nEvents = t->GetEntries();
1890 // set arrays and pointers
1898 // loop over events and fill them
1899 for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
1900 t->GetEntry(iEvent);
1902 // Multiplicity information needed by the header (to be revised!)
1903 Int_t nTracks = esd->GetNumberOfTracks();
1904 Int_t nPosTracks = 0;
1905 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
1906 if (esd->GetTrack(iTrack)->Charge()> 0) nPosTracks++;
1908 // Access the header
1909 AliAODHeader *header = aod->GetHeader();
1912 header->SetRunNumber (esd->GetRunNumber() );
1913 header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
1914 header->SetOrbitNumber (esd->GetOrbitNumber() );
1915 header->SetPeriodNumber (esd->GetPeriodNumber() );
1916 header->SetTriggerMask (esd->GetTriggerMask() );
1917 header->SetTriggerCluster (esd->GetTriggerCluster() );
1918 header->SetEventType (esd->GetEventType() );
1919 header->SetMagneticField (esd->GetMagneticField() );
1920 header->SetZDCN1Energy (esd->GetZDCN1Energy() );
1921 header->SetZDCP1Energy (esd->GetZDCP1Energy() );
1922 header->SetZDCN2Energy (esd->GetZDCN2Energy() );
1923 header->SetZDCP2Energy (esd->GetZDCP2Energy() );
1924 header->SetZDCEMEnergy (esd->GetZDCEMEnergy() );
1925 header->SetRefMultiplicity (nTracks);
1926 header->SetRefMultiplicityPos(nPosTracks);
1927 header->SetRefMultiplicityNeg(nTracks - nPosTracks);
1928 header->SetMuonMagFieldScale(-999.); // FIXME
1929 header->SetCentrality(-999.); // FIXME
1931 Int_t nV0s = esd->GetNumberOfV0s();
1932 Int_t nCascades = esd->GetNumberOfCascades();
1933 Int_t nKinks = esd->GetNumberOfKinks();
1934 Int_t nVertices = nV0s + nCascades + nKinks;
1936 aod->ResetStd(nTracks, nVertices);
1937 AliAODTrack *aodTrack;
1939 // Array to take into account the tracks already added to the AOD
1940 Bool_t * usedTrack = NULL;
1942 usedTrack = new Bool_t[nTracks];
1943 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
1945 // Array to take into account the V0s already added to the AOD
1946 Bool_t * usedV0 = NULL;
1948 usedV0 = new Bool_t[nV0s];
1949 for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
1951 // Array to take into account the kinks already added to the AOD
1952 Bool_t * usedKink = NULL;
1954 usedKink = new Bool_t[nKinks];
1955 for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
1958 // Access to the AOD container of vertices
1959 TClonesArray &vertices = *(aod->GetVertices());
1962 // Access to the AOD container of tracks
1963 TClonesArray &tracks = *(aod->GetTracks());
1966 // Add primary vertex. The primary tracks will be defined
1967 // after the loops on the composite objects (V0, cascades, kinks)
1968 const AliESDVertex *vtx = esd->GetPrimaryVertex();
1970 vtx->GetXYZ(pos); // position
1971 vtx->GetCovMatrix(covVtx); //covariance matrix
1973 AliAODVertex * primary = new(vertices[jVertices++])
1974 AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
1976 // Create vertices starting from the most complex objects
1979 for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
1980 AliESDcascade *cascade = esd->GetCascade(nCascade);
1982 cascade->GetXYZcascade(pos[0], pos[1], pos[2]); // Bo: bug correction
1983 cascade->GetPosCovXi(covVtx);
1985 // Add the cascade vertex
1986 AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
1988 cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
1991 AliAODVertex::kCascade);
1993 primary->AddDaughter(vcascade);
1995 // Add the V0 from the cascade. The ESD class have to be optimized...
1996 // Now we have to search for the corresponding V0 in the list of V0s
1997 // using the indeces of the positive and negative tracks
1999 Int_t posFromV0 = cascade->GetPindex();
2000 Int_t negFromV0 = cascade->GetNindex();
2002 AliESDv0 * v0 = 0x0;
2005 for (Int_t iV0=0; iV0<nV0s; ++iV0) {
2007 v0 = esd->GetV0(iV0);
2008 Int_t posV0 = v0->GetPindex();
2009 Int_t negV0 = v0->GetNindex();
2011 if (posV0==posFromV0 && negV0==negFromV0) {
2017 AliAODVertex * vV0FromCascade = 0x0;
2019 if (indV0>-1 && !usedV0[indV0] ) {
2021 // the V0 exists in the array of V0s and is not used
2023 usedV0[indV0] = kTRUE;
2025 v0->GetXYZ(pos[0], pos[1], pos[2]);
2026 v0->GetPosCov(covVtx);
2028 vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
2030 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2036 // the V0 doesn't exist in the array of V0s or was used
2037 cerr << "Error: event " << iEvent << " cascade " << nCascade
2038 << " The V0 " << indV0
2039 << " doesn't exist in the array of V0s or was used!" << endl;
2041 cascade->GetXYZ(pos[0], pos[1], pos[2]);
2042 cascade->GetPosCov(covVtx);
2044 vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
2046 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2050 vcascade->AddDaughter(vV0FromCascade);
2053 // Add the positive tracks from the V0
2055 if (! usedTrack[posFromV0]) {
2057 usedTrack[posFromV0] = kTRUE;
2059 AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
2060 esdTrack->GetPxPyPz(p);
2061 esdTrack->GetXYZ(pos);
2062 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2063 esdTrack->GetESDpid(pid);
2065 vV0FromCascade->AddDaughter(aodTrack =
2066 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2067 esdTrack->GetLabel(),
2073 (Short_t)esdTrack->Charge(),
2074 esdTrack->GetITSClusterMap(),
2077 kTRUE, // check if this is right
2078 kFALSE, // check if this is right
2079 AliAODTrack::kSecondary)
2081 aodTrack->ConvertAliPIDtoAODPID();
2084 cerr << "Error: event " << iEvent << " cascade " << nCascade
2085 << " track " << posFromV0 << " has already been used!" << endl;
2088 // Add the negative tracks from the V0
2090 if (!usedTrack[negFromV0]) {
2092 usedTrack[negFromV0] = kTRUE;
2094 AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
2095 esdTrack->GetPxPyPz(p);
2096 esdTrack->GetXYZ(pos);
2097 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2098 esdTrack->GetESDpid(pid);
2100 vV0FromCascade->AddDaughter(aodTrack =
2101 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2102 esdTrack->GetLabel(),
2108 (Short_t)esdTrack->Charge(),
2109 esdTrack->GetITSClusterMap(),
2112 kTRUE, // check if this is right
2113 kFALSE, // check if this is right
2114 AliAODTrack::kSecondary)
2116 aodTrack->ConvertAliPIDtoAODPID();
2119 cerr << "Error: event " << iEvent << " cascade " << nCascade
2120 << " track " << negFromV0 << " has already been used!" << endl;
2123 // Add the bachelor track from the cascade
2125 Int_t bachelor = cascade->GetBindex();
2127 if(!usedTrack[bachelor]) {
2129 usedTrack[bachelor] = kTRUE;
2131 AliESDtrack *esdTrack = esd->GetTrack(bachelor);
2132 esdTrack->GetPxPyPz(p);
2133 esdTrack->GetXYZ(pos);
2134 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2135 esdTrack->GetESDpid(pid);
2137 vcascade->AddDaughter(aodTrack =
2138 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2139 esdTrack->GetLabel(),
2145 (Short_t)esdTrack->Charge(),
2146 esdTrack->GetITSClusterMap(),
2149 kTRUE, // check if this is right
2150 kFALSE, // check if this is right
2151 AliAODTrack::kSecondary)
2153 aodTrack->ConvertAliPIDtoAODPID();
2156 cerr << "Error: event " << iEvent << " cascade " << nCascade
2157 << " track " << bachelor << " has already been used!" << endl;
2160 // Add the primary track of the cascade (if any)
2162 } // end of the loop on cascades
2166 for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
2168 if (usedV0[nV0]) continue; // skip if aready added to the AOD
2170 AliESDv0 *v0 = esd->GetV0(nV0);
2172 v0->GetXYZ(pos[0], pos[1], pos[2]);
2173 v0->GetPosCov(covVtx);
2175 AliAODVertex * vV0 =
2176 new(vertices[jVertices++]) AliAODVertex(pos,
2178 v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
2182 primary->AddDaughter(vV0);
2184 Int_t posFromV0 = v0->GetPindex();
2185 Int_t negFromV0 = v0->GetNindex();
2187 // Add the positive tracks from the V0
2189 if (!usedTrack[posFromV0]) {
2191 usedTrack[posFromV0] = kTRUE;
2193 AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
2194 esdTrack->GetPxPyPz(p);
2195 esdTrack->GetXYZ(pos);
2196 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2197 esdTrack->GetESDpid(pid);
2199 vV0->AddDaughter(aodTrack =
2200 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2201 esdTrack->GetLabel(),
2207 (Short_t)esdTrack->Charge(),
2208 esdTrack->GetITSClusterMap(),
2211 kTRUE, // check if this is right
2212 kFALSE, // check if this is right
2213 AliAODTrack::kSecondary)
2215 aodTrack->ConvertAliPIDtoAODPID();
2218 cerr << "Error: event " << iEvent << " V0 " << nV0
2219 << " track " << posFromV0 << " has already been used!" << endl;
2222 // Add the negative tracks from the V0
2224 if (!usedTrack[negFromV0]) {
2226 usedTrack[negFromV0] = kTRUE;
2228 AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
2229 esdTrack->GetPxPyPz(p);
2230 esdTrack->GetXYZ(pos);
2231 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2232 esdTrack->GetESDpid(pid);
2234 vV0->AddDaughter(aodTrack =
2235 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2236 esdTrack->GetLabel(),
2242 (Short_t)esdTrack->Charge(),
2243 esdTrack->GetITSClusterMap(),
2246 kTRUE, // check if this is right
2247 kFALSE, // check if this is right
2248 AliAODTrack::kSecondary)
2250 aodTrack->ConvertAliPIDtoAODPID();
2253 cerr << "Error: event " << iEvent << " V0 " << nV0
2254 << " track " << negFromV0 << " has already been used!" << endl;
2257 } // end of the loop on V0s
2259 // Kinks: it is a big mess the access to the information in the kinks
2260 // The loop is on the tracks in order to find the mother and daugther of each kink
2263 for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
2266 AliESDtrack * esdTrack = esd->GetTrack(iTrack);
2268 Int_t ikink = esdTrack->GetKinkIndex(0);
2271 // Negative kink index: mother, positive: daughter
2273 // Search for the second track of the kink
2275 for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
2277 AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
2279 Int_t jkink = esdTrack1->GetKinkIndex(0);
2281 if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
2283 // The two tracks are from the same kink
2285 if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
2288 Int_t idaughter = -1;
2290 if (ikink<0 && jkink>0) {
2295 else if (ikink>0 && jkink<0) {
2301 cerr << "Error: Wrong combination of kink indexes: "
2302 << ikink << " " << jkink << endl;
2306 // Add the mother track
2308 AliAODTrack * mother = NULL;
2310 if (!usedTrack[imother]) {
2312 usedTrack[imother] = kTRUE;
2314 AliESDtrack *esdTrack = esd->GetTrack(imother);
2315 esdTrack->GetPxPyPz(p);
2316 esdTrack->GetXYZ(pos);
2317 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2318 esdTrack->GetESDpid(pid);
2321 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2322 esdTrack->GetLabel(),
2328 (Short_t)esdTrack->Charge(),
2329 esdTrack->GetITSClusterMap(),
2332 kTRUE, // check if this is right
2333 kTRUE, // check if this is right
2334 AliAODTrack::kPrimary);
2335 primary->AddDaughter(mother);
2336 mother->ConvertAliPIDtoAODPID();
2339 cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
2340 << " track " << imother << " has already been used!" << endl;
2343 // Add the kink vertex
2344 AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
2346 AliAODVertex * vkink =
2347 new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
2351 esdTrack->GetID(), // This is the track ID of the mother's track!
2352 AliAODVertex::kKink);
2353 // Add the daughter track
2355 AliAODTrack * daughter = NULL;
2357 if (!usedTrack[idaughter]) {
2359 usedTrack[idaughter] = kTRUE;
2361 AliESDtrack *esdTrack = esd->GetTrack(idaughter);
2362 esdTrack->GetPxPyPz(p);
2363 esdTrack->GetXYZ(pos);
2364 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2365 esdTrack->GetESDpid(pid);
2368 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2369 esdTrack->GetLabel(),
2375 (Short_t)esdTrack->Charge(),
2376 esdTrack->GetITSClusterMap(),
2379 kTRUE, // check if this is right
2380 kTRUE, // check if this is right
2381 AliAODTrack::kPrimary);
2382 vkink->AddDaughter(daughter);
2383 daughter->ConvertAliPIDtoAODPID();
2386 cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
2387 << " track " << idaughter << " has already been used!" << endl;
2399 // Tracks (primary and orphan)
2401 for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
2404 if (usedTrack[nTrack]) continue;
2406 AliESDtrack *esdTrack = esd->GetTrack(nTrack);
2407 esdTrack->GetPxPyPz(p);
2408 esdTrack->GetXYZ(pos);
2409 esdTrack->GetCovarianceXYZPxPyPz(covTr);
2410 esdTrack->GetESDpid(pid);
2412 Float_t impactXY, impactZ;
2414 esdTrack->GetImpactParameters(impactXY,impactZ);
2417 // track inside the beam pipe
2419 primary->AddDaughter(aodTrack =
2420 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2421 esdTrack->GetLabel(),
2427 (Short_t)esdTrack->Charge(),
2428 esdTrack->GetITSClusterMap(),
2431 kTRUE, // check if this is right
2432 kTRUE, // check if this is right
2433 AliAODTrack::kPrimary)
2435 aodTrack->ConvertAliPIDtoAODPID();
2438 // outside the beam pipe: orphan track
2440 new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
2441 esdTrack->GetLabel(),
2447 (Short_t)esdTrack->Charge(),
2448 esdTrack->GetITSClusterMap(),
2451 kFALSE, // check if this is right
2452 kFALSE, // check if this is right
2453 AliAODTrack::kOrphan);
2454 aodTrack->ConvertAliPIDtoAODPID();
2456 } // end of loop on tracks
2459 Int_t nMuTracks = esd->GetNumberOfMuonTracks();
2460 for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
2462 AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);
2463 p[0] = esdMuTrack->Px();
2464 p[1] = esdMuTrack->Py();
2465 p[2] = esdMuTrack->Pz();
2466 pos[0] = primary->GetX();
2467 pos[1] = primary->GetY();
2468 pos[2] = primary->GetZ();
2470 // has to be changed once the muon pid is provided by the ESD
2471 for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
2473 primary->AddDaughter(aodTrack =
2474 new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
2475 0, // no label provided
2480 NULL, // no covariance matrix provided
2481 esdMuTrack->Charge(),
2482 0, // ITSClusterMap is set below
2485 kFALSE, // muon tracks are not used to fit the primary vtx
2486 kFALSE, // not used for vertex fit
2487 AliAODTrack::kPrimary)
2490 aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
2491 Int_t track2Trigger = esdMuTrack->GetMatchTrigger();
2492 aodTrack->SetMatchTrigger(track2Trigger);
2494 aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
2496 aodTrack->SetChi2MatchTrigger(0.);
2499 // Access to the AOD container of clusters
2500 TClonesArray &clusters = *(aod->GetClusters());
2504 Int_t nClusters = esd->GetNumberOfCaloClusters();
2506 for (Int_t iClust=0; iClust<nClusters; ++iClust) {
2508 AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
2510 Int_t id = cluster->GetID();
2512 Float_t energy = cluster->E();
2513 cluster->GetPosition(posF);
2514 AliAODVertex *prodVertex = primary;
2515 AliAODTrack *primTrack = NULL;
2516 Char_t ttype=AliAODCluster::kUndef;
2518 if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster){
2519 ttype = AliAODCluster::kPHOSNeutral;
2521 else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1){
2522 ttype = AliAODCluster::kEMCALClusterv1;
2524 else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALPseudoCluster){
2525 ttype = AliAODCluster::kEMCALPseudoCluster;
2528 new(clusters[jClusters++]) AliAODCluster(id,
2532 NULL, // no covariance matrix provided
2533 NULL, // no pid for clusters provided
2538 } // end of loop on calo clusters
2541 const AliMultiplicity *mult = esd->GetMultiplicity();
2543 if (mult->GetNumberOfTracklets()>0) {
2544 aod->GetTracklets()->CreateContainer(mult->GetNumberOfTracklets());
2546 for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
2547 aod->GetTracklets()->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
2551 Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
2554 delete [] usedTrack;
2558 // fill the tree for this event
2560 } // end of event loop
2562 aodTree->GetUserInfo()->Add(aod);
2567 // write the tree to the specified file
2568 aodFile = aodTree->GetCurrentFile();
2575 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
2577 // Write space-points which are then used in the alignment procedures
2578 // For the moment only ITS, TRD and TPC
2580 // Load TOF clusters
2582 fLoader[3]->LoadRecPoints("read");
2583 TTree* tree = fLoader[3]->TreeR();
2585 AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2588 fTracker[3]->LoadClusters(tree);
2590 Int_t ntracks = esd->GetNumberOfTracks();
2591 for (Int_t itrack = 0; itrack < ntracks; itrack++)
2593 AliESDtrack *track = esd->GetTrack(itrack);
2596 for (Int_t iDet = 3; iDet >= 0; iDet--)
2597 nsp += track->GetNcls(iDet);
2599 AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2600 track->SetTrackPointArray(sp);
2602 for (Int_t iDet = 3; iDet >= 0; iDet--) {
2603 AliTracker *tracker = fTracker[iDet];
2604 if (!tracker) continue;
2605 Int_t nspdet = track->GetNcls(iDet);
2606 if (nspdet <= 0) continue;
2607 track->GetClusters(iDet,idx);
2611 while (isp < nspdet) {
2613 if(IsSelected(fgkDetectorName[iDet],fUseTrackingErrorsForAlignment)) {
2614 isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
2616 isvalid = tracker->GetTrackPoint(idx[isp2],p);
2619 const Int_t kNTPCmax = 159;
2620 if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
2621 if (!isvalid) continue;
2622 sp->AddPoint(isptrack,&p); isptrack++; isp++;
2628 fTracker[3]->UnloadClusters();
2629 fLoader[3]->UnloadRecPoints();
2633 //_____________________________________________________________________________
2634 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2636 // The method reads the raw-data error log
2637 // accumulated within the rawReader.
2638 // It extracts the raw-data errors related to
2639 // the current event and stores them into
2640 // a TClonesArray inside the esd object.
2642 if (!fRawReader) return;
2644 for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2646 AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2648 if (iEvent != log->GetEventNumber()) continue;
2650 esd->AddRawDataErrorLog(log);
2655 TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
2656 // Dump a file content into a char in TNamed
2658 in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2659 Int_t kBytes = (Int_t)in.tellg();
2660 printf("Size: %d \n",kBytes);
2663 char* memblock = new char [kBytes];
2664 in.seekg (0, ios::beg);
2665 in.read (memblock, kBytes);
2667 TString fData(memblock,kBytes);
2668 fn = new TNamed(fName,fData);
2669 printf("fData Size: %d \n",fData.Sizeof());
2670 printf("fName Size: %d \n",fName.Sizeof());
2671 printf("fn Size: %d \n",fn->Sizeof());
2675 AliInfo(Form("Could not Open %s\n",fPath.Data()));
2681 void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
2682 // This is not really needed in AliReconstruction at the moment
2683 // but can serve as a template
2685 TList *fList = fTree->GetUserInfo();
2686 TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
2687 printf("fn Size: %d \n",fn->Sizeof());
2689 TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
2690 const char* cdata = fn->GetTitle();
2691 printf("fTmp Size %d\n",fTmp.Sizeof());
2693 int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2694 printf("calculated size %d\n",size);
2695 ofstream out(fName.Data(),ios::out | ios::binary);
2696 out.write(cdata,size);
2703 //_____________________________________________________________________________
2704 AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet)
2706 // get the quality assurance data maker object and the loader for a detector
2708 if (fQADataMaker[iDet])
2709 return fQADataMaker[iDet];
2711 // load the QA data maker object
2712 TPluginManager* pluginManager = gROOT->GetPluginManager();
2713 TString detName = fgkDetectorName[iDet];
2714 TString qadmName = "Ali" + detName + "QADataMaker";
2715 if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
2718 AliQADataMaker * qadm = NULL;
2719 // first check if a plugin is defined for the quality assurance data maker
2720 TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
2721 // if not, add a plugin for it
2722 if (!pluginHandler) {
2723 AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2724 TString libs = gSystem->GetLibraries();
2725 if (libs.Contains("lib" + detName + "base.so") ||
2726 (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2727 pluginManager->AddHandler("AliQADataMaker", detName,
2728 qadmName, detName + "qadm", qadmName + "()");
2730 pluginManager->AddHandler("AliQADataMaker", detName,
2731 qadmName, detName, qadmName + "()");
2733 pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
2735 if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2736 qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0);
2739 AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet]));
2740 qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
2741 qadm->StartOfCycle(AliQA::kRECPOINTS);
2742 qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
2743 qadm->StartOfCycle(AliQA::kESDS, "same") ;
2744 fQADataMaker[iDet] = qadm;
2750 //_____________________________________________________________________________
2751 Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
2753 // run the Quality Assurance data producer
2755 AliCodeTimerAuto("")
2756 TString detStr = detectors;
2757 for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2758 if (!IsSelected(fgkDetectorName[iDet], detStr))
2760 AliQADataMaker * qadm = GetQADataMaker(iDet);
2763 AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2764 AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2766 qadm->Exec(AliQA::kESDS, esd) ;
2769 AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2771 if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2772 AliError(Form("the following detectors were not found: %s",
2783 //_____________________________________________________________________________
2784 void AliReconstruction::CheckQA()
2786 // check the QA of SIM for this run and remove the detectors
2787 // with status Fatal
2789 TString newDetList ;
2790 for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2791 TString detName(AliQA::GetDetName(iDet)) ;
2792 if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2793 fRunLocalReconstruction.Contains("ALL") ) {
2794 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX(iDet)) ;
2795 if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kFATAL)) {
2796 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
2797 } else if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kERROR)) {
2798 AliError(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was ERROR", detName.Data())) ;
2799 newDetList += detName ;
2801 } else if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kWARNING) ) {
2802 AliWarning(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was WARNING", detName.Data())) ;
2803 newDetList += detName ;
2805 } else if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kINFO) ) {
2806 AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was INFO", detName.Data())) ;
2807 newDetList += detName ;
2812 fRunLocalReconstruction = newDetList ;
2815 //_____________________________________________________________________________
2816 Int_t AliReconstruction::GetDetIndex(const char* detector)
2818 // return the detector index corresponding to detector
2820 for (index = 0; index < fgkNDetectors ; index++) {
2821 if ( strcmp(detector, fgkDetectorName[index]) == 0 )