// 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 "AliAlignObj.h"
#include "AliCentralTrigger.h"
+#include "AliTriggerConfiguration.h"
+#include "AliTriggerClass.h"
#include "AliCTPRawStream.h"
#include "AliAODEvent.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),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fRunQA(kTRUE),
- fQAInLoop(kFALSE)
+ fRunGlobalQA(kFALSE),
+ fInLoopQA(kFALSE),
+ fRunPlaneEff(kFALSE)
{
// create reconstruction object with default parameters
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),
fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
- fRunQA(kTRUE),
- fQAInLoop(kFALSE)
-
+ fRunQA(rec.fRunQA),
+ fRunGlobalQA(rec.fRunGlobalQA),
+ fInLoopQA(rec.fInLoopQA),
+ fRunPlaneEff(rec.fRunPlaneEff)
{
// copy constructor
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());
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::Run(const char* input)
+Bool_t AliReconstruction::Run(const char* input, Bool_t IsOnline)
{
// run the reconstruction
AliCodeTimerAuto("")
// 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);
+ if (!IsOnline) {
+ if (!input) input = fInput.Data();
+ TString fileName(input);
+ if (fileName.EndsWith("/")) {
+ fRawReader = new AliRawReaderFile(fileName);
+ } else if (fileName.EndsWith(".root")) {
+ fRawReader = new AliRawReaderRoot(fileName);
+ } else if (!fileName.IsNull()) {
+ fRawReader = new AliRawReaderDate(fileName);
+ }
+ }
+ else {
+ if (!input) {
+ AliError("Null pointer to the event structure!");
+ return kFALSE;
+ }
+ fRawReader = new AliRawReaderDate((void *)input);
}
+
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;
//QA
AliQADataMakerSteer qas ;
- if ( fRunQA && fRawReader)
- qas.Run("ALL", 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()) {
AliVertexerTracks tVertexer(AliTracker::GetBz());
if(fDiamondProfile && fMeanVertexConstraint) tVertexer.SetVtxStart(fDiamondProfile);
- // loop over events
-
if (fRawReader) fRawReader->RewindEvents();
- TString detStr(fFillESD) ;
ProcInfo_t ProcInfo;
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+
+ //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(fgkNDetectors);
+ AliInfo(Form("Initializing the global QA data maker"));
+ TObjArray *arr=
+ qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
+ AliTracker::SetResidualsArray(arr);
+ qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
+ if (!fInLoopQA) {
+ qadm->StartOfCycle(AliQA::kRECPOINTS);
+ qadm->StartOfCycle(AliQA::kESDS,"same");
+ }
+ }
+ }
+
+ //Initialize the Plane Efficiency framework
+ if (fRunPlaneEff && !InitPlaneEff()) {
+ if(fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ }
+
+ //******* The loop over events
for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
if (fRawReader) fRawReader->NextEvent();
if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
}
AliInfo(Form("processing event %d", iEvent));
+
+ //Start of cycle for the in-loop QA
+ if (fRunQA && fInLoopQA) {
+ 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);
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ }
+ if (fRunGlobalQA) {
+ AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
+ qadm->StartOfCycle(AliQA::kRECPOINTS);
+ qadm->StartOfCycle(AliQA::kESDS,"same");
+ }
+ }
+
fRunLoader->GetEvent(iEvent);
char aFileName[256];
fRunLoader->GetHeader()->GetEventNrInRun());
if (!gSystem->AccessPathName(aFileName)) continue;
- // local reconstruction
+ // local signle event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
}
}
-
esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
// HLT tracking
if (!fRunTracking.IsNull()) {
if (fRunHLTTracking) {
- hltesd->SetVertex(esd->GetVertex());
+ hltesd->SetPrimaryVertexSPD(esd->GetVertex());
if (!RunHLTTracking(hltesd)) {
if (fStopOnError) {CleanUp(file, fileOld); 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);}
file->cd();
- //Try to improve the reconstructed primary vertex position using the tracks
- AliESDVertex *pvtx=0;
- Bool_t dovertex=kTRUE;
- TObject* obj = fOptions.FindObject("ITS");
+ //
+ // Propagate track to the beam pipe (if not laready done by ITS)
+ //
+ const Int_t ntracks = esd->GetNumberOfTracks();
+ const Double_t kBz = esd->GetMagneticField();
+ const 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 = esd->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(esd->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
+ AliESDVertex *pvtx=tVertexer.FindPrimaryVertex(esd);
+ if (pvtx) {
+ if (pvtx->GetStatus()) {
+ esd->SetPrimaryVertex(pvtx);
+ for (Int_t i=0; i<ntracks; i++) {
+ AliESDtrack *t = esd->GetTrack(i);
+ t->RelateToVertex(pvtx, kBz, kRadius);
+ }
+ }
+ }
+
+ // TPC-only primary vertex
+ pvtx=tVertexer.FindPrimaryVertex(&trkArray,selectedIdx);
+ if (pvtx) {
+ if (pvtx->GetStatus()) {
+ esd->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);
+ delete[] selectedIdx;
+
if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
- if (pvtx)
- if (pvtx->GetStatus()) {
- // Store the improved primary vertex
- esd->SetPrimaryVertex(pvtx);
- // Propagate the tracks to the DCA to the improved primary vertex
- Double_t somethingbig = 777.;
- Double_t bz = esd->GetMagneticField();
- Int_t nt=esd->GetNumberOfTracks();
- while (nt--) {
- AliESDtrack *t = esd->GetTrack(nt);
- t->RelateToVertex(pvtx, bz, somethingbig);
- }
- }
if (fRunV0Finder) {
// V0 finding
// write ESD
if (fCleanESD) CleanESD(esd);
+
+ if (fRunQA && fRunGlobalQA) {
+ AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
+ if (qadm) qadm->Exec(AliQA::kESDS, esd);
+ }
+
if (fWriteESDfriend) {
esdf->~AliESDfriend();
new (esdf) AliESDfriend(); // Reset...
esdf->~AliESDfriend();
new (esdf) AliESDfriend(); // Reset...
}
- // esdf->Reset();
- // delete esdf; esdf = 0;
- // ESD QA
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 (fRunQA && fInLoopQA) {
+ RunQA(fFillESD.Data(), esd);
+ 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(fgkNDetectors);
+ if (qadm) {
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
+ }
+ }
+ }
+ //******** End of the loop over events
+
+
tree->GetUserInfo()->Add(esd);
hlttree->GetUserInfo()->Add(hltesd);
file->cd();
+
if (fWriteESDfriend)
tree->SetBranchStatus("ESDfriend*",0);
// we want to have only one tree version number
tree->Write(tree->GetName(),TObject::kOverwrite);
hlttree->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);
+ if (fWriteAOD) {
+ TFile *esdFile = TFile::Open("AliESDs.root", "READONLY");
+ TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
+ ESDFile2AODFile(esdFile, aodFile);
+ aodFile->Close();
+ esdFile->Close();
+ }
+
// 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();
aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
}
- //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 (fRunQA && !fInLoopQA) {
+ qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS);
+ //qas.Reset() ;
+ qas.Run(fRunTracking.Data(), AliQA::kESDS);
+
+ if (fRunGlobalQA) {
+ AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
+ if (qadm) {
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
+ }
}
// Cleanup of CDB manager: cache and active storages!
//_____________________________________________________________________________
-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("")
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();
}
- // 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]));
+
+ qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
+
+ //AliCodeTimerStop
+ //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
+ }
+ }
- loader->WriteRecPoints("OVERWRITE");
+ loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
}
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);
}
// pass 2: ALL backwards
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
WriteAlignmentData(esd);
// pass 3: TRD + TPC + ITS refit inwards
+
+ if (fRunQA && fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
+
for (Int_t iDet = 2; iDet >= 0; iDet--) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
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);
- }
+
+ if (fRunQA && 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!");
+ 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!");
+ 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);
+ }
+
return kTRUE;
}
fRunLoader = NULL;
delete fRawReader;
fRawReader = NULL;
+ if (fParentRawReader) delete fParentRawReader;
+ fParentRawReader=NULL;
if (file) {
file->Close();
caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
// end of loop on calo clusters
- // fill PHOS cell info
-
- 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));
+ // 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();
}
- aodEMcells.Sort();
// fill PHOS cell info
-
- 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));
+ 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();
}
- aodPHcells.Sort();
// tracklets
AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
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);
}
}
//_____________________________________________________________________________
-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;
}
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]));
}
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]) ret=fTracker[iDet]->GetPlaneEff()->WriteIntoCDB();
+ }
+ 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;
+}