// The index -1 (default) can be used for the last event to indicate no //
// upper limit of the event range. //
// //
+// In case of raw-data reconstruction the user can modify the default //
+// number of events per digits/clusters/tracks file. In case the option //
+// is not used the number is set 1. In case the user provides 0, than //
+// the number of events is equal to the number of events inside the //
+// raw-data file (i.e. one digits/clusters/tracks file): //
+// //
+// rec.SetNumberOfEventsPerFile(...); //
+// //
+// //
// 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 //
// //
// Uniform/nonuniform field tracking switches (default: uniform field) //
// //
-// rec.SetUniformFieldTracking(); ( rec.SetNonuniformFieldTracking(); ) //
+// rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
// //
// The filling of additional ESD information can be steered by //
// //
#include <TSystem.h>
#include <TROOT.h>
#include <TPluginManager.h>
-#include <TStopwatch.h>
#include <TGeoManager.h>
+#include <TLorentzVector.h>
#include "AliReconstruction.h"
+#include "AliCodeTimer.h"
#include "AliReconstructor.h"
#include "AliLog.h"
#include "AliRunLoader.h"
#include "AliRawReaderFile.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
-#include "AliESD.h"
+#include "AliRawEventHeaderBase.h"
+#include "AliESDEvent.h"
+#include "AliESDMuonTrack.h"
+#include "AliESDfriend.h"
#include "AliESDVertex.h"
+#include "AliESDcascade.h"
+#include "AliESDkink.h"
+#include "AliESDtrack.h"
+#include "AliESDCaloCluster.h"
+#include "AliMultiplicity.h"
#include "AliTracker.h"
#include "AliVertexer.h"
+#include "AliVertexerTracks.h"
+#include "AliV0vertexer.h"
+#include "AliCascadeVertexer.h"
#include "AliHeader.h"
#include "AliGenEventHeader.h"
#include "AliPID.h"
#include "AliESDpid.h"
+#include "AliESDtrack.h"
-#include "AliRunTag.h"
-//#include "AliLHCTag.h"
-#include "AliDetectorTag.h"
-#include "AliEventTag.h"
+#include "AliESDTagCreator.h"
+#include "AliGeomManager.h"
#include "AliTrackPointArray.h"
+#include "AliCDBManager.h"
+#include "AliCDBEntry.h"
+#include "AliAlignObj.h"
+
+#include "AliCentralTrigger.h"
+#include "AliCTPRawStream.h"
+
+#include "AliAODEvent.h"
+#include "AliAODHeader.h"
+#include "AliAODTrack.h"
+#include "AliAODVertex.h"
+#include "AliAODCluster.h"
+
ClassImp(AliReconstruction)
//_____________________________________________________________________________
-const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "RICH", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "START", "VZERO", "CRT", "HLT"};
+const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "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),
+ fRunMuonTracking(kFALSE),
+ fStopOnError(kFALSE),
+ fWriteAlignmentData(kFALSE),
+ fCleanESD(kTRUE),
+ fWriteESDfriend(kFALSE),
+ fWriteAOD(kFALSE),
+ fFillTriggerESD(kTRUE),
+
+ fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
fGAliceFileName(gAliceFilename),
fInput(""),
+ fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
- fStopOnError(kFALSE),
+ fNumberOfEventsPerFile(1),
fCheckPointLevel(0),
fOptions(),
+ fLoadAlignFromCDB(kTRUE),
+ fLoadAlignData("ALL"),
+ fESDPar(""),
fRunLoader(NULL),
fRawReader(NULL),
fVertexer(NULL),
+ fDiamondProfile(NULL),
- fWriteAlignmentData(kFALSE)
+ fAlignObjArray(NULL),
+ fCDBUri(cdbUri),
+ fSpecCDBUri()
{
// create reconstruction object with default parameters
fTracker[iDet] = NULL;
}
AliPID pid;
- // Import TGeo geometry
- TGeoManager::Import("geometry.root");
}
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
TNamed(rec),
- fRunLocalReconstruction(rec.fRunLocalReconstruction),
fUniformField(rec.fUniformField),
fRunVertexFinder(rec.fRunVertexFinder),
fRunHLTTracking(rec.fRunHLTTracking),
+ fRunMuonTracking(rec.fRunMuonTracking),
+ fStopOnError(rec.fStopOnError),
+ fWriteAlignmentData(rec.fWriteAlignmentData),
+ fCleanESD(rec.fCleanESD),
+ fWriteESDfriend(rec.fWriteESDfriend),
+ fWriteAOD(rec.fWriteAOD),
+ fFillTriggerESD(rec.fFillTriggerESD),
+
+ fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
fGAliceFileName(rec.fGAliceFileName),
fInput(rec.fInput),
+ fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
- fStopOnError(rec.fStopOnError),
+ fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
fCheckPointLevel(0),
fOptions(),
+ fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
+ fLoadAlignData(rec.fLoadAlignData),
+ fESDPar(rec.fESDPar),
fRunLoader(NULL),
fRawReader(NULL),
fVertexer(NULL),
+ fDiamondProfile(NULL),
- fWriteAlignmentData(rec.fWriteAlignmentData)
+ fAlignObjArray(rec.fAlignObjArray),
+ fCDBUri(rec.fCDBUri),
+ fSpecCDBUri()
{
// copy constructor
- for (Int_t i = 0; i < fOptions.GetEntriesFast(); i++) {
+ for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
}
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
}
+ for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
+ if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
+ }
}
//_____________________________________________________________________________
CleanUp();
fOptions.Delete();
+ fSpecCDBUri.Delete();
+
+ AliCodeTimer::Instance()->Print();
}
+//_____________________________________________________________________________
+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 has been already set !");
+ AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ fCDBUri = "";
+ }
+ else {
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ man->SetDefaultStorage(fCDBUri);
+ }
+
+ // Now activate the detector specific CDB storage locations
+ for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
+ TObject* obj = fSpecCDBUri[i];
+ if (!obj) continue;
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
+ }
+ man->Print();
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetDefaultStorage(const char* uri) {
+// Store the desired default CDB storage location
+// Activate it later within the Run() method
+
+ fCDBUri = uri;
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
+// Store a detector-specific CDB storage location
+// Activate it later within the Run() method
+
+ AliCDBPath aPath(calibType);
+ if(!aPath.IsValid()){
+ // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if(!strcmp(calibType, fgkDetectorName[iDet])) {
+ aPath.SetPath(Form("%s/*", calibType));
+ AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
+ break;
+ }
+ }
+ if(!aPath.IsValid()){
+ AliError(Form("Not a valid path or detector: %s", calibType));
+ return;
+ }
+ }
+
+ // check that calibType refers to a "valid" detector name
+ Bool_t isDetector = kFALSE;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ TString detName = fgkDetectorName[iDet];
+ if(aPath.GetLevel0() == detName) {
+ isDetector = kTRUE;
+ break;
+ }
+ }
+
+ if(!isDetector) {
+ AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
+ return;
+ }
+
+ TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
+ if (obj) fSpecCDBUri.Remove(obj);
+ fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
+
+}
+
+
+
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetRunNumber()
+{
+ // The method is called in Run() in order
+ // to set a correct run number.
+ // In case of raw data reconstruction the
+ // run number is taken from the raw data header
+
+ if(AliCDBManager::Instance()->GetRun() < 0) {
+ if (!fRunLoader) {
+ AliError("No run loader is found !");
+ return kFALSE;
+ }
+ // read run number from gAlice
+ if(fRunLoader->GetAliRun())
+ AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
+ else {
+ if(fRawReader) {
+ if(fRawReader->NextEvent()) {
+ AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
+ fRawReader->RewindEvents();
+ }
+ else {
+ AliError("No raw-data events found !");
+ return kFALSE;
+ }
+ }
+ else {
+ AliError("Neither gAlice nor RawReader objects are found !");
+ return kFALSE;
+ }
+ }
+ AliInfo(Form("CDB Run number: %d",AliCDBManager::Instance()->GetRun()));
+ }
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
+{
+ // Read the alignment objects from CDB.
+ // Each detector is supposed to have the
+ // alignment objects in DET/Align/Data CDB path.
+ // All the detector objects are then collected,
+ // sorted by geometry level (starting from ALIC) and
+ // then applied to the TGeo geometry.
+ // Finally an overlaps check is performed.
+
+ // Load alignment data from CDB and fill fAlignObjArray
+ if(fLoadAlignFromCDB){
+
+ TString detStr = detectors;
+ TString loadAlObjsListOfDets = "";
+
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ loadAlObjsListOfDets += fgkDetectorName[iDet];
+ loadAlObjsListOfDets += " ";
+ } // end loop over detectors
+ AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
+ }else{
+ // Check if the array with alignment objects was
+ // provided by the user. If yes, apply the objects
+ // to the present TGeo geometry
+ if (fAlignObjArray) {
+ if (gGeoManager && gGeoManager->IsClosed()) {
+ if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
+ AliError("The misalignment of one or more volumes failed!"
+ "Compare the list of simulated detectors and the list of detector alignment data!");
+ return kFALSE;
+ }
+ }
+ else {
+ AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
+ return kFALSE;
+ }
+ }
+ }
+
+ delete fAlignObjArray; fAlignObjArray=0;
+
+ return kTRUE;
+}
//_____________________________________________________________________________
void AliReconstruction::SetGAliceFile(const char* fileName)
//_____________________________________________________________________________
-Bool_t AliReconstruction::Run(const char* input,
- Int_t firstEvent, Int_t lastEvent)
+Bool_t AliReconstruction::Run(const char* input)
{
// run the reconstruction
+ AliCodeTimerAuto("")
+
// set the input
if (!input) input = fInput.Data();
TString fileName(input);
fRawReader = new AliRawReaderDate(fileName);
fRawReader->SelectEvents(7);
}
+ if (!fEquipIdMap.IsNull() && fRawReader)
+ fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
+
// get the run loader
if (!InitRunLoader()) return kFALSE;
+ // Initialize the CDB storage
+ InitCDBStorage();
+
+ // Set run number in CDBManager (if it is not already set by the user)
+ if (!SetRunNumber()) if (fStopOnError) return kFALSE;
+
+ // Import ideal TGeo geometry and apply misalignment
+ if (!gGeoManager) {
+ TString geom(gSystem->DirName(fGAliceFileName));
+ geom += "/geometry.root";
+ AliGeomManager::LoadGeometry(geom.Data());
+ if (!gGeoManager) if (fStopOnError) return kFALSE;
+ }
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
+
// local reconstruction
if (!fRunLocalReconstruction.IsNull()) {
if (!RunLocalReconstruction(fRunLocalReconstruction)) {
}
}
-
- TStopwatch stopwatch;
- stopwatch.Start();
-
// get the possibly already existing ESD file and tree
- AliESD* esd = new AliESD; AliESD* hltesd = new AliESD;
+ AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
TFile* fileOld = NULL;
TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
if (!gSystem->AccessPathName("AliESDs.root")){
fileOld = TFile::Open("AliESDs.old.root");
if (fileOld && fileOld->IsOpen()) {
treeOld = (TTree*) fileOld->Get("esdTree");
- if (treeOld) treeOld->SetBranchAddress("ESD", &esd);
+ if (treeOld)esd->ReadFromTree(treeOld);
hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
- if (hlttreeOld) hlttreeOld->SetBranchAddress("ESD", &hltesd);
+ if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld);
}
}
// create the ESD output file and tree
TFile* file = TFile::Open("AliESDs.root", "RECREATE");
+ file->SetCompressionLevel(2);
if (!file->IsOpen()) {
AliError("opening AliESDs.root failed");
if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
+
TTree* tree = new TTree("esdTree", "Tree with ESD objects");
- tree->Branch("ESD", "AliESD", &esd);
+ esd = new AliESDEvent();
+ esd->CreateStdContent();
+ esd->WriteToTree(tree);
+
TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
- hlttree->Branch("ESD", "AliESD", &hltesd);
+ hltesd = new AliESDEvent();
+ hltesd->CreateStdContent();
+ hltesd->WriteToTree(hlttree);
+
+ /* CKB Why?
delete esd; delete hltesd;
esd = NULL; hltesd = NULL;
- gROOT->cd();
+ */
+ // create the branch with ESD additions
+
+
+
+ AliESDfriend *esdf = 0;
+ if (fWriteESDfriend) {
+ esdf = new AliESDfriend();
+ TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf);
+ br->SetFile("AliESDfriends.root");
+ esd->AddObject(esdf);
+ }
+
+
+ // Get the diamond profile from OCDB
+ AliCDBEntry* entry = AliCDBManager::Instance()
+ ->Get("GRP/Calib/MeanVertex");
+
+ if(entry) {
+ fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ AliError("No diamond profile found in OCDB!");
+ }
+
+ AliVertexerTracks tVertexer(AliTracker::GetBz());
+ if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
// 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))) {
+ if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
// copy old ESD to the new one
if (treeOld) {
- treeOld->SetBranchAddress("ESD", &esd);
+ esd->ReadFromTree(treeOld);
treeOld->GetEntry(iEvent);
}
tree->Fill();
if (hlttreeOld) {
- hlttreeOld->SetBranchAddress("ESD", &hltesd);
+ esd->ReadFromTree(hlttreeOld);
hlttreeOld->GetEntry(iEvent);
}
hlttree->Fill();
continue;
}
-
+
AliInfo(Form("processing event %d", iEvent));
fRunLoader->GetEvent(iEvent);
- char fileName[256];
- sprintf(fileName, "ESD_%d.%d_final.root",
+ char aFileName[256];
+ sprintf(aFileName, "ESD_%d.%d_final.root",
fRunLoader->GetHeader()->GetRun(),
fRunLoader->GetHeader()->GetEventNrInRun());
- if (!gSystem->AccessPathName(fileName)) continue;
+ if (!gSystem->AccessPathName(aFileName)) continue;
// local reconstruction
if (!fRunLocalReconstruction.IsNull()) {
}
}
- 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());
- hltesd->SetMagneticField(gAlice->Field()->SolenoidField());
- } else {
- // ???
- }
+ esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+ hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+
+ // Set magnetic field from the tracker
+ esd->SetMagneticField(AliTracker::GetBz());
+ hltesd->SetMagneticField(AliTracker::GetBz());
+
+
+
+ // Fill raw-data error log into the ESD
+ if (fRawReader) FillRawDataErrorLog(iEvent,esd);
// vertex finder
if (fRunVertexFinder) {
}
}
+ // Muon tracking
+ if (!fRunTracking.IsNull()) {
+ if (fRunMuonTracking) {
+ if (!RunMuonTracking(esd)) {
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ }
+ }
+ }
+
// barrel tracking
if (!fRunTracking.IsNull()) {
if (!ReadESD(esd, "tracking")) {
if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
}
+ // fill Event header information from the RawEventHeader
+ if (fRawReader){FillRawEventHeaderESD(esd);}
// combined PID
AliESDpid::MakePID(esd);
if (fCheckPointLevel > 1) WriteESD(esd, "PID");
+ if (fFillTriggerESD) {
+ if (!ReadESD(esd, "trigger")) {
+ if (!FillTriggerESD(esd)) {
+ if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ }
+ if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
+ }
+ }
+
+ //Try to improve the reconstructed primary vertex position using the tracks
+ AliESDVertex *pvtx=0;
+ Bool_t dovertex=kTRUE;
+ TObject* obj = fOptions.FindObject("ITS");
+ if (obj) {
+ TString optITS = obj->GetTitle();
+ if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
+ dovertex=kFALSE;
+ }
+ if(dovertex) pvtx=tVertexer.FindPrimaryVertex(esd);
+ if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
+
+ if (pvtx)
+ if (pvtx->GetStatus()) {
+ // Store the improved primary vertex
+ esd->SetPrimaryVertex(pvtx);
+ // Propagate the tracks to the DCA to the improved primary vertex
+ Double_t somethingbig = 777.;
+ Double_t bz = esd->GetMagneticField();
+ Int_t nt=esd->GetNumberOfTracks();
+ while (nt--) {
+ AliESDtrack *t = esd->GetTrack(nt);
+ t->RelateToVertex(pvtx, bz, somethingbig);
+ }
+ }
+
+ {
+ // V0 finding
+ AliV0vertexer vtxer;
+ vtxer.Tracks2V0vertices(esd);
+
+ // Cascade finding
+ AliCascadeVertexer cvtxer;
+ cvtxer.V0sTracks2CascadeVertices(esd);
+ }
+
// write ESD
+ if (fCleanESD) CleanESD(esd);
+ if (fWriteESDfriend) {
+ new (esdf) AliESDfriend(); // Reset...
+ esd->GetESDfriend(esdf);
+ }
tree->Fill();
+
// write HLT ESD
hlttree->Fill();
if (fCheckPointLevel > 0) WriteESD(esd, "final");
-
- delete esd; delete hltesd;
- esd = NULL; hltesd = NULL;
+ esd->Reset();
+ hltesd->Reset();
+ if (fWriteESDfriend) {
+ new (esdf) AliESDfriend(); // Reset...
+ }
+ // esdf->Reset();
+ // delete esdf; esdf = 0;
+ }
+
+
+
+
+ tree->GetUserInfo()->Add(esd);
+ hlttree->GetUserInfo()->Add(hltesd);
+
+
+
+ if(fESDPar.Contains("ESD.par")){
+ AliInfo("Attaching ESD.par to Tree");
+ TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
+ tree->GetUserInfo()->Add(fn);
}
- AliInfo(Form("Execution time for filling ESD : R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
file->cd();
+ if (fWriteESDfriend)
+ tree->SetBranchStatus("ESDfriend*",0);
tree->Write();
hlttree->Write();
+ if (fWriteAOD) {
+ TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
+ ESDFile2AODFile(file, aodFile);
+ aodFile->Close();
+ }
+
+ gROOT->cd();
+ CleanUp(file, fileOld);
+
// 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);
+ AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent);
+ //if (fWriteAOD) tagCreator->CreateAODTags(fFirstEvent,fLastEvent);
return kTRUE;
}
{
// run the local reconstruction
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
+
+ AliCDBManager* man = AliCDBManager::Instance();
+ Bool_t origCache = man->GetCacheFlag();
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!reconstructor) continue;
if (reconstructor->HasLocalReconstruction()) continue;
+ AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- TStopwatch stopwatchDet;
- stopwatchDet.Start();
+
+ AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+ AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+
+ man->SetCacheFlag(kTRUE);
+ TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
+ man->GetAll(calibPath); // entries are cached!
+
+ AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+
if (fRawReader) {
fRawReader->RewindEvents();
reconstructor->Reconstruct(fRunLoader, fRawReader);
} else {
reconstructor->Reconstruct(fRunLoader);
}
- AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
- fgkDetectorName[iDet],
- stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
+
+ AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+
+ // unload calibration data
+ man->UnloadFromCache(calibPath);
+ //man->ClearCache();
}
+ man->SetCacheFlag(origCache);
+
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;
}
{
// run the local reconstruction
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (fRawReader && reconstructor->HasDigitConversion()) {
AliInfo(Form("converting raw data digits into root objects for %s",
fgkDetectorName[iDet]));
- TStopwatch stopwatchDet;
- stopwatchDet.Start();
+ AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
+ fgkDetectorName[iDet]));
loader->LoadDigits("update");
loader->CleanDigits();
loader->MakeDigitsContainer();
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();
+ AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
loader->LoadRecPoints("update");
loader->CleanRecPoints();
loader->MakeRecPointsContainer();
}
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()) {
if (fStopOnError) return kFALSE;
}
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunVertexFinder(AliESD*& esd)
+Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
{
// run the barrel tracking
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
AliESDVertex* vertex = NULL;
Double_t vtxPos[3] = {0, 0, 0};
}
if (fVertexer) {
+ if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
AliInfo("running the ITS vertex finder");
if (fLoader[0]) fLoader[0]->LoadRecPoints();
vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
if(!vertex){
AliWarning("Vertex not found");
vertex = new AliESDVertex();
+ vertex->SetName("default");
}
else {
- vertex->SetTruePos(vtxPos); // store also the vertex from MC
+ vertex->SetName("reconstructed");
}
} else {
vertex = new AliESDVertex(vtxPos, vtxErr);
}
esd->SetVertex(vertex);
+ // if SPD multiplicity has been determined, it is stored in the ESD
+ AliMultiplicity *mult = fVertexer->GetMultiplicity();
+ if(mult)esd->SetMultiplicity(mult);
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
}
delete vertex;
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunHLTTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
{
// run the HLT barrel tracking
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
if (!fRunLoader) {
AliError("Missing runLoader!");
delete tracker;
}
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
+ return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
+{
+// run the muon spectrometer tracking
+
+ AliCodeTimerAuto("")
+
+ if (!fRunLoader) {
+ AliError("Missing runLoader!");
+ return kFALSE;
+ }
+ Int_t iDet = 7; // for MUON
+
+ AliInfo("is running...");
+
+ // Get a pointer to the MUON reconstructor
+ AliReconstructor *reconstructor = GetReconstructor(iDet);
+ if (!reconstructor) return kFALSE;
+
+
+ TString detName = fgkDetectorName[iDet];
+ AliDebug(1, Form("%s tracking", detName.Data()));
+ AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+ if (!tracker) {
+ AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
+ return kFALSE;
+ }
+
+ // create Tracks
+ fLoader[iDet]->LoadTracks("update");
+ fLoader[iDet]->CleanTracks();
+ fLoader[iDet]->MakeTracksContainer();
+
+ // read RecPoints
+ fLoader[iDet]->LoadRecPoints("read");
+ tracker->LoadClusters(fLoader[iDet]->TreeR());
+
+ Int_t rv = tracker->Clusters2Tracks(esd);
+
+ fLoader[iDet]->UnloadRecPoints();
+
+ if ( rv )
+ {
+ AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
+ return kFALSE;
+ }
+
+ tracker->UnloadClusters();
+
+ fLoader[iDet]->UnloadRecPoints();
+
+ fLoader[iDet]->WriteTracks("OVERWRITE");
+ fLoader[iDet]->UnloadTracks();
+
+ delete tracker;
+
return kTRUE;
}
+
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
{
// run the barrel tracking
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
AliInfo("running tracking");
+ //Fill the ESD with the T0 info (will be used by the TOF)
+ if (fReconstructor[11])
+ GetReconstructor(11)->FillESD(fRunLoader, esd);
+
// pass 1: TPC + ITS inwards
for (Int_t iDet = 1; iDet >= 0; iDet--) {
if (!fTracker[iDet]) continue;
// run tracking
if (fTracker[iDet]->PropagateBack(esd) != 0) {
AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
- return kFALSE;
+ // return kFALSE;
}
if (fCheckPointLevel > 1) {
WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
fTracker[iDet]->UnloadClusters();
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
// run tracking
if (fTracker[iDet]->RefitInward(esd) != 0) {
AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
- return kFALSE;
+ // return kFALSE;
}
if (fCheckPointLevel > 1) {
WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
fTracker[iDet]->UnloadClusters();
fLoader[iDet]->UnloadRecPoints();
}
+ //
+ // 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, fieldZ, track->GetMass(),kMaxStep,kTRUE);
+ track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
+ }
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
+ //
+ // Remove the data which are not needed for the physics analysis.
+ //
+
+ AliInfo("Cleaning the ESD...");
+
+ const AliESDVertex *vertex=esd->GetVertex();
+ Double_t vz=vertex->GetZv();
+
+ Int_t nTracks=esd->GetNumberOfTracks();
+ for (Int_t i=0; i<nTracks; i++) {
+ AliESDtrack *track=esd->GetTrack(i);
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
+ Float_t xy,z; track->GetImpactParameters(xy,z);
+ if (TMath::Abs(xy) < 50.) continue;
+ if (vertex->GetStatus())
+ if (TMath::Abs(vz-z) < 5.) continue;
+
+ esd->RemoveTrack(i);
+ }
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
+Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
{
// fill the event summary data
- TStopwatch stopwatch;
- stopwatch.Start();
- AliInfo("filling ESD");
+ AliCodeTimerAuto("")
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (fStopOnError) return kFALSE;
}
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
+{
+ // Reads the trigger decision which is
+ // stored in Trigger.root file and fills
+ // the corresponding esd entries
+
+ AliCodeTimerAuto("")
+
+ AliInfo("Filling trigger information into the ESD");
+
+ if (fRawReader) {
+ AliCTPRawStream input(fRawReader);
+ if (!input.Next()) {
+ AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
+ return kFALSE;
+ }
+ esd->SetTriggerMask(input.GetClassMask());
+ esd->SetTriggerCluster(input.GetClusterMask());
+ }
+ else {
+ AliRunLoader *runloader = AliRunLoader::GetRunLoader();
+ if (runloader) {
+ if (!runloader->LoadTrigger()) {
+ AliCentralTrigger *aCTP = runloader->GetTrigger();
+ esd->SetTriggerMask(aCTP->GetClassMask());
+ esd->SetTriggerCluster(aCTP->GetClusterMask());
+ }
+ else {
+ AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
+ return kFALSE;
+ }
+ }
+ else {
+ AliError("No run loader is available! The trigger information is not stored in the ESD !");
+ return kFALSE;
+ }
+ }
+
+ return kTRUE;
+}
+
+
+
+
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
+{
+ //
+ // Filling information from RawReader Header
+ //
+
+ AliInfo("Filling information from RawReader Header");
+ esd->SetBunchCrossNumber(0);
+ esd->SetOrbitNumber(0);
+ esd->SetPeriodNumber(0);
+ esd->SetTimeStamp(0);
+ esd->SetEventType(0);
+ const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
+ if (eventHeader){
+
+ const UInt_t *id = eventHeader->GetP("Id");
+ esd->SetBunchCrossNumber((id)[1]&0x00000fff);
+ esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
+ esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
+
+ esd->SetTimeStamp((eventHeader->Get("Timestamp")));
+ esd->SetEventType((eventHeader->Get("Type")));
+ }
return kTRUE;
}
iEvent++;
}
fRawReader->RewindEvents();
+ if (fNumberOfEventsPerFile > 0)
+ fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
+ else
+ fRunLoader->SetNumberOfEventsPerFile(iEvent);
fRunLoader->WriteHeader("OVERWRITE");
fRunLoader->CdGAFile();
fRunLoader->Write(0, TObject::kOverwrite);
if (detName == "HLT") {
if (!gROOT->GetClass("AliLevel3")) {
- gSystem->Load("libAliL3Src.so");
- gSystem->Load("libAliL3Misc.so");
- gSystem->Load("libAliL3Hough.so");
- gSystem->Load("libAliL3Comp.so");
+ gSystem->Load("libAliHLTSrc.so");
+ gSystem->Load("libAliHLTMisc.so");
+ gSystem->Load("libAliHLTHough.so");
+ gSystem->Load("libAliHLTComp.so");
}
}
->CreateDetectorFolders(fRunLoader->GetEventFolder(),
detName, detName);
// first check if a plugin is defined for the loader
- TPluginHandler* pluginHandler =
+ pluginHandler =
pluginManager->FindHandler("AliLoader", detName);
// if not, add a plugin for it
if (!pluginHandler) {
fRunHLTTracking = kTRUE;
continue;
}
+ if (detName == "MUON") {
+ fRunMuonTracking = kTRUE;
+ continue;
+ }
+
fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
if (!fTracker[iDet] && (iDet < 7)) {
}
delete fVertexer;
fVertexer = NULL;
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
delete fRunLoader;
fRunLoader = NULL;
//_____________________________________________________________________________
-Bool_t AliReconstruction::ReadESD(AliESD*& esd, const char* recStep) const
+
+Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
{
// read the ESD event from a file
if (!esd) return kFALSE;
char fileName[256];
sprintf(fileName, "ESD_%d.%d_%s.root",
- esd->GetRunNumber(), esd->GetEventNumber(), recStep);
+ esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
if (gSystem->AccessPathName(fileName)) return kFALSE;
AliInfo(Form("reading ESD from file %s", fileName));
gROOT->cd();
delete esd;
- esd = (AliESD*) file->Get("ESD");
+ esd = (AliESDEvent*) file->Get("ESD");
file->Close();
delete file;
return kTRUE;
+
}
+
+
//_____________________________________________________________________________
-void AliReconstruction::WriteESD(AliESD* esd, const char* recStep) const
+void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
{
// write the ESD event to a file
if (!esd) return;
char fileName[256];
sprintf(fileName, "ESD_%d.%d_%s.root",
- esd->GetRunNumber(), esd->GetEventNumber(), recStep);
+ esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
AliDebug(1, Form("writing ESD to file %s", fileName));
TFile* file = TFile::Open(fileName, "recreate");
+
//_____________________________________________________________________________
-void AliReconstruction::CreateTag(TFile* file)
+void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
{
- // 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();
- AliDetectorTag *detTag = new AliDetectorTag();
- AliEventTag *evTag = new AliEventTag();
- TTree ttag("T","A Tree with event tags");
- TBranch * btag = ttag.Branch("AliTAG", "AliRunTag", &tag);
- btag->SetCompressionLevel(9);
-
- AliInfo(Form("Creating the tags......."));
+ // write all files from the given esd file to an aod file
- if (!file || !file->IsOpen()) {
- AliError(Form("opening failed"));
- delete file;
- return ;
- }
+ // create an AliAOD object
+ AliAODEvent *aod = new AliAODEvent();
+ aod->CreateStdContent();
+
+ // go to the file
+ aodFile->cd();
+
+ // create the tree
+ TTree *aodTree = new TTree("AOD", "AliAOD tree");
+ aodTree->Branch(aod->GetList());
+
+ // connect to ESD
+ TTree *t = (TTree*) esdFile->Get("esdTree");
+ AliESDEvent *esd = new AliESDEvent();
+ esd->ReadFromTree(t);
+
+ Int_t nEvents = t->GetEntries();
+
+ // set arrays and pointers
+ Float_t posF[3];
+ Double_t pos[3];
+ Double_t p[3];
+ Double_t covVtx[6];
+ Double_t covTr[21];
+ Double_t pid[10];
+
+ // loop over events and fill them
+ for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
+ t->GetEntry(iEvent);
+
+ // Multiplicity information needed by the header (to be revised!)
+ Int_t nTracks = esd->GetNumberOfTracks();
+ Int_t nPosTracks = 0;
+ for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
+ if (esd->GetTrack(iTrack)->GetSign()> 0) nPosTracks++;
+
+ // Update the header
+ AliAODHeader* header = aod->GetHeader();
+
+ header->SetRunNumber (esd->GetRunNumber() );
+ header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
+ header->SetOrbitNumber (esd->GetOrbitNumber() );
+ header->SetPeriodNumber (esd->GetPeriodNumber() );
+ header->SetTriggerMask (esd->GetTriggerMask() );
+ header->SetTriggerCluster (esd->GetTriggerCluster() );
+ header->SetEventType (esd->GetEventType() );
+ header->SetMagneticField (esd->GetMagneticField() );
+ header->SetZDCN1Energy (esd->GetZDCN1Energy() );
+ header->SetZDCP1Energy (esd->GetZDCP1Energy() );
+ header->SetZDCN2Energy (esd->GetZDCN2Energy() );
+ header->SetZDCP2Energy (esd->GetZDCP2Energy() );
+ header->SetZDCEMEnergy (esd->GetZDCEMEnergy() );
+ header->SetRefMultiplicity (nTracks);
+ header->SetRefMultiplicityPos(nPosTracks);
+ header->SetRefMultiplicityNeg(nTracks - nPosTracks);
+ header->SetMuonMagFieldScale(-999.); // FIXME
+ header->SetCentrality(-999.); // FIXME
+//
+//
+
+ Int_t nV0s = esd->GetNumberOfV0s();
+ Int_t nCascades = esd->GetNumberOfCascades();
+ Int_t nKinks = esd->GetNumberOfKinks();
+ Int_t nVertices = nV0s + nCascades + nKinks;
+
+ aod->ResetStd(nTracks, nVertices);
+ AliAODTrack *aodTrack;
+
+
+ // Array to take into account the tracks already added to the AOD
+ Bool_t * usedTrack = NULL;
+ if (nTracks>0) {
+ usedTrack = new Bool_t[nTracks];
+ for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
+ }
+ // Array to take into account the V0s already added to the AOD
+ Bool_t * usedV0 = NULL;
+ if (nV0s>0) {
+ usedV0 = new Bool_t[nV0s];
+ for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
+ }
+ // Array to take into account the kinks already added to the AOD
+ Bool_t * usedKink = NULL;
+ if (nKinks>0) {
+ usedKink = new Bool_t[nKinks];
+ for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
+ }
- TTree *t = (TTree*) file->Get("esdTree");
- TBranch * b = t->GetBranch("ESD");
- AliESD *esd = 0;
- b->SetAddress(&esd);
+ // Access to the AOD container of vertices
+ TClonesArray &vertices = *(aod->GetVertices());
+ Int_t jVertices=0;
- tag->SetRunId(esd->GetRunNumber());
+ // Access to the AOD container of tracks
+ TClonesArray &tracks = *(aod->GetTracks());
+ Int_t jTracks=0;
+
+ // Add primary vertex. The primary tracks will be defined
+ // after the loops on the composite objects (V0, cascades, kinks)
+ const AliESDVertex *vtx = esd->GetPrimaryVertex();
+
+ vtx->GetXYZ(pos); // position
+ vtx->GetCovMatrix(covVtx); //covariance matrix
- Int_t firstEvent = 0,lastEvent = 0;
- 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-->remove extremely high Pt tracks
- 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;
+ AliAODVertex * primary = new(vertices[jVertices++])
+ AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary);
+
+ // Create vertices starting from the most complex objects
+
+ // Cascades
+ for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
+ AliESDcascade *cascade = esd->GetCascade(nCascade);
+
+ cascade->GetXYZ(pos[0], pos[1], pos[2]);
+ cascade->GetPosCovXi(covVtx);
+
+ // Add the cascade vertex
+ AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
+ covVtx,
+ cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
+ primary,
+ AliAODVertex::kCascade);
+
+ primary->AddDaughter(vcascade);
+
+ // Add the V0 from the cascade. The ESD class have to be optimized...
+ // Now we have to search for the corresponding Vo in the list of V0s
+ // using the indeces of the positive and negative tracks
+
+ Int_t posFromV0 = cascade->GetPindex();
+ Int_t negFromV0 = cascade->GetNindex();
+
+
+ AliESDv0 * v0 = 0x0;
+ Int_t indV0 = -1;
+
+ for (Int_t iV0=0; iV0<nV0s; ++iV0) {
+
+ v0 = esd->GetV0(iV0);
+ Int_t posV0 = v0->GetPindex();
+ Int_t negV0 = v0->GetNindex();
+
+ if (posV0==posFromV0 && negV0==negFromV0) {
+ indV0 = iV0;
+ break;
+ }
+ }
+
+ AliAODVertex * vV0FromCascade = 0x0;
+
+ if (indV0>-1 && !usedV0[indV0] ) {
+
+ // the V0 exists in the array of V0s and is not used
+
+ usedV0[indV0] = kTRUE;
+
+ v0->GetXYZ(pos[0], pos[1], pos[2]);
+ v0->GetPosCov(covVtx);
+
+ vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
+ covVtx,
+ v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
+ vcascade,
+ AliAODVertex::kV0);
+ } else {
+
+ // the V0 doesn't exist in the array of V0s or was used
+ cerr << "Error: event " << iEvent << " cascade " << nCascade
+ << " The V0 " << indV0
+ << " doesn't exist in the array of V0s or was used!" << endl;
+
+ cascade->GetXYZ(pos[0], pos[1], pos[2]);
+ cascade->GetPosCov(covVtx);
+
+ vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
+ covVtx,
+ v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
+ vcascade,
+ AliAODVertex::kV0);
+ vcascade->AddDaughter(vV0FromCascade);
+ }
+
+ // Add the positive tracks from the V0
+
+ if (! usedTrack[posFromV0]) {
+
+ usedTrack[posFromV0] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ vV0FromCascade->AddDaughter(aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ vV0FromCascade,
+ kTRUE, // check if this is right
+ kFALSE, // check if this is right
+ AliAODTrack::kSecondary)
+ );
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ else {
+ cerr << "Error: event " << iEvent << " cascade " << nCascade
+ << " track " << posFromV0 << " has already been used!" << endl;
+ }
+
+ // Add the negative tracks from the V0
+
+ if (!usedTrack[negFromV0]) {
+
+ usedTrack[negFromV0] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ vV0FromCascade->AddDaughter(aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ vV0FromCascade,
+ kTRUE, // check if this is right
+ kFALSE, // check if this is right
+ AliAODTrack::kSecondary)
+ );
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ else {
+ cerr << "Error: event " << iEvent << " cascade " << nCascade
+ << " track " << negFromV0 << " has already been used!" << endl;
+ }
+
+ // Add the bachelor track from the cascade
+
+ Int_t bachelor = cascade->GetBindex();
+
+ if(!usedTrack[bachelor]) {
+
+ usedTrack[bachelor] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(bachelor);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ vcascade->AddDaughter(aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ vcascade,
+ kTRUE, // check if this is right
+ kFALSE, // check if this is right
+ AliAODTrack::kSecondary)
+ );
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ else {
+ cerr << "Error: event " << iEvent << " cascade " << nCascade
+ << " track " << bachelor << " has already been used!" << endl;
+ }
+
+ // Add the primary track of the cascade (if any)
+
+ } // end of the loop on cascades
+
+ // V0s
+
+ for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
+
+ if (usedV0[nV0]) continue; // skip if aready added to the AOD
+
+ AliESDv0 *v0 = esd->GetV0(nV0);
+
+ v0->GetXYZ(pos[0], pos[1], pos[2]);
+ v0->GetPosCov(covVtx);
+
+ AliAODVertex * vV0 =
+ new(vertices[jVertices++]) AliAODVertex(pos,
+ covVtx,
+ v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
+ primary,
+ AliAODVertex::kV0);
+ primary->AddDaughter(vV0);
+
+ Int_t posFromV0 = v0->GetPindex();
+ Int_t negFromV0 = v0->GetNindex();
+
+ // Add the positive tracks from the V0
+
+ if (!usedTrack[posFromV0]) {
+
+ usedTrack[posFromV0] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ vV0->AddDaughter(aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ vV0,
+ kTRUE, // check if this is right
+ kFALSE, // check if this is right
+ AliAODTrack::kSecondary)
+ );
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ else {
+ cerr << "Error: event " << iEvent << " V0 " << nV0
+ << " track " << posFromV0 << " has already been used!" << endl;
+ }
+
+ // Add the negative tracks from the V0
+
+ if (!usedTrack[negFromV0]) {
+
+ usedTrack[negFromV0] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ vV0->AddDaughter(aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ vV0,
+ kTRUE, // check if this is right
+ kFALSE, // check if this is right
+ AliAODTrack::kSecondary)
+ );
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ else {
+ cerr << "Error: event " << iEvent << " V0 " << nV0
+ << " track " << negFromV0 << " has already been used!" << endl;
+ }
+
+ } // end of the loop on V0s
+
+ // Kinks: it is a big mess the access to the information in the kinks
+ // The loop is on the tracks in order to find the mother and daugther of each kink
+
+
+ for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
+
+
+ AliESDtrack * esdTrack = esd->GetTrack(iTrack);
+
+ Int_t ikink = esdTrack->GetKinkIndex(0);
+
+ if (ikink) {
+ // Negative kink index: mother, positive: daughter
+
+ // Search for the second track of the kink
+
+ for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
+
+ AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
+
+ Int_t jkink = esdTrack1->GetKinkIndex(0);
+
+ if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
+
+ // The two tracks are from the same kink
- if(esdTrack->GetSign() > 0)
- {
- nPos++;
- if(fPt > 1.0)
- nCh1GeV++;
- if(fPt > 3.0)
- nCh3GeV++;
- if(fPt > 10.0)
- nCh10GeV++;
+ if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
+
+ Int_t imother = -1;
+ Int_t idaughter = -1;
+
+ if (ikink<0 && jkink>0) {
+
+ imother = iTrack;
+ idaughter = jTrack;
}
- if(esdTrack->GetSign() < 0)
- {
- nNeg++;
- if(fPt > 1.0)
- nCh1GeV++;
- if(fPt > 3.0)
- nCh3GeV++;
- if(fPt > 10.0)
- nCh10GeV++;
+ else if (ikink>0 && jkink<0) {
+
+ imother = jTrack;
+ idaughter = iTrack;
}
- if(esdTrack->GetSign() == 0)
- nNeutr++;
-
- //PID
- Double_t prob[10];
- esdTrack->GetESDpid(prob);
-
- //K0s
- if ((prob[8]>prob[7])&&(prob[8]>prob[6])&&(prob[8]>prob[5])&&(prob[8]>prob[4])&&(prob[8]>prob[3])&&(prob[8]>prob[2])&&(prob[8]>prob[1])&&(prob[8]>prob[0]))
- nK0s++;
- //neutrons
- if ((prob[7]>prob[8])&&(prob[7]>prob[6])&&(prob[7]>prob[5])&&(prob[7]>prob[4])&&(prob[7]>prob[3])&&(prob[7]>prob[2])&&(prob[7]>prob[1])&&(prob[7]>prob[0]))
- nNeutrons++;
- //pi0s
- if ((prob[6]>prob[8])&&(prob[6]>prob[7])&&(prob[6]>prob[5])&&(prob[6]>prob[4])&&(prob[6]>prob[3])&&(prob[6]>prob[2])&&(prob[6]>prob[1])&&(prob[6]>prob[0]))
- nPi0s++;
- //gamas
- if ((prob[5]>prob[8])&&(prob[5]>prob[7])&&(prob[5]>prob[6])&&(prob[5]>prob[4])&&(prob[5]>prob[3])&&(prob[5]>prob[2])&&(prob[5]>prob[1])&&(prob[5]>prob[0]))
- nGamas++;
- //protons
- if ((prob[4]>prob[8])&&(prob[4]>prob[7])&&(prob[4]>prob[6])&&(prob[4]>prob[5])&&(prob[4]>prob[3])&&(prob[4]>prob[2])&&(prob[4]>prob[1])&&(prob[4]>prob[0]))
- nProtons++;
- //kaons
- if ((prob[3]>prob[8])&&(prob[3]>prob[7])&&(prob[3]>prob[6])&&(prob[3]>prob[5])&&(prob[3]>prob[4])&&(prob[3]>prob[2])&&(prob[3]>prob[1])&&(prob[3]>prob[0]))
- nKaons++;
- //kaons
- if ((prob[2]>prob[8])&&(prob[2]>prob[7])&&(prob[2]>prob[6])&&(prob[2]>prob[5])&&(prob[2]>prob[4])&&(prob[2]>prob[3])&&(prob[2]>prob[1])&&(prob[2]>prob[0]))
- nPions++;
- //muons
- if ((prob[1]>prob[8])&&(prob[1]>prob[7])&&(prob[1]>prob[6])&&(prob[1]>prob[5])&&(prob[1]>prob[4])&&(prob[1]>prob[3])&&(prob[1]>prob[2])&&(prob[1]>prob[0]))
- {
- nMuons++;
- if(fPt > 1.0)
- nMu1GeV++;
- if(fPt > 3.0)
- nMu3GeV++;
- if(fPt > 10.0)
- nMu10GeV++;
+ else {
+ cerr << "Error: Wrong combination of kink indexes: "
+ << ikink << " " << jkink << endl;
+ continue;
}
- //electrons
- if ((prob[0]>prob[8])&&(prob[0]>prob[7])&&(prob[0]>prob[6])&&(prob[0]>prob[5])&&(prob[0]>prob[4])&&(prob[0]>prob[3])&&(prob[0]>prob[2])&&(prob[0]>prob[1]))
- {
- nElectrons++;
- if(fPt > 1.0)
- nEl1GeV++;
- if(fPt > 3.0)
- nEl3GeV++;
- if(fPt > 10.0)
- nEl10GeV++;
+
+ // Add the mother track
+
+ AliAODTrack * mother = NULL;
+
+ if (!usedTrack[imother]) {
+
+ usedTrack[imother] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(imother);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ mother =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ primary,
+ kTRUE, // check if this is right
+ kTRUE, // check if this is right
+ AliAODTrack::kPrimary);
+ primary->AddDaughter(mother);
+ mother->ConvertAliPIDtoAODPID();
}
-
-
-
- ntrack++;
- }//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());
+ else {
+ cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
+ << " track " << imother << " has already been used!" << endl;
+ }
+
+ // Add the kink vertex
+ AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
+
+ AliAODVertex * vkink =
+ new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
+ NULL,
+ 0.,
+ mother,
+ AliAODVertex::kKink);
+ // Add the daughter track
+
+ AliAODTrack * daughter = NULL;
+
+ if (!usedTrack[idaughter]) {
+
+ usedTrack[idaughter] = kTRUE;
+
+ AliESDtrack *esdTrack = esd->GetTrack(idaughter);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ daughter =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ vkink,
+ kTRUE, // check if this is right
+ kTRUE, // check if this is right
+ AliAODTrack::kPrimary);
+ vkink->AddDaughter(daughter);
+ daughter->ConvertAliPIDtoAODPID();
+ }
+ else {
+ cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
+ << " track " << idaughter << " has already been used!" << endl;
+ }
+
+
+ }
+ }
+
+ }
+
+ }
+
+
+ // Tracks (primary and orphan)
- evTag->SetZDCNeutronEnergy(esd->GetZDCNEnergy());
- evTag->SetZDCProtonEnergy(esd->GetZDCPEnergy());
- evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
- evTag->SetNumOfParticipants(esd->GetZDCParticipants());
+ for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
+
+
+ if (usedTrack[nTrack]) continue;
+
+ AliESDtrack *esdTrack = esd->GetTrack(nTrack);
+ esdTrack->GetPxPyPz(p);
+ esdTrack->GetXYZ(pos);
+ esdTrack->GetCovarianceXYZPxPyPz(covTr);
+ esdTrack->GetESDpid(pid);
+
+ Float_t impactXY, impactZ;
+
+ esdTrack->GetImpactParameters(impactXY,impactZ);
+
+ if (impactXY<3) {
+ // track inside the beam pipe
+ primary->AddDaughter(aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ primary,
+ kTRUE, // check if this is right
+ kTRUE, // check if this is right
+ AliAODTrack::kPrimary)
+ );
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ else {
+ // outside the beam pipe: orphan track
+ aodTrack =
+ new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
+ esdTrack->GetLabel(),
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ covTr,
+ (Short_t)esdTrack->GetSign(),
+ esdTrack->GetITSClusterMap(),
+ pid,
+ NULL,
+ kFALSE, // check if this is right
+ kFALSE, // check if this is right
+ AliAODTrack::kOrphan);
+ aodTrack->ConvertAliPIDtoAODPID();
+ }
+ } // end of loop on tracks
+
+ // muon tracks
+ Int_t nMuTracks = esd->GetNumberOfMuonTracks();
+ for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
- evTag->SetNumOfTracks(esd->GetNumberOfTracks());
- evTag->SetNumOfPosTracks(nPos);
- evTag->SetNumOfNegTracks(nNeg);
- evTag->SetNumOfNeutrTracks(nNeutr);
+ AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);
+ p[0] = esdMuTrack->Px();
+ p[1] = esdMuTrack->Py();
+ p[2] = esdMuTrack->Pz();
+ pos[0] = primary->GetX();
+ pos[1] = primary->GetY();
+ pos[2] = primary->GetZ();
- evTag->SetNumOfV0s(esd->GetNumberOfV0s());
- evTag->SetNumOfCascades(esd->GetNumberOfCascades());
- evTag->SetNumOfKinks(esd->GetNumberOfKinks());
- evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
+ // has to be changed once the muon pid is provided by the ESD
+ for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
- 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);
+ primary->AddDaughter(
+ new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
+ 0, // no label provided
+ p,
+ kTRUE,
+ pos,
+ kFALSE,
+ NULL, // no covariance matrix provided
+ (Short_t)-99, // no charge provided
+ 0, // no ITSClusterMap
+ pid,
+ primary,
+ kFALSE, // muon tracks are not used to fit the primary vtx
+ kFALSE, // not used for vertex fit
+ AliAODTrack::kPrimary)
+ );
+ }
+
+ // Access to the AOD container of clusters
+ TClonesArray &clusters = *(aod->GetClusters());
+ Int_t jClusters=0;
+
+ // Calo Clusters
+ Int_t nClusters = esd->GetNumberOfCaloClusters();
+
+ for (Int_t iClust=0; iClust<nClusters; ++iClust) {
+
+ AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
+
+ Int_t id = cluster->GetID();
+ Int_t label = -1;
+ Float_t energy = cluster->E();
+ cluster->GetPosition(posF);
+ AliAODVertex *prodVertex = primary;
+ AliAODTrack *primTrack = NULL;
+ Char_t ttype=AliAODCluster::kUndef;
- 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);
+ if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
+ else if (cluster->IsEMCAL()) {
+
+ if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
+ ttype = AliAODCluster::kEMCALPseudoCluster;
+ else
+ ttype = AliAODCluster::kEMCALClusterv1;
+
+ }
- evTag->SetNumOfPHOSTracks(esd->GetNumberOfPHOSParticles());
- evTag->SetNumOfEMCALTracks(esd->GetNumberOfEMCALParticles());
+ new(clusters[jClusters++]) AliAODCluster(id,
+ label,
+ energy,
+ pos,
+ NULL, // no covariance matrix provided
+ NULL, // no pid for clusters provided
+ prodVertex,
+ primTrack,
+ ttype);
- evTag->SetTotalMomentum(totalP);
- evTag->SetMeanPt(meanPt);
- evTag->SetMaxPt(maxPt);
+ } // end of loop on calo clusters
+
+ delete [] usedTrack;
+ delete [] usedV0;
+ delete [] usedKink;
+
+ // fill the tree for this event
+ aodTree->Fill();
+ } // end of event loop
- 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 detTag;
- delete evTag;
+ aodTree->GetUserInfo()->Add(aod);
+
+ // close ESD file
+ esdFile->Close();
+
+ // write the tree to the specified file
+ aodFile = aodTree->GetCurrentFile();
+ aodFile->cd();
+ aodTree->Write();
+
+ return;
}
-void AliReconstruction::WriteAlignmentData(AliESD* esd)
+void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
{
// Write space-points which are then used in the alignment procedures
// For the moment only ITS, TRD and TPC
// Load TOF clusters
- fLoader[3]->LoadRecPoints("read");
- TTree* tree = fLoader[3]->TreeR();
- if (!tree) {
- AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
- return;
+ 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);
}
- 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];
+ Int_t idx[200];
for (Int_t iDet = 3; iDet >= 0; iDet--)
nsp += track->GetNcls(iDet);
if (nsp) {
AliTracker *tracker = fTracker[iDet];
if (!tracker) continue;
Int_t nspdet = track->GetNcls(iDet);
- cout<<iDet<<" "<<nspdet<<endl;
if (nspdet <= 0) continue;
track->GetClusters(iDet,idx);
AliTrackPoint p;
Int_t isp2 = 0;
while (isp < nspdet) {
Bool_t isvalid = tracker->GetTrackPoint(idx[isp2],p); isp2++;
+ const Int_t kNTPCmax = 159;
+ if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
if (!isvalid) continue;
sp->AddPoint(isptrack,&p); isptrack++; isp++;
}
- // for (Int_t isp = 0; isp < nspdet; isp++) {
- // AliCluster *cl = tracker->GetCluster(idx[isp]);
- // UShort_t volid = tracker->GetVolumeID(idx[isp]);
- // tracker->GetTrackPoint(idx[isp],p);
- // sp->AddPoint(isptrack,&p); isptrack++;
- // }
}
}
}
- fTracker[3]->UnloadClusters();
- fLoader[3]->UnloadRecPoints();
+ if (fTracker[3]){
+ fTracker[3]->UnloadClusters();
+ fLoader[3]->UnloadRecPoints();
+ }
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
+{
+ // The method reads the raw-data error log
+ // accumulated within the rawReader.
+ // It extracts the raw-data errors related to
+ // the current event and stores them into
+ // a TClonesArray inside the esd object.
+
+ if (!fRawReader) return;
+
+ for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
+
+ AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
+ if (!log) continue;
+ if (iEvent != log->GetEventNumber()) continue;
+
+ esd->AddRawDataErrorLog(log);
+ }
+
}
+
+TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
+ // Dump a file content into a char in TNamed
+ ifstream in;
+ in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
+ Int_t kBytes = (Int_t)in.tellg();
+ printf("Size: %d \n",kBytes);
+ TNamed *fn = 0;
+ if(in.good()){
+ char* memblock = new char [kBytes];
+ in.seekg (0, ios::beg);
+ in.read (memblock, kBytes);
+ in.close();
+ TString fData(memblock,kBytes);
+ fn = new TNamed(fName,fData);
+ printf("fData Size: %d \n",fData.Sizeof());
+ printf("fName Size: %d \n",fName.Sizeof());
+ printf("fn Size: %d \n",fn->Sizeof());
+ delete[] memblock;
+ }
+ else{
+ AliInfo(Form("Could not Open %s\n",fPath.Data()));
+ }
+
+ return fn;
+}
+
+void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
+ // This is not really needed in AliReconstruction at the moment
+ // but can serve as a template
+
+ TList *fList = fTree->GetUserInfo();
+ TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
+ printf("fn Size: %d \n",fn->Sizeof());
+
+ TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
+ const char* cdata = fn->GetTitle();
+ printf("fTmp Size %d\n",fTmp.Sizeof());
+
+ int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
+ printf("calculated size %d\n",size);
+ ofstream out(fName.Data(),ios::out | ios::binary);
+ out.write(cdata,size);
+ out.close();
+
+}
+