#include <TArrayD.h>
#include <TObjArray.h>
#include <TMap.h>
+#include <TChain.h>
+#include <TProof.h>
+#include <TProofOutputFile.h>
+#include <TParameter.h>
#include "AliReconstruction.h"
#include "AliCodeTimer.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliRawEventHeaderBase.h"
+#include "AliRawEvent.h"
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
#include "AliESDfriend.h"
#include "AliESDPmdTrack.h"
#include "AliESDTagCreator.h"
-#include "AliAODTagCreator.h"
#include "AliGeomManager.h"
#include "AliTrackPointArray.h"
#include "AliMagWrapCheb.h"
#include "AliDetectorRecoParam.h"
+#include "AliGRPRecoParam.h"
#include "AliRunInfo.h"
#include "AliEventInfo.h"
#include "AliDAQ.h"
-ClassImp(AliReconstruction)
+#include "AliGRPObject.h"
+ClassImp(AliReconstruction)
//_____________________________________________________________________________
-const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
+const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename,
- const char* name, const char* title) :
- TNamed(name, title),
-
+AliReconstruction::AliReconstruction(const char* gAliceFilename) :
+ TSelector(),
fUniformField(kFALSE),
- fForcedFieldMap(0x0),
+ fForcedFieldMap(NULL),
fRunVertexFinder(kTRUE),
fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
fStopOnError(kFALSE),
fWriteAlignmentData(kFALSE),
fWriteESDfriend(kFALSE),
- fWriteAOD(kFALSE),
fFillTriggerESD(kTRUE),
fCleanESD(kTRUE),
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fLoadCDB(""),
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
- fInput(""),
+ fRawInput(""),
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
- fNumberOfEventsPerFile(1),
+ fNumberOfEventsPerFile((UInt_t)-1),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
- fESDPar(""),
fUseHLTData(),
fRunInfo(NULL),
fEventInfo(),
fRecoParam(),
- fVertexer(NULL),
+ fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(kTRUE),
-
+
fGRPData(NULL),
fAlignObjArray(NULL),
fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
- fInLoopQA(kFALSE),
fSameQACycle(kFALSE),
fRunPlaneEff(kFALSE),
fhlttree(NULL),
ftVertexer(NULL),
fIsNewRunLoader(kFALSE),
- fRunAliEVE(kFALSE)
+ fRunAliEVE(kFALSE),
+ fChain(NULL)
{
// create reconstruction object with default parameters
+ gGeoManager = NULL;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQACycles[iDet] = 999999;
}
- fQASteer = new AliQADataMakerSteer("rec") ;
- fQASteer->SetActiveDetectors(fQADetectors) ;
- fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
- fQASteer->SetTasks(fQATasks) ;
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ fQACycles[iDet] = 999999 ;
+ fQAWriteExpert[iDet] = kFALSE ;
+ }
+
AliPID pid;
}
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
- TNamed(rec),
-
+ TSelector(),
fUniformField(rec.fUniformField),
- fForcedFieldMap(0x0),
+ fForcedFieldMap(NULL),
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
fStopOnError(rec.fStopOnError),
fWriteAlignmentData(rec.fWriteAlignmentData),
fWriteESDfriend(rec.fWriteESDfriend),
- fWriteAOD(rec.fWriteAOD),
fFillTriggerESD(rec.fFillTriggerESD),
fCleanESD(rec.fCleanESD),
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
+ fLoadCDB(rec.fLoadCDB),
fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
- fInput(rec.fInput),
+ fRawInput(rec.fRawInput),
fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
- fESDPar(rec.fESDPar),
fUseHLTData(rec.fUseHLTData),
fRunInfo(NULL),
fEventInfo(),
fRawReader(NULL),
fParentRawReader(NULL),
- fRecoParam(),
-
- fVertexer(NULL),
- fDiamondProfile(NULL),
- fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(rec.fMeanVertexConstraint),
+ fRecoParam(rec.fRecoParam),
+ fDiamondProfileSPD(rec.fDiamondProfileSPD),
+ fDiamondProfile(rec.fDiamondProfile),
+ fDiamondProfileTPC(rec.fDiamondProfileTPC),
+
fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
fQADetectors(rec.fQADetectors),
- fQASteer(rec.fQASteer),
+ fQASteer(NULL),
fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
- fInLoopQA(rec.fInLoopQA),
fSameQACycle(rec.fSameQACycle),
fRunPlaneEff(rec.fRunPlaneEff),
fhlttree(NULL),
ftVertexer(NULL),
fIsNewRunLoader(rec.fIsNewRunLoader),
- fRunAliEVE(kFALSE)
+ fRunAliEVE(kFALSE),
+ fChain(NULL)
{
// copy constructor
for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
}
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQACycles[iDet] = rec.fQACycles[iDet];
+ }
+
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ fQACycles[iDet] = rec.fQACycles[iDet];
+ fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
}
+
for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
}
-
- fForcedFieldMap=new AliMagWrapCheb(*((AliMagWrapCheb*)rec.fForcedFieldMap));
}
//_____________________________________________________________________________
AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
{
// assignment operator
+// Used in PROOF mode
+// Be very careful while modifing it!
+// Simple rules to follow:
+// for persistent data members - use their assignment operators
+// for non-persistent ones - do nothing or take the default values from constructor
+// TSelector members should not be touched
+ if(&rec == this) return *this;
+
+ fUniformField = rec.fUniformField;
+ fForcedFieldMap = NULL;
+ fRunVertexFinder = rec.fRunVertexFinder;
+ fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
+ fRunHLTTracking = rec.fRunHLTTracking;
+ fRunMuonTracking = rec.fRunMuonTracking;
+ fRunV0Finder = rec.fRunV0Finder;
+ fRunCascadeFinder = rec.fRunCascadeFinder;
+ fStopOnError = rec.fStopOnError;
+ fWriteAlignmentData = rec.fWriteAlignmentData;
+ fWriteESDfriend = rec.fWriteESDfriend;
+ 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;
+ fLoadCDB = rec.fLoadCDB;
+ fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
+ fGAliceFileName = rec.fGAliceFileName;
+ fRawInput = rec.fRawInput;
+ fEquipIdMap = rec.fEquipIdMap;
+ fFirstEvent = rec.fFirstEvent;
+ fLastEvent = rec.fLastEvent;
+ fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
+
+ for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
+ if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
+ }
+
+ fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
+ fLoadAlignData = rec.fLoadAlignData;
+ fUseHLTData = rec.fUseHLTData;
+
+ delete fRunInfo; fRunInfo = NULL;
+ if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
+
+ fEventInfo = rec.fEventInfo;
+
+ fRunLoader = NULL;
+ fRawReader = NULL;
+ fParentRawReader = NULL;
+
+ fRecoParam = rec.fRecoParam;
+
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
+ delete fLoader[iDet]; fLoader[iDet] = NULL;
+ delete fTracker[iDet]; fTracker[iDet] = NULL;
+ }
+
+ for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
+ fQACycles[iDet] = rec.fQACycles[iDet];
+ fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
+ }
+
+ delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
+ if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
+ delete fDiamondProfile; fDiamondProfile = NULL;
+ if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
+ delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
+ if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
+
+ delete fGRPData; fGRPData = NULL;
+ // if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
+ if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
+
+ delete fAlignObjArray; fAlignObjArray = NULL;
+
+ fCDBUri = "";
+ fSpecCDBUri.Delete();
+ fInitCDBCalled = rec.fInitCDBCalled;
+ fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
+ fQADetectors = rec.fQADetectors;
+ fQASteer = NULL;
+ fQATasks = rec.fQATasks;
+ fRunQA = rec.fRunQA;
+ fRunGlobalQA = rec.fRunGlobalQA;
+ fSameQACycle = rec.fSameQACycle;
+ fRunPlaneEff = rec.fRunPlaneEff;
+
+ fesd = NULL;
+ fhltesd = NULL;
+ fesdf = NULL;
+ ffile = NULL;
+ ftree = NULL;
+ fhlttree = NULL;
+ ftVertexer = NULL;
+ fIsNewRunLoader = rec.fIsNewRunLoader;
+ fRunAliEVE = kFALSE;
+ fChain = NULL;
- this->~AliReconstruction();
- new(this) AliReconstruction(rec);
return *this;
}
// clean up
CleanUp();
+ delete fGRPData;
+ delete fForcedFieldMap;
fOptions.Delete();
+ if (fAlignObjArray) {
+ fAlignObjArray->Delete();
+ delete fAlignObjArray;
+ }
fSpecCDBUri.Delete();
- delete fForcedFieldMap;
- delete fQASteer ;
+ delete fQASteer;
AliCodeTimer::Instance()->Print();
}
// 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
+ AliCodeTimerAuto("");
if (fInitCDBCalled) return;
fInitCDBCalled = kTRUE;
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
}
-
+ AliSysInfo::AddStamp("InitCDB");
}
//_____________________________________________________________________________
AliCDBPath aPath(calibType);
if(!aPath.IsValid()){
// if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!strcmp(calibType, fgkDetectorName[iDet])) {
aPath.SetPath(Form("%s/*", calibType));
AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
// // check that calibType refers to a "valid" detector name
// Bool_t isDetector = kFALSE;
-// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+// for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
// TString detName = fgkDetectorName[iDet];
// if(aPath.GetLevel0() == detName) {
// isDetector = kTRUE;
fSetRunNumberFromDataCalled = kTRUE;
AliCDBManager* man = AliCDBManager::Instance();
-
- if(man->GetRun() > 0) {
+
+ if(fRawReader) {
+ if(fRawReader->NextEvent()) {
+ if(man->GetRun() > 0) {
AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
- }
-
- if (!fRunLoader) {
- AliError("No run loader is found !");
+ }
+ man->SetRun(fRawReader->GetRunNumber());
+ fRawReader->RewindEvents();
+ }
+ else {
+ if(man->GetRun() > 0) {
+ AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
+ }
+ else {
+ AliWarning("Neither raw events nor settings in AliCDBManager are found !");
+ return kFALSE;
+ }
+ }
+ }
+ else {
+ AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
+ if (!rl) {
+ AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
return kFALSE;
}
- // read run number from gAlice
- if(fRunLoader->GetAliRun())
- AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
else {
- if(fRawReader) {
- if(fRawReader->NextEvent()) {
- AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
- fRawReader->RewindEvents();
- }
- else {
- if(man->GetRun() > 0) {
- AliWarning("No raw events is found ! Using settings in AliCDBManager !");
- man->Print();
- return kTRUE;
- }
- else {
- AliWarning("Neither raw events nor settings in AliCDBManager are found !");
- return kFALSE;
- }
- }
+ rl->LoadHeader();
+ // read run number from gAlice
+ if(rl->GetHeader()) {
+ man->SetRun(rl->GetHeader()->GetRun());
+ rl->UnloadHeader();
+ delete rl;
}
else {
- AliError("Neither gAlice nor RawReader objects are found !");
+ AliError("Neither run-loader header nor RawReader objects are found !");
+ delete rl;
return kFALSE;
}
+ }
}
man->Print();
TString detStr = detectors;
TString loadAlObjsListOfDets = "";
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- loadAlObjsListOfDets += fgkDetectorName[iDet];
- loadAlObjsListOfDets += " ";
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
+
+ if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
+ {
+ loadAlObjsListOfDets += fgkDetectorName[iDet];
+ loadAlObjsListOfDets += " ";
+ }
} // end loop over detectors
- loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
+
+ if(AliGeomManager::GetNalignable("GRP") != 0)
+ loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
+ AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
}else{
// Check if the array with alignment objects was
// provided by the user. If yes, apply the objects
}
}
- delete fAlignObjArray; fAlignObjArray=0;
+ if (fAlignObjArray) {
+ fAlignObjArray->Delete();
+ delete fAlignObjArray; fAlignObjArray=NULL;
+ }
return kTRUE;
}
// mem://: - events taken from DAQ monitoring libs online
// or
// mem://<filename> - emulation of the above mode (via DATE monitoring libs)
- fInput = input;
+ if (input) fRawInput = input;
}
//_____________________________________________________________________________
{
// Set custom reconstruction parameters for a given detector
// Single set of parameters for all the events
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+
+ // First check if the reco-params are global
+ if(!strcmp(detector, "GRP")) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(kNDetectors,par);
+ return;
+ }
+
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if(!strcmp(detector, fgkDetectorName[iDet])) {
par->SetAsDefault();
fRecoParam.AddDetRecoParam(iDet,par);
//------------------------------------
AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
- if (entry) fGRPData = dynamic_cast<TMap*>(entry->GetObject());
+ if (entry) {
+
+ TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
+
+ if (m) {
+ AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
+ m->Print();
+ fGRPData = new AliGRPObject();
+ fGRPData->ReadValuesFromMap(m);
+ }
+
+ else {
+ AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
+ fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
+ entry->SetOwner(0);
+ }
+
+ AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
+ }
if (!fGRPData) {
AliError("No GRP entry found in OCDB!");
return kFALSE;
}
- TObjString *lhcState=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fLHCState"));
- if (!lhcState) {
+ TString lhcState = fGRPData->GetLHCState();
+ if (lhcState==AliGRPObject::GetInvalidString()) {
AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
+ lhcState = "UNKNOWN";
}
- TObjString *beamType=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamType"));
- if (!beamType) {
+ TString beamType = fGRPData->GetBeamType();
+ if (beamType==AliGRPObject::GetInvalidString()) {
AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
+ beamType = "UNKNOWN";
}
- TObjString *beamEnergyStr=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamEnergy"));
- if (!beamEnergyStr) {
+ Float_t beamEnergy = fGRPData->GetBeamEnergy();
+ if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
+ beamEnergy = 0;
}
- TObjString *runType=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fRunType"));
- if (!runType) {
+ TString runType = fGRPData->GetRunType();
+ if (runType==AliGRPObject::GetInvalidString()) {
AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
+ runType = "UNKNOWN";
}
- TObjString *activeDetectors=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fDetectorMask"));
- if (!activeDetectors) {
+ Int_t activeDetectors = fGRPData->GetDetectorMask();
+ if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
+ activeDetectors = 1074790399;
}
- fRunInfo = new AliRunInfo(lhcState ? lhcState->GetString().Data() : "UNKNOWN",
- beamType ? beamType->GetString().Data() : "UNKNOWN",
- beamEnergyStr ? beamEnergyStr->GetString().Atof() : 0,
- runType ? runType->GetString().Data() : "UNKNOWN",
- activeDetectors ? activeDetectors->GetString().Atoi() : 1074790399);
+ fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
+
+ fRunInfo->Dump();
+
// Process the list of active detectors
- if (activeDetectors && activeDetectors->GetString().IsDigit()) {
- UInt_t detMask = activeDetectors->GetString().Atoi();
+ if (activeDetectors) {
+ UInt_t detMask = activeDetectors;
fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
fRunTracking = MatchDetectorList(fRunTracking,detMask);
fFillESD = MatchDetectorList(fFillESD,detMask);
fQADetectors = MatchDetectorList(fQADetectors,detMask);
- fQASteer->SetActiveDetectors(fQADetectors) ;
+ fLoadCDB.Form("%s %s %s %s",
+ fRunLocalReconstruction.Data(),
+ fRunTracking.Data(),
+ fFillESD.Data(),
+ fQADetectors.Data());
+ fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
+ if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1)) {
+ // switch off the vertexer
+ AliInfo("SPD is not in the list of active detectors. Vertexer switched off.");
+ fRunVertexFinder = kFALSE;
+ }
+ if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
+ // switch off the reading of CTP raw-data payload
+ if (fFillTriggerESD) {
+ AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
+ fFillTriggerESD = kFALSE;
+ }
+ }
}
AliInfo("===================================================================================");
AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
+ AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
AliInfo("===================================================================================");
//*** Dealing with the magnetic field map
Bool_t ok = kTRUE;
// L3
+ Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
+ if (l3Current == AliGRPObject::GetInvalidFloat()) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 current !");
+ ok = kFALSE;
+ }
+
+ Char_t l3Polarity = fGRPData->GetL3Polarity();
+ if (l3Polarity == AliGRPObject::GetInvalidChar()) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
+ ok = kFALSE;
+ }
+
+ // Dipole
+ Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
+ if (diCurrent == AliGRPObject::GetInvalidFloat()) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole current !");
+ ok = kFALSE;
+ }
+
+ Char_t diPolarity = fGRPData->GetDipolePolarity();
+ if (diPolarity == AliGRPObject::GetInvalidChar()) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
+ ok = kFALSE;
+ }
+
+ /*
TObjString *l3Current=
dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
if (!l3Current) {
AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
ok = kFALSE;
}
-
+
// Dipole
TObjString *diCurrent=
dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
ok = kFALSE;
}
+ */
if (ok) {
- Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
- Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
- Float_t l3Pol=atof(l3Polarity->GetName());
+ Float_t l3Cur=TMath::Abs(l3Current);
+ Float_t diCur=TMath::Abs(diCurrent);
+ Float_t l3Pol=l3Polarity;
+ // Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
+ //Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
+ //Float_t l3Pol=atof(l3Polarity->GetName());
Float_t factor=1.;
if (l3Pol != 0.) factor=-1.;
}
+ //*** Get the diamond profiles from OCDB
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
+ if (entry) {
+ fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ AliError("No SPD diamond profile found in OCDB!");
+ }
- //*** Get the diamond profile from OCDB
entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
if (entry) {
-
fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
} else {
AliError("No diamond profile found in OCDB!");
}
entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
if (entry) {
-
fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
} else {
- AliError("No diamond profile found in OCDB!");
+ AliError("No TPC diamond profile found in OCDB!");
}
return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::LoadCDB()
+{
+ AliCodeTimerAuto("");
+
+ AliCDBManager::Instance()->Get("GRP/CTP/Config");
+
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
+ }
+ return kTRUE;
+}
+
//_____________________________________________________________________________
Bool_t AliReconstruction::Run(const char* input)
{
// Run Run Run
AliCodeTimerAuto("");
- if (!InitRun(input)) return kFALSE;
- //******* The loop over events
- Int_t iEvent = 0;
- while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
- (fRawReader && fRawReader->NextEvent())) {
- if (!RunEvent(iEvent)) return kFALSE;
- iEvent++;
+ InitRun(input);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+
+ TChain *chain = NULL;
+ if (fRawReader && (chain = fRawReader->GetChain())) {
+ // Proof mode
+ if (gProof) {
+ gProof->AddInput(this);
+ TUrl outputFile;
+ outputFile.SetProtocol("root",kTRUE);
+ outputFile.SetHost(gSystem->HostName());
+ outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
+ AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl()));
+ chain->SetProof();
+ chain->Process("AliReconstruction");
+ }
+ else {
+ chain->Process(this);
+ }
+ }
+ else {
+ Begin(NULL);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+ SlaveBegin(NULL);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+ //******* The loop over events
+ AliInfo("Starting looping over events");
+ Int_t iEvent = 0;
+ while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
+ (fRawReader && fRawReader->NextEvent())) {
+ if (!ProcessEvent(iEvent)) {
+ Abort("ProcessEvent",TSelector::kAbortFile);
+ return kFALSE;
+ }
+ iEvent++;
+ }
+ SlaveTerminate();
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+ Terminate();
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
}
-
- if (!FinishRun()) return kFALSE;
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::InitRun(const char* input)
+void AliReconstruction::InitRawReader(const char* input)
{
- // Initialize all the stuff before
- // going into the event loop
- // If the second argument is given, the first one is ignored and
- // the reconstruction works in an online mode
AliCodeTimerAuto("");
- // Overwrite the previous setting
- if (input) fInput = input;
-
+ // Init raw-reader and
// set the input in case of raw data
- fRawReader = AliRawReader::Create(fInput.Data());
+ if (input) fRawInput = input;
+ fRawReader = AliRawReader::Create(fRawInput.Data());
if (!fRawReader)
AliInfo("Reconstruction will run over digits");
AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
}
}
+ AliSysInfo::AddStamp("CreateRawReader");
+}
- AliSysInfo::AddStamp("Start");
- // get the run loader
- if (!InitRunLoader()) return kFALSE;
- AliSysInfo::AddStamp("LoadLoader");
+//_____________________________________________________________________________
+void AliReconstruction::InitRun(const char* input)
+{
+ // Initialization of raw-reader,
+ // run number, CDB etc.
+ AliCodeTimerAuto("");
+ AliSysInfo::AddStamp("Start");
+
+ // Initialize raw-reader if any
+ InitRawReader(input);
// Initialize the CDB storage
InitCDB();
-
- AliSysInfo::AddStamp("LoadCDB");
// Set run number in CDBManager (if it is not already set by the user)
- if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
-
+ if (!SetRunNumberFromData()) {
+ Abort("SetRunNumberFromData", TSelector::kAbortProcess);
+ return;
+ }
+
// 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();
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::Begin(TTree *)
+{
+ // Initialize AlReconstruction before
+ // going into the event loop
+ // Should follow the TSelector convention
+ // i.e. initialize only the object on the client side
+ AliCodeTimerAuto("");
+
+ AliReconstruction *reco = NULL;
+ if (fInput) {
+ if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
+ *this = *reco;
+ }
+ AliSysInfo::AddStamp("ReadInputInBegin");
+ }
+
// Import ideal TGeo geometry and apply misalignment
if (!gGeoManager) {
TString geom(gSystem->DirName(fGAliceFileName));
geom += "/geometry.root";
AliGeomManager::LoadGeometry(geom.Data());
-
+ if (!gGeoManager) {
+ Abort("LoadGeometry", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadGeom");
TString detsToCheck=fRunLocalReconstruction;
- if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data()))
- AliFatalClass("Current loaded geometry differs in the definition of symbolic names!");
- if (!gGeoManager) if (fStopOnError) return kFALSE;
+ if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
+ Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("CheckGeom");
}
- if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
- AliSysInfo::AddStamp("LoadGeom");
+ if (!MisalignGeometry(fLoadAlignData)) {
+ Abort("MisalignGeometry", TSelector::kAbortProcess);
+ return;
+ }
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
+ AliSysInfo::AddStamp("MisalignGeom");
+ if (!InitGRP()) {
+ Abort("InitGRP", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("InitGRP");
- if (!InitGRP()) return kFALSE;
+ if (!LoadCDB()) {
+ Abort("LoadCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadCDB");
// Read the reconstruction parameters from OCDB
if (!InitRecoParams()) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
+ AliWarning("Not all detectors have correct RecoParam objects initialized");
}
- AliSysInfo::AddStamp("ReadRecoParam");
+ AliSysInfo::AddStamp("InitRecoParams");
- ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
- if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
+ if (fInput) {
+ if (reco) *reco = *this;
+ fInput->Add(gGeoManager);
+ gGeoManager = NULL;
+ fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
+ fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
+ AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap();
+ magFieldMap->SetName("MagneticFieldMap");
+ fInput->Add(magFieldMap);
+ }
- // get vertexer
- if (fRunVertexFinder && !CreateVertexer()) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SlaveBegin(TTree*)
+{
+ // Initialization related to run-loader,
+ // vertexer, trackers, recontructors
+ // In proof mode it is executed on the slave
+ AliCodeTimerAuto("");
+
+ TProofOutputFile *outProofFile = NULL;
+ if (fInput) {
+ if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
+ *this = *reco;
+ }
+ if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
+ gGeoManager = tgeo;
+ AliGeomManager::SetGeometry(tgeo);
+ }
+ if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
+ Int_t runNumber = -1;
+ if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
+ AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
+ man->SetCacheFlag(kTRUE);
+ man->SetLock(kTRUE);
+ man->Print();
+ }
}
+ if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
+ AliTracker::SetFieldMap(map,fUniformField);
+ }
+ if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
+ outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
+ outProofFile->SetOutputFileName(outputFileName->GetTitle());
+ fOutput->Add(outProofFile);
+ }
+ AliSysInfo::AddStamp("ReadInputInSlaveBegin");
+ }
+
+ // get the run loader
+ if (!InitRunLoader()) {
+ Abort("InitRunLoader", TSelector::kAbortProcess);
+ return;
}
- AliSysInfo::AddStamp("Vertexer");
+ AliSysInfo::AddStamp("LoadLoader");
+
+ ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
- }
- AliSysInfo::AddStamp("LoadTrackers");
+ Abort("CreateTrackers", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("CreateTrackers");
// create the ESD output file and tree
- ffile = TFile::Open("AliESDs.root", "RECREATE");
- ffile->SetCompressionLevel(2);
- if (!ffile->IsOpen()) {
- AliError("opening AliESDs.root failed");
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
+ if (!outProofFile) {
+ ffile = TFile::Open("AliESDs.root", "RECREATE");
+ ffile->SetCompressionLevel(2);
+ if (!ffile->IsOpen()) {
+ Abort("OpenESDFile", TSelector::kAbortProcess);
+ return;
+ }
+ }
+ else {
+ if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
+ Abort(Form("Problems opening output PROOF file: %s/%s",
+ outProofFile->GetDir(), outProofFile->GetFileName()),
+ TSelector::kAbortProcess);
+ return;
+ }
}
ftree = new TTree("esdTree", "Tree with ESD objects");
fesd = new AliESDEvent();
fesd->CreateStdContent();
- fesd->WriteToTree(ftree);
-
- fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
- fhltesd = new AliESDEvent();
- fhltesd->CreateStdContent();
- fhltesd->WriteToTree(fhlttree);
-
+ fesd->WriteToTree(ftree);
if (fWriteESDfriend) {
+ // careful:
+ // Since we add the branch manually we must
+ // book and add it after WriteToTree
+ // otherwise it is created twice,
+ // once via writetotree and once here.
+ // The case for AliESDfriend is now
+ // caught also in AlIESDEvent::WriteToTree but
+ // be careful when changing the name (AliESDfriend is not
+ // a TNamed so we had to hardwire it)
fesdf = new AliESDfriend();
TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
br->SetFile("AliESDfriends.root");
fesd->AddObject(fesdf);
}
+ ftree->GetUserInfo()->Add(fesd);
+ fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
+ fhltesd = new AliESDEvent();
+ fhltesd->CreateStdContent();
+ // read the ESD template from CDB
+ // HLT is allowed to put non-std content to its ESD, the non-std
+ // objects need to be created before invocation of WriteToTree in
+ // order to create all branches. Initialization is done from an
+ // ESD layout template in CDB
+ AliCDBManager* man = AliCDBManager::Instance();
+ AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
+ AliCDBEntry* hltESDConfig=NULL;
+ if (man->GetId(hltESDConfigPath)!=NULL &&
+ (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
+ AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
+ if (pESDLayout) {
+ // init all internal variables from the list of objects
+ pESDLayout->GetStdContent();
+
+ // copy content and create non-std objects
+ *fhltesd=*pESDLayout;
+ fhltesd->Reset();
+ } else {
+ AliError(Form("error setting hltEsd layout from %s: invalid object type",
+ hltESDConfigPath.GetPath().Data()));
+ }
+ }
- if (fRawReader) fRawReader->RewindEvents();
+ fhltesd->WriteToTree(fhlttree);
+ fhlttree->GetUserInfo()->Add(fhltesd);
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ ProcInfo_t procInfo;
+ gSystem->GetProcInfo(&procInfo);
+ AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
//QA
- if ( !fInLoopQA ) {
- if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) {
- fQASteer->Run(fQADetectors, fRawReader) ;
- fSameQACycle = kTRUE ;
+ //Initialize the QA and start of cycle
+ if (fRunQA) {
+ fQASteer = new AliQADataMakerSteer("rec") ;
+ fQASteer->SetActiveDetectors(fQADetectors) ;
+ for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
+ fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
+ if (fQAWriteExpert[det])
+ fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
+ }
+
+ if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
+ fQASteer->SetTasks(fQATasks) ;
+ fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam) ;
+ }
+
+ if (fRunGlobalQA) {
+ Bool_t sameCycle = kFALSE ;
+ if (!fQASteer) fQASteer = new AliQADataMakerSteer("rec") ;
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ AliInfo(Form("Initializing the global QA data maker"));
+ if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
+ qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ TObjArray *arr=qadm->Init(AliQA::kRECPOINTS);
+ AliTracker::SetResidualsArray(arr);
+ sameCycle = kTRUE ;
+ }
+ if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
+ qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ qadm->Init(AliQA::kESDS);
}
}
-
- //Initialize the QA and start of cycle for out-of-loop QA
- if (fRunQA) {
- fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, !fInLoopQA) ;
- }
-
- if (fRunGlobalQA) {
- fSameQACycle = kFALSE;
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- AliInfo(Form("Initializing the global QA data maker"));
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- TObjArray *arr=qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
- AliTracker::SetResidualsArray(arr);
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- }
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- }
- }
//Initialize the Plane Efficiency framework
if (fRunPlaneEff && !InitPlaneEff()) {
- if(fStopOnError) {CleanUp(ffile); return kFALSE;}
+ Abort("InitPlaneEff", TSelector::kAbortProcess);
+ return;
}
if (strcmp(gProgName,"alieve") == 0)
fRunAliEVE = InitAliEVE();
- return kTRUE;
+ return;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::Process(Long64_t entry)
+{
+ // run the reconstruction over a single entry
+ // from the chain with raw data
+ AliCodeTimerAuto("");
+
+ TTree *currTree = fChain->GetTree();
+ AliRawEvent *event = new AliRawEvent;
+ currTree->SetBranchAddress("rawevent",&event);
+ currTree->GetEntry(entry);
+ fRawReader = new AliRawReaderRoot(event);
+ fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
+ delete fRawReader;
+ fRawReader = NULL;
+ delete event;
+
+ return fStatus;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::Init(TTree *tree)
+{
+ if (tree == 0) {
+ AliError("The input tree is not found!");
+ return;
+ }
+ fChain = tree;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunEvent(Int_t iEvent)
+Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
{
// run the reconstruction over a single event
// The event loop is steered in Run method
fRunLoader->SetEventNumber(iEvent);
fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
iEvent, iEvent);
- //?? fRunLoader->MakeTree("H");
fRunLoader->TreeE()->Fill();
+ if (fRawReader && fRawReader->UseAutoSaveESD())
+ fRunLoader->TreeE()->AutoSave("SaveSelf");
}
if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
AliInfo(Form("processing event %d", iEvent));
+ fRunLoader->GetEvent(iEvent);
+
// Fill Event-info object
GetEventInfo();
fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
+ AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
- //Start of cycle for the in-loop QA
- if (fInLoopQA && fRunQA) {
- fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, fInLoopQA) ;
- }
- if (fInLoopQA && fRunGlobalQA) {
- fSameQACycle = kFALSE;
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
- fSameQACycle = kTRUE;
- }
- }
-
- fRunLoader->GetEvent(iEvent);
-
- char aFileName[256];
- sprintf(aFileName, "ESD_%d.%d_final.root",
- fRunLoader->GetHeader()->GetRun(),
- fRunLoader->GetHeader()->GetEventNrInRun());
- if (!gSystem->AccessPathName(aFileName)) return kTRUE;
+ // Set the reco-params
+ {
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ AliReconstructor *reconstructor = GetReconstructor(iDet);
+ if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ reconstructor->SetRecoParam(par);
+ }
+ }
+ }
// QA on single raw
- if (fInLoopQA && fRunQA)
+ if (fRunQA)
fQASteer->RunOneEvent(fRawReader) ;
// local single event reconstruction
// ;-( IsSelected changes the string
if (IsSelected("HLT", detectors) &&
!RunLocalEventReconstruction("HLT")) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
detectors=fRunLocalReconstruction;
detectors.ReplaceAll("HLT", "");
if (!RunLocalEventReconstruction(detectors)) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
fesd->SetMagneticField(AliTracker::GetBz());
fhltesd->SetMagneticField(AliTracker::GetBz());
-
+ // Set most probable pt, for B=0 tracking
+ // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
+ const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
+ if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
// Fill raw-data error log into the ESD
if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
// vertex finder
if (fRunVertexFinder) {
- if (!ReadESD(fesd, "vertex")) {
- if (!RunVertexFinder(fesd)) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
- }
+ if (!RunVertexFinder(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
if (!fRunTracking.IsNull()) {
if (fRunMuonTracking) {
if (!RunMuonTracking(fesd)) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
}
// barrel tracking
if (!fRunTracking.IsNull()) {
- if (!ReadESD(fesd, "tracking")) {
- if (!RunTracking(fesd)) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
- }
+ if (!RunTracking(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
// ;-( IsSelected changes the string
if (IsSelected("HLT", detectors) &&
!FillESD(fhltesd, "HLT")) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
detectors=fFillESD;
// Temporary fix to avoid problems with HLT that overwrites the offline ESDs
if (detectors.Contains("ALL")) {
detectors="";
- for (Int_t idet=0; idet<fgkNDetectors; ++idet){
+ for (Int_t idet=0; idet<kNDetectors; ++idet){
detectors += fgkDetectorName[idet];
detectors += " ";
}
}
detectors.ReplaceAll("HLT", "");
if (!FillESD(fesd, detectors)) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
AliESDpid::MakePID(fesd);
if (fFillTriggerESD) {
- if (!ReadESD(fesd, "trigger")) {
- if (!FillTriggerESD(fesd)) {
- if (fStopOnError) {CleanUp(ffile); return kFALSE;}
- }
+ if (!FillTriggerESD(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
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
+ const Double_t kMaxStep = 1; //max step over the material
Bool_t ok;
AliESDtrack *track = fesd->GetTrack(itrack);
ok = kFALSE;
if (tpcTrack)
ok = AliTracker::
- PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
if (ok) {
Int_t n=trkArray.GetEntriesFast();
if (track->IsOn(AliESDtrack::kITSrefit)) continue;
AliTracker::
- PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
}
//
// 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"))
- fRunVertexFinderTracks=kFALSE;
+ Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
+ if(fesd->GetPrimaryVertexSPD()) {
+ TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
+ if(vtitle.Contains("cosmics")) {
+ runVertexFinderTracks=kFALSE;
+ }
}
- if (fRunVertexFinderTracks) {
+
+ if (runVertexFinderTracks) {
// TPC + ITS primary vertex
- ftVertexer->SetITSrefitRequired();
- if(fDiamondProfile && fMeanVertexConstraint) {
- ftVertexer->SetVtxStart(fDiamondProfile);
- } else {
- ftVertexer->SetConstraintOff();
+ ftVertexer->SetITSMode();
+ ftVertexer->SetConstraintOff();
+ // get cuts for vertexer from AliGRPRecoParam
+ if (grpRecoParam) {
+ Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
+ Double_t *cutsVertexer = new Double_t[nCutsVertexer];
+ grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
+ ftVertexer->SetCuts(cutsVertexer);
+ delete [] cutsVertexer; cutsVertexer = NULL;
+ if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
+ ftVertexer->SetVtxStart(fDiamondProfile);
}
AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
if (pvtx->GetStatus()) {
- fesd->SetPrimaryVertex(pvtx);
+ fesd->SetPrimaryVertexTracks(pvtx);
for (Int_t i=0; i<ntracks; i++) {
AliESDtrack *t = fesd->GetTrack(i);
t->RelateToVertex(pvtx, kBz, kVeryBig);
}
// TPC-only primary vertex
- ftVertexer->SetITSrefitNotRequired();
- if(fDiamondProfileTPC && fMeanVertexConstraint) {
- ftVertexer->SetVtxStart(fDiamondProfileTPC);
- } else {
- ftVertexer->SetConstraintOff();
+ ftVertexer->SetTPCMode();
+ ftVertexer->SetConstraintOff();
+ // get cuts for vertexer from AliGRPRecoParam
+ if (grpRecoParam) {
+ Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
+ Double_t *cutsVertexer = new Double_t[nCutsVertexer];
+ grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
+ ftVertexer->SetCuts(cutsVertexer);
+ delete [] cutsVertexer; cutsVertexer = NULL;
+ if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
+ ftVertexer->SetVtxStart(fDiamondProfileTPC);
}
pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
if (pvtx) {
// write ESD
if (fCleanESD) CleanESD(fesd);
- if (fRunQA) {
- if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->Exec(AliQA::kESDS, fesd);
- }
+ if (fRunQA)
+ fQASteer->RunOneEvent(fesd) ;
+
+ if (fRunGlobalQA) {
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
+ qadm->Exec(AliQA::kESDS, fesd);
}
if (fWriteESDfriend) {
- fesdf->~AliESDfriend();
- new (fesdf) AliESDfriend(); // Reset...
+ // fesdf->~AliESDfriend();
+ // new (fesdf) AliESDfriend(); // Reset...
fesd->GetESDfriend(fesdf);
}
ftree->Fill();
// Auto-save the ESD tree in case of prompt reco @P2
- if (fRawReader && fRawReader->UseAutoSaveESD())
+ if (fRawReader && fRawReader->UseAutoSaveESD()) {
ftree->AutoSave("SaveSelf");
+ TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
+ if (friendfile) friendfile->Save();
+ }
// write HLT ESD
fhlttree->Fill();
new (fesdf) AliESDfriend(); // Reset...
}
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ ProcInfo_t procInfo;
+ gSystem->GetProcInfo(&procInfo);
+ AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
-
- // End of cycle for the in-loop
- if (fInLoopQA && fRunQA) {
- fQASteer->RunOneEvent(fesd) ;
- fQASteer->EndOfCycle() ;
- }
- if (fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (qadm) {
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
-
fEventInfo.Reset();
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fReconstructor[iDet])
- fReconstructor[iDet]->SetRecoParam(NULL);
+ fReconstructor[iDet]->SetRecoParam(NULL);
}
+ if (fRunQA || fRunGlobalQA)
+ fQASteer->Increment() ;
+
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::FinishRun()
+void AliReconstruction::SlaveTerminate()
{
- // Finalize the run
+ // Finalize the run on the slave side
// Called after the exit
// from the event loop
AliCodeTimerAuto("");
fRunLoader->Write(0, TObject::kOverwrite);
}
- ftree->GetUserInfo()->Add(fesd);
- fhlttree->GetUserInfo()->Add(fhltesd);
-
const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
ftree->GetUserInfo()->Add(cdbListCopy);
- if(fESDPar.Contains("ESD.par")){
- AliInfo("Attaching ESD.par to Tree");
- TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
- ftree->GetUserInfo()->Add(fn);
- }
-
-
ffile->cd();
if (fWriteESDfriend)
AliWarning("Finish PlaneEff evaluation failed");
}
+ // End of cycle for the in-loop
+ if (fRunQA) {
+ fQASteer->EndOfCycle() ;
+ }
+ if (fRunGlobalQA) {
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ if (qadm) {
+ if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
+ }
gROOT->cd();
- CleanUp(ffile);
+ CleanUp();
+}
- if (fWriteAOD) {
- AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
- }
-
+//_____________________________________________________________________________
+void AliReconstruction::Terminate()
+{
// 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
+ AliCodeTimerAuto("");
+
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
- if (fWriteAOD) {
- AliWarning("AOD tag creation not supported anymore during reconstruction.");
- }
-
- //Finish QA and end of cycle for out-of-loop QA
- if (!fInLoopQA && fRunQA)
- fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kNULLTASKINDEX, fSameQACycle) ;
- if (!fInLoopQA && fRunGlobalQA) {
- AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
- if (qadm) {
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- 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*/)
-{
-// run the local reconstruction
- static Int_t eventNr=0;
- AliCodeTimerAuto("")
-
- // 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;
-
-// 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]));
-
-// 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]));
-
-// if (fRawReader) {
-// fRawReader->RewindEvents();
-// reconstructor->Reconstruct(fRunLoader, fRawReader);
-// } else {
-// reconstructor->Reconstruct(fRunLoader);
-// }
-
-// 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();
-// }
-
-// 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;
-// }
-
- eventNr++;
- return kTRUE;
}
//_____________________________________________________________________________
AliCodeTimerAuto("")
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
loader->UnloadDigits();
}
- // In-loop QA for local reconstrucion
TString detQAStr(fQADetectors) ;
- if (fRunQA && fInLoopQA)
+ if (fRunQA)
fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
- }
- if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ }
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
if (fStopOnError) return kFALSE;
AliCodeTimerAuto("")
+ AliVertexer *vertexer = CreateVertexer();
+ if (!vertexer) return kFALSE;
+
+ AliInfo("running the ITS vertex finder");
AliESDVertex* vertex = NULL;
- Double_t vtxPos[3] = {0, 0, 0};
- Double_t vtxErr[3] = {0.07, 0.07, 0.1};
- TArrayF mcVertex(3);
- if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
- fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
- for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
- }
-
- if (fVertexer) {
- AliInfo("running the ITS vertex finder");
- if (fLoader[0]) {
- fLoader[0]->LoadRecPoints();
- TTree* cltree = fLoader[0]->TreeR();
- if (cltree) {
- if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
- vertex = fVertexer->FindVertexForCurrentEvent(cltree);
- }
- else {
- AliError("Can't get the ITS cluster tree");
- }
- fLoader[0]->UnloadRecPoints();
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
+ vertex = vertexer->FindVertexForCurrentEvent(cltree);
}
else {
- AliError("Can't get the ITS loader");
+ AliError("Can't get the ITS cluster tree");
}
- if(!vertex){
- AliWarning("Vertex not found");
- vertex = new AliESDVertex();
- vertex->SetName("default");
- }
- else {
- vertex->SetName("reconstructed");
- }
-
- } else {
- AliInfo("getting the primary vertex from MC");
- vertex = new AliESDVertex(vtxPos, vtxErr);
+ fLoader[0]->UnloadRecPoints();
}
-
- if (vertex) {
- vertex->GetXYZ(vtxPos);
- vertex->GetSigmaXYZ(vtxErr);
- } else {
- AliWarning("no vertex reconstructed");
- vertex = new AliESDVertex(vtxPos, vtxErr);
+ else {
+ AliError("Can't get the ITS loader");
+ }
+ if(!vertex){
+ AliWarning("Vertex not found");
+ vertex = new AliESDVertex();
+ vertex->SetName("default");
+ }
+ else {
+ vertex->SetName("reconstructed");
}
+
+ Double_t vtxPos[3];
+ Double_t vtxErr[3];
+ vertex->GetXYZ(vtxPos);
+ vertex->GetSigmaXYZ(vtxErr);
+
esd->SetPrimaryVertexSPD(vertex);
// if SPD multiplicity has been determined, it is stored in the ESD
- AliMultiplicity *mult = fVertexer->GetMultiplicity();
+ AliMultiplicity *mult = vertexer->GetMultiplicity();
if(mult)esd->SetMultiplicity(mult);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
}
delete vertex;
+ delete vertexer;
+
return kTRUE;
}
AliInfo("running HLT tracking");
// Get a pointer to the HLT reconstructor
- AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
+ AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
if (!reconstructor) return kFALSE;
// TPC + ITS
if (fReconstructor[11] && fLoader[11]) {
fLoader[11]->LoadRecPoints("READ");
TTree *treeR = fLoader[11]->TreeR();
- GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+ if (treeR) {
+ GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
+ }
}
// pass 1: TPC + ITS inwards
// pass 2: ALL backwards
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
static Int_t eventNr=0;
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
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;
+ AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
+ TTree* clustersTree = NULL;
+ if (fLoader[iDet]) {
+ fLoader[iDet]->LoadRecPoints("read");
+ clustersTree = fLoader[iDet]->TreeR();
+ if (!clustersTree) {
+ AliError(Form("Can't get the %s clusters tree",
+ fgkDetectorName[iDet]));
+ if (fStopOnError) return kFALSE;
+ }
+ }
+ if (fRawReader && !reconstructor->HasDigitConversion()) {
+ reconstructor->FillESD(fRawReader, clustersTree, esd);
+ } else {
+ TTree* digitsTree = NULL;
if (fLoader[iDet]) {
- fLoader[iDet]->LoadRecPoints("read");
- clustersTree = fLoader[iDet]->TreeR();
- if (!clustersTree) {
- AliError(Form("Can't get the %s clusters tree",
+ fLoader[iDet]->LoadDigits("read");
+ digitsTree = fLoader[iDet]->TreeD();
+ if (!digitsTree) {
+ AliError(Form("Can't get the %s digits tree",
fgkDetectorName[iDet]));
if (fStopOnError) return kFALSE;
}
}
- if (fRawReader && !reconstructor->HasDigitConversion()) {
- reconstructor->FillESD(fRawReader, clustersTree, esd);
- } else {
- TTree* digitsTree = NULL;
- if (fLoader[iDet]) {
- fLoader[iDet]->LoadDigits("read");
- digitsTree = fLoader[iDet]->TreeD();
- if (!digitsTree) {
- AliError(Form("Can't get the %s digits tree",
- fgkDetectorName[iDet]));
- if (fStopOnError) return kFALSE;
- }
- }
- reconstructor->FillESD(digitsTree, clustersTree, esd);
- if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
- }
- if (fLoader[iDet]) {
- fLoader[iDet]->UnloadRecPoints();
- }
-
+ reconstructor->FillESD(digitsTree, clustersTree, esd);
+ if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
+ }
+ if (fLoader[iDet]) {
+ fLoader[iDet]->UnloadRecPoints();
}
}
if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
// load all base libraries to get the loader classes
TString libs = gSystem->GetLibraries();
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
TString detName = fgkDetectorName[iDet];
if (detName == "HLT") continue;
if (libs.Contains("lib" + detName + "base.so")) continue;
} else { // galice.root does not exist
if (!fRawReader) {
AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
- CleanUp();
- return kFALSE;
}
fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
AliConfig::GetDefaultEventFolderName(),
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::CreateVertexer()
+AliVertexer* AliReconstruction::CreateVertexer()
{
// create the vertexer
+// Please note that the caller is the owner of the
+// vertexer
- fVertexer = NULL;
+ AliVertexer* vertexer = NULL;
AliReconstructor* itsReconstructor = GetReconstructor(0);
if (itsReconstructor) {
- fVertexer = itsReconstructor->CreateVertexer();
+ vertexer = itsReconstructor->CreateVertexer();
}
- if (!fVertexer) {
+ if (!vertexer) {
AliWarning("couldn't create a vertexer for ITS");
- if (fStopOnError) return kFALSE;
}
- return kTRUE;
+ return vertexer;
}
//_____________________________________________________________________________
Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
{
// create the trackers
+ AliInfo("Creating trackers");
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
}
//_____________________________________________________________________________
-void AliReconstruction::CleanUp(TFile* file)
+void AliReconstruction::CleanUp()
{
// delete trackers and the run loader and close and delete the file
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
delete fReconstructor[iDet];
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
}
- if (fRunInfo) delete fRunInfo;
+ delete fRunInfo;
fRunInfo = NULL;
- delete fVertexer;
- fVertexer = NULL;
-
- if (ftVertexer) delete ftVertexer;
+ delete ftVertexer;
ftVertexer = NULL;
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
- delete fDiamondProfile;
- fDiamondProfile = NULL;
- delete fDiamondProfileTPC;
- fDiamondProfileTPC = NULL;
- delete fGRPData;
- fGRPData = NULL;
+ delete fDiamondProfileSPD;
+ fDiamondProfileSPD = NULL;
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
+ delete fDiamondProfileTPC;
+ fDiamondProfileTPC = NULL;
}
-
-
delete fRunLoader;
fRunLoader = NULL;
delete fRawReader;
fRawReader = NULL;
- if (fParentRawReader) delete fParentRawReader;
+ delete fParentRawReader;
fParentRawReader=NULL;
- if (file) {
- file->Close();
- delete file;
+ if (ffile) {
+ ffile->Close();
+ delete ffile;
+ ffile = NULL;
}
-
}
-//_____________________________________________________________________________
-
-Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
-{
-// read the ESD event from a file
-
- if (!esd) return kFALSE;
- char fileName[256];
- sprintf(fileName, "ESD_%d.%d_%s.root",
- esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
- if (gSystem->AccessPathName(fileName)) return kFALSE;
-
- AliInfo(Form("reading ESD from file %s", fileName));
- AliDebug(1, Form("reading ESD from file %s", fileName));
- TFile* file = TFile::Open(fileName);
- if (!file || !file->IsOpen()) {
- AliError(Form("opening %s failed", fileName));
- delete file;
- return kFALSE;
- }
-
- gROOT->cd();
- delete esd;
- esd = (AliESDEvent*) file->Get("ESD");
- file->Close();
- delete file;
- return kTRUE;
-
-}
-
-
-
-//_____________________________________________________________________________
-void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
-{
-// write the ESD event to a file
-
- if (!esd) return;
- char fileName[256];
- sprintf(fileName, "ESD_%d.%d_%s.root",
- esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
-
- AliDebug(1, Form("writing ESD to file %s", fileName));
- TFile* file = TFile::Open(fileName, "recreate");
- if (!file || !file->IsOpen()) {
- AliError(Form("opening %s failed", fileName));
- } else {
- esd->Write("ESD");
- file->Close();
- }
- delete file;
-}
-
-
void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
{
// Write space-points which are then used in the alignment procedures
AliESDtrack *track = esd->GetTrack(itrack);
Int_t nsp = 0;
Int_t idx[200];
- for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
+ for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
nsp += track->GetNcls(iDet);
if (iDet==0) { // ITS "extra" clusters
AliTrackPointArray *sp = new AliTrackPointArray(nsp);
track->SetTrackPointArray(sp);
Int_t isptrack = 0;
- for (Int_t iDet = 3; iDet >= 0; iDet--) {
+ for (Int_t iDet = 5; iDet >= 0; iDet--) {
AliTracker *tracker = fTracker[iDet];
if (!tracker) continue;
Int_t nspdet = track->GetClusters(iDet,idx);
}
-TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
- // Dump a file content into a char in TNamed
- ifstream in;
- in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
- Int_t kBytes = (Int_t)in.tellg();
- printf("Size: %d \n",kBytes);
- TNamed *fn = 0;
- if(in.good()){
- char* memblock = new char [kBytes];
- in.seekg (0, ios::beg);
- in.read (memblock, kBytes);
- in.close();
- TString fData(memblock,kBytes);
- fn = new TNamed(pName,fData);
- printf("fData Size: %d \n",fData.Sizeof());
- printf("pName Size: %d \n",pName.Sizeof());
- printf("fn Size: %d \n",fn->Sizeof());
- delete[] memblock;
- }
- else{
- AliInfo(Form("Could not Open %s\n",fPath.Data()));
- }
-
- return fn;
-}
-
-void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
- // This is not really needed in AliReconstruction at the moment
- // but can serve as a template
-
- TList *fList = fTree->GetUserInfo();
- TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
- printf("fn Size: %d \n",fn->Sizeof());
-
- TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
- const char* cdata = fn->GetTitle();
- printf("fTmp Size %d\n",fTmp.Sizeof());
-
- int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
- printf("calculated size %d\n",size);
- ofstream out(pName.Data(),ios::out | ios::binary);
- out.write(cdata,size);
- out.close();
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::CheckQA()
{
{
// return the detector index corresponding to detector
Int_t index = -1 ;
- for (index = 0; index < fgkNDetectors ; index++) {
+ for (index = 0; index < kNDetectors ; index++) {
if ( strcmp(detector, fgkDetectorName[index]) == 0 )
break ;
}
// 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 < kNDetectors; iDet++) {
for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
//if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
if(fTracker[iDet]) {
AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
- gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->SetAutoLoad(kTRUE);gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
+ gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
gROOT->ProcessLine("alieve_online_init()");
return kTRUE;
// successful initialization of AliEVE.
AliInfo("Running AliEVE...");
- gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
- gROOT->ProcessLine("gAliEveEvent->StartStopAutoLoadTimer();");
+ gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
gSystem->Run();
}
tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ;
tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
- fQASteer->SetActiveDetectors(fQADetectors) ;
- fQASteer->SetTasks(fQATasks) ;
AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
fRunQA = kTRUE ;
return kTRUE;
Bool_t isOK = kTRUE;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
if (fRecoParam.GetDetRecoParamArray(iDet)) {
AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
isOK = kFALSE;
}
entry->SetOwner(0);
+ AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
}
}
- fRecoParam.Print();
+ if (AliDebugLevel() > 0) fRecoParam.Print();
return isOK;
}
for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
if (trclass) {
- Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
+ Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
fesd->SetTriggerClass(trclass->GetName(),trindex);
+ if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
if (trmask & (1 << trindex)) {
trclasses += " ";
trclasses += trclass->GetName();
if ((detectorMask >> iDet) & 0x1) {
TString det = AliDAQ::OfflineModuleName(iDet);
if ((detList.CompareTo("ALL") == 0) ||
- detList.BeginsWith("ALL ") ||
- detList.EndsWith(" ALL") ||
- detList.Contains(" ALL ") ||
+ ((detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ")) &&
+ !(detList.BeginsWith("-"+det+" ") ||
+ detList.EndsWith(" -"+det) ||
+ detList.Contains(" -"+det+" "))) ||
(detList.CompareTo(det) == 0) ||
- detList.BeginsWith(det) ||
- detList.EndsWith(det) ||
+ detList.BeginsWith(det+" ") ||
+ detList.EndsWith(" "+det) ||
detList.Contains( " "+det+" " )) {
if (!resultList.EndsWith(det + " ")) {
resultList += det;
if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
if ((detList.CompareTo("ALL") == 0) ||
- detList.BeginsWith("ALL ") ||
- detList.EndsWith(" ALL") ||
- detList.Contains(" ALL ") ||
+ ((detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ")) &&
+ !(detList.BeginsWith("-"+hltDet+" ") ||
+ detList.EndsWith(" -"+hltDet) ||
+ detList.Contains(" -"+hltDet+" "))) ||
(detList.CompareTo(hltDet) == 0) ||
- detList.BeginsWith(hltDet) ||
- detList.EndsWith(hltDet) ||
+ detList.BeginsWith(hltDet+" ") ||
+ detList.EndsWith(" "+hltDet) ||
detList.Contains( " "+hltDet+" " )) {
resultList += hltDet;
}
return resultList.Data();
}
+
+//______________________________________________________________________________
+void AliReconstruction::Abort(const char *method, EAbort what)
+{
+ // Abort processing. If what = kAbortProcess, the Process() loop will be
+ // aborted. If what = kAbortFile, the current file in a chain will be
+ // aborted and the processing will continue with the next file, if there
+ // is no next file then Process() will be aborted. Abort() can also be
+ // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
+ // the SlaveTerminate() and Terminate() are always called. The abort flag
+ // can be checked in these methods using GetAbort().
+ //
+ // The method is overwritten in AliReconstruction for better handling of
+ // reco specific errors
+
+ if (!fStopOnError) return;
+
+ CleanUp();
+
+ TString whyMess = method;
+ whyMess += " failed! Aborting...";
+
+ AliError(whyMess.Data());
+
+ fAbort = what;
+ TString mess = "Abort";
+ if (fAbort == kAbortProcess)
+ mess = "AbortProcess";
+ else if (fAbort == kAbortFile)
+ mess = "AbortFile";
+
+ Info(mess, whyMess.Data());
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff