// 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 <TArrayF.h>
#include <TFile.h>
+#include <TList.h>
#include <TSystem.h>
#include <TROOT.h>
#include <TPluginManager.h>
#include <TGeoManager.h>
#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 "AliPID.h"
#include "AliESDpid.h"
#include "AliESDtrack.h"
+#include "AliESDPmdTrack.h"
#include "AliESDTagCreator.h"
#include "AliAODTagCreator.h"
#include "AliGeomManager.h"
#include "AliTrackPointArray.h"
#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
#include "AliCDBEntry.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 "AliAODCluster.h"
+#include "AliAODv0.h"
+#include "AliAODJet.h"
+#include "AliAODCaloCells.h"
+#include "AliAODCaloCluster.h"
+#include "AliAODPmdCluster.h"
+#include "AliAODFmdCluster.h"
+#include "AliAODTracklets.h"
+
+#include "AliQADataMakerRec.h"
+#include "AliGlobalQADataMaker.h"
+#include "AliQA.h"
+#include "AliQADataMakerSteer.h"
+
+#include "AliPlaneEff.h"
+
+#include "AliSysInfo.h" // memory snapshots
+#include "AliRawHLTManager.h"
-#include "AliQualAssDataMaker.h"
ClassImp(AliReconstruction)
const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename, const char* cdbUri,
+AliReconstruction::AliReconstruction(const char* gAliceFilename,
const char* name, const char* title) :
TNamed(name, title),
fUniformField(kTRUE),
fRunVertexFinder(kTRUE),
+ fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
fRunMuonTracking(kFALSE),
fRunV0Finder(kTRUE),
fRunCascadeFinder(kTRUE),
fStopOnError(kFALSE),
fWriteAlignmentData(kFALSE),
- fCleanESD(kTRUE),
fWriteESDfriend(kFALSE),
fWriteAOD(kFALSE),
fFillTriggerESD(kTRUE),
+ fCleanESD(kTRUE),
+ fV0DCAmax(3.),
+ fV0CsPmin(0.),
+ fDmax(50.),
+ fZmax(50.),
+
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
fInput(""),
fEquipIdMap(""),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
fESDPar(""),
+ fUseHLTData(),
fRunLoader(NULL),
fRawReader(NULL),
+ fParentRawReader(NULL),
fVertexer(NULL),
fDiamondProfile(NULL),
+ fDiamondProfileTPC(NULL),
+ fMeanVertexConstraint(kTRUE),
+
+ fGRPList(NULL),
fAlignObjArray(NULL),
- fCDBUri(cdbUri),
- fRemoteCDBUri(""),
- fSpecCDBUri()
+ fCDBUri(),
+ fSpecCDBUri(),
+ fInitCDBCalled(kFALSE),
+ fSetRunNumberFromDataCalled(kFALSE),
+ fRunQA(kTRUE),
+ fRunGlobalQA(kTRUE),
+ fInLoopQA(kFALSE),
+
+ fRunPlaneEff(kFALSE)
{
// create reconstruction object with default parameters
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQualAssDataMaker[iDet] = NULL;
+ 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),
fRunCascadeFinder(rec.fRunCascadeFinder),
fStopOnError(rec.fStopOnError),
fWriteAlignmentData(rec.fWriteAlignmentData),
- fCleanESD(rec.fCleanESD),
fWriteESDfriend(rec.fWriteESDfriend),
fWriteAOD(rec.fWriteAOD),
fFillTriggerESD(rec.fFillTriggerESD),
+ fCleanESD(rec.fCleanESD),
+ fV0DCAmax(rec.fV0DCAmax),
+ fV0CsPmin(rec.fV0CsPmin),
+ fDmax(rec.fDmax),
+ fZmax(rec.fZmax),
+
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
+ fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
fInput(rec.fInput),
fEquipIdMap(rec.fEquipIdMap),
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),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
- fRemoteCDBUri(rec.fRemoteCDBUri),
- fSpecCDBUri()
+ fSpecCDBUri(),
+ fInitCDBCalled(rec.fInitCDBCalled),
+ fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
+ fRunQA(rec.fRunQA),
+ fRunGlobalQA(rec.fRunGlobalQA),
+ fInLoopQA(rec.fInLoopQA),
+ fRunPlaneEff(rec.fRunPlaneEff)
{
// copy constructor
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQualAssDataMaker[iDet] = NULL;
+ 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());
}
}
//_____________________________________________________________________________
-void AliReconstruction::InitCDBStorage()
+void AliReconstruction::InitCDB()
{
// activate a default CDB storage
// First check if we have any CDB storage set, because it is used
// to retrieve the calibration and alignment constants
+ if (fInitCDBCalled) return;
+ fInitCDBCalled = kTRUE;
+
AliCDBManager* man = AliCDBManager::Instance();
if (man->IsDefaultStorageSet())
{
AliWarning("Default CDB storage has been already set !");
AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- fCDBUri = "";
+ fCDBUri = man->GetDefaultStorage()->GetURI();
}
else {
- AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- AliDebug(2, Form("Default CDB storage is set to: %s",fCDBUri.Data()));
- AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ if (fCDBUri.Length() > 0)
+ {
+ AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ } else {
+ fCDBUri="local://$ALICE_ROOT";
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default CDB storage not yet set !!!!");
+ AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
man->SetDefaultStorage(fCDBUri);
}
- // Remote storage (the Grid storage) is used if it is activated
- // and if the object is not found in the default storage
- if (man->IsRemoteStorageSet())
- {
- AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- AliWarning("Remote CDB storage has been already set !");
- AliWarning(Form("Ignoring the remote storage declared in AliReconstruction: %s",fRemoteCDBUri.Data()));
- AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- fRemoteCDBUri = "";
- }
- else {
- AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- AliDebug(2, Form("Remote CDB storage is set to: %s",fRemoteCDBUri.Data()));
- AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- man->SetRemoteStorage(fRemoteCDBUri);
- }
-
// Now activate the detector specific CDB storage locations
for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
TObject* obj = fSpecCDBUri[i];
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
}
- man->Print();
+
}
//_____________________________________________________________________________
}
-//_____________________________________________________________________________
-void AliReconstruction::SetRemoteStorage(const char* uri) {
-// Store the desired remote CDB storage location
-// Activate it later within the Run() method
-// Remote storage (the Grid storage) is used if it is activated
-// and if the object is not found in the default storage
-
- fRemoteCDBUri = uri;
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
}
-
-
-
//_____________________________________________________________________________
-Bool_t AliReconstruction::SetRunNumber()
+Bool_t AliReconstruction::SetRunNumberFromData()
{
// The method is called in Run() in order
// to set a correct run number.
// In case of raw data reconstruction the
// run number is taken from the raw data header
- if(AliCDBManager::Instance()->GetRun() < 0) {
- if (!fRunLoader) {
+ if (fSetRunNumberFromDataCalled) return kTRUE;
+ fSetRunNumberFromDataCalled = kTRUE;
+
+ AliCDBManager* man = AliCDBManager::Instance();
+
+ if(man->GetRun() > 0) {
+ AliWarning("Run number is taken from event header! Ignoring settings in AliCDBManager!");
+ }
+
+ if (!fRunLoader) {
AliError("No run loader is found !");
return kFALSE;
}
// read run number from gAlice
if(fRunLoader->GetAliRun())
- AliCDBManager::Instance()->SetRun(fRunLoader->GetAliRun()->GetRunNumber());
+ AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
else {
if(fRawReader) {
if(fRawReader->NextEvent()) {
AliError("Neither gAlice nor RawReader objects are found !");
return kFALSE;
}
- }
- AliInfo(Form("CDB Run number: %d",AliCDBManager::Instance()->GetRun()));
}
+
+ man->Print();
+
return kTRUE;
}
+//_____________________________________________________________________________
+void AliReconstruction::SetCDBLock() {
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+
+ AliCDBManager::Instance()->SetLock(1);
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
{
//_____________________________________________________________________________
-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;
+ AliSysInfo::AddStamp("LoadLoader");
// Initialize the CDB storage
- InitCDBStorage();
+ InitCDB();
+
+ AliSysInfo::AddStamp("LoadCDB");
// Set run number in CDBManager (if it is not already set by the user)
- if (!SetRunNumber()) if (fStopOnError) return kFALSE;
-
+ if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
+
+ // Set CDB lock: from now on it is forbidden to reset the run number
+ // or the default storage or to activate any further storage!
+ SetCDBLock();
+
// Import ideal TGeo geometry and apply misalignment
if (!gGeoManager) {
TString geom(gSystem->DirName(fGAliceFileName));
if (!gGeoManager) if (fStopOnError) return kFALSE;
}
- AliCDBManager* man = AliCDBManager::Instance();
if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
-
+ AliSysInfo::AddStamp("LoadGeom");
+
+ //QA
+ Int_t sameQACycle = kFALSE ;
+ AliQADataMakerSteer qas ;
+ if (fRunQA && fRawReader) {
+ qas.Run(fRunLocalReconstruction, fRawReader) ;
+ sameQACycle = 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()) {
return kFALSE;
}
}
+ AliSysInfo::AddStamp("Vertexer");
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
return kFALSE;
}
}
+ AliSysInfo::AddStamp("LoadTrackers");
// get the possibly already existing ESD file and tree
AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
}
+ // Get the GRP CDB entry
+ AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+
+ if(entryGRP) {
+ fGRPList = dynamic_cast<TList*> (entryGRP->GetObject());
+ } else {
+ AliError("No GRP entry found in OCDB!");
+ }
+
// Get the diamond profile from OCDB
AliCDBEntry* entry = AliCDBManager::Instance()
->Get("GRP/Calib/MeanVertex");
AliError("No diamond profile found in OCDB!");
}
+ 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!");
+ }
+
AliVertexerTracks tVertexer(AliTracker::GetBz());
- if(fDiamondProfile) tVertexer.SetVtxStart(fDiamondProfile);
+ if(fDiamondProfile && fMeanVertexConstraint) tVertexer.SetVtxStart(fDiamondProfile);
- // loop over events
-
if (fRawReader) fRawReader->RewindEvents();
- TString detStr(fFillESD) ;
-// initialises quality assurance for ESDs
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
- if (!qadm)
- continue;
- qadm->Init(AliQualAss::kESDS) ;
- }
-
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(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, sameQACycle);
+ 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))) {
if (treeOld) {
esd->ReadFromTree(treeOld);
treeOld->GetEntry(iEvent);
+ tree->Fill();
}
- tree->Fill();
if (hlttreeOld) {
esd->ReadFromTree(hlttreeOld);
hlttreeOld->GetEntry(iEvent);
+ hlttree->Fill();
}
- hlttree->Fill();
continue;
}
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, sameQACycle);
+ qadm->StartOfCycle(AliQA::kESDS, "same") ;
+ }
+ }
+ if (fRunGlobalQA) {
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
+ qadm->StartOfCycle(AliQA::kRECPOINTS, sameQACycle);
+ 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())
- RunQualAss(fFillESD.Data(), esd);
-
// fill Event header information from the RawEventHeader
if (fRawReader){FillRawEventHeaderESD(esd);}
}
}
- //Try to improve the reconstructed primary vertex position using the tracks
- AliESDVertex *pvtx=0;
- Bool_t dovertex=kTRUE;
- TObject* obj = fOptions.FindObject("ITS");
+ file->cd();
+
+ //
+ // Propagate track to the beam pipe (if not laready done by ITS)
+ //
+ const Int_t ntracks = esd->GetNumberOfTracks();
+ const Double_t kBz = esd->GetMagneticField();
+ const 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
+ tVertexer.SetITSrefitRequired();
+ if(fDiamondProfile && fMeanVertexConstraint) {
+ tVertexer.SetVtxStart(fDiamondProfile);
+ } else {
+ tVertexer.SetConstraintOff();
+ }
+ 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
+ tVertexer.SetITSrefitNotRequired();
+ if(fDiamondProfileTPC && fMeanVertexConstraint) {
+ tVertexer.SetVtxStart(fDiamondProfileTPC);
+ } else {
+ tVertexer.SetConstraintOff();
+ }
+ 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 (fRunGlobalQA) {
+ AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
+ 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)
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
- if (!qadm)
- continue;
- qadm->Finish(AliQualAss::kESDS) ;
- }
+
+ // End of cycle for the in-loop QA
+ if (fInLoopQA) {
+ if (fRunQA) {
+ 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(AliQA::kGLOBAL);
+ 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);
-
+
+ const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
+ const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
+
+ TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
+ cdbMapCopy->SetOwner(1);
+ cdbMapCopy->SetName("cdbMap");
+ TIter iter(cdbMap->GetTable());
+
+ TPair* pair = 0;
+ while((pair = dynamic_cast<TPair*> (iter.Next()))){
+ TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
+ TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
+ cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
+ }
+
+ TList *cdbListCopy = new TList();
+ cdbListCopy->SetOwner(1);
+ cdbListCopy->SetName("cdbList");
+
+ TIter iter2(cdbList);
+
+ AliCDBId* id=0;
+ while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
+ cdbListCopy->Add(new TObjString(id->ToString().Data()));
+ }
+
+ tree->GetUserInfo()->Add(cdbMapCopy);
+ tree->GetUserInfo()->Add(cdbListCopy);
if(fESDPar.Contains("ESD.par")){
file->cd();
+
if (fWriteESDfriend)
tree->SetBranchStatus("ESDfriend*",0);
- tree->Write();
+ // we want to have only one tree version number
+ tree->Write(tree->GetName(),TObject::kOverwrite);
hlttree->Write();
+// 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(file, aodFile);
+ ESDFile2AODFile(esdFile, aodFile);
aodFile->Close();
+ esdFile->Close();
}
- gROOT->cd();
- CleanUp(file, fileOld);
-
// Create tags for the events in the ESD tree (the ESD tree is always present)
// In case of empty events the tags will contain dummy values
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
- esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent);
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList);
if (fWriteAOD) {
AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
- aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent);
+ aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
}
+ //Finish QA and end of cycle for out-of-loop QA
+ if (!fInLoopQA) {
+ if (fRunQA) {
+ qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, sameQACycle);
+ //qas.Reset() ;
+ qas.Run(fRunTracking.Data(), AliQA::kESDS, sameQACycle);
+ }
+ 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;
AliCodeTimerAuto("")
- AliCDBManager* man = AliCDBManager::Instance();
- Bool_t origCache = man->GetCacheFlag();
+ // AliCDBManager* man = AliCDBManager::Instance();
+// Bool_t origCache = man->GetCacheFlag();
- TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliReconstructor* reconstructor = GetReconstructor(iDet);
- if (!reconstructor) continue;
- if (reconstructor->HasLocalReconstruction()) continue;
+// TString detStr = detectors;
+// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+// AliReconstructor* reconstructor = GetReconstructor(iDet);
+// if (!reconstructor) continue;
+// if (reconstructor->HasLocalReconstruction()) continue;
- AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
- AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
- man->SetCacheFlag(kTRUE);
- TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
- man->GetAll(calibPath); // entries are cached!
+// man->SetCacheFlag(kTRUE);
+// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
+// man->GetAll(calibPath); // entries are cached!
- AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
+// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
- if (fRawReader) {
- fRawReader->RewindEvents();
- reconstructor->Reconstruct(fRunLoader, fRawReader);
- } else {
- reconstructor->Reconstruct(fRunLoader);
- }
+// if (fRawReader) {
+// fRawReader->RewindEvents();
+// reconstructor->Reconstruct(fRunLoader, fRawReader);
+// } else {
+// reconstructor->Reconstruct(fRunLoader);
+// }
- AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
- // unload calibration data
- man->UnloadFromCache(calibPath);
- //man->ClearCache();
- }
+// // unload calibration data
+// man->UnloadFromCache(calibPath);
+// //man->ClearCache();
+// }
- man->SetCacheFlag(origCache);
+// man->SetCacheFlag(origCache);
- if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- AliError(Form("the following detectors were not found: %s",
- detStr.Data()));
- if (fStopOnError) return kFALSE;
- }
+// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+// AliError(Form("the following detectors were not found: %s",
+// detStr.Data()));
+// if (fStopOnError) return kFALSE;
+// }
+ eventNr++;
return kTRUE;
}
{
// run the local reconstruction
+ static Int_t eventNr=0;
AliCodeTimerAuto("")
TString detStr = detectors;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
AliLoader* loader = fLoader[iDet];
-
+ if (!loader) {
+ AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
+ continue;
+ }
// conversion of digits
if (fRawReader && reconstructor->HasDigitConversion()) {
AliInfo(Form("converting raw data digits into root objects for %s",
loader->WriteDigits("OVERWRITE");
loader->UnloadDigits();
}
-
// local reconstruction
- if (!reconstructor->HasLocalReconstruction()) continue;
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
loader->LoadRecPoints("update");
}
loader->UnloadDigits();
}
+
+ // 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();
+ AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
}
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
detStr.Data()));
if (fStopOnError) return kFALSE;
}
-
+ eventNr++;
return kTRUE;
}
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);
TString detName = fgkDetectorName[iDet];
AliDebug(1, Form("%s HLT tracking", detName.Data()));
reconstructor->SetOption(detName.Data());
- AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+ AliTracker *tracker = reconstructor->CreateTracker();
if (!tracker) {
AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
if (fStopOnError) return kFALSE;
TString detName = fgkDetectorName[iDet];
AliDebug(1, Form("%s tracking", detName.Data()));
- AliTracker *tracker = reconstructor->CreateTracker(fRunLoader);
+ AliTracker *tracker = reconstructor->CreateTracker();
if (!tracker) {
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
return kFALSE;
}
- // 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;
Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
{
// run the barrel tracking
-
+ static Int_t eventNr=0;
AliCodeTimerAuto("")
AliInfo("running tracking");
//Fill the ESD with the T0 info (will be used by the TOF)
- if (fReconstructor[11])
- GetReconstructor(11)->FillESD(fRunLoader, esd);
+ if (fReconstructor[11] && fLoader[11]) {
+ fLoader[11]->LoadRecPoints("READ");
+ TTree *treeR = fLoader[11]->TreeR();
+ GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+ }
// pass 1: TPC + ITS inwards
for (Int_t iDet = 1; iDet >= 0; iDet--) {
// load clusters
fLoader[iDet]->LoadRecPoints("read");
+ AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
TTree* tree = fLoader[iDet]->TreeR();
if (!tree) {
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
}
fTracker[iDet]->LoadClusters(tree);
-
+ AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
// run tracking
if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
}
// preliminary PID in TPC needed by the ITS tracker
if (iDet == 1) {
- GetReconstructor(1)->FillESD(fRunLoader, esd);
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
AliESDpid::MakePID(esd);
- }
+ }
+ AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
}
// pass 2: ALL backwards
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
if (iDet > 1) { // all except ITS, TPC
TTree* tree = NULL;
fLoader[iDet]->LoadRecPoints("read");
+ AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
tree = fLoader[iDet]->TreeR();
if (!tree) {
AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
return kFALSE;
}
- fTracker[iDet]->LoadClusters(tree);
+ fTracker[iDet]->LoadClusters(tree);
+ AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
}
// 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;
}
// updated PID in TPC needed by the ITS tracker -MI
if (iDet == 1) {
- GetReconstructor(1)->FillESD(fRunLoader, esd);
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
AliESDpid::MakePID(esd);
}
+ AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), 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]));
}
-
+ AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
// unload clusters
fTracker[iDet]->UnloadClusters();
+ AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
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;
}
// Remove the data which are not needed for the physics analysis.
//
- AliInfo("Cleaning the ESD...");
-
- const AliESDVertex *vertex=esd->GetVertex();
- Double_t vz=vertex->GetZv();
-
Int_t nTracks=esd->GetNumberOfTracks();
- for (Int_t i=0; i<nTracks; i++) {
- AliESDtrack *track=esd->GetTrack(i);
+ Int_t nV0s=esd->GetNumberOfV0s();
+ AliInfo
+ (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
- Float_t xy,z; track->GetImpactParameters(xy,z);
- if (TMath::Abs(xy) < 50.) continue;
- if (vertex->GetStatus())
- if (TMath::Abs(vz-z) < 5.) continue;
+ Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
+ Bool_t rc=esd->Clean(cleanPars);
- esd->RemoveTrack(i);
- }
+ nTracks=esd->GetNumberOfTracks();
+ nV0s=esd->GetNumberOfV0s();
+ AliInfo
+ (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
- return kTRUE;
+ return rc;
}
//_____________________________________________________________________________
// fill the event summary data
AliCodeTimerAuto("")
-
+ static Int_t eventNr=0;
TString detStr = detectors;
+
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
-
if (!ReadESD(esd, fgkDetectorName[iDet])) {
AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
TTree* clustersTree = NULL;
- if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+ if (fLoader[iDet]) {
fLoader[iDet]->LoadRecPoints("read");
clustersTree = fLoader[iDet]->TreeR();
if (!clustersTree) {
reconstructor->FillESD(digitsTree, clustersTree, esd);
if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
}
- if (reconstructor->HasLocalReconstruction() && fLoader[iDet]) {
+ if (fLoader[iDet]) {
fLoader[iDet]->UnloadRecPoints();
}
- if (fRawReader) {
- reconstructor->FillESD(fRunLoader, fRawReader, esd);
- } else {
- reconstructor->FillESD(fRunLoader, esd);
- }
if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
}
}
detStr.Data()));
if (fStopOnError) return kFALSE;
}
-
+ AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
+ eventNr++;
return kTRUE;
}
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;
}
//PH This is a temporary fix to give access to the kinematics
//PH that is needed for the labels of ITS clusters
+ fRunLoader->LoadHeader();
fRunLoader->LoadKinematics();
} else { // galice.root does not exist
TString recName = "Ali" + detName + "Reconstructor";
if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
- if (detName == "HLT") {
- if (!gROOT->GetClass("AliLevel3")) {
- gSystem->Load("libAliHLTSrc.so");
- gSystem->Load("libAliHLTMisc.so");
- gSystem->Load("libAliHLTHough.so");
- gSystem->Load("libAliHLTComp.so");
- }
- }
-
AliReconstructor* reconstructor = NULL;
// first check if a plugin is defined for the reconstructor
TPluginHandler* pluginHandler =
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
- reconstructor->Init(fRunLoader);
+ reconstructor->Init();
fReconstructor[iDet] = reconstructor;
}
fVertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
if (itsReconstructor) {
- fVertexer = itsReconstructor->CreateVertexer(fRunLoader);
+ fVertexer = itsReconstructor->CreateVertexer();
}
if (!fVertexer) {
AliWarning("couldn't create a vertexer for ITS");
}
- fTracker[iDet] = reconstructor->CreateTracker(fRunLoader);
+ fTracker[iDet] = reconstructor->CreateTracker();
if (!fTracker[iDet] && (iDet < 7)) {
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
if (fStopOnError) return kFALSE;
}
+ AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
}
return kTRUE;
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
- delete fQualAssDataMaker[iDet];
- fQualAssDataMaker[iDet] = NULL;
+// delete fQADataMaker[iDet];
+// fQADataMaker[iDet] = NULL;
}
delete fVertexer;
fVertexer = NULL;
- delete fDiamondProfile;
- fDiamondProfile = NULL;
+
+ if(!(AliCDBManager::Instance()->GetCacheFlag())) {
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
+ delete fDiamondProfileTPC;
+ fDiamondProfileTPC = NULL;
+ delete fGRPList;
+ fGRPList = NULL;
+ }
+
delete fRunLoader;
fRunLoader = NULL;
delete fRawReader;
fRawReader = NULL;
+ if (fParentRawReader) delete fParentRawReader;
+ fParentRawReader=NULL;
if (file) {
file->Close();
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!)
header->SetZDCP1Energy (esd->GetZDCP1Energy() );
header->SetZDCN2Energy (esd->GetZDCN2Energy() );
header->SetZDCP2Energy (esd->GetZDCP2Energy() );
- header->SetZDCEMEnergy (esd->GetZDCEMEnergy() );
+ header->SetZDCEMEnergy (esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
header->SetRefMultiplicity (nTracks);
header->SetRefMultiplicityPos(nPosTracks);
header->SetRefMultiplicityNeg(nTracks - nPosTracks);
Int_t nV0s = esd->GetNumberOfV0s();
Int_t nCascades = esd->GetNumberOfCascades();
Int_t nKinks = esd->GetNumberOfKinks();
- Int_t nVertices = nV0s + nCascades + nKinks;
-
- aod->ResetStd(nTracks, nVertices);
- AliAODTrack *aodTrack;
+ 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;
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();
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->GetXYZcascade(pos[0], pos[1], pos[2]); // Bo: bug correction
+ cascade->GetXYZ(pos[0], pos[1], pos[2]);
cascade->GetPosCovXi(covVtx);
// Add the cascade vertex
nCascade,
AliAODVertex::kCascade);
- primary->AddDaughter(vcascade);
+ 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
Int_t posFromV0 = cascade->GetPindex();
Int_t negFromV0 = cascade->GetNindex();
+
AliESDv0 * v0 = 0x0;
Int_t indV0 = -1;
AliAODVertex * vV0FromCascade = 0x0;
- if (indV0>-1 && !usedV0[indV0] ) {
+ if (indV0>-1 && !usedV0[indV0]) {
// the V0 exists in the array of V0s and is not used
indV0,
AliAODVertex::kV0);
vcascade->AddDaughter(vV0FromCascade);
+
}
// Add the positive tracks from the V0
usedTrack[posFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
- esdTrack->GetPxPyPz(p);
+ 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,
+ p_pos,
kTRUE,
pos,
kFALSE,
usedTrack[negFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
- esdTrack->GetPxPyPz(p);
+ 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,
+ p_neg,
kTRUE,
pos,
kFALSE,
<< " 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();
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);
-
+ AliESDv0 *v0 = esd->GetV0(nV0);
+
v0->GetXYZ(pos[0], pos[1], pos[2]);
v0->GetPosCov(covVtx);
usedTrack[posFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
- esdTrack->GetPxPyPz(p);
+ 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,
+ p_pos,
kTRUE,
pos,
kFALSE,
usedTrack[negFromV0] = kTRUE;
AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
- esdTrack->GetPxPyPz(p);
+ 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,
+ p_neg,
kTRUE,
pos,
kFALSE,
<< " track " << negFromV0 << " has already been used!" << endl;
}
- } // end of the loop on V0s
+ // 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);
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;
esdTrack->GetImpactParameters(impactXY,impactZ);
- if (impactXY<3) {
+ if (impactXY<3.) {
// track inside the beam pipe
primary->AddDaughter(aodTrack =
}
else {
// outside the beam pipe: orphan track
- aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- NULL,
- kFALSE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kOrphan);
- aodTrack->ConvertAliPIDtoAODPID();
+ // 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) {
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 &clusters = *(aod->GetClusters());
+ TClonesArray &caloClusters = *(aod->GetCaloClusters());
Int_t jClusters=0;
-
- // Calo Clusters
- Int_t nClusters = esd->GetNumberOfCaloClusters();
-
- for (Int_t iClust=0; iClust<nClusters; ++iClust) {
+
+ for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
Int_t id = cluster->GetID();
- Int_t label = -1;
+ Int_t nLabel = 0;
+ Int_t *label = 0x0;
Float_t energy = cluster->E();
cluster->GetPosition(posF);
- AliAODVertex *prodVertex = primary;
- AliAODTrack *primTrack = NULL;
Char_t ttype=AliAODCluster::kUndef;
- if (cluster->IsPHOS()) ttype=AliAODCluster::kPHOSNeutral;
- else if (cluster->IsEMCAL()) {
+ if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
+ ttype=AliAODCluster::kPHOSNeutral;
+ }
+ else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
+ ttype = AliAODCluster::kEMCALClusterv1;
+ }
- if (cluster->GetClusterType() == AliESDCaloCluster::kPseudoCluster)
- ttype = AliAODCluster::kEMCALPseudoCluster;
- else
- ttype = AliAODCluster::kEMCALClusterv1;
+
+ AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
+ nLabel,
+ label,
+ energy,
+ pos,
+ NULL,
+ ttype);
+
+ caloCluster->SetCaloCluster(); // to be refined!
- }
+ }
+ caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
+ // end of loop on calo clusters
- new(clusters[jClusters++]) AliAODCluster(id,
- label,
- energy,
- pos,
- NULL, // no covariance matrix provided
- NULL, // no pid for clusters provided
- prodVertex,
- primTrack,
- ttype);
+ // 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();
+ }
- } // end of loop on calo clusters
+ // fill PHOS cell info
+ if (esd->GetPHOSCells()) { // protection against missing ESD information
+ AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
+ Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
+
+ AliAODCaloCells &aodPHcells = *(aod->GetPHOSCells());
+ aodPHcells.CreateContainer(nPHcell);
+ aodPHcells.SetType(AliAODCaloCells::kPHOS);
+ for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
+ aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
+ }
+ aodPHcells.Sort();
+ }
- // tracklets
+ // tracklets
+ AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
const AliMultiplicity *mult = esd->GetMultiplicity();
if (mult) {
if (mult->GetNumberOfTracklets()>0) {
- aod->GetTracklets()->CreateContainer(mult->GetNumberOfTracklets());
+ SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
- aod->GetTracklets()->SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
+ SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
}
}
} else {
aodTree->GetUserInfo()->Add(aod);
- // close ESD file
- esdFile->Close();
-
// write the tree to the specified file
aodFile = aodTree->GetCurrentFile();
aodFile->cd();
AliTrackPoint p;
Int_t isp = 0;
Int_t isp2 = 0;
- while (isp < nspdet) {
- Bool_t isvalid = tracker->GetTrackPoint(idx[isp2],p); isp2++;
+ while (isp2 < nspdet) {
+ Bool_t isvalid;
+ 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);
+ }
+ isp2++;
const Int_t kNTPCmax = 159;
if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
if (!isvalid) continue;
out.close();
}
-
+
//_____________________________________________________________________________
-AliQualAssDataMaker * AliReconstruction::GetQualAssDataMaker(Int_t iDet)
+AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
{
-// get the quality assurance data maker object and the loader for a detector
+ // get the quality assurance data maker object and the loader for a detector
- if (fQualAssDataMaker[iDet])
- return fQualAssDataMaker[iDet];
+ 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 + "QualAssDataMaker";
+ TString qadmName = "Ali" + detName + "QADataMakerRec";
if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
return NULL;
- AliQualAssDataMaker * qadm = NULL;
// first check if a plugin is defined for the quality assurance data maker
- TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", 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("AliQualAssDataMaker", detName,
+ pluginManager->AddHandler("AliQADataMakerRec", detName,
qadmName, detName + "qadm", qadmName + "()");
} else {
- pluginManager->AddHandler("AliQualAssDataMaker", detName,
+ pluginManager->AddHandler("AliQADataMakerRec", detName,
qadmName, detName, qadmName + "()");
}
- pluginHandler = pluginManager->FindHandler("AliQualAssDataMaker", detName);
+ pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
}
if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- qadm = (AliQualAssDataMaker *) pluginHandler->ExecPlugin(0);
- }
- if (qadm) {
- // TObject* obj = fOptions.FindObject(detName.Data());
- // if (obj) reconstructor->SetOption(obj->GetTitle());
- fQualAssDataMaker[iDet] = qadm;
+ qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
}
- // get or create the loader
- fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
- if (!fLoader[iDet]) {
- AliConfig::Instance()
- ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
- detName, detName);
- // first check if a plugin is defined for the loader
- pluginHandler =
- pluginManager->FindHandler("AliLoader", detName);
- // if not, add a plugin for it
- if (!pluginHandler) {
- TString loaderName = "Ali" + detName + "Loader";
- AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
- pluginManager->AddHandler("AliLoader", detName,
- loaderName, detName + "base",
- loaderName + "(const char*, TFolder*)");
- pluginHandler = pluginManager->FindHandler("AliLoader", detName);
- }
- if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- fLoader[iDet] =
- (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
- fRunLoader->GetEventFolder());
- }
- if (!fLoader[iDet]) { // use default loader
- fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
- }
- if (!fLoader[iDet]) {
- AliWarning(Form("couldn't get loader for %s", detName.Data()));
- if (fStopOnError) return NULL;
- } else {
- fRunLoader->AddLoader(fLoader[iDet]);
- fRunLoader->CdGAFile();
- if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
- fRunLoader->Write(0, TObject::kOverwrite);
- }
- }
-
+ fQADataMaker[iDet] = qadm;
+
return qadm;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunQualAss(const char* detectors, AliESDEvent *& esd)
+Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
{
// run the Quality Assurance data producer
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr))
continue;
- AliQualAssDataMaker * qadm = GetQualAssDataMaker(iDet);
+ 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->SetData(esd) ;
- qadm->Exec(AliQualAss::kESDS) ;
+ qadm->Exec(AliQA::kESDS, esd) ;
+ qadm->Increment() ;
AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
}
}
return kTRUE;
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::CheckQA()
+{
+// check the QA of SIM for this run and remove the detectors
+// with status Fatal
+
+ TString newRunLocalReconstruction ;
+ TString newRunTracking ;
+ TString newFillESD ;
+
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ TString detName(AliQA::GetDetName(iDet)) ;
+ 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)) ||
+ fRunLocalReconstruction.Contains("ALL") ) {
+ newRunLocalReconstruction += detName ;
+ newRunLocalReconstruction += " " ;
+ }
+ if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
+ fRunTracking.Contains("ALL") ) {
+ newRunTracking += detName ;
+ newRunTracking += " " ;
+ }
+ if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
+ fFillESD.Contains("ALL") ) {
+ newFillESD += detName ;
+ newFillESD += " " ;
+ }
+ }
+ }
+ fRunLocalReconstruction = newRunLocalReconstruction ;
+ fRunTracking = newRunTracking ;
+ fFillESD = newFillESD ;
+}
+
+//_____________________________________________________________________________
+Int_t AliReconstruction::GetDetIndex(const char* detector)
+{
+ // return the detector index corresponding to detector
+ Int_t index = -1 ;
+ for (index = 0; index < fgkNDetectors ; index++) {
+ if ( strcmp(detector, fgkDetectorName[index]) == 0 )
+ break ;
+ }
+ return index ;
+}
+//_____________________________________________________________________________
+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;
}