#include "AliTriggerClass.h"
#include "AliCTPRawStream.h"
-#include "AliAODEvent.h"
-#include "AliAODHeader.h"
-#include "AliAODTrack.h"
-#include "AliAODVertex.h"
-#include "AliAODv0.h"
-#include "AliAODJet.h"
-#include "AliAODCaloCells.h"
-#include "AliAODCaloCluster.h"
-#include "AliAODPmdCluster.h"
-#include "AliAODFmdCluster.h"
-#include "AliAODTracklets.h"
-
#include "AliQADataMakerRec.h"
#include "AliGlobalQADataMaker.h"
#include "AliQA.h"
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
fInput(""),
+ fpEvent(NULL),
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
fRunGlobalQA(kTRUE),
fInLoopQA(kFALSE),
- fRunPlaneEff(kFALSE)
+ fRunPlaneEff(kFALSE),
+
+ fesd(NULL),
+ fhltesd(NULL),
+ fesdf(NULL),
+ ffile(NULL),
+ ftree(NULL),
+ fhlttree(NULL),
+ ffileOld(NULL),
+ ftreeOld(NULL),
+ fhlttreeOld(NULL),
+ ftVertexer(NULL),
+ fIsNewRunLoader(kFALSE)
{
// create reconstruction object with default parameters
fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
fInput(rec.fInput),
+ fpEvent(rec.fpEvent),
fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
fInLoopQA(rec.fInLoopQA),
- fRunPlaneEff(rec.fRunPlaneEff)
+ fRunPlaneEff(rec.fRunPlaneEff),
+
+ fesd(NULL),
+ fhltesd(NULL),
+ fesdf(NULL),
+ ffile(NULL),
+ ftree(NULL),
+ fhlttree(NULL),
+ ffileOld(NULL),
+ ftreeOld(NULL),
+ fhlttreeOld(NULL),
+ ftVertexer(NULL),
+ fIsNewRunLoader(rec.fIsNewRunLoader)
{
// copy constructor
AliCDBManager* man = AliCDBManager::Instance();
if(man->GetRun() > 0) {
- AliWarning("Run number is taken from event header! Ignoring settings in AliCDBManager!");
+ AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
}
if (!fRunLoader) {
fRawReader->RewindEvents();
}
else {
- AliError("No raw-data events found !");
- return kFALSE;
+ if(man->GetRun() > 0) {
+ AliWarning("No raw events is found ! Using settings in AliCDBManager !");
+ man->Print();
+ return kTRUE;
+ }
+ else {
+ AliWarning("Neither raw events nor settings in AliCDBManager are found !");
+ return kFALSE;
+ }
}
}
else {
fGAliceFileName = fileName;
}
+//_____________________________________________________________________________
+void AliReconstruction::SetInput(const char* input,void **pEvent)
+{
+ // In case event pointer is given, we run in an online mode
+ // and the first argument is ignored.
+ // In case event pointer is NULL, we run in a normal
+ // mode over a raw-data file and the first argument points
+ // to the name of that file
+ if (!pEvent) {
+ fInput = input;
+ fpEvent = NULL;
+ }
+ else {
+ fInput = "";
+ fpEvent = pEvent;
+ }
+}
+
//_____________________________________________________________________________
void AliReconstruction::SetOption(const char* detector, const char* option)
{
fOptions.Add(new TNamed(detector, option));
}
-
//_____________________________________________________________________________
-Bool_t AliReconstruction::Run(const char* input, Bool_t IsOnline)
+Bool_t AliReconstruction::Run(const char* input)
{
-// run the reconstruction
+ // Run Run Run
+ AliCodeTimerAuto("");
- AliCodeTimerAuto("")
+ if (!InitRun(input)) return kFALSE;
- // set the input
- if (!IsOnline) {
- if (!input) input = fInput.Data();
- TString fileName(input);
- if (fileName.EndsWith("/")) {
- fRawReader = new AliRawReaderFile(fileName);
- } else if (fileName.EndsWith(".root")) {
- fRawReader = new AliRawReaderRoot(fileName);
- } else if (!fileName.IsNull()) {
- fRawReader = new AliRawReaderDate(fileName);
+ //******* The loop over events
+ Int_t iEvent = 0;
+ while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
+ (fRawReader && fRawReader->NextEvent())) {
+ if (!RunEvent(iEvent)) return kFALSE;
+ iEvent++;
+ }
+
+ if (!FinishRun()) return kFALSE;
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::InitRun(const char* input, void **pEvent)
+{
+ // Initialize all the stuff before
+ // going into the event loop
+ // If the second argument is given, the first one is ignored and
+ // the reconstruction works in an online mode
+ AliCodeTimerAuto("");
+
+ if (pEvent) fpEvent = pEvent;
+ if (input) fInput = input;
+
+ // set the input in case of raw data
+ if (!fInput.IsNull() || fpEvent) {
+ if (!fInput.IsNull()) {
+ AliInfo(Form("Reconstruction will run over a raw-data file: %s",fInput.Data()));
+ TString fileName(fInput);
+ if (fInput.EndsWith("/")) {
+ fRawReader = new AliRawReaderFile(fInput);
+ } else if (fInput.EndsWith(".root")) {
+ fRawReader = new AliRawReaderRoot(fInput);
+ } else {
+ fRawReader = new AliRawReaderDate(fInput);
+ }
+ }
+ else {
+ AliInfo(Form("Reconstruction will run over an event in memory at: %p",*fpEvent));
+ fRawReader = new AliRawReaderDate((void *)(*fpEvent));
}
}
else {
- if (!input) {
- AliError("Null pointer to the event structure!");
- return kFALSE;
- }
- fRawReader = new AliRawReaderDate((void *)input);
+ AliInfo("Reconstruction will run over digits");
}
if (!fEquipIdMap.IsNull() && fRawReader)
if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
AliSysInfo::AddStamp("LoadGeom");
- //QA
+ //QA
AliQADataMakerSteer qas ;
- if (fRunQA && fRawReader) qas.Run(fRunLocalReconstruction, fRawReader) ;
+ if (fRunQA && fRawReader) {
+ qas.Run(fRunLocalReconstruction, fRawReader) ;
+ }
// checking the QA of previous steps
//CheckQA() ;
AliSysInfo::AddStamp("LoadTrackers");
// get the possibly already existing ESD file and tree
- AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
- TFile* fileOld = NULL;
- TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
+ fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
if (!gSystem->AccessPathName("AliESDs.root")){
gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
- fileOld = TFile::Open("AliESDs.old.root");
- if (fileOld && fileOld->IsOpen()) {
- treeOld = (TTree*) fileOld->Get("esdTree");
- if (treeOld)esd->ReadFromTree(treeOld);
- hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
- if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld);
+ ffileOld = TFile::Open("AliESDs.old.root");
+ if (ffileOld && ffileOld->IsOpen()) {
+ ftreeOld = (TTree*) ffileOld->Get("esdTree");
+ if (ftreeOld)fesd->ReadFromTree(ftreeOld);
+ fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
+ if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld);
}
}
// create the ESD output file and tree
- TFile* file = TFile::Open("AliESDs.root", "RECREATE");
- file->SetCompressionLevel(2);
- if (!file->IsOpen()) {
+ ffile = TFile::Open("AliESDs.root", "RECREATE");
+ ffile->SetCompressionLevel(2);
+ if (!ffile->IsOpen()) {
AliError("opening AliESDs.root failed");
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
- TTree* tree = new TTree("esdTree", "Tree with ESD objects");
- esd = new AliESDEvent();
- esd->CreateStdContent();
- esd->WriteToTree(tree);
+ ftree = new TTree("esdTree", "Tree with ESD objects");
+ fesd = new AliESDEvent();
+ fesd->CreateStdContent();
+ fesd->WriteToTree(ftree);
- TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
- hltesd = new AliESDEvent();
- hltesd->CreateStdContent();
- hltesd->WriteToTree(hlttree);
+ fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
+ fhltesd = new AliESDEvent();
+ fhltesd->CreateStdContent();
+ fhltesd->WriteToTree(fhlttree);
/* CKB Why?
delete esd; delete hltesd;
- AliESDfriend *esdf = 0;
if (fWriteESDfriend) {
- esdf = new AliESDfriend();
- TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf);
+ fesdf = new AliESDfriend();
+ TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
br->SetFile("AliESDfriends.root");
- esd->AddObject(esdf);
+ fesd->AddObject(fesdf);
}
AliError("No diamond profile found in OCDB!");
}
- AliVertexerTracks tVertexer(AliTracker::GetBz());
- if(fDiamondProfile && fMeanVertexConstraint) tVertexer.SetVtxStart(fDiamondProfile);
+ ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
+ if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
if (fRawReader) fRawReader->RewindEvents();
fgkDetectorName[iDet]));
qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS,"same");
- }
+ // if (!fInLoopQA) {
+// qadm->StartOfCycle(AliQA::kRECPOINTS);
+// qadm->StartOfCycle(AliQA::kESDS,"same");
+// }
}
}
if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
AliInfo(Form("Initializing the global QA data maker"));
TObjArray *arr=
qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
AliTracker::SetResidualsArray(arr);
qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS,"same");
+ qadm->StartOfCycle(AliQA::kRECPOINTS, (fRunQA && fRawReader));
+ qadm->StartOfCycle(AliQA::kESDS, "same");
}
}
//Initialize the Plane Efficiency framework
if (fRunPlaneEff && !InitPlaneEff()) {
- if(fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
- //******* The loop over events
- 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) {
- esd->ReadFromTree(treeOld);
- treeOld->GetEntry(iEvent);
- tree->Fill();
- }
- if (hlttreeOld) {
- esd->ReadFromTree(hlttreeOld);
- hlttreeOld->GetEntry(iEvent);
- hlttree->Fill();
- }
- continue;
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunEvent(Int_t iEvent)
+{
+ // run the reconstruction over a single event
+ // The event loop is steered in Run method
+
+ AliCodeTimerAuto("");
+
+ if (iEvent >= fRunLoader->GetNumberOfEvents()) {
+ fRunLoader->SetEventNumber(iEvent);
+ fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
+ iEvent, iEvent);
+ //?? fRunLoader->MakeTree("H");
+ fRunLoader->TreeE()->Fill();
+ }
+
+ if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
+ // copy old ESD to the new one
+ if (ftreeOld) {
+ fesd->ReadFromTree(ftreeOld);
+ ftreeOld->GetEntry(iEvent);
+ ftree->Fill();
}
-
- AliInfo(Form("processing event %d", iEvent));
+ if (fhlttreeOld) {
+ fesd->ReadFromTree(fhlttreeOld);
+ fhlttreeOld->GetEntry(iEvent);
+ fhlttree->Fill();
+ }
+ return kTRUE;
+ }
+
+ AliInfo(Form("processing event %d", iEvent));
//Start of cycle for the in-loop QA
if (fInLoopQA) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliQADataMakerRec *qadm = GetQADataMaker(iDet);
if (!qadm) continue;
- qadm->StartOfCycle(AliQA::kRECPOINTS);
+ qadm->StartOfCycle(AliQA::kRECPOINTS, (fRunQA && fRawReader));
qadm->StartOfCycle(AliQA::kESDS, "same") ;
}
}
if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS,"same");
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
+ qadm->StartOfCycle(AliQA::kRECPOINTS, (fRunQA && fRawReader));
+ qadm->StartOfCycle(AliQA::kESDS, "same");
}
}
sprintf(aFileName, "ESD_%d.%d_final.root",
fRunLoader->GetHeader()->GetRun(),
fRunLoader->GetHeader()->GetEventNrInRun());
- if (!gSystem->AccessPathName(aFileName)) continue;
+ if (!gSystem->AccessPathName(aFileName)) return kTRUE;
// local signle event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
}
- esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
- hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
- esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
- hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+ fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+ fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+ fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+ fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
// Set magnetic field from the tracker
- esd->SetMagneticField(AliTracker::GetBz());
- hltesd->SetMagneticField(AliTracker::GetBz());
+ fesd->SetMagneticField(AliTracker::GetBz());
+ fhltesd->SetMagneticField(AliTracker::GetBz());
// Fill raw-data error log into the ESD
- if (fRawReader) FillRawDataErrorLog(iEvent,esd);
+ if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
// vertex finder
if (fRunVertexFinder) {
- if (!ReadESD(esd, "vertex")) {
- if (!RunVertexFinder(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (!ReadESD(fesd, "vertex")) {
+ if (!RunVertexFinder(fesd)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
- if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
+ if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
}
}
// HLT tracking
if (!fRunTracking.IsNull()) {
if (fRunHLTTracking) {
- hltesd->SetPrimaryVertexSPD(esd->GetVertex());
- if (!RunHLTTracking(hltesd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ fhltesd->SetPrimaryVertexSPD(fesd->GetVertex());
+ if (!RunHLTTracking(fhltesd)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
}
}
// Muon tracking
if (!fRunTracking.IsNull()) {
if (fRunMuonTracking) {
- if (!RunMuonTracking(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (!RunMuonTracking(fesd)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
}
}
// barrel tracking
if (!fRunTracking.IsNull()) {
- if (!ReadESD(esd, "tracking")) {
- if (!RunTracking(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (!ReadESD(fesd, "tracking")) {
+ if (!RunTracking(fesd)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
- if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
+ if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
}
}
// fill ESD
if (!fFillESD.IsNull()) {
- if (!FillESD(esd, fFillESD)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (!FillESD(fesd, fFillESD)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
}
// fill Event header information from the RawEventHeader
- if (fRawReader){FillRawEventHeaderESD(esd);}
+ if (fRawReader){FillRawEventHeaderESD(fesd);}
// combined PID
- AliESDpid::MakePID(esd);
- if (fCheckPointLevel > 1) WriteESD(esd, "PID");
+ AliESDpid::MakePID(fesd);
+ if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
if (fFillTriggerESD) {
- if (!ReadESD(esd, "trigger")) {
- if (!FillTriggerESD(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (!ReadESD(fesd, "trigger")) {
+ if (!FillTriggerESD(fesd)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
- if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
+ if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
}
}
- file->cd();
+ ffile->cd();
//
// Propagate track to the beam pipe (if not laready done by ITS)
//
- const Int_t ntracks = esd->GetNumberOfTracks();
- const Double_t kBz = esd->GetMagneticField();
+ const Int_t ntracks = fesd->GetNumberOfTracks();
+ const Double_t kBz = fesd->GetMagneticField();
const Double_t kRadius = 2.8; //something less than the beam pipe radius
TObjArray trkArray;
const Double_t kMaxStep = 5; //max step over the material
Bool_t ok;
- AliESDtrack *track = esd->GetTrack(itrack);
+ AliESDtrack *track = fesd->GetTrack(itrack);
if (!track) continue;
AliExternalTrackParam *tpcTrack =
ok = AliTracker::
PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
if (ok) {
- track->RelateToVertex(esd->GetPrimaryVertexSPD(), kBz, kRadius);
+ track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius);
}
}
}
if (fRunVertexFinderTracks) {
// TPC + ITS primary vertex
- tVertexer.SetITSrefitRequired();
+ ftVertexer->SetITSrefitRequired();
if(fDiamondProfile && fMeanVertexConstraint) {
- tVertexer.SetVtxStart(fDiamondProfile);
+ ftVertexer->SetVtxStart(fDiamondProfile);
} else {
- tVertexer.SetConstraintOff();
+ ftVertexer->SetConstraintOff();
}
- AliESDVertex *pvtx=tVertexer.FindPrimaryVertex(esd);
+ AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
if (pvtx->GetStatus()) {
- esd->SetPrimaryVertex(pvtx);
+ fesd->SetPrimaryVertex(pvtx);
for (Int_t i=0; i<ntracks; i++) {
- AliESDtrack *t = esd->GetTrack(i);
+ AliESDtrack *t = fesd->GetTrack(i);
t->RelateToVertex(pvtx, kBz, kRadius);
}
}
}
// TPC-only primary vertex
- tVertexer.SetITSrefitNotRequired();
+ ftVertexer->SetITSrefitNotRequired();
if(fDiamondProfileTPC && fMeanVertexConstraint) {
- tVertexer.SetVtxStart(fDiamondProfileTPC);
+ ftVertexer->SetVtxStart(fDiamondProfileTPC);
} else {
- tVertexer.SetConstraintOff();
+ ftVertexer->SetConstraintOff();
}
- pvtx=tVertexer.FindPrimaryVertex(&trkArray,selectedIdx);
+ pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
if (pvtx) {
if (pvtx->GetStatus()) {
- esd->SetPrimaryVertexTPC(pvtx);
+ fesd->SetPrimaryVertexTPC(pvtx);
Int_t nsel=trkArray.GetEntriesFast();
for (Int_t i=0; i<nsel; i++) {
AliExternalTrackParam *t =
}
delete[] selectedIdx;
- if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
+ if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
if (fRunV0Finder) {
// V0 finding
AliV0vertexer vtxer;
- vtxer.Tracks2V0vertices(esd);
+ vtxer.Tracks2V0vertices(fesd);
if (fRunCascadeFinder) {
// Cascade finding
AliCascadeVertexer cvtxer;
- cvtxer.V0sTracks2CascadeVertices(esd);
+ cvtxer.V0sTracks2CascadeVertices(fesd);
}
}
// write ESD
- if (fCleanESD) CleanESD(esd);
+ if (fCleanESD) CleanESD(fesd);
if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- if (qadm) qadm->Exec(AliQA::kESDS, esd);
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
+ if (qadm) qadm->Exec(AliQA::kESDS, fesd);
}
if (fWriteESDfriend) {
- esdf->~AliESDfriend();
- new (esdf) AliESDfriend(); // Reset...
- esd->GetESDfriend(esdf);
+ fesdf->~AliESDfriend();
+ new (fesdf) AliESDfriend(); // Reset...
+ fesd->GetESDfriend(fesdf);
}
- tree->Fill();
+ ftree->Fill();
// write HLT ESD
- hlttree->Fill();
+ fhlttree->Fill();
- if (fCheckPointLevel > 0) WriteESD(esd, "final");
- esd->Reset();
- hltesd->Reset();
+ if (fCheckPointLevel > 0) WriteESD(fesd, "final");
+ fesd->Reset();
+ fhltesd->Reset();
if (fWriteESDfriend) {
- esdf->~AliESDfriend();
- new (esdf) AliESDfriend(); // Reset...
+ fesdf->~AliESDfriend();
+ new (fesdf) AliESDfriend(); // Reset...
}
+ ProcInfo_t ProcInfo;
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
// End of cycle for the in-loop QA
if (fInLoopQA) {
if (fRunQA) {
- RunQA(fFillESD.Data(), esd);
+ RunQA(fFillESD.Data(), fesd);
TString detStr(fFillESD);
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (!qadm) continue;
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
+ if (!IsSelected(fgkDetectorName[iDet], detStr))
+ continue;
+ AliQADataMakerRec * qadm = GetQADataMaker(iDet);
+ if (!qadm)
+ continue;
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
}
if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
if (qadm) {
qadm->EndOfCycle(AliQA::kRECPOINTS);
qadm->EndOfCycle(AliQA::kESDS);
}
}
}
- }
- //******** End of the loop over events
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::AddEventAndRun()
+{
+ // for online usage only
+ // Add an event to the run-loader
+ // and
+ // re-creates AliRawReaderDate for this new event
+ AliCodeTimerAuto("");
+
+ if (!fpEvent) {
+ AliError("No raw-data event in memory given as an input! Do nothing!");
+ return kFALSE;
+ }
+
+ // New raw-reader. Could be redone in a better way... To do
+ fRawReader->~AliRawReader();
+ new (fRawReader) AliRawReaderDate((void*)(*fpEvent));
+ if (!fRawReader->NextEvent()) return kFALSE;
+ // Expand the number of events in the run-loader
- tree->GetUserInfo()->Add(esd);
- hlttree->GetUserInfo()->Add(hltesd);
+ Int_t nEvents = fRunLoader->GetNumberOfEvents();
+
+ return RunEvent(nEvents);
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FinishRun()
+{
+ // Finalize the run
+ // Called after the exit
+ // from the event loop
+ AliCodeTimerAuto("");
+
+ if (fIsNewRunLoader) { // galice.root didn't exist
+ fRunLoader->WriteHeader("OVERWRITE");
+ fRunLoader->CdGAFile();
+ fRunLoader->Write(0, TObject::kOverwrite);
+ }
+
+ ftree->GetUserInfo()->Add(fesd);
+ fhlttree->GetUserInfo()->Add(fhltesd);
const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
cdbListCopy->Add(new TObjString(id->ToString().Data()));
}
- tree->GetUserInfo()->Add(cdbMapCopy);
- tree->GetUserInfo()->Add(cdbListCopy);
+ ftree->GetUserInfo()->Add(cdbMapCopy);
+ ftree->GetUserInfo()->Add(cdbListCopy);
if(fESDPar.Contains("ESD.par")){
AliInfo("Attaching ESD.par to Tree");
TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
- tree->GetUserInfo()->Add(fn);
+ ftree->GetUserInfo()->Add(fn);
}
- file->cd();
+ ffile->cd();
if (fWriteESDfriend)
- tree->SetBranchStatus("ESDfriend*",0);
+ ftree->SetBranchStatus("ESDfriend*",0);
// we want to have only one tree version number
- tree->Write(tree->GetName(),TObject::kOverwrite);
- hlttree->Write();
+ ftree->Write(ftree->GetName(),TObject::kOverwrite);
+ fhlttree->Write();
// Finish with Plane Efficiency evaluation: before of CleanUp !!!
if (fRunPlaneEff && !FinishPlaneEff()) {
}
gROOT->cd();
- CleanUp(file, fileOld);
+ CleanUp(ffile, ffileOld);
if (fWriteAOD) {
- TFile *esdFile = TFile::Open("AliESDs.root", "READONLY");
- TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
- ESDFile2AODFile(esdFile, aodFile);
- aodFile->Close();
- esdFile->Close();
+ AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
}
// Create tags for the events in the ESD tree (the ESD tree is always present)
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList);
if (fWriteAOD) {
- AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
- aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
+ AliWarning("AOD tag creation not supported anymore during reconstruction.");
}
//Finish QA and end of cycle for out-of-loop QA
if (!fInLoopQA) {
if (fRunQA) {
- qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS);
- //qas.Reset() ;
- qas.Run(fRunTracking.Data(), AliQA::kESDS);
+ AliQADataMakerSteer qas;
+ qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, (fRunQA && fRawReader));
+ //qas.Reset() ;
+ qas.Run(fRunTracking.Data(), AliQA::kESDS, (fRunQA && fRawReader));
}
if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
if (qadm) {
qadm->EndOfCycle(AliQA::kRECPOINTS);
qadm->EndOfCycle(AliQA::kESDS);
// Cleanup of CDB manager: cache and active storages!
AliCDBManager::Instance()->ClearCache();
-
return kTRUE;
}
}
// run tracking
+ if (iDet>1) // start filling residuals for the "outer" detectors
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
+
if (fTracker[iDet]->PropagateBack(esd) != 0) {
AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
// return kFALSE;
}
AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
}
+ //stop filling residuals for the "outer" detectors
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
// write space-points to the ESD in case alignment data output
// is switched on
// pass 3: TRD + TPC + ITS refit inwards
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
-
for (Int_t iDet = 2; iDet >= 0; iDet--) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
// run tracking
+ if (iDet<2) // start filling residuals for TPC and ITS
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
+
if (fTracker[iDet]->RefitInward(esd) != 0) {
AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
// return kFALSE;
fLoader[iDet]->UnloadRecPoints();
AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
}
-
+ // stop filling residuals for TPC and ITS
if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
eventNr++;
TString configstr("");
if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
+ delete aCTP;
return kFALSE;
}
}
// Now fill the trigger class names into AliESDRun object
AliTriggerConfiguration *config = aCTP->GetConfiguration();
+ if (fRawReader) delete aCTP;
if (!config) {
AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
return kFALSE;
CleanUp();
return kFALSE;
}
+ fIsNewRunLoader = kTRUE;
fRunLoader->MakeTree("E");
- Int_t iEvent = 0;
- while (fRawReader->NextEvent()) {
- fRunLoader->SetEventNumber(iEvent);
- fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
- iEvent, iEvent);
- fRunLoader->MakeTree("H");
- fRunLoader->TreeE()->Fill();
- iEvent++;
- }
- fRawReader->RewindEvents();
+
if (fNumberOfEventsPerFile > 0)
fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
else
- fRunLoader->SetNumberOfEventsPerFile(iEvent);
- fRunLoader->WriteHeader("OVERWRITE");
- fRunLoader->CdGAFile();
- fRunLoader->Write(0, TObject::kOverwrite);
-// AliTracker::SetFieldMap(???);
+ fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
}
return kTRUE;
}
delete fVertexer;
fVertexer = NULL;
+
+ if (ftVertexer) delete ftVertexer;
+ ftVertexer = NULL;
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
delete fDiamondProfile;
delete fileOld;
gSystem->Unlink("AliESDs.old.root");
}
+
}
//_____________________________________________________________________________
}
-
-
-
-//_____________________________________________________________________________
-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();
-
- // go to the file
- aodFile->cd();
-
- // create the tree
- TTree *aodTree = new TTree("aodTree", "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 p_pos[3];
- Double_t p_neg[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) {
- //cout << "event: " << iEvent << endl;
- 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)->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(0),esd->GetZDCEMEnergy(1));
- 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 + 2*nCascades /*could lead to two vertices, one V0 and the Xi */+ nKinks + 1 /* = prim. vtx*/;
- Int_t nJets = 0;
- Int_t nCaloClus = esd->GetNumberOfCaloClusters();
- Int_t nFmdClus = 0;
- Int_t nPmdClus = esd->GetNumberOfPmdTracks();
-
- aod->ResetStd(nTracks, nVertices, nV0s+nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
-
- // 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;
- }
-
- // Access to the AOD container of vertices
- TClonesArray &vertices = *(aod->GetVertices());
- Int_t jVertices=0;
-
- // Access to the AOD container of tracks
- TClonesArray &tracks = *(aod->GetTracks());
- Int_t jTracks=0;
-
- // Access to the AOD container of V0s
- TClonesArray &V0s = *(aod->GetV0s());
- Int_t jV0s=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
-
- AliAODVertex * primary = new(vertices[jVertices++])
- AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
-
-
- AliAODTrack *aodTrack = 0x0;
-
- // 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,
- nCascade,
- AliAODVertex::kCascade);
-
- primary->AddDaughter(vcascade); // the cascade 'particle' (represented by a vertex) is added as a daughter to the primary vertex
-
- // Add the V0 from the cascade. The ESD class have to be optimized...
- // 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;
-
- 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,
- indV0,
- 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,
- indV0,
- 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_pos);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0FromCascade->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_pos,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- 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_neg);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0FromCascade->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_neg,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- 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 it to the V0 array as well
- Double_t d0[2] = { -999., -99.};
- // counting is probably wrong
- new(V0s[jV0s++]) AliAODv0(vV0FromCascade, -999., -99., p_pos, p_neg, d0); // to be refined
-
- // 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->Charge(),
- 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,
- nV0,
- 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_pos);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_pos,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- 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_neg);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_neg,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- 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;
- }
-
- // add it to the V0 array as well
- Double_t d0[2] = { 999., 99.};
- new(V0s[jV0s++]) AliAODv0(vV0, 999., 99., p_pos, p_neg, d0); // to be refined
- }
- V0s.Expand(jV0s);
- // 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 (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;
- }
- else if (ikink>0 && jkink<0) {
-
- imother = jTrack;
- idaughter = iTrack;
- }
- else {
- cerr << "Error: Wrong combination of kink indexes: "
- << ikink << " " << jkink << endl;
- continue;
- }
-
- // 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->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- primary,
- kTRUE, // check if this is right
- kTRUE, // check if this is right
- AliAODTrack::kPrimary);
- primary->AddDaughter(mother);
- mother->ConvertAliPIDtoAODPID();
- }
- 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,
- esdTrack->GetID(), // This is the track ID of the mother's track!
- 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->Charge(),
- 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;
- }
- }
- }
- }
- }
- vertices.Expand(jVertices);
-
- // Tracks (primary and orphan)
- 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->Charge(),
- 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
- // Don't write them anymore!
- continue;
- }
- } // end of loop on tracks
-
- // muon tracks
- Int_t nMuTracks = esd->GetNumberOfMuonTracks();
- for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
-
- 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();
-
- // 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(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
- 0, // no label provided
- p,
- kTRUE,
- pos,
- kFALSE,
- NULL, // no covariance matrix provided
- esdMuTrack->Charge(),
- 0, // ITSClusterMap is set below
- pid,
- primary,
- 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.);
- }
- tracks.Expand(jTracks); // remove 'empty slots' due to unwritten tracks
-
- // Access to the AOD container of PMD clusters
- TClonesArray &pmdClusters = *(aod->GetPmdClusters());
- Int_t jPmdClusters=0;
-
- for (Int_t iPmd = 0; iPmd < nPmdClus; ++iPmd) {
- // file pmd clusters, to be revised!
- AliESDPmdTrack *pmdTrack = esd->GetPmdTrack(iPmd);
- Int_t nLabel = 0;
- Int_t *label = 0x0;
- Double_t pos[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ() };
- Double_t pid[9] = { 0., 0., 0., 0., 0., 0., 0., 0., 0. }; // to be revised!
- // type not set!
- // assoc cluster not set
- new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), pos, pid);
- }
-
- // Access to the AOD container of clusters
- TClonesArray &caloClusters = *(aod->GetCaloClusters());
- Int_t jClusters=0;
-
- for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
-
- AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
-
- Int_t id = cluster->GetID();
- Int_t nLabel = 0;
- Int_t *label = 0x0;
- Float_t energy = cluster->E();
- cluster->GetPosition(posF);
- Char_t ttype=AliAODCluster::kUndef;
-
- if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
- ttype=AliAODCluster::kPHOSNeutral;
- }
- else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
- ttype = AliAODCluster::kEMCALClusterv1;
- }
-
-
- AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
- nLabel,
- label,
- energy,
- pos,
- NULL,
- ttype);
-
- caloCluster->SetCaloCluster(); // to be refined!
-
- }
- caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
- // end of loop on calo clusters
-
- // fill EMCAL cell info
- if (esd->GetEMCALCells()) { // protection against missing ESD information
- AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
- Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
-
- AliAODCaloCells &aodEMcells = *(aod->GetEMCALCells());
- aodEMcells.CreateContainer(nEMcell);
- aodEMcells.SetType(AliAODCaloCells::kEMCAL);
- for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
- aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
- }
- aodEMcells.Sort();
- }
-
- // fill PHOS cell info
- if (esd->GetPHOSCells()) { // protection against missing ESD information
- AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
- Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
-
- AliAODCaloCells &aodPHcells = *(aod->GetPHOSCells());
- aodPHcells.CreateContainer(nPHcell);
- aodPHcells.SetType(AliAODCaloCells::kPHOS);
- for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
- aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
- }
- aodPHcells.Sort();
- }
-
- // tracklets
- AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
- const AliMultiplicity *mult = esd->GetMultiplicity();
- if (mult) {
- if (mult->GetNumberOfTracklets()>0) {
- SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
-
- for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
- SPDTracklets.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);
-
- // write the tree to the specified file
- aodFile = aodTree->GetCurrentFile();
- aodFile->cd();
- aodTree->Write();
-
- return;
-}
-
void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
{
// Write space-points which are then used in the alignment procedures
for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
TString detName(AliQA::GetDetName(iDet)) ;
- AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX(iDet)) ;
- if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kFATAL)) {
+ AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
+ if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
} else {
if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff