X-Git-Url: http://git.uio.no/git/?a=blobdiff_plain;f=STEER%2FAliReconstruction.cxx;h=9a4dc8c5cfcfaeb64611fdd3ed873878ad744cab;hb=21a3aa099311093e7f9b0b920624f24441c1ae51;hp=b3af235fadd464d37efd41427974ba6d62744e07;hpb=9df1f104e09dcda16f753a979cbf8163de224b63;p=u%2Fmrichter%2FAliRoot.git diff --git a/STEER/AliReconstruction.cxx b/STEER/AliReconstruction.cxx index b3af235fadd..9a4dc8c5cfc 100644 --- a/STEER/AliReconstruction.cxx +++ b/STEER/AliReconstruction.cxx @@ -101,6 +101,10 @@ // The reconstruction requires digits or raw data as input. For the creation // // of digits and raw data have a look at the class AliSimulation. // // // +// The input data of a detector can be replaced by the corresponding HLT // +// data by calling (usual detector string) // +// SetUseHLTData("..."); // +// // // For debug purposes the method SetCheckPointLevel can be used. If the // // argument is greater than 0, files with ESD events will be written after // // selected steps of the reconstruction for each event: // @@ -124,6 +128,7 @@ #include #include #include +#include #include "AliReconstruction.h" #include "AliCodeTimer.h" @@ -168,25 +173,19 @@ #include "AliAlignObj.h" #include "AliCentralTrigger.h" +#include "AliTriggerConfiguration.h" +#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 "AliQADataMaker.h" +#include "AliQADataMakerRec.h" +#include "AliGlobalQADataMaker.h" #include "AliQA.h" #include "AliQADataMakerSteer.h" +#include "AliPlaneEff.h" + #include "AliSysInfo.h" // memory snapshots +#include "AliRawHLTManager.h" ClassImp(AliReconstruction) @@ -202,6 +201,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fUniformField(kTRUE), fRunVertexFinder(kTRUE), + fRunVertexFinderTracks(kTRUE), fRunHLTTracking(kFALSE), fRunMuonTracking(kFALSE), fRunV0Finder(kTRUE), @@ -224,6 +224,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fUseTrackingErrorsForAlignment(""), fGAliceFileName(gAliceFilename), fInput(""), + fpEvent(NULL), fEquipIdMap(""), fFirstEvent(0), fLastEvent(-1), @@ -233,12 +234,15 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fLoadAlignFromCDB(kTRUE), fLoadAlignData("ALL"), fESDPar(""), + fUseHLTData(), fRunLoader(NULL), fRawReader(NULL), + fParentRawReader(NULL), fVertexer(NULL), fDiamondProfile(NULL), + fDiamondProfileTPC(NULL), fMeanVertexConstraint(kTRUE), fGRPList(NULL), @@ -249,8 +253,22 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fInitCDBCalled(kFALSE), fSetRunNumberFromDataCalled(kFALSE), fRunQA(kTRUE), - fQAInLoop(kFALSE) - + fRunGlobalQA(kTRUE), + fInLoopQA(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 @@ -261,6 +279,7 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename, fQADataMaker[iDet] = NULL; fQACycles[iDet] = 999999; } + fQADataMaker[fgkNDetectors]=NULL; //Global QA AliPID pid; } @@ -270,6 +289,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fUniformField(rec.fUniformField), fRunVertexFinder(rec.fRunVertexFinder), + fRunVertexFinderTracks(rec.fRunVertexFinderTracks), fRunHLTTracking(rec.fRunHLTTracking), fRunMuonTracking(rec.fRunMuonTracking), fRunV0Finder(rec.fRunV0Finder), @@ -292,6 +312,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment), fGAliceFileName(rec.fGAliceFileName), fInput(rec.fInput), + fpEvent(rec.fpEvent), fEquipIdMap(rec.fEquipIdMap), fFirstEvent(rec.fFirstEvent), fLastEvent(rec.fLastEvent), @@ -301,12 +322,15 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fLoadAlignFromCDB(rec.fLoadAlignFromCDB), fLoadAlignData(rec.fLoadAlignData), fESDPar(rec.fESDPar), + fUseHLTData(rec.fUseHLTData), fRunLoader(NULL), fRawReader(NULL), + fParentRawReader(NULL), fVertexer(NULL), fDiamondProfile(NULL), + fDiamondProfileTPC(NULL), fMeanVertexConstraint(rec.fMeanVertexConstraint), fGRPList(NULL), @@ -316,9 +340,22 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fSpecCDBUri(), fInitCDBCalled(rec.fInitCDBCalled), fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled), - fRunQA(kTRUE), - fQAInLoop(kFALSE) - + fRunQA(rec.fRunQA), + fRunGlobalQA(rec.fRunGlobalQA), + fInLoopQA(rec.fInLoopQA), + 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 @@ -332,6 +369,7 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) : fQADataMaker[iDet] = NULL; fQACycles[iDet] = rec.fQACycles[iDet]; } + fQADataMaker[fgkNDetectors]=NULL; //Global QA for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) { if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone()); } @@ -472,7 +510,7 @@ Bool_t AliReconstruction::SetRunNumberFromData() 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) { @@ -489,8 +527,15 @@ Bool_t AliReconstruction::SetRunNumberFromData() 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 { @@ -568,6 +613,24 @@ void AliReconstruction::SetGAliceFile(const char* fileName) 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) { @@ -578,28 +641,76 @@ void AliReconstruction::SetOption(const char* detector, const char* option) fOptions.Add(new TNamed(detector, option)); } - //_____________________________________________________________________________ Bool_t AliReconstruction::Run(const char* input) { -// run the reconstruction + // Run Run Run + AliCodeTimerAuto(""); - AliCodeTimerAuto("") + if (!InitRun(input)) return kFALSE; - // set the input - 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); - fRawReader->SelectEvents(7); + //******* 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 { + AliInfo("Reconstruction will run over digits"); + } + if (!fEquipIdMap.IsNull() && fRawReader) fRawReader->LoadEquipmentIdsMap(fEquipIdMap); + if (!fUseHLTData.IsNull()) { + // create the RawReaderHLT which performs redirection of HLT input data for + // the specified detectors + AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data()); + if (pRawReader) { + fParentRawReader=fRawReader; + fRawReader=pRawReader; + } else { + AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data())); + } + } + AliSysInfo::AddStamp("Start"); // get the run loader if (!InitRunLoader()) return kFALSE; @@ -628,22 +739,22 @@ Bool_t AliReconstruction::Run(const char* input) if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE; AliSysInfo::AddStamp("LoadGeom"); - //QA + //QA AliQADataMakerSteer qas ; - if ( fRunQA && fRawReader) - qas.Run(fRunLocalReconstruction, fRawReader) ; - - // checking the QA of previous steps - CheckQA() ; + if (fRunQA && fRawReader) { + qas.Run(fRunLocalReconstruction, fRawReader) ; + } + // checking the QA of previous steps + //CheckQA() ; + /* // local reconstruction if (!fRunLocalReconstruction.IsNull()) { if (!RunLocalReconstruction(fRunLocalReconstruction)) { if (fStopOnError) {CleanUp(); return kFALSE;} } } -// if (!fRunVertexFinder && fRunTracking.IsNull() && -// fFillESD.IsNull()) return kTRUE; + */ // get vertexer if (fRunVertexFinder && !CreateVertexer()) { @@ -664,37 +775,35 @@ Bool_t AliReconstruction::Run(const char* input) 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; @@ -704,12 +813,11 @@ Bool_t AliReconstruction::Run(const char* input) - 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); } @@ -732,82 +840,161 @@ Bool_t AliReconstruction::Run(const char* input) AliError("No diamond profile found in OCDB!"); } - AliVertexerTracks tVertexer(AliTracker::GetBz()); - if(fDiamondProfile && fMeanVertexConstraint) tVertexer.SetVtxStart(fDiamondProfile); + entry = 0; + entry = AliCDBManager::Instance() + ->Get("GRP/Calib/MeanVertexTPC"); + + if(entry) { + fDiamondProfileTPC = dynamic_cast (entry->GetObject()); + } else { + AliError("No diamond profile found in OCDB!"); + } + + ftVertexer = new AliVertexerTracks(AliTracker::GetBz()); + if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->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) { - esd->ReadFromTree(treeOld); - treeOld->GetEntry(iEvent); - } - tree->Fill(); - if (hlttreeOld) { - esd->ReadFromTree(hlttreeOld); - hlttreeOld->GetEntry(iEvent); - } - hlttree->Fill(); - continue; + + //Initialize the QA and start of cycle for out-of-cycle QA + if (fRunQA) { + TString detStr(fFillESD); + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + AliQADataMakerRec *qadm = GetQADataMaker(iDet); + if (!qadm) continue; + AliInfo(Form("Initializing the QA data maker for %s", + 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 (fRunGlobalQA) { + 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, (fRunQA && fRawReader)); + qadm->StartOfCycle(AliQA::kESDS, "same"); + } + } + + //Initialize the Plane Efficiency framework + if (fRunPlaneEff && !InitPlaneEff()) { + if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;} + } + + 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 (fRunQA) { + 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->StartOfCycle(AliQA::kRECPOINTS, (fRunQA && fRawReader)); + qadm->StartOfCycle(AliQA::kESDS, "same") ; + } + } + if (fRunGlobalQA) { + AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); + qadm->StartOfCycle(AliQA::kRECPOINTS, (fRunQA && fRawReader)); + qadm->StartOfCycle(AliQA::kESDS, "same"); + } + } + fRunLoader->GetEvent(iEvent); char aFileName[256]; 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 reconstruction + // 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->SetVertex(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;} } } } @@ -815,136 +1002,256 @@ Bool_t AliReconstruction::Run(const char* input) // 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;} } } -// if (!fFillESD.IsNull()) - - // do QA in the event loop if requested - if (fQAInLoop) - RunQA(fFillESD.Data(), esd); - // 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 = fesd->GetNumberOfTracks(); + const Double_t kBz = fesd->GetMagneticField(); + const Double_t kRadius = 2.8; //something less than the beam pipe radius + + TObjArray trkArray; + UShort_t *selectedIdx=new UShort_t[ntracks]; + + for (Int_t itrack=0; itrackGetTrack(itrack); + if (!track) continue; + + AliExternalTrackParam *tpcTrack = + (AliExternalTrackParam *)track->GetTPCInnerParam(); + ok = kFALSE; + if (tpcTrack) + ok = AliTracker:: + PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE); - //Try to improve the reconstructed primary vertex position using the tracks - AliESDVertex *pvtx=0; - Bool_t dovertex=kTRUE; - TObject* obj = fOptions.FindObject("ITS"); + + + if (ok) { + Int_t n=trkArray.GetEntriesFast(); + selectedIdx[n]=track->GetID(); + trkArray.AddLast(tpcTrack); + } + + if (track->GetX() < kRadius) continue; + + ok = AliTracker:: + PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE); + if (ok) { + track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius); + } + } + + // + // Improve the reconstructed primary vertex position using the tracks + // + TObject *obj = fOptions.FindObject("ITS"); if (obj) { TString optITS = obj->GetTitle(); if (optITS.Contains("cosmics") || optITS.Contains("COSMICS")) - dovertex=kFALSE; + fRunVertexFinderTracks=kFALSE; + } + if (fRunVertexFinderTracks) { + // TPC + ITS primary vertex + ftVertexer->SetITSrefitRequired(); + if(fDiamondProfile && fMeanVertexConstraint) { + ftVertexer->SetVtxStart(fDiamondProfile); + } else { + ftVertexer->SetConstraintOff(); + } + AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd); + if (pvtx) { + if (pvtx->GetStatus()) { + fesd->SetPrimaryVertex(pvtx); + for (Int_t i=0; iGetTrack(i); + t->RelateToVertex(pvtx, kBz, kRadius); + } + } + } + + // TPC-only primary vertex + ftVertexer->SetITSrefitNotRequired(); + if(fDiamondProfileTPC && fMeanVertexConstraint) { + ftVertexer->SetVtxStart(fDiamondProfileTPC); + } else { + ftVertexer->SetConstraintOff(); + } + pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx); + if (pvtx) { + if (pvtx->GetStatus()) { + fesd->SetPrimaryVertexTPC(pvtx); + Int_t nsel=trkArray.GetEntriesFast(); + for (Int_t i=0; iPropagateToDCA(pvtx, kBz, kRadius); + } + } + } + } - if(dovertex) pvtx=tVertexer.FindPrimaryVertex(esd); - if(fDiamondProfile) esd->SetDiamond(fDiamondProfile); + delete[] selectedIdx; + + if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile); - if (pvtx) - if (pvtx->GetStatus()) { - // Store the improved primary vertex - esd->SetPrimaryVertex(pvtx); - // Propagate the tracks to the DCA to the improved primary vertex - Double_t somethingbig = 777.; - Double_t bz = esd->GetMagneticField(); - Int_t nt=esd->GetNumberOfTracks(); - while (nt--) { - AliESDtrack *t = esd->GetTrack(nt); - t->RelateToVertex(pvtx, bz, somethingbig); - } - } 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(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... } - // esdf->Reset(); - // delete esdf; esdf = 0; - // ESD QA + ProcInfo_t ProcInfo; 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) - if (fQAInLoop) { - 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(); - } + // End of cycle for the in-loop QA + if (fInLoopQA) { + if (fRunQA) { + 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 (fRunGlobalQA) { + AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL); + if (qadm) { + qadm->EndOfCycle(AliQA::kRECPOINTS); + qadm->EndOfCycle(AliQA::kESDS); + qadm->Finish(); + } + } + } + + 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 + + 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); } - tree->GetUserInfo()->Add(esd); - hlttree->GetUserInfo()->Add(hltesd); + ftree->GetUserInfo()->Add(fesd); + fhlttree->GetUserInfo()->Add(fhltesd); const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap(); const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds(); @@ -972,61 +1279,72 @@ Bool_t AliReconstruction::Run(const char* input) 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(); - if (fWriteAOD) { - TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE"); - ESDFile2AODFile(file, aodFile); - aodFile->Close(); +// Finish with Plane Efficiency evaluation: before of CleanUp !!! + if (fRunPlaneEff && !FinishPlaneEff()) { + AliWarning("Finish PlaneEff evaluation failed"); } gROOT->cd(); - CleanUp(file, fileOld); + CleanUp(ffile, ffileOld); + if (fWriteAOD) { + 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) // In case of empty events the tags will contain dummy values 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."); } - //QA fone outside the event loop - if (!fQAInLoop) { - if ( fRunQA ) { - qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS) ; - // qas.Reset() ; - qas.Run(fRunTracking.Data(), AliQA::kESDS) ; - } + //Finish QA and end of cycle for out-of-loop QA + if (!fInLoopQA) { + if (fRunQA) { + 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(AliQA::kGLOBAL); + if (qadm) { + qadm->EndOfCycle(AliQA::kRECPOINTS); + qadm->EndOfCycle(AliQA::kESDS); + qadm->Finish(); + } + } } // Cleanup of CDB manager: cache and active storages! AliCDBManager::Instance()->ClearCache(); - return kTRUE; } //_____________________________________________________________________________ -Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors) +Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/) { // run the local reconstruction static Int_t eventNr=0; @@ -1085,6 +1403,7 @@ Bool_t AliReconstruction::RunLocalReconstruction(const TString& detectors) Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) { // run the local reconstruction + static Int_t eventNr=0; AliCodeTimerAuto("") @@ -1098,7 +1417,6 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) 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", @@ -1113,7 +1431,6 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) loader->WriteDigits("OVERWRITE"); loader->UnloadDigits(); } - // local reconstruction AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet])); AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet])); @@ -1135,24 +1452,23 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors) loader->UnloadDigits(); } - // do QA in the event loop if requested - if (fQAInLoop) { - 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])); - } - } + // In-loop QA for local reconstrucion + if (fRunQA && fInLoopQA) { + AliQADataMakerRec * qadm = GetQADataMaker(iDet); + if (qadm) { + //AliCodeTimerStart + //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); + //AliInfo + //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); - loader->WriteRecPoints("OVERWRITE"); + qadm->Exec(AliQA::kRECPOINTS, clustersTree) ; + + //AliCodeTimerStop + //(Form("Running QA data maker for %s", fgkDetectorName[iDet])); + } + } + + loader->WriteRecPoints("OVERWRITE"); loader->UnloadRecPoints(); AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr); } @@ -1209,7 +1525,7 @@ Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd) AliWarning("no vertex reconstructed"); vertex = new AliESDVertex(vtxPos, vtxErr); } - esd->SetVertex(vertex); + esd->SetPrimaryVertexSPD(vertex); // if SPD multiplicity has been determined, it is stored in the ESD AliMultiplicity *mult = fVertexer->GetMultiplicity(); if(mult)esd->SetMultiplicity(mult); @@ -1377,6 +1693,7 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) } // pass 2: ALL backwards + for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { if (!fTracker[iDet]) continue; AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet])); @@ -1396,6 +1713,9 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) } // 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; @@ -1416,6 +1736,8 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) } 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 @@ -1423,15 +1745,24 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) WriteAlignmentData(esd); // pass 3: TRD + TPC + ITS refit inwards + 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; } + // run postprocessing + if (fTracker[iDet]->PostProcess(esd) != 0) { + AliError(Form("%s postprocessing failed", fgkDetectorName[iDet])); + // return kFALSE; + } if (fCheckPointLevel > 1) { WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet])); } @@ -1442,21 +1773,9 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd) fLoader[iDet]->UnloadRecPoints(); AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr); } - // - // Propagate track to the vertex - if not done by ITS - // - Int_t ntracks = esd->GetNumberOfTracks(); - for (Int_t itrack=0; itrackGetTrack(itrack); - if (!track) continue; - if (track->IsOn(AliESDtrack::kITSrefit)) continue; - AliTracker::PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE); - track->RelateToVertex(esd->GetVertex(),fieldZ, kMaxD); - } + // stop filling residuals for TPC and ITS + if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE); + eventNr++; return kTRUE; } @@ -1478,7 +1797,7 @@ Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){ nTracks=esd->GetNumberOfTracks(); nV0s=esd->GetNumberOfV0s(); AliInfo - (Form("Number of ESD tracks and V0s after cleaning %d",nTracks,nV0s)); + (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s)); return rc; } @@ -1553,6 +1872,8 @@ Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd) AliInfo("Filling trigger information into the ESD"); + AliCentralTrigger *aCTP = NULL; + if (fRawReader) { AliCTPRawStream input(fRawReader); if (!input.Next()) { @@ -1561,12 +1882,19 @@ Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd) } esd->SetTriggerMask(input.GetClassMask()); esd->SetTriggerCluster(input.GetClusterMask()); + + aCTP = new AliCentralTrigger(); + 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!"); + return kFALSE; + } } else { AliRunLoader *runloader = AliRunLoader::GetRunLoader(); if (runloader) { if (!runloader->LoadTrigger()) { - AliCentralTrigger *aCTP = runloader->GetTrigger(); + aCTP = runloader->GetTrigger(); esd->SetTriggerMask(aCTP->GetClassMask()); esd->SetTriggerCluster(aCTP->GetClusterMask()); } @@ -1581,6 +1909,21 @@ Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd) } } + // Now fill the trigger class names into AliESDRun object + AliTriggerConfiguration *config = aCTP->GetConfiguration(); + if (!config) { + AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!"); + return kFALSE; + } + + const TObjArray& classesArray = config->GetClasses(); + Int_t nclasses = classesArray.GetEntriesFast(); + for( Int_t j=0; jGetMask()); + esd->SetTriggerClass(trclass->GetName(),trindex); + } + return kTRUE; } @@ -1707,25 +2050,13 @@ Bool_t AliReconstruction::InitRunLoader() 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; @@ -1880,19 +2211,26 @@ void AliReconstruction::CleanUp(TFile* file, TFile* fileOld) } delete fVertexer; fVertexer = NULL; + + if (ftVertexer) delete ftVertexer; + ftVertexer = NULL; if(!(AliCDBManager::Instance()->GetCacheFlag())) { delete fDiamondProfile; fDiamondProfile = NULL; + delete fDiamondProfileTPC; + fDiamondProfileTPC = NULL; + delete fGRPList; + fGRPList = NULL; } - delete fGRPList; - fGRPList = NULL; delete fRunLoader; fRunLoader = NULL; delete fRawReader; fRawReader = NULL; + if (fParentRawReader) delete fParentRawReader; + fParentRawReader=NULL; if (file) { file->Close(); @@ -1904,6 +2242,7 @@ void AliReconstruction::CleanUp(TFile* file, TFile* fileOld) delete fileOld; gSystem->Unlink("AliESDs.old.root"); } + } //_____________________________________________________________________________ @@ -1960,760 +2299,6 @@ void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const } - - - -//_____________________________________________________________________________ -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; iTrackGetTrack(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; iTrack0) { - usedV0 = new Bool_t[nV0s]; - for (Int_t iV0=0; iV00) { - usedKink = new Bool_t[nKinks]; - for (Int_t iKink=0; iKinkGetVertices()); - 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; iV0GetV0(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; iTrackGetTrack(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; jTrackGetTrack(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; iClustGetCaloCluster(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; nGetNumberOfTracklets(); 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 @@ -2750,7 +2335,7 @@ void AliReconstruction::WriteAlignmentData(AliESDEvent* esd) AliTrackPoint p; Int_t isp = 0; Int_t isp2 = 0; - while (isp < nspdet) { + while (isp2 < nspdet) { Bool_t isvalid; TString dets = fgkDetectorName[iDet]; if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) || @@ -2845,49 +2430,49 @@ void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){ } //_____________________________________________________________________________ -AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet) +AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet) { // get the quality assurance data maker object and the loader for a detector if (fQADataMaker[iDet]) return fQADataMaker[iDet]; + AliQADataMakerRec * qadm = NULL; + if (iDet == fgkNDetectors) { //Global QA + qadm = new AliGlobalQADataMaker(); + fQADataMaker[iDet] = qadm; + return qadm; + } + // load the QA data maker object TPluginManager* pluginManager = gROOT->GetPluginManager(); TString detName = fgkDetectorName[iDet]; - TString qadmName = "Ali" + detName + "QADataMaker"; + TString qadmName = "Ali" + detName + "QADataMakerRec"; 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); + TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", 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, + pluginManager->AddHandler("AliQADataMakerRec", detName, qadmName, detName + "qadm", qadmName + "()"); } else { - pluginManager->AddHandler("AliQADataMaker", detName, + pluginManager->AddHandler("AliQADataMakerRec", detName, qadmName, detName, qadmName + "()"); } - pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName); + pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", 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; + qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0); } + fQADataMaker[iDet] = qadm; + return qadm; } @@ -2901,7 +2486,7 @@ Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd) for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; - AliQADataMaker * qadm = GetQADataMaker(iDet); + AliQADataMakerRec * qadm = GetQADataMaker(iDet); if (!qadm) continue; AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet])); @@ -2935,8 +2520,8 @@ void AliReconstruction::CheckQA() 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)) || @@ -2972,3 +2557,50 @@ Int_t AliReconstruction::GetDetIndex(const char* detector) } return index ; } +//_____________________________________________________________________________ +Bool_t AliReconstruction::FinishPlaneEff() { + // + // Here execute all the necessary operationis, at the end of the tracking phase, + // in case that evaluation of PlaneEfficiencies was required for some detector. + // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated. + // + // This Preliminary version works only FOR ITS !!!!! + // other detectors (TOF,TRD, etc. have to develop their specific codes) + // + // Input: none + // Return: kTRUE if all operations have been done properly, kFALSE otherwise + // + Bool_t ret=kFALSE; + //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) { + for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS + //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue; + if(fTracker[iDet]) { + AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff(); + ret=planeeff->WriteIntoCDB(); + if(planeeff->GetCreateHistos()) { + TString name="PlaneEffHisto"; + name+=fgkDetectorName[iDet]; + name+=".root"; + ret*=planeeff->WriteHistosToFile(name,"RECREATE"); + } + } + } + return ret; +} +//_____________________________________________________________________________ +Bool_t AliReconstruction::InitPlaneEff() { +// + // Here execute all the necessary operations, before of the tracking phase, + // for the evaluation of PlaneEfficiencies, in case required for some detectors. + // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency + // which should be updated/recalculated. + // + // This Preliminary version will work only FOR ITS !!!!! + // other detectors (TOF,TRD, etc. have to develop their specific codes) + // + // Input: none + // Return: kTRUE if all operations have been done properly, kFALSE otherwise + // + AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE")); + return kTRUE; +}