// 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: //
#include <TLorentzVector.h>
#include <TArrayS.h>
#include <TArrayD.h>
+#include <TObjArray.h>
#include "AliReconstruction.h"
#include "AliCodeTimer.h"
#include "AliESDkink.h"
#include "AliESDtrack.h"
#include "AliESDCaloCluster.h"
+#include "AliESDCaloCells.h"
#include "AliMultiplicity.h"
#include "AliTracker.h"
#include "AliVertexer.h"
#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)
fUniformField(kTRUE),
fRunVertexFinder(kTRUE),
+ fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
fRunMuonTracking(kFALSE),
fRunV0Finder(kTRUE),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
fESDPar(""),
+ fUseHLTData(),
fRunLoader(NULL),
fRawReader(NULL),
+ fParentRawReader(NULL),
fVertexer(NULL),
fDiamondProfile(NULL),
+ fDiamondProfileTPC(NULL),
+ fMeanVertexConstraint(kTRUE),
- fGRPList(NULL),
+ fGRPData(NULL),
fAlignObjArray(NULL),
fCDBUri(),
fSpecCDBUri(),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
- fRunQA(kTRUE)
-
+ fRunQA(kTRUE),
+ fRunGlobalQA(kTRUE),
+ fInLoopQA(kFALSE),
+ fSameQACycle(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
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
-// fQADataMaker[iDet] = NULL;
-// fQACycles[iDet] = 999999;
+ fQADataMaker[iDet] = NULL;
+ fQACycles[iDet] = 999999;
}
+ fQADataMaker[fgkNDetectors]=NULL; //Global QA
AliPID pid;
}
fUniformField(rec.fUniformField),
fRunVertexFinder(rec.fRunVertexFinder),
+ fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
fRunMuonTracking(rec.fRunMuonTracking),
fRunV0Finder(rec.fRunV0Finder),
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),
+ fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
+ fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
- fSpecCDBUri(),
- fRunQA(kTRUE)
+ fRunQA(rec.fRunQA),
+ fRunGlobalQA(rec.fRunGlobalQA),
+ fInLoopQA(rec.fInLoopQA),
+ fSameQACycle(rec.fSameQACycle),
+ 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
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
-// fQADataMaker[iDet] = NULL;
-// fQACycles[iDet] = rec.fQACycles[iDet];
+ 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());
}
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)
+{
+ // In case the input string starts with 'mem://', we run in an online mode
+ // and AliRawReaderDateOnline object is created. In all other cases a raw-data
+ // file is assumed. One can give as an input:
+ // mem://: - events taken from DAQ monitoring libs online
+ // or
+ // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
+ fInput = input;
+}
+
//_____________________________________________________________________________
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;
+
+ Bool_t runAliEVE = kFALSE;
+ if (strcmp(gProgName,"alieve") == 0) runAliEVE = kTRUE;
+
+ if (runAliEVE) {
+ TString macroStr;
+ macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
+ AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
+ if (gROOT->LoadMacro(macroStr.Data()) != 0)
+ runAliEVE = kFALSE;
+ else
+ gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online()\");gEve->AddEvent(gAliEveEvent);};");
+ }
- // 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 (runAliEVE) {
+ AliInfo("Running AliEVE...");
+ gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
+ gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();");
+ gSystem->Run();
+ }
}
+
+ if (!FinishRun()) return kFALSE;
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::InitRun(const char* input)
+{
+ // 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("");
+
+ // Overwrite the previous setting
+ if (input) fInput = input;
+
+ // set the input in case of raw data
+ fRawReader = AliRawReader::Create(fInput.Data());
+ if (!fRawReader)
+ 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;
if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
AliSysInfo::AddStamp("LoadGeom");
- //QA
+ //QA
AliQADataMakerSteer qas ;
- if ( fRunQA && fRawReader)
- qas.Run("ALL", fRawReader) ;
-
- // checking the QA of previous steps
- CheckQA() ;
+ if (fRunQA && fRawReader) {
+ qas.Run(fRunLocalReconstruction, fRawReader) ;
+ fSameQACycle = kTRUE ;
+ }
+ // 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()) {
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);
}
-
// Get the GRP CDB entry
AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
- if(entryGRP) {
- fGRPList = dynamic_cast<TList*> (entryGRP->GetObject());
- } else {
+ if (entryGRP)
+ fGRPData = dynamic_cast<TMap*> (entryGRP->GetObject());
+
+ if (!fGRPData)
AliError("No GRP entry found in OCDB!");
- }
// Get the diamond profile from OCDB
AliCDBEntry* entry = AliCDBManager::Instance()
AliError("No diamond profile found in OCDB!");
}
- AliVertexerTracks tVertexer(AliTracker::GetBz());
- if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
+ entry = 0;
+ entry = AliCDBManager::Instance()
+ ->Get("GRP/Calib/MeanVertexTPC");
+
+ if(entry) {
+ fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (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, fSameQACycle);
+ 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, fSameQACycle);
+ qadm->StartOfCycle(AliQA::kESDS, "same");
+ }
+ }
+ if (!fInLoopQA)
+ fSameQACycle = kTRUE;
+ }
+
+ //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) {
+ fhltesd->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, fSameQACycle);
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ }
+ if (fRunGlobalQA) {
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
+ qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
+ 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 single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
- if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ TString detectors=fRunLocalReconstruction;
+ // run HLT event reconstruction first
+ // ;-( IsSelected changes the string
+ if (IsSelected("HLT", detectors) &&
+ !RunLocalEventReconstruction("HLT")) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+ }
+ detectors=fRunLocalReconstruction;
+ detectors.ReplaceAll("HLT", "");
+ if (!RunLocalEventReconstruction(detectors)) {
+ 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 (fCheckPointLevel > 0) WriteESD(esd, "vertex");
- }
- }
-
- // HLT tracking
- if (!fRunTracking.IsNull()) {
- if (fRunHLTTracking) {
- hltesd->SetVertex(esd->GetVertex());
- if (!RunHLTTracking(hltesd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (!ReadESD(fesd, "vertex")) {
+ if (!RunVertexFinder(fesd)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
+ if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
}
}
// 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;}
+ TString detectors=fFillESD;
+ // run HLT first and on hltesd
+ // ;-( IsSelected changes the string
+ if (IsSelected("HLT", detectors) &&
+ !FillESD(fhltesd, "HLT")) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+ }
+ detectors=fFillESD;
+ detectors.ReplaceAll("HLT", "");
+ if (!FillESD(fesd, detectors)) {
+ if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
}
}
-// if (!fFillESD.IsNull())
-// 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 already 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; itrack<ntracks; itrack++){
+ const Double_t kMaxStep = 5; //max step over the material
+ Bool_t ok;
+
+ AliESDtrack *track = fesd->GetTrack(itrack);
+ if (!track) continue;
+
+ AliExternalTrackParam *tpcTrack =
+ (AliExternalTrackParam *)track->GetTPCInnerParam();
+ ok = kFALSE;
+ if (tpcTrack)
+ ok = AliTracker::
+ PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
+
+
+
+ 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);
+ }
+ }
- //Try to improve the reconstructed primary vertex position using the tracks
- AliESDVertex *pvtx=0;
- Bool_t dovertex=kTRUE;
- TObject* obj = fOptions.FindObject("ITS");
+ //
+ // 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; i<ntracks; i++) {
+ AliESDtrack *t = fesd->GetTrack(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; i<nsel; i++) {
+ AliExternalTrackParam *t =
+ (AliExternalTrackParam *)trkArray.UncheckedAt(i);
+ t->PropagateToDCA(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 (fRunQA) {
+ 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)
-// 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();
-// }
- tree->GetUserInfo()->Add(esd);
- hlttree->GetUserInfo()->Add(hltesd);
+ // 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::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();
AliCDBId* id=0;
while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
- cdbListCopy->Add(id->Clone());
+ 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);
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
if (fWriteAOD) {
- AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
- aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
- }
-
- //QA
- if ( fRunQA ) {
- qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS) ;
-// qas.Reset() ;
- qas.Run(fRunTracking.Data(), AliQA::kESDS) ;
+ AliWarning("AOD tag creation not supported anymore during reconstruction.");
+ }
+
+ //Finish QA and end of cycle for out-of-loop QA
+ if (!fInLoopQA) {
+ if (fRunQA) {
+ AliQADataMakerSteer qas;
+ qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
+ //qas.Reset() ;
+ qas.Run(fRunTracking.Data(), AliQA::kESDS, fSameQACycle);
+ 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;
Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
{
// run the local reconstruction
+
static Int_t eventNr=0;
AliCodeTimerAuto("")
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
AliLoader* loader = fLoader[iDet];
+ // Matthias April 2008: temporary fix to run HLT reconstruction
+ // although the HLT loader is missing
+ if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
+ if (fRawReader) {
+ reconstructor->Reconstruct(fRawReader, NULL);
+ } else {
+ TTree* dummy=NULL;
+ reconstructor->Reconstruct(dummy, NULL);
+ }
+ continue;
+ }
if (!loader) {
AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
continue;
}
-
// conversion of digits
if (fRawReader && reconstructor->HasDigitConversion()) {
AliInfo(Form("converting raw data digits into root objects for %s",
loader->WriteDigits("OVERWRITE");
loader->UnloadDigits();
}
-
// local reconstruction
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
loader->UnloadDigits();
}
-// AliQADataMaker * qadm = GetQADataMaker(iDet);
-// if (qadm) {
-// AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-// AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-//
-// if (qadm->IsCycleDone() ) {
-// qadm->EndOfCycle(AliQA::kRECPOINTS) ;
-// qadm->EndOfCycle(AliQA::kESDS) ;
-// qadm->StartOfCycle(AliQA::kRECPOINTS) ;
-// qadm->StartOfCycle(AliQA::kESDS, "same") ;
-// }
-// qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
-// AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-// }
+ // 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]));
+
+ qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
+
+ //AliCodeTimerStop
+ //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
+ }
+ }
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
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);
return kFALSE;
}
- // create Tracks
- fLoader[iDet]->LoadTracks("update");
- fLoader[iDet]->CleanTracks();
- fLoader[iDet]->MakeTracksContainer();
-
// read RecPoints
fLoader[iDet]->LoadRecPoints("read");
+
tracker->LoadClusters(fLoader[iDet]->TreeR());
Int_t rv = tracker->Clusters2Tracks(esd);
- fLoader[iDet]->UnloadRecPoints();
-
if ( rv )
{
AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
return kFALSE;
}
- tracker->UnloadClusters();
-
fLoader[iDet]->UnloadRecPoints();
- fLoader[iDet]->WriteTracks("OVERWRITE");
- fLoader[iDet]->UnloadTracks();
-
+ tracker->UnloadClusters();
+
delete tracker;
return kTRUE;
}
// pass 2: ALL backwards
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
}
// 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
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]));
}
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; itrack<ntracks; itrack++){
- const Double_t kRadius = 3; // beam pipe radius
- const Double_t kMaxStep = 5; // max step
- const Double_t kMaxD = 123456; // max distance to prim vertex
- Double_t fieldZ = AliTracker::GetBz(); //
- AliESDtrack * track = esd->GetTrack(itrack);
- if (!track) continue;
- if (track->IsOn(AliESDtrack::kITSrefit)) continue;
- 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;
}
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;
}
AliInfo("Filling trigger information into the ESD");
+ AliCentralTrigger *aCTP = NULL;
+
if (fRawReader) {
AliCTPRawStream input(fRawReader);
if (!input.Next()) {
}
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!");
+ delete aCTP;
+ 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());
}
}
}
+ // 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!");
+ if (fRawReader) delete aCTP;
+ return kFALSE;
+ }
+
+ const TObjArray& classesArray = config->GetClasses();
+ Int_t nclasses = classesArray.GetEntriesFast();
+ for( Int_t j=0; j<nclasses; j++ ) {
+ AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
+ Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
+ esd->SetTriggerClass(trclass->GetName(),trindex);
+ }
+
+ if (fRawReader) delete aCTP;
return kTRUE;
}
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;
TPluginManager* pluginManager = gROOT->GetPluginManager();
TString detName = fgkDetectorName[iDet];
TString recName = "Ali" + detName + "Reconstructor";
- if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
+
+ if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
AliReconstructor* reconstructor = NULL;
// first check if a plugin is defined for the reconstructor
}
delete fVertexer;
fVertexer = NULL;
+
+ if (ftVertexer) delete ftVertexer;
+ ftVertexer = NULL;
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
delete fDiamondProfile;
fDiamondProfile = NULL;
+ delete fDiamondProfileTPC;
+ fDiamondProfileTPC = NULL;
+ delete fGRPData;
+ fGRPData = NULL;
}
- delete fGRPList;
- fGRPList = NULL;
delete fRunLoader;
fRunLoader = NULL;
delete fRawReader;
fRawReader = NULL;
+ if (fParentRawReader) delete fParentRawReader;
+ fParentRawReader=NULL;
if (file) {
file->Close();
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() );
- 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;
-
- // Calo Clusters
- TArrayS EMCCellNumber(15000);
- TArrayD EMCCellAmplitude(15000);
- Int_t nEMCCells = 0;
- const Float_t fEMCAmpScale = 1./500;
-
- 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;
- }
- else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALPseudoCluster) {
- // Collect raw tower info
- for (Int_t iDig = 0; iDig < cluster->GetNumberOfDigits(); iDig++) {
- EMCCellNumber[nEMCCells] = cluster->GetDigitIndex()->At(iDig);
- EMCCellAmplitude[nEMCCells] = fEMCAmpScale*cluster->GetDigitAmplitude()->At(iDig);
- nEMCCells++;
- }
- // don't write cluster data (it's just a pseudo cluster, holding the tower information)
- continue;
- }
-
- 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 EMC cell info
- AliAODCaloCells &EMCCells = *(aod->GetCaloCells());
- EMCCells.CreateContainer(nEMCCells);
- EMCCells.SetType(AliAODCaloCells::kEMCAL);
- for (Int_t iCell = 0; iCell < nEMCCells; iCell++) {
- EMCCells.SetCell(iCell,EMCCellNumber[iCell],EMCCellAmplitude[iCell]);
- }
- EMCCells.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
AliTrackPoint p;
Int_t isp = 0;
Int_t isp2 = 0;
- while (isp < nspdet) {
+ while (isp2 < nspdet) {
Bool_t isvalid;
- if(IsSelected(fgkDetectorName[iDet],fUseTrackingErrorsForAlignment)) {
- isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
+ TString dets = fgkDetectorName[iDet];
+ if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
+ fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
+ fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
+ fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
+ isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
} else {
isvalid = tracker->GetTrackPoint(idx[isp2],p);
}
}
+//_____________________________________________________________________________
+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 + "QADataMakerRec";
+ if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT"))
+ return NULL;
+
+ // first check if a plugin is defined for the quality assurance data maker
+ 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("AliQADataMakerRec", detName,
+ qadmName, detName + "qadm", qadmName + "()");
+ } else {
+ pluginManager->AddHandler("AliQADataMakerRec", detName,
+ qadmName, detName, qadmName + "()");
+ }
+ pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
+ }
+ if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
+ qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
+ }
+
+ fQADataMaker[iDet] = qadm;
+
+ return qadm;
+}
//_____________________________________________________________________________
-//AliQADataMaker * AliReconstruction::GetQADataMaker(Int_t iDet)
-//{
-// get the quality assurance data maker object and the loader for a detector
-//
-// if (fQADataMaker[iDet])
-// return fQADataMaker[iDet];
-//
-// // load the QA data maker object
-// TPluginManager* pluginManager = gROOT->GetPluginManager();
-// TString detName = fgkDetectorName[iDet];
-// TString qadmName = "Ali" + detName + "QADataMaker";
-// if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
-// return NULL;
-//
-// AliQADataMaker * qadm = NULL;
-// // first check if a plugin is defined for the quality assurance data maker
-// TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
-// // if not, add a plugin for it
-// if (!pluginHandler) {
-// AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
-// TString libs = gSystem->GetLibraries();
-// if (libs.Contains("lib" + detName + "base.so") ||
-// (gSystem->Load("lib" + detName + "base.so") >= 0)) {
-// pluginManager->AddHandler("AliQADataMaker", detName,
-// qadmName, detName + "qadm", qadmName + "()");
-// } else {
-// pluginManager->AddHandler("AliQADataMaker", detName,
-// qadmName, detName, qadmName + "()");
-// }
-// pluginHandler = pluginManager->FindHandler("AliQADataMaker", detName);
-// }
-// if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
-// qadm = (AliQADataMaker *) pluginHandler->ExecPlugin(0);
-// }
-// if (qadm) {
-// AliInfo(Form("Initializing quality assurance data maker for %s", fgkDetectorName[iDet]));
-// qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), GetQACycles(fgkDetectorName[iDet]));
-// qadm->StartOfCycle(AliQA::kRECPOINTS);
-// qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
-// qadm->StartOfCycle(AliQA::kESDS, "same") ;
-// fQADataMaker[iDet] = qadm;
-// }
-//
-// return qadm;
-//}
-//
-//_____________________________________________________________________________
-//Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
-//{
-// // run the Quality Assurance data producer
-//
-// AliCodeTimerAuto("")
-// TString detStr = detectors;
-// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-// if (!IsSelected(fgkDetectorName[iDet], detStr))
-// continue;
-// AliQADataMaker * qadm = GetQADataMaker(iDet);
-// if (!qadm)
-// continue;
-// AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-// AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-//
-// qadm->Exec(AliQA::kESDS, esd) ;
-// qadm->Increment() ;
-//
-// AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-// }
-// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-// AliError(Form("the following detectors were not found: %s",
-// detStr.Data()));
-// if (fStopOnError)
-// return kFALSE;
-// }
-//
-// return kTRUE;
-//
-//}
-//
+Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
+{
+ // run the Quality Assurance data producer
+
+ AliCodeTimerAuto("")
+ TString detStr = detectors;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr))
+ continue;
+ AliQADataMakerRec * qadm = GetQADataMaker(iDet);
+ if (!qadm)
+ continue;
+ AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+
+ qadm->Exec(AliQA::kESDS, esd) ;
+ qadm->Increment() ;
+
+ AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
+ }
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ AliError(Form("the following detectors were not found: %s",
+ detStr.Data()));
+ if (fStopOnError)
+ return kFALSE;
+ }
+
+ return kTRUE;
+
+}
//_____________________________________________________________________________
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)) ||
}
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;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff