#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 "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliRawEventHeaderBase.h"
-#include "AliESD.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 "AliESDpid.h"
#include "AliESDtrack.h"
-#include "AliRunTag.h"
-#include "AliDetectorTag.h"
-#include "AliEventTag.h"
+#include "AliESDTagCreator.h"
+#include "AliAODTagCreator.h"
#include "AliGeomManager.h"
#include "AliTrackPointArray.h"
#include "AliAODVertex.h"
#include "AliAODCluster.h"
+#include "AliQADataMaker.h"
+
+//#include "TMemStatManager.h" // memory snapshots
+#include "AliSysInfo.h" // memory snapshots
ClassImp(AliReconstruction)
fRunVertexFinder(kTRUE),
fRunHLTTracking(kFALSE),
fRunMuonTracking(kFALSE),
+ fRunV0Finder(kTRUE),
+ fRunCascadeFinder(kTRUE),
fStopOnError(kFALSE),
fWriteAlignmentData(kFALSE),
fWriteESDfriend(kFALSE),
fWriteAOD(kFALSE),
fFillTriggerESD(kTRUE),
+ fCleanESD(kTRUE),
+ fDmax(50.),
+ fZmax(50.),
+
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
fInput(""),
fEquipIdMap(""),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
+ fESDPar(""),
fRunLoader(NULL),
fRawReader(NULL),
fAlignObjArray(NULL),
fCDBUri(cdbUri),
+ fRemoteCDBUri(""),
fSpecCDBUri()
{
// create reconstruction object with default parameters
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
+ fQADataMaker[iDet] = NULL;
+ fQACycles[iDet] = 999999;
}
AliPID pid;
}
fRunVertexFinder(rec.fRunVertexFinder),
fRunHLTTracking(rec.fRunHLTTracking),
fRunMuonTracking(rec.fRunMuonTracking),
+ fRunV0Finder(rec.fRunV0Finder),
+ fRunCascadeFinder(rec.fRunCascadeFinder),
fStopOnError(rec.fStopOnError),
fWriteAlignmentData(rec.fWriteAlignmentData),
fWriteESDfriend(rec.fWriteESDfriend),
fWriteAOD(rec.fWriteAOD),
fFillTriggerESD(rec.fFillTriggerESD),
+ fCleanESD(rec.fCleanESD),
+ fDmax(rec.fDmax),
+ fZmax(rec.fZmax),
+
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
+ fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
fInput(rec.fInput),
fEquipIdMap(rec.fEquipIdMap),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
+ fESDPar(rec.fESDPar),
fRunLoader(NULL),
fRawReader(NULL),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
+ fRemoteCDBUri(rec.fRemoteCDBUri),
fSpecCDBUri()
{
// copy constructor
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
+ fQADataMaker[iDet] = NULL;
+ fQACycles[iDet] = rec.fQACycles[iDet];
}
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();
}
//_____________________________________________________________________________
man->SetDefaultStorage(fCDBUri);
}
+ // Remote storage (the Grid storage) is used if it is activated
+ // and if the object is not found in the default storage
+ // OBSOLETE: Removed
+ // if (man->IsRemoteStorageSet())
+ // {
+ // AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ // AliWarning("Remote CDB storage has been already set !");
+ // AliWarning(Form("Ignoring the remote storage declared in AliReconstruction: %s",fRemoteCDBUri.Data()));
+ // AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ // fRemoteCDBUri = "";
+ // }
+ // else {
+ // AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ // AliDebug(2, Form("Remote CDB storage is set to: %s",fRemoteCDBUri.Data()));
+ // AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ // man->SetRemoteStorage(fRemoteCDBUri);
+ // }
+
// Now activate the detector specific CDB storage locations
for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
TObject* obj = fSpecCDBUri[i];
}
+//_____________________________________________________________________________
+void AliReconstruction::SetRemoteStorage(const char* uri) {
+// Store the desired remote CDB storage location
+// Activate it later within the Run() method
+// Remote storage (the Grid storage) is used if it is activated
+// and if the object is not found in the default storage
+
+ fRemoteCDBUri = uri;
+
+}
+
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
}
}
- // 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;
- }
+// // 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);
}
+
+
+
//_____________________________________________________________________________
Bool_t AliReconstruction::SetRunNumber()
{
loadAlObjsListOfDets += fgkDetectorName[iDet];
loadAlObjsListOfDets += " ";
} // end loop over detectors
- (AliGeomManager::Instance())->ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
+ loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
+ 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::Instance())->ApplyAlignObjsToGeom(fAlignObjArray) == kFALSE) {
+ 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;
delete fAlignObjArray; fAlignObjArray=0;
- // Update the TGeoPhysicalNodes
- gGeoManager->RefreshPhysicalNodes();
-
return kTRUE;
}
{
// run the reconstruction
+ AliCodeTimerAuto("")
+
// set the input
if (!input) input = fInput.Data();
TString fileName(input);
if (!fEquipIdMap.IsNull() && fRawReader)
fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
-
+ AliSysInfo::AddStamp("Start");
// get the run loader
if (!InitRunLoader()) return kFALSE;
+ AliSysInfo::AddStamp("LoadLoader");
// Initialize the CDB storage
InitCDBStorage();
+ AliSysInfo::AddStamp("LoadCDB");
// Set run number in CDBManager (if it is not already set by the user)
if (!SetRunNumber()) if (fStopOnError) return kFALSE;
if (!gGeoManager) {
TString geom(gSystem->DirName(fGAliceFileName));
geom += "/geometry.root";
- TGeoManager::Import(geom.Data());
+ AliGeomManager::LoadGeometry(geom.Data());
if (!gGeoManager) if (fStopOnError) return kFALSE;
}
- AliCDBManager* man = AliCDBManager::Instance();
if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
+ AliSysInfo::AddStamp("LoadGeom");
// local reconstruction
if (!fRunLocalReconstruction.IsNull()) {
return kFALSE;
}
}
+ AliSysInfo::AddStamp("Vertexer");
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
return kFALSE;
}
}
-
-
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliSysInfo::AddStamp("LoadTrackers");
// 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;
-
+ */
// create the branch with ESD additions
- AliESDfriend *esdf=0;
+
+
+
+ AliESDfriend *esdf = 0;
if (fWriteESDfriend) {
- TBranch *br=tree->Branch("ESDfriend.", "AliESDfriend", &esdf);
- br->SetFile("AliESDfriends.root");
+ 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(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
// loop over events
+
if (fRawReader) fRawReader->RewindEvents();
-
+ TString detStr(fFillESD) ;
+
+ ProcInfo_t ProcInfo;
+ gSystem->GetProcInfo(&ProcInfo);
+ AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
if (fRawReader) fRawReader->NextEvent();
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);
}
}
- esd = new AliESD; hltesd = new AliESD;
+
esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
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);
// Muon tracking
if (!fRunTracking.IsNull()) {
if (fRunMuonTracking) {
- if (!RunMuonTracking()) {
+ if (!RunMuonTracking(esd)) {
if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
}
if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
}
+
+ if (!fFillESD.IsNull())
+ RunQA(fFillESD.Data(), esd);
+
// fill Event header information from the RawEventHeader
if (fRawReader){FillRawEventHeaderESD(esd);}
}
}
+ file->cd();
+
//Try to improve the reconstructed primary vertex position using the tracks
- AliESDVertex *pvtx=tVertexer.FindPrimaryVertex(esd);
+ 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)
}
}
- {
- // V0 finding
- AliV0vertexer vtxer;
- vtxer.Tracks2V0vertices(esd);
+ if (fRunV0Finder) {
+ // V0 finding
+ AliV0vertexer vtxer;
+ vtxer.Tracks2V0vertices(esd);
- // Cascade finding
- AliCascadeVertexer cvtxer;
- cvtxer.V0sTracks2CascadeVertices(esd);
+ if (fRunCascadeFinder) {
+ // Cascade finding
+ AliCascadeVertexer cvtxer;
+ cvtxer.V0sTracks2CascadeVertices(esd);
+ }
}
// write ESD
+ if (fCleanESD) CleanESD(esd);
if (fWriteESDfriend) {
- esdf=new AliESDfriend();
- esd->GetESDfriend(esdf);
+ esdf->~AliESDfriend();
+ new (esdf) AliESDfriend(); // Reset...
+ esd->GetESDfriend(esdf);
}
tree->Fill();
hlttree->Fill();
if (fCheckPointLevel > 0) WriteESD(esd, "final");
+ esd->Reset();
+ hltesd->Reset();
+ if (fWriteESDfriend) {
+ esdf->~AliESDfriend();
+ new (esdf) AliESDfriend(); // Reset...
+ }
+ // esdf->Reset();
+ // delete esdf; esdf = 0;
+ // ESD QA
- delete esd; delete esdf; delete hltesd;
- esd = NULL; esdf=NULL; hltesd = NULL;
+ gSystem->GetProcInfo(&ProcInfo);
+ AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ }
+
+ detStr = fFillESD ;
+ // write quality assurance ESDs data (one entry for all events)
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr))
+ continue;
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ if (!qadm) continue;
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish(AliQA::kRECPOINTS);
+ qadm->Finish(AliQA::kESDS) ;
+ }
+
+ 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();
+ // we want to have only one tree version number
+ tree->Write(tree->GetName(),TObject::kOverwrite);
hlttree->Write();
if (fWriteAOD) {
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) {
+ AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
+ aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent);
+ }
return kTRUE;
}
Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors)
{
// run the local reconstruction
+ static Int_t eventNr=0;
+ AliCodeTimerAuto("")
- TStopwatch stopwatch;
- stopwatch.Start();
+ // AliCDBManager* man = AliCDBManager::Instance();
+// Bool_t origCache = man->GetCacheFlag();
- AliCDBManager* man = AliCDBManager::Instance();
- Bool_t origCache = man->GetCacheFlag();
+// TString detStr = detectors;
+// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+// AliReconstructor* reconstructor = GetReconstructor(iDet);
+// if (!reconstructor) continue;
+// if (reconstructor->HasLocalReconstruction()) continue;
- TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- 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;
- stopwatchDet.Start();
+// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+
+// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+// AliInfo(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!
- 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);
+// }
+
+// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
- 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()));
+// // unload calibration data
+// man->UnloadFromCache(calibPath);
+// //man->ClearCache();
+// }
- // unload calibration data
- man->ClearCache();
- }
+// man->SetCacheFlag(origCache);
- 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()));
+// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+// AliError(Form("the following detectors were not found: %s",
+// detStr.Data()));
+// if (fStopOnError) return kFALSE;
+// }
+ eventNr++;
return kTRUE;
}
Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
{
// run the local reconstruction
-
- TStopwatch stopwatch;
- stopwatch.Start();
+ static Int_t eventNr=0;
+ AliCodeTimerAuto("")
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
AliLoader* loader = fLoader[iDet];
+ if (!loader) {
+ AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
+ continue;
+ }
// conversion of digits
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->UnloadDigits();
}
+
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ if (qadm) {
+ AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+
+ if (qadm->IsCycleDone() ) {
+ qadm->EndOfCycle(AliQA::kRECPOINTS) ;
+ qadm->EndOfCycle(AliQA::kESDS) ;
+ qadm->StartOfCycle(AliQA::kRECPOINTS) ;
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ }
+ qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
+ AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ }
+
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
- AliInfo(Form("Execution time for %s: R:%.2fs C:%.2fs",
- fgkDetectorName[iDet],
- stopwatchDet.RealTime(),stopwatchDet.CpuTime()));
+ AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
detStr.Data()));
if (fStopOnError) return kFALSE;
}
-
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
+ eventNr++;
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};
}
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!");
TString detName = fgkDetectorName[iDet];
AliDebug(1, Form("%s HLT tracking", detName.Data()));
reconstructor->SetOption(detName.Data());
- AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+ AliTracker *tracker = reconstructor->CreateTracker();
if (!tracker) {
AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
if (fStopOnError) return kFALSE;
delete tracker;
}
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunMuonTracking()
+Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
{
// run the muon spectrometer tracking
- TStopwatch stopwatch;
- stopwatch.Start();
+ AliCodeTimerAuto("")
if (!fRunLoader) {
AliError("Missing runLoader!");
TString detName = fgkDetectorName[iDet];
AliDebug(1, Form("%s tracking", detName.Data()));
- AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+ AliTracker *tracker = reconstructor->CreateTracker();
if (!tracker) {
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
return kFALSE;
fLoader[iDet]->MakeTracksContainer();
// read RecPoints
- fLoader[iDet]->LoadRecPoints("read");
-
- if (!tracker->Clusters2Tracks(0x0)) {
+ 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");
delete tracker;
-
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESD*& esd)
+Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
{
// run the barrel tracking
-
- TStopwatch stopwatch;
- stopwatch.Start();
+ static Int_t eventNr=0;
+ 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);
+ if (fReconstructor[11] && fLoader[11]) {
+ fLoader[11]->LoadRecPoints("READ");
+ TTree *treeR = fLoader[11]->TreeR();
+ GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+ }
// pass 1: TPC + ITS inwards
for (Int_t iDet = 1; iDet >= 0; iDet--) {
}
// 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);
- }
+ }
+ AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr));
}
// pass 2: ALL backwards
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
}
- fTracker[iDet]->LoadClusters(tree);
+ fTracker[iDet]->LoadClusters(tree);
+ AliSysInfo::AddStamp(Form("LoadCluster0%s_%d",fgkDetectorName[iDet],eventNr));
}
// run tracking
}
// 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);
}
+ AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr));
}
// write space-points to the ESD in case alignment data output
// unload clusters
fTracker[iDet]->UnloadClusters();
fLoader[iDet]->UnloadRecPoints();
+ AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr));
}
//
// Propagate track to the vertex - if not done by ITS
AliESDtrack * track = esd->GetTrack(itrack);
if (!track) continue;
if (track->IsOn(AliESDtrack::kITSrefit)) continue;
- track->PropagateTo(kRadius, fieldZ, track->GetMass(),kMaxStep,kTRUE);
+ AliTracker::PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD);
}
-
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
+ eventNr++;
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillESD(AliESD*& esd, const TString& detectors)
+Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
+ //
+ // Remove the data which are not needed for the physics analysis.
+ //
+
+ AliInfo("Cleaning the ESD...");
+ Int_t nTracks=esd->GetNumberOfTracks();
+ AliInfo(Form("Number of ESD tracks before cleaning %d",nTracks));
+
+ Float_t cleanPars[]={fDmax,fZmax};
+ Bool_t rc=esd->Clean(cleanPars);
+
+ nTracks=esd->GetNumberOfTracks();
+ AliInfo(Form("Number of ESD tracks after cleaning %d",nTracks));
+
+ return rc;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
{
// fill the event summary data
- TStopwatch stopwatch;
- stopwatch.Start();
- AliInfo("filling ESD");
-
+ AliCodeTimerAuto("")
+ static Int_t eventNr=0;
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
if (!ReadESD(esd, fgkDetectorName[iDet])) {
AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
TTree* clustersTree = NULL;
- if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+ if (fLoader[iDet]) {
fLoader[iDet]->LoadRecPoints("read");
clustersTree = fLoader[iDet]->TreeR();
if (!clustersTree) {
reconstructor->FillESD(digitsTree, clustersTree, esd);
if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
}
- if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+ if (fLoader[iDet]) {
fLoader[iDet]->UnloadRecPoints();
}
- if (fRawReader) {
- reconstructor->FillESD(fRunLoader, fRawReader, esd);
- } else {
- reconstructor->FillESD(fRunLoader, esd);
- }
if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
}
}
detStr.Data()));
if (fStopOnError) return kFALSE;
}
-
- AliInfo(Form("Execution time: R:%.2fs C:%.2fs",
- stopwatch.RealTime(),stopwatch.CpuTime()));
-
+ AliSysInfo::AddStamp(Form("FillESD%d",eventNr));
+ eventNr++;
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillTriggerESD(AliESD*& esd)
+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) {
//_____________________________________________________________________________
-Bool_t AliReconstruction::FillRawEventHeaderESD(AliESD*& esd)
+Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
{
//
// Filling information from RawReader Header
return kFALSE;
}
+ //PH This is a temporary fix to give access to the kinematics
+ //PH that is needed for the labels of ITS clusters
+ fRunLoader->LoadKinematics();
+
} else { // galice.root does not exist
if (!fRawReader) {
AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
TString recName = "Ali" + detName + "Reconstructor";
if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
- if (detName == "HLT") {
- if (!gROOT->GetClass("AliLevel3")) {
- gSystem->Load("libAliHLTSrc.so");
- gSystem->Load("libAliHLTMisc.so");
- gSystem->Load("libAliHLTHough.so");
- gSystem->Load("libAliHLTComp.so");
- }
- }
-
AliReconstructor* reconstructor = NULL;
// first check if a plugin is defined for the reconstructor
TPluginHandler* pluginHandler =
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
- reconstructor->Init(fRunLoader);
+ reconstructor->Init();
fReconstructor[iDet] = reconstructor;
}
fVertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
if (itsReconstructor) {
- fVertexer = itsReconstructor->CreateVertexer(fRunLoader);
+ fVertexer = itsReconstructor->CreateVertexer();
}
if (!fVertexer) {
AliWarning("couldn't create a vertexer for ITS");
}
- fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
+ fTracker[iDet] = reconstructor->CreateTracker();
if (!fTracker[iDet] && (iDet < 7)) {
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
if (fStopOnError) return kFALSE;
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
+ delete fQADataMaker[iDet];
+ fQADataMaker[iDet] = NULL;
}
delete fVertexer;
fVertexer = 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
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
-//_____________________________________________________________________________
-void AliReconstruction::CreateTag(TFile* file)
-{
- //GRP
- Float_t lhcLuminosity = 0.0;
- TString lhcState = "test";
- UInt_t detectorMask = 0;
-
- /////////////
- //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;
- Int_t fVertexflag;
- Int_t iRunNumber = 0;
- TString fVertexName("default");
-
- 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 lastEvent = 0;
- TTree *t = (TTree*) file->Get("esdTree");
- TBranch * b = t->GetBranch("ESD");
- AliESD *esd = 0;
- b->SetAddress(&esd);
-
- b->GetEntry(fFirstEvent);
- Int_t iInitRunNumber = esd->GetRunNumber();
-
- Int_t iNumberOfEvents = (Int_t)b->GetEntries();
- if(fLastEvent != -1) iNumberOfEvents = fLastEvent + 1;
- for (Int_t iEventNumber = fFirstEvent; 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;
- fVertexflag = 0;
-
- b->GetEntry(iEventNumber);
- iRunNumber = esd->GetRunNumber();
- if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
- const AliESDVertex * vertexIn = esd->GetVertex();
- if (!vertexIn) AliError("ESD has not defined vertex.");
- if (vertexIn) fVertexName = vertexIn->GetName();
- if(fVertexName != "default") fVertexflag = 1;
- 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);
- if (vertexIn) {
- evTag->SetVertexX(vertexIn->GetXv());
- evTag->SetVertexY(vertexIn->GetYv());
- evTag->SetVertexZ(vertexIn->GetZv());
- evTag->SetVertexZError(vertexIn->GetZRes());
- }
- evTag->SetVertexFlag(fVertexflag);
-
- evTag->SetT0VertexZ(esd->GetT0zVertex());
-
- evTag->SetTriggerMask(esd->GetTriggerMask());
- evTag->SetTriggerCluster(esd->GetTriggerCluster());
-
- evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
- evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
- evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
- evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
- 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->SetLHCTag(lhcLuminosity,lhcState);
- tag->SetDetectorTag(detectorMask);
-
- tag->SetRunId(iInitRunNumber);
- tag->AddEventTag(*evTag);
- }
- if(fLastEvent == -1) lastEvent = (Int_t)b->GetEntries();
- else lastEvent = fLastEvent;
-
- ttag.Fill();
- tag->Clear();
-
- char fileName[256];
- sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root",
- tag->GetRunId(),fFirstEvent,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::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
{
// write all files from the given esd file to an aod file
-
+
// create an AliAOD object
AliAODEvent *aod = new AliAODEvent();
aod->CreateStdContent();
aodFile->cd();
// create the tree
- TTree *aodTree = new TTree("AOD", "AliAOD tree");
+ TTree *aodTree = new TTree("aodTree", "AliAOD tree");
aodTree->Branch(aod->GetList());
// connect to ESD
TTree *t = (TTree*) esdFile->Get("esdTree");
- TBranch *b = t->GetBranch("ESD");
- AliESD *esd = 0;
- b->SetAddress(&esd);
+ AliESDEvent *esd = new AliESDEvent();
+ esd->ReadFromTree(t);
- Int_t nEvents = b->GetEntries();
+ Int_t nEvents = t->GetEntries();
// set arrays and pointers
Float_t posF[3];
// loop over events and fill them
for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
- b->GetEntry(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++;
-
- // create the header
- aod->AddHeader(new AliAODHeader(esd->GetRunNumber(),
- esd->GetBunchCrossNumber(),
- esd->GetOrbitNumber(),
- esd->GetPeriodNumber(),
- nTracks,
- nPosTracks,
- nTracks-nPosTracks,
- esd->GetMagneticField(),
- -999., // fill muon magnetic field
- -999., // centrality; to be filled, still
- esd->GetZDCN1Energy(),
- esd->GetZDCP1Energy(),
- esd->GetZDCN2Energy(),
- esd->GetZDCP2Energy(),
- esd->GetZDCEMEnergy(),
- esd->GetTriggerMask(),
- esd->GetTriggerCluster(),
- esd->GetEventType()));
+ if (esd->GetTrack(iTrack)->Charge()> 0) nPosTracks++;
+
+ // Access the header
+ AliAODHeader *header = aod->GetHeader();
+
+ // fill the header
+ 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();
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) {
vtx->GetCovMatrix(covVtx); //covariance matrix
AliAODVertex * primary = new(vertices[jVertices++])
- AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, AliAODVertex::kPrimary);
+ AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
// Create vertices starting from the most complex objects
for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
AliESDcascade *cascade = esd->GetCascade(nCascade);
- cascade->GetXYZ(pos[0], pos[1], pos[2]);
+ cascade->GetXYZcascade(pos[0], pos[1], pos[2]); // Bo: bug correction
cascade->GetPosCovXi(covVtx);
// Add the cascade vertex
covVtx,
cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
primary,
+ nCascade,
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
+ // Now we have to search for the corresponding V0 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;
covVtx,
v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
vcascade,
+ indV0,
AliAODVertex::kV0);
} else {
covVtx,
v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
vcascade,
+ indV0,
AliAODVertex::kV0);
vcascade->AddDaughter(vV0FromCascade);
}
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
vV0FromCascade,
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
vV0FromCascade,
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
vcascade,
covVtx,
v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
primary,
+ nV0,
AliAODVertex::kV0);
primary->AddDaughter(vV0);
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
vV0,
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
vV0,
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
primary,
NULL,
0.,
mother,
+ esdTrack->GetID(), // This is the track ID of the mother's track!
AliAODVertex::kKink);
// Add the daughter track
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
vkink,
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
primary,
pos,
kFALSE,
covTr,
- (Short_t)esdTrack->GetSign(),
+ (Short_t)esdTrack->Charge(),
esdTrack->GetITSClusterMap(),
pid,
NULL,
// 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.;
- primary->AddDaughter(
+ primary->AddDaughter(aodTrack =
new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
0, // no label provided
p,
pos,
kFALSE,
NULL, // no covariance matrix provided
- (Short_t)-99, // no charge provided
- 0, // no ITSClusterMap
+ esdMuTrack->Charge(),
+ 0, // ITSClusterMap is set below
pid,
primary,
- kTRUE, // check if this is right
- kTRUE, // not used for vertex fit
+ kFALSE, // muon tracks are not used to fit the primary vtx
+ kFALSE, // not used for vertex fit
AliAODTrack::kPrimary)
);
+
+ aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
+ Int_t track2Trigger = esdMuTrack->GetMatchTrigger();
+ aodTrack->SetMatchTrigger(track2Trigger);
+ if (track2Trigger)
+ aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
+ else
+ aodTrack->SetChi2MatchTrigger(0.);
}
// Access to the AOD container of clusters
Int_t id = cluster->GetID();
Int_t label = -1;
- Float_t energy = cluster->GetClusterEnergy();
- cluster->GetGlobalPosition(posF);
+ Float_t energy = cluster->E();
+ cluster->GetPosition(posF);
AliAODVertex *prodVertex = primary;
AliAODTrack *primTrack = NULL;
Char_t ttype=AliAODCluster::kUndef;
-
- if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
- else if (cluster->IsEMCAL()) {
-
- if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
- ttype = AliAODCluster::kEMCALPseudoCluster;
- else
- ttype = AliAODCluster::kEMCALClusterv1;
-
+
+ if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster){
+ ttype = AliAODCluster::kPHOSNeutral;
}
-
+ else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1){
+ ttype = AliAODCluster::kEMCALClusterv1;
+ }
+ else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALPseudoCluster){
+ ttype = AliAODCluster::kEMCALPseudoCluster;
+ }
+
new(clusters[jClusters++]) AliAODCluster(id,
label,
energy,
prodVertex,
primTrack,
ttype);
-
+
} // end of loop on calo clusters
-
+
+ // tracklets
+ const AliMultiplicity *mult = esd->GetMultiplicity();
+ if (mult) {
+ if (mult->GetNumberOfTracklets()>0) {
+ aod->GetTracklets()->CreateContainer(mult->GetNumberOfTracklets());
+
+ for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
+ aod->GetTracklets()->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
+ }
+ }
+ } else {
+ Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
+ }
+
delete [] usedTrack;
delete [] usedV0;
delete [] usedKink;
-
+
// fill the tree for this event
aodTree->Fill();
} // end of event loop
-
+
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
Int_t isp = 0;
Int_t isp2 = 0;
while (isp < nspdet) {
- Bool_t isvalid = tracker->GetTrackPoint(idx[isp2],p); isp2++;
+ Bool_t isvalid;
+ if(IsSelected(fgkDetectorName[iDet],fUseTrackingErrorsForAlignment)) {
+ isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
+ } else {
+ isvalid = tracker->GetTrackPoint(idx[isp2],p);
+ }
+ isp2++;
const Int_t kNTPCmax = 159;
if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
if (!isvalid) continue;
}
//_____________________________________________________________________________
-void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESD* esd)
+void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
{
// The method reads the raw-data error log
// accumulated within the rawReader.
}
}
+
+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();
+
+}
+
+//_____________________________________________________________________________
+AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet)
+{
+// get the quality assurance data maker object and the loader for a detector
+
+ if (fQADataMaker[iDet])
+ return fQADataMaker[iDet];
+
+ // load the QA data maker object
+ TPluginManager* pluginManager = gROOT->GetPluginManager();
+ TString detName = fgkDetectorName[iDet];
+ TString qadmName = "Ali" + detName + "QADataMaker";
+ if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
+ return NULL;
+
+ AliQADataMaker * qadm = NULL;
+ // first check if a plugin is defined for the quality assurance data maker
+ TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
+ // if not, add a plugin for it
+ if (!pluginHandler) {
+ AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
+ TString libs = gSystem->GetLibraries();
+ if (libs.Contains("lib" + detName + "base.so") ||
+ (gSystem->Load("lib" + detName + "base.so") >= 0)) {
+ pluginManager->AddHandler("AliQADataMaker", detName,
+ qadmName, detName + "qadm", qadmName + "()");
+ } else {
+ pluginManager->AddHandler("AliQADataMaker", detName,
+ qadmName, detName, qadmName + "()");
+ }
+ pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
+ }
+ if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
+ qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0);
+ }
+ if (qadm) {
+ AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet]));
+ qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
+ qadm->StartOfCycle(AliQA::kRECPOINTS);
+ qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ fQADataMaker[iDet] = qadm;
+ }
+
+ return qadm;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
+{
+ // run the Quality Assurance data producer
+
+ AliCodeTimerAuto("")
+ TString detStr = detectors;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr))
+ continue;
+ AliQADataMaker * qadm = GetQADataMaker(iDet);
+ if (!qadm)
+ continue;
+ AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+
+ qadm->Exec(AliQA::kESDS, esd) ;
+ qadm->Increment() ;
+
+ AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ }
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
+ if (fStopOnError)
+ return kFALSE;
+ }
+
+ return kTRUE;
+
+
+}
+
+//_____________________________________________________________________________
+Int_t AliReconstruction::GetDetIndex(const char* detector)
+{
+ // return the detector index corresponding to detector
+ Int_t index = -1 ;
+ for (index = 0; index < fgkNDetectors ; index++) {
+ if ( strcmp(detector, fgkDetectorName[index]) == 0 )
+ break ;
+ }
+ return index ;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff