// - raw data DATE file: DATE file name, any other non-empty string //
// - MC root files : empty string, default //
// //
+// By default all events are reconstructed. The reconstruction can be //
+// limited to a range of events by giving the index of the first and the //
+// last event as an argument to the Run method or by calling //
+// //
+// rec.SetEventRange(..., ...); //
+// //
+// The index -1 (default) can be used for the last event to indicate no //
+// upper limit of the event range. //
+// //
// The name of the galice file can be changed from the default //
// "galice.root" by passing it as argument to the AliReconstruction //
// constructor or by //
// //
// rec.SetRunTracking("..."); //
// //
+// Uniform/nonuniform field tracking switches (default: uniform field) //
+// //
+// rec.SetUniformFieldTracking(); ( rec.SetNonuniformFieldTracking(); ) //
+// //
// The filling of additional ESD information can be steered by //
// //
// rec.SetFillESD("..."); //
#include <TROOT.h>
#include <TPluginManager.h>
#include <TStopwatch.h>
+#include <TGeoManager.h>
+#include <TLorentzVector.h>
#include "AliReconstruction.h"
#include "AliReconstructor.h"
#include "AliRawReaderFile.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
-#include "AliTracker.h"
#include "AliESD.h"
#include "AliESDVertex.h"
+#include "AliTracker.h"
#include "AliVertexer.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
+#include "AliPID.h"
#include "AliESDpid.h"
-#include "AliMagF.h"
+#include "AliESDtrack.h"
+
+#include "AliRunTag.h"
+//#include "AliLHCTag.h"
+#include "AliDetectorTag.h"
+#include "AliEventTag.h"
+
+#include "AliTrackPointArray.h"
+#include "AliCDBManager.h"
ClassImp(AliReconstruction)
const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename,
+AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri,
const char* name, const char* title) :
TNamed(name, title),
fRunLocalReconstruction("ALL"),
+ fUniformField(kTRUE),
fRunVertexFinder(kTRUE),
+ fRunHLTTracking(kFALSE),
fRunTracking("ALL"),
fFillESD("ALL"),
fGAliceFileName(gAliceFilename),
fInput(""),
+ fFirstEvent(0),
+ fLastEvent(-1),
fStopOnError(kFALSE),
fCheckPointLevel(0),
fOptions(),
fRunLoader(NULL),
fRawReader(NULL),
- fVertexer(NULL)
+ fVertexer(NULL),
+
+ fWriteAlignmentData(kFALSE),
+ fCDBUri(cdbUri)
{
// create reconstruction object with default parameters
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
+ AliPID pid;
+ // Import TGeo geometry
+ TString geom(gSystem->DirName(gAliceFilename));
+ geom += "/geometry.root";
+ TGeoManager::Import(geom.Data());
}
//_____________________________________________________________________________
TNamed(rec),
fRunLocalReconstruction(rec.fRunLocalReconstruction),
+ fUniformField(rec.fUniformField),
fRunVertexFinder(rec.fRunVertexFinder),
+ fRunHLTTracking(rec.fRunHLTTracking),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
fGAliceFileName(rec.fGAliceFileName),
fInput(rec.fInput),
+ fFirstEvent(rec.fFirstEvent),
+ fLastEvent(rec.fLastEvent),
fStopOnError(rec.fStopOnError),
fCheckPointLevel(0),
fOptions(),
fRunLoader(NULL),
fRawReader(NULL),
- fVertexer(NULL)
+ fVertexer(NULL),
+
+ fWriteAlignmentData(rec.fWriteAlignmentData),
+ fCDBUri(rec.fCDBUri)
{
// copy constructor
fOptions.Delete();
}
+//_____________________________________________________________________________
+void AliReconstruction::InitCDBStorage()
+{
+// activate a default CDB storage
+// First check if we have any CDB storage set, because it is used
+// to retrieve the calibration and alignment constants
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ if (!man->IsDefaultStorageSet())
+ {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default CDB storage not yet set");
+ AliWarning(Form("Using default storage declared in AliSimulation: %s",fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ SetDefaultStorage(fCDBUri);
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetDefaultStorage(const char* uri) {
+// activate a default CDB storage
+
+ AliCDBManager::Instance()->SetDefaultStorage(uri);
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetSpecificStorage(const char* detName, const char* uri) {
+// activate a detector-specific CDB storage
+
+ AliCDBManager::Instance()->SetSpecificStorage(detName, uri);
+
+}
+
//_____________________________________________________________________________
void AliReconstruction::SetGAliceFile(const char* fileName)
//_____________________________________________________________________________
-Bool_t AliReconstruction::Run(const char* input)
+Bool_t AliReconstruction::Run(const char* input,
+ Int_t firstEvent, Int_t lastEvent)
{
// run the reconstruction
+ InitCDBStorage();
+
// set the input
if (!input) input = fInput.Data();
TString fileName(input);
if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
- if (!fRunVertexFinder && fRunTracking.IsNull() &&
- fFillESD.IsNull()) return kTRUE;
+// if (!fRunVertexFinder && fRunTracking.IsNull() &&
+// fFillESD.IsNull()) return kTRUE;
// get vertexer
if (fRunVertexFinder && !CreateVertexer()) {
}
}
+
+ TStopwatch stopwatch;
+ stopwatch.Start();
+
+ // get the possibly already existing ESD file and tree
+ AliESD* esd = new AliESD; AliESD* hltesd = new AliESD;
+ TFile* fileOld = NULL;
+ TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
+ if (!gSystem->AccessPathName("AliESDs.root")){
+ gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
+ fileOld = TFile::Open("AliESDs.old.root");
+ if (fileOld && fileOld->IsOpen()) {
+ treeOld = (TTree*) fileOld->Get("esdTree");
+ if (treeOld) treeOld->SetBranchAddress("ESD", &esd);
+ hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
+ if (hlttreeOld) hlttreeOld->SetBranchAddress("ESD", &hltesd);
+ }
+ }
+
// create the ESD output file and tree
TFile* file = TFile::Open("AliESDs.root", "RECREATE");
if (!file->IsOpen()) {
AliError("opening AliESDs.root failed");
- if (fStopOnError) {CleanUp(file); return kFALSE;}
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
- AliESD* esd = new AliESD;
TTree* tree = new TTree("esdTree", "Tree with ESD objects");
tree->Branch("ESD", "AliESD", &esd);
- delete esd;
+ TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
+ hlttree->Branch("ESD", "AliESD", &hltesd);
+ delete esd; delete hltesd;
+ esd = NULL; hltesd = NULL;
gROOT->cd();
// loop over events
if (fRawReader) fRawReader->RewindEvents();
for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
+ if (fRawReader) fRawReader->NextEvent();
+ if ((iEvent < firstEvent) || ((lastEvent >= 0) && (iEvent > lastEvent))) {
+ // copy old ESD to the new one
+ if (treeOld) {
+ treeOld->SetBranchAddress("ESD", &esd);
+ treeOld->GetEntry(iEvent);
+ }
+ tree->Fill();
+ if (hlttreeOld) {
+ hlttreeOld->SetBranchAddress("ESD", &hltesd);
+ hlttreeOld->GetEntry(iEvent);
+ }
+ hlttree->Fill();
+ continue;
+ }
+
AliInfo(Form("processing event %d", iEvent));
fRunLoader->GetEvent(iEvent);
- if (fRawReader) fRawReader->NextEvent();
char fileName[256];
sprintf(fileName, "ESD_%d.%d_final.root",
fRunLoader->GetHeader()->GetEventNrInRun());
if (!gSystem->AccessPathName(fileName)) continue;
- esd = new AliESD;
+ // local reconstruction
+ if (!fRunLocalReconstruction.IsNull()) {
+ if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ }
+ }
+
+ esd = new AliESD; hltesd = new AliESD;
esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+ hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
esd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
+ hltesd->SetEventNumber(fRunLoader->GetHeader()->GetEventNrInRun());
if (gAlice) {
- esd->SetMagneticField(gAlice->Field()->SolenoidField());
+ esd->SetMagneticField(AliTracker::GetBz());
+ hltesd->SetMagneticField(AliTracker::GetBz());
} else {
// ???
}
if (fRunVertexFinder) {
if (!ReadESD(esd, "vertex")) {
if (!RunVertexFinder(esd)) {
- if (fStopOnError) {CleanUp(file); return kFALSE;}
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
}
}
+ // HLT tracking
+ if (!fRunTracking.IsNull()) {
+ if (fRunHLTTracking) {
+ hltesd->SetVertex(esd->GetVertex());
+ if (!RunHLTTracking(hltesd)) {
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ }
+ }
+ }
+
// barrel tracking
if (!fRunTracking.IsNull()) {
if (!ReadESD(esd, "tracking")) {
if (!RunTracking(esd)) {
- if (fStopOnError) {CleanUp(file); return kFALSE;}
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
}
// fill ESD
if (!fFillESD.IsNull()) {
if (!FillESD(esd, fFillESD)) {
- if (fStopOnError) {CleanUp(file); return kFALSE;}
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
}
// write ESD
tree->Fill();
+ // write HLT ESD
+ hlttree->Fill();
- if (fCheckPointLevel > 0) WriteESD(esd, "final");
- delete esd;
+ if (fCheckPointLevel > 0) WriteESD(esd, "final");
+
+ delete esd; delete hltesd;
+ esd = NULL; hltesd = NULL;
}
+ AliInfo(Form("Execution time for filling ESD : R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
+
file->cd();
tree->Write();
- CleanUp(file);
+ hlttree->Write();
+
+ // Create tags for the events in the ESD tree (the ESD tree is always present)
+ // In case of empty events the tags will contain dummy values
+ CreateTag(file);
+ CleanUp(file, fileOld);
return kTRUE;
}
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
+ if (reconstructor->HasLocalReconstruction()) continue;
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
TStopwatch stopwatchDet;
} else {
reconstructor->Reconstruct(fRunLoader);
}
- AliInfo(Form("execution time for %s:", fgkDetectorName[iDet]));
- ToAliInfo(stopwatchDet.Print());
+ AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
+ fgkDetectorName[iDet],
+ stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
if (fStopOnError) return kFALSE;
}
- AliInfo("execution time:");
- ToAliInfo(stopwatch.Print());
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
+{
+// run the local reconstruction
+
+ TStopwatch stopwatch;
+ stopwatch.Start();
+
+ TString detStr = detectors;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ AliReconstructor* reconstructor = GetReconstructor(iDet);
+ if (!reconstructor) continue;
+ AliLoader* loader = fLoader[iDet];
+
+ // conversion of digits
+ if (fRawReader && reconstructor->HasDigitConversion()) {
+ AliInfo(Form("converting raw data digits into root objects for %s",
+ fgkDetectorName[iDet]));
+ TStopwatch stopwatchDet;
+ stopwatchDet.Start();
+ loader->LoadDigits("update");
+ loader->CleanDigits();
+ loader->MakeDigitsContainer();
+ TTree* digitsTree = loader->TreeD();
+ reconstructor->ConvertDigits(fRawReader, digitsTree);
+ loader->WriteDigits("OVERWRITE");
+ loader->UnloadDigits();
+ AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
+ fgkDetectorName[iDet],
+ stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
+ }
+
+ // local reconstruction
+ if (!reconstructor->HasLocalReconstruction()) continue;
+ AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ TStopwatch stopwatchDet;
+ stopwatchDet.Start();
+ loader->LoadRecPoints("update");
+ loader->CleanRecPoints();
+ loader->MakeRecPointsContainer();
+ TTree* clustersTree = loader->TreeR();
+ if (fRawReader && !reconstructor->HasDigitConversion()) {
+ reconstructor->Reconstruct(fRawReader, clustersTree);
+ } else {
+ loader->LoadDigits("read");
+ TTree* digitsTree = loader->TreeD();
+ if (!digitsTree) {
+ AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
+ if (fStopOnError) return kFALSE;
+ } else {
+ reconstructor->Reconstruct(digitsTree, clustersTree);
+ }
+ loader->UnloadDigits();
+ }
+ loader->WriteRecPoints("OVERWRITE");
+ loader->UnloadRecPoints();
+ AliDebug(1,Form("Execution time for %s: R:%.2fs C:%.2fs",
+ fgkDetectorName[iDet],
+ stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
+ }
+
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
+ if (fStopOnError) return kFALSE;
+ }
+
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
if (fVertexer) {
AliInfo("running the ITS vertex finder");
+ if (fLoader[0]) fLoader[0]->LoadRecPoints();
vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
+ if (fLoader[0]) fLoader[0]->UnloadRecPoints();
if(!vertex){
AliWarning("Vertex not found");
vertex = new AliESDVertex();
}
delete vertex;
- AliInfo("execution time:");
- ToAliInfo(stopwatch.Print());
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd)
+{
+// run the HLT barrel tracking
+
+ TStopwatch stopwatch;
+ stopwatch.Start();
+
+ if (!fRunLoader) {
+ AliError("Missing runLoader!");
+ return kFALSE;
+ }
+
+ AliInfo("running HLT tracking");
+
+ // Get a pointer to the HLT reconstructor
+ AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
+ if (!reconstructor) return kFALSE;
+
+ // TPC + ITS
+ for (Int_t iDet = 1; iDet >= 0; iDet--) {
+ TString detName = fgkDetectorName[iDet];
+ AliDebug(1, Form("%s HLT tracking", detName.Data()));
+ reconstructor->SetOption(detName.Data());
+ AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+ if (!tracker) {
+ AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
+ if (fStopOnError) return kFALSE;
+ continue;
+ }
+ Double_t vtxPos[3];
+ Double_t vtxErr[3]={0.005,0.005,0.010};
+ const AliESDVertex *vertex = esd->GetVertex();
+ vertex->GetXYZ(vtxPos);
+ tracker->SetVertex(vtxPos,vtxErr);
+ if(iDet != 1) {
+ fLoader[iDet]->LoadRecPoints("read");
+ TTree* tree = fLoader[iDet]->TreeR();
+ if (!tree) {
+ AliError(Form("Can't get the %s cluster tree", detName.Data()));
+ return kFALSE;
+ }
+ tracker->LoadClusters(tree);
+ }
+ if (tracker->Clusters2Tracks(esd) != 0) {
+ AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
+ return kFALSE;
+ }
+ if(iDet != 1) {
+ tracker->UnloadClusters();
+ }
+ delete tracker;
+ }
+
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
// preliminary PID in TPC needed by the ITS tracker
if (iDet == 1) {
GetReconstructor(1)->FillESD(fRunLoader, esd);
+ GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
AliESDpid::MakePID(esd);
}
}
// load clusters
if (iDet > 1) { // all except ITS, TPC
TTree* tree = NULL;
- if (iDet == 3) { // TOF
- fLoader[iDet]->LoadDigits("read");
- tree = fLoader[iDet]->TreeD();
- } else {
- fLoader[iDet]->LoadRecPoints("read");
- tree = fLoader[iDet]->TreeR();
- }
+ fLoader[iDet]->LoadRecPoints("read");
+ tree = fLoader[iDet]->TreeR();
if (!tree) {
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
// unload clusters
if (iDet > 2) { // all except ITS, TPC, TRD
fTracker[iDet]->UnloadClusters();
- if (iDet == 3) { // TOF
- fLoader[iDet]->UnloadDigits();
- } else {
- fLoader[iDet]->UnloadRecPoints();
- }
+ fLoader[iDet]->UnloadRecPoints();
+ }
+ // updated PID in TPC needed by the ITS tracker -MI
+ if (iDet == 1) {
+ GetReconstructor(1)->FillESD(fRunLoader, esd);
+ GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
+ AliESDpid::MakePID(esd);
}
}
+ // write space-points to the ESD in case alignment data output
+ // is switched on
+ if (fWriteAlignmentData)
+ WriteAlignmentData(esd);
+
// pass 3: TRD + TPC + ITS refit inwards
for (Int_t iDet = 2; iDet >= 0; iDet--) {
if (!fTracker[iDet]) continue;
fTracker[iDet]->UnloadClusters();
fLoader[iDet]->UnloadRecPoints();
}
-
- AliInfo("execution time:");
- ToAliInfo(stopwatch.Print());
+ //
+ // Propagate track to the vertex - if not done by ITS
+ //
+ Int_t ntracks = esd->GetNumberOfTracks();
+ for (Int_t itrack=0; itrack<ntracks; itrack++){
+ const Double_t kRadius = 3; // beam pipe radius
+ const Double_t kMaxStep = 5; // max step
+ const Double_t kMaxD = 123456; // max distance to prim vertex
+ Double_t fieldZ = AliTracker::GetBz(); //
+ AliESDtrack * track = esd->GetTrack(itrack);
+ if (!track) continue;
+ if (track->IsOn(AliESDtrack::kITSrefit)) continue;
+ track->PropagateTo(kRadius, track->GetMass(),kMaxStep,kTRUE);
+ track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
+ }
+
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
if (!ReadESD(esd, fgkDetectorName[iDet])) {
AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
+ TTree* clustersTree = NULL;
+ if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+ fLoader[iDet]->LoadRecPoints("read");
+ clustersTree = fLoader[iDet]->TreeR();
+ if (!clustersTree) {
+ AliError(Form("Can't get the %s clusters tree",
+ fgkDetectorName[iDet]));
+ if (fStopOnError) return kFALSE;
+ }
+ }
+ if (fRawReader && !reconstructor->HasDigitConversion()) {
+ reconstructor->FillESD(fRawReader, clustersTree, esd);
+ } else {
+ TTree* digitsTree = NULL;
+ if (fLoader[iDet]) {
+ fLoader[iDet]->LoadDigits("read");
+ digitsTree = fLoader[iDet]->TreeD();
+ if (!digitsTree) {
+ AliError(Form("Can't get the %s digits tree",
+ fgkDetectorName[iDet]));
+ if (fStopOnError) return kFALSE;
+ }
+ }
+ reconstructor->FillESD(digitsTree, clustersTree, esd);
+ if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
+ }
+ if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+ fLoader[iDet]->UnloadRecPoints();
+ }
+
if (fRawReader) {
reconstructor->FillESD(fRunLoader, fRawReader, esd);
} else {
if (fStopOnError) return kFALSE;
}
- AliInfo("execution time:");
- ToAliInfo(stopwatch.Print());
+ AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
+ stopwatch.RealTime(),stopwatch.CpuTime()));
return kTRUE;
}
if (gAlice) delete gAlice;
gAlice = NULL;
- if (!gSystem->AccessPathName(fGAliceFileName.Data())) {
+ if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+ // load all base libraries to get the loader classes
+ TString libs = gSystem->GetLibraries();
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ TString detName = fgkDetectorName[iDet];
+ if (detName == "HLT") continue;
+ if (libs.Contains("lib" + detName + "base.so")) continue;
+ gSystem->Load("lib" + detName + "base.so");
+ }
fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
if (!fRunLoader) {
AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
CleanUp();
return kFALSE;
}
- if (fRunLoader->LoadgAlice() == 0) {
- gAlice = fRunLoader->GetAliRun();
- AliTracker::SetFieldMap(gAlice->Field());
+ fRunLoader->CdGAFile();
+ if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
+ if (fRunLoader->LoadgAlice() == 0) {
+ gAlice = fRunLoader->GetAliRun();
+ AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
+ }
}
if (!gAlice && !fRawReader) {
AliError(Form("no gAlice object found in file %s",
// if not, add a plugin for it
if (!pluginHandler) {
AliDebug(1, Form("defining plugin for %s", recName.Data()));
- if (gSystem->Load("lib" + detName + "base.so") == 0) {
+ TString libs = gSystem->GetLibraries();
+ if (libs.Contains("lib" + detName + "base.so") ||
+ (gSystem->Load("lib" + detName + "base.so") >= 0)) {
pluginManager->AddHandler("AliReconstructor", detName,
recName, detName + "rec", recName + "()");
} else {
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
+ reconstructor->Init(fRunLoader);
fReconstructor[iDet] = reconstructor;
}
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
TString detName = fgkDetectorName[iDet];
- if (detName == "HLT") continue;
+ if (detName == "HLT") {
+ fRunHLTTracking = kTRUE;
+ continue;
+ }
fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
if (!fTracker[iDet] && (iDet < 7)) {
}
//_____________________________________________________________________________
-void AliReconstruction::CleanUp(TFile* file)
+void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
{
// delete trackers and the run loader and close and delete the file
file->Close();
delete file;
}
+
+ if (fileOld) {
+ fileOld->Close();
+ delete fileOld;
+ gSystem->Unlink("AliESDs.old.root");
+ }
}
esd->GetRunNumber(), esd->GetEventNumber(), recStep);
if (gSystem->AccessPathName(fileName)) return kFALSE;
+ AliInfo(Form("reading ESD from file %s", fileName));
AliDebug(1, Form("reading ESD from file %s", fileName));
TFile* file = TFile::Open(fileName);
if (!file || !file->IsOpen()) {
}
delete file;
}
+
+
+
+
+//_____________________________________________________________________________
+void AliReconstruction::CreateTag(TFile* file)
+{
+ /////////////
+ //muon code//
+ ////////////
+ Double_t fMUONMASS = 0.105658369;
+ //Variables
+ Double_t fX,fY,fZ ;
+ Double_t fThetaX, fThetaY, fPyz, fChisquare;
+ Double_t fPxRec,fPyRec, fPzRec, fEnergy;
+ Int_t fCharge;
+ TLorentzVector fEPvector;
+
+ Float_t fZVertexCut = 10.0;
+ Float_t fRhoVertexCut = 2.0;
+
+ Float_t fLowPtCut = 1.0;
+ Float_t fHighPtCut = 3.0;
+ Float_t fVeryHighPtCut = 10.0;
+ ////////////
+
+ Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
+
+ // Creates the tags for all the events in a given ESD file
+ Int_t ntrack;
+ Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
+ Int_t nPos, nNeg, nNeutr;
+ Int_t nK0s, nNeutrons, nPi0s, nGamas;
+ Int_t nCh1GeV, nCh3GeV, nCh10GeV;
+ Int_t nMu1GeV, nMu3GeV, nMu10GeV;
+ Int_t nEl1GeV, nEl3GeV, nEl10GeV;
+ Float_t maxPt = .0, meanPt = .0, totalP = .0;
+
+ AliRunTag *tag = new AliRunTag();
+ AliEventTag *evTag = new AliEventTag();
+ TTree ttag("T","A Tree with event tags");
+ TBranch * btag = ttag.Branch("AliTAG", &tag);
+ btag->SetCompressionLevel(9);
+
+ AliInfo(Form("Creating the tags......."));
+
+ if (!file || !file->IsOpen()) {
+ AliError(Form("opening failed"));
+ delete file;
+ return ;
+ }
+ Int_t firstEvent = 0,lastEvent = 0;
+ TTree *t = (TTree*) file->Get("esdTree");
+ TBranch * b = t->GetBranch("ESD");
+ AliESD *esd = 0;
+ b->SetAddress(&esd);
+
+ tag->SetRunId(esd->GetRunNumber());
+
+ Int_t iNumberOfEvents = b->GetEntries();
+ for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
+ ntrack = 0;
+ nPos = 0;
+ nNeg = 0;
+ nNeutr =0;
+ nK0s = 0;
+ nNeutrons = 0;
+ nPi0s = 0;
+ nGamas = 0;
+ nProtons = 0;
+ nKaons = 0;
+ nPions = 0;
+ nMuons = 0;
+ nElectrons = 0;
+ nCh1GeV = 0;
+ nCh3GeV = 0;
+ nCh10GeV = 0;
+ nMu1GeV = 0;
+ nMu3GeV = 0;
+ nMu10GeV = 0;
+ nEl1GeV = 0;
+ nEl3GeV = 0;
+ nEl10GeV = 0;
+ maxPt = .0;
+ meanPt = .0;
+ totalP = .0;
+
+ b->GetEntry(iEventNumber);
+ const AliESDVertex * vertexIn = esd->GetVertex();
+
+ for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
+ AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
+ UInt_t status = esdTrack->GetStatus();
+
+ //select only tracks with ITS refit
+ if ((status&AliESDtrack::kITSrefit)==0) continue;
+ //select only tracks with TPC refit
+ if ((status&AliESDtrack::kTPCrefit)==0) continue;
+
+ //select only tracks with the "combined PID"
+ if ((status&AliESDtrack::kESDpid)==0) continue;
+ Double_t p[3];
+ esdTrack->GetPxPyPz(p);
+ Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
+ Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
+ totalP += momentum;
+ meanPt += fPt;
+ if(fPt > maxPt) maxPt = fPt;
+
+ if(esdTrack->GetSign() > 0) {
+ nPos++;
+ if(fPt > fLowPtCut) nCh1GeV++;
+ if(fPt > fHighPtCut) nCh3GeV++;
+ if(fPt > fVeryHighPtCut) nCh10GeV++;
+ }
+ if(esdTrack->GetSign() < 0) {
+ nNeg++;
+ if(fPt > fLowPtCut) nCh1GeV++;
+ if(fPt > fHighPtCut) nCh3GeV++;
+ if(fPt > fVeryHighPtCut) nCh10GeV++;
+ }
+ if(esdTrack->GetSign() == 0) nNeutr++;
+
+ //PID
+ Double_t prob[5];
+ esdTrack->GetESDpid(prob);
+
+ Double_t rcc = 0.0;
+ for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
+ if(rcc == 0.0) continue;
+ //Bayes' formula
+ Double_t w[5];
+ for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
+
+ //protons
+ if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
+ //kaons
+ if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
+ //pions
+ if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
+ //electrons
+ if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
+ nElectrons++;
+ if(fPt > fLowPtCut) nEl1GeV++;
+ if(fPt > fHighPtCut) nEl3GeV++;
+ if(fPt > fVeryHighPtCut) nEl10GeV++;
+ }
+ ntrack++;
+ }//track loop
+
+ /////////////
+ //muon code//
+ ////////////
+ Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
+ // loop over all reconstructed tracks (also first track of combination)
+ for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
+ AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
+ if (muonTrack == 0x0) continue;
+
+ // Coordinates at vertex
+ fZ = muonTrack->GetZ();
+ fY = muonTrack->GetBendingCoor();
+ fX = muonTrack->GetNonBendingCoor();
+
+ fThetaX = muonTrack->GetThetaX();
+ fThetaY = muonTrack->GetThetaY();
+
+ fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
+ fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
+ fPxRec = fPzRec * TMath::Tan(fThetaX);
+ fPyRec = fPzRec * TMath::Tan(fThetaY);
+ fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
+
+ //ChiSquare of the track if needed
+ fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
+ fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
+ fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
+
+ // total number of muons inside a vertex cut
+ if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
+ nMuons++;
+ if(fEPvector.Pt() > fLowPtCut) {
+ nMu1GeV++;
+ if(fEPvector.Pt() > fHighPtCut) {
+ nMu3GeV++;
+ if (fEPvector.Pt() > fVeryHighPtCut) {
+ nMu10GeV++;
+ }
+ }
+ }
+ }
+ }//muon track loop
+
+ // Fill the event tags
+ if(ntrack != 0)
+ meanPt = meanPt/ntrack;
+
+ evTag->SetEventId(iEventNumber+1);
+ evTag->SetVertexX(vertexIn->GetXv());
+ evTag->SetVertexY(vertexIn->GetYv());
+ evTag->SetVertexZ(vertexIn->GetZv());
+
+ evTag->SetT0VertexZ(esd->GetT0zVertex());
+
+ evTag->SetTrigger(esd->GetTrigger());
+
+ evTag->SetZDCNeutronEnergy(esd->GetZDCNEnergy());
+ evTag->SetZDCProtonEnergy(esd->GetZDCPEnergy());
+ evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
+ evTag->SetNumOfParticipants(esd->GetZDCParticipants());
+
+
+ evTag->SetNumOfTracks(esd->GetNumberOfTracks());
+ evTag->SetNumOfPosTracks(nPos);
+ evTag->SetNumOfNegTracks(nNeg);
+ evTag->SetNumOfNeutrTracks(nNeutr);
+
+ evTag->SetNumOfV0s(esd->GetNumberOfV0s());
+ evTag->SetNumOfCascades(esd->GetNumberOfCascades());
+ evTag->SetNumOfKinks(esd->GetNumberOfKinks());
+ evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
+
+ evTag->SetNumOfProtons(nProtons);
+ evTag->SetNumOfKaons(nKaons);
+ evTag->SetNumOfPions(nPions);
+ evTag->SetNumOfMuons(nMuons);
+ evTag->SetNumOfElectrons(nElectrons);
+ evTag->SetNumOfPhotons(nGamas);
+ evTag->SetNumOfPi0s(nPi0s);
+ evTag->SetNumOfNeutrons(nNeutrons);
+ evTag->SetNumOfKaon0s(nK0s);
+
+ evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
+ evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
+ evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
+ evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
+ evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
+ evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
+ evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
+ evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
+ evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
+
+ evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
+ evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
+
+ evTag->SetTotalMomentum(totalP);
+ evTag->SetMeanPt(meanPt);
+ evTag->SetMaxPt(maxPt);
+
+ tag->AddEventTag(*evTag);
+ }
+ lastEvent = iNumberOfEvents;
+
+ ttag.Fill();
+ tag->Clear();
+
+ char fileName[256];
+ sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root",
+ tag->GetRunId(),firstEvent,lastEvent );
+ AliInfo(Form("writing tags to file %s", fileName));
+ AliDebug(1, Form("writing tags to file %s", fileName));
+
+ TFile* ftag = TFile::Open(fileName, "recreate");
+ ftag->cd();
+ ttag.Write();
+ ftag->Close();
+ file->cd();
+ delete tag;
+ delete evTag;
+}
+
+void AliReconstruction::WriteAlignmentData(AliESD* esd)
+{
+ // Write space-points which are then used in the alignment procedures
+ // For the moment only ITS, TRD and TPC
+
+ // Load TOF clusters
+ if (fTracker[3]){
+ fLoader[3]->LoadRecPoints("read");
+ TTree* tree = fLoader[3]->TreeR();
+ if (!tree) {
+ AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
+ return;
+ }
+ fTracker[3]->LoadClusters(tree);
+ }
+ Int_t ntracks = esd->GetNumberOfTracks();
+ for (Int_t itrack = 0; itrack < ntracks; itrack++)
+ {
+ AliESDtrack *track = esd->GetTrack(itrack);
+ Int_t nsp = 0;
+ UInt_t idx[200];
+ for (Int_t iDet = 3; iDet >= 0; iDet--)
+ nsp += track->GetNcls(iDet);
+ if (nsp) {
+ AliTrackPointArray *sp = new AliTrackPointArray(nsp);
+ track->SetTrackPointArray(sp);
+ Int_t isptrack = 0;
+ for (Int_t iDet = 3; iDet >= 0; iDet--) {
+ AliTracker *tracker = fTracker[iDet];
+ if (!tracker) continue;
+ Int_t nspdet = track->GetNcls(iDet);
+ if (nspdet <= 0) continue;
+ track->GetClusters(iDet,idx);
+ AliTrackPoint p;
+ Int_t isp = 0;
+ Int_t isp2 = 0;
+ while (isp < nspdet) {
+ Bool_t isvalid = tracker->GetTrackPoint(idx[isp2],p); isp2++;
+ if (!isvalid) continue;
+ sp->AddPoint(isptrack,&p); isptrack++; isp++;
+ }
+ }
+ }
+ }
+ if (fTracker[3]){
+ fTracker[3]->UnloadClusters();
+ fLoader[3]->UnloadRecPoints();
+ }
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff