// 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: //
-// level 1: after tracking and after filling of ESD (final) //
-// level 2: in addition after each tracking step //
-// level 3: in addition after the filling of ESD for each detector //
-// If a final check point file exists for an event, this event will be //
-// skipped in the reconstruction. The tracking and the filling of ESD for //
-// a detector will be skipped as well, if the corresponding check point //
-// file exists. The ESD event will then be loaded from the file instead. //
// //
///////////////////////////////////////////////////////////////////////////////
#include <TArrayS.h>
#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 "AliCentralTrigger.h"
#include "AliTriggerConfiguration.h"
#include "AliTriggerClass.h"
+#include "AliTriggerCluster.h"
#include "AliCTPRawStream.h"
#include "AliQADataMakerRec.h"
#include "AliSysInfo.h" // memory snapshots
#include "AliRawHLTManager.h"
+#include "AliMagWrapCheb.h"
-ClassImp(AliReconstruction)
+#include "AliDetectorRecoParam.h"
+#include "AliGRPRecoParam.h"
+#include "AliRunInfo.h"
+#include "AliEventInfo.h"
+
+#include "AliDAQ.h"
+#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"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename,
- const char* name, const char* title) :
- TNamed(name, title),
-
- fUniformField(kTRUE),
+AliReconstruction::AliReconstruction(const char* gAliceFilename) :
+ TSelector(),
+ fUniformField(kFALSE),
+ 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),
- fCheckPointLevel(0),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
fESDPar(""),
fUseHLTData(),
+ fRunInfo(NULL),
+ fEventInfo(),
fRunLoader(NULL),
fRawReader(NULL),
fParentRawReader(NULL),
+ fRecoParam(),
+
fVertexer(NULL),
+ fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(kTRUE),
-
- fGRPList(NULL),
+
+ fGRPData(NULL),
fAlignObjArray(NULL),
fCDBUri(),
fSpecCDBUri(),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
+ fQADetectors("ALL"),
+ fQASteer(NULL),
+ fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
- fInLoopQA(kFALSE),
fSameQACycle(kFALSE),
fRunPlaneEff(kFALSE),
ffile(NULL),
ftree(NULL),
fhlttree(NULL),
- ffileOld(NULL),
- ftreeOld(NULL),
- fhlttreeOld(NULL),
ftVertexer(NULL),
- fIsNewRunLoader(kFALSE)
+ fIsNewRunLoader(kFALSE),
+ fRunAliEVE(kFALSE),
+ fChain(NULL)
{
// create reconstruction object with default parameters
+ gGeoManager = NULL;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQADataMaker[iDet] = NULL;
- fQACycles[iDet] = 999999;
}
- fQADataMaker[fgkNDetectors]=NULL; //Global QA
+ 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(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),
fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
- fCheckPointLevel(0),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
fESDPar(rec.fESDPar),
fUseHLTData(rec.fUseHLTData),
+ fRunInfo(NULL),
+ fEventInfo(),
fRunLoader(NULL),
fRawReader(NULL),
fParentRawReader(NULL),
- fVertexer(NULL),
- fDiamondProfile(NULL),
- fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(rec.fMeanVertexConstraint),
+ fRecoParam(rec.fRecoParam),
- fGRPList(NULL),
+ fVertexer(NULL),
+ fDiamondProfileSPD(rec.fDiamondProfileSPD),
+ fDiamondProfile(rec.fDiamondProfile),
+ fDiamondProfileTPC(rec.fDiamondProfileTPC),
+
+ fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
+ fQADetectors(rec.fQADetectors),
+ fQASteer(NULL),
+ fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
- fInLoopQA(rec.fInLoopQA),
fSameQACycle(rec.fSameQACycle),
fRunPlaneEff(rec.fRunPlaneEff),
ffile(NULL),
ftree(NULL),
fhlttree(NULL),
- ffileOld(NULL),
- ftreeOld(NULL),
- fhlttreeOld(NULL),
ftVertexer(NULL),
- fIsNewRunLoader(rec.fIsNewRunLoader)
+ fIsNewRunLoader(rec.fIsNewRunLoader),
+ fRunAliEVE(kFALSE),
+ fChain(NULL)
{
// copy constructor
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQADataMaker[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] ;
}
- 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());
}
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;
+ fESDPar = rec.fESDPar;
+ 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 < fgkNDetectors; 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] ;
+ }
+
+ fVertexer = NULL;
+ 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 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");
}
//_____________________________________________________________________________
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 loadAlObjsListOfDets = "";
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- loadAlObjsListOfDets += fgkDetectorName[iDet];
- loadAlObjsListOfDets += " ";
+ if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
+ if(AliGeomManager::IsModuleInGeom(fgkDetectorName[iDet]))
+ {
+ loadAlObjsListOfDets += fgkDetectorName[iDet];
+ loadAlObjsListOfDets += " ";
+ }
} // end loop over detectors
- loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
+ if(AliGeomManager::IsModuleInGeom("FRAME"))
+ 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;
}
//_____________________________________________________________________________
fOptions.Add(new TNamed(detector, option));
}
+//_____________________________________________________________________________
+void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
+{
+ // Set custom reconstruction parameters for a given detector
+ // Single set of parameters for all the events
+
+ // First check if the reco-params are global
+ if(!strcmp(detector, "GRP")) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(fgkNDetectors,par);
+ return;
+ }
+
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if(!strcmp(detector, fgkDetectorName[iDet])) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(iDet,par);
+ break;
+ }
+ }
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) {
+ //------------------------------------------------
+ // The magnetic field map, defined externally...
+ // L3 current 30000 A -> 0.5 T
+ // L3 current 12000 A -> 0.2 T
+ // dipole current 6000 A
+ // The polarities must be the same
+ //------------------------------------------------
+ const Float_t l3NominalCurrent1=30000.; // (A)
+ const Float_t l3NominalCurrent2=12000.; // (A)
+ const Float_t diNominalCurrent =6000. ; // (A)
+
+ const Float_t tolerance=0.03; // relative current tolerance
+ const Float_t zero=77.; // "zero" current (A)
+
+ Int_t map=0;
+ Bool_t dipoleON=kFALSE;
+
+ TString s=(factor < 0) ? "L3: -" : "L3: +";
+
+ l3Current = TMath::Abs(l3Current);
+ if (TMath::Abs(l3Current-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
+ map=AliMagWrapCheb::k5kG;
+ s+="0.5 T; ";
+ } else
+ if (TMath::Abs(l3Current-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
+ map=AliMagWrapCheb::k2kG;
+ s+="0.2 T; ";
+ } else
+ if (l3Current < zero) {
+ map=AliMagWrapCheb::k2kG;
+ s+="0.0 T; ";
+ factor=0.; // in fact, this is a global factor...
+ fUniformField=kTRUE; // track with the uniform (zero) B field
+ } else {
+ AliError(Form("Wrong L3 current (%f A)!",l3Current));
+ return kFALSE;
+ }
+
+ diCurrent = TMath::Abs(diCurrent);
+ if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
+ // 3% current tolerance...
+ dipoleON=kTRUE;
+ s+="Dipole ON";
+ } else
+ if (diCurrent < zero) { // some small current..
+ dipoleON=kFALSE;
+ s+="Dipole OFF";
+ } else {
+ AliError(Form("Wrong dipole current (%f A)!",diCurrent));
+ return kFALSE;
+ }
+
+ delete fForcedFieldMap;
+ fForcedFieldMap=
+ new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path);
+
+ fForcedFieldMap->Print();
+
+ AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
+
+ return kTRUE;
+}
+
+
+Bool_t AliReconstruction::InitGRP() {
+ //------------------------------------
+ // Initialization of the GRP entry
+ //------------------------------------
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+
+ 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;
+ }
+
+ TString lhcState = fGRPData->GetLHCState();
+ if (lhcState==AliGRPObject::GetInvalidString()) {
+ AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
+ lhcState = "UNKNOWN";
+ }
+
+ TString beamType = fGRPData->GetBeamType();
+ if (beamType==AliGRPObject::GetInvalidString()) {
+ AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
+ beamType = "UNKNOWN";
+ }
+
+ Float_t beamEnergy = fGRPData->GetBeamEnergy();
+ if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
+ AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
+ beamEnergy = 0;
+ }
+
+ TString runType = fGRPData->GetRunType();
+ if (runType==AliGRPObject::GetInvalidString()) {
+ AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
+ runType = "UNKNOWN";
+ }
+
+ 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, beamType, beamEnergy, runType, activeDetectors);
+
+ fRunInfo->Dump();
+
+
+ // Process the list of active detectors
+ if (activeDetectors) {
+ UInt_t detMask = activeDetectors;
+ fLoadCDB.Form("%s %s %s %s",
+ fRunLocalReconstruction.Data(),
+ fRunTracking.Data(),
+ fFillESD.Data(),
+ fQADetectors.Data());
+ fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
+ fRunTracking = MatchDetectorList(fRunTracking,detMask);
+ fFillESD = MatchDetectorList(fFillESD,detMask);
+ fQADetectors = MatchDetectorList(fQADetectors,detMask);
+ 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;
+ }
+ }
+
+ AliInfo("===================================================================================");
+ AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
+ 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
+ if (AliTracker::GetFieldMap()) {
+ AliInfo("Running with the externally set B field !");
+ } else {
+ // Construct the field map out of the information retrieved from GRP.
+
+ 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 current !");
+ ok = kFALSE;
+ }
+ TObjString *l3Polarity=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
+ if (!l3Polarity) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
+ ok = kFALSE;
+ }
+
+ // Dipole
+ TObjString *diCurrent=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
+ if (!diCurrent) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole current !");
+ ok = kFALSE;
+ }
+ TObjString *diPolarity=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
+ if (!diPolarity) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
+ ok = kFALSE;
+ }
+ */
+
+ if (ok) {
+ 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.;
+
+
+ if (!SetFieldMap(l3Cur, diCur, factor)) {
+ AliFatal("Failed to creat a B field map ! Exiting...");
+ }
+ AliInfo("Running with the B field constructed out of GRP !");
+ }
+ else {
+ AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
+ }
+
+ }
+
+ //*** 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!");
+ }
+
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
+ if (entry) {
+ 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());
+ } else {
+ 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 < fgkNDetectors; 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) if (fStopOnError) return kFALSE;
+ if (!gGeoManager) {
+ Abort("LoadGeometry", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadGeom");
+ TString detsToCheck=fRunLocalReconstruction;
+ 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");
-
- /*
- // local reconstruction
- if (!fRunLocalReconstruction.IsNull()) {
- if (!RunLocalReconstruction(fRunLocalReconstruction)) {
- if (fStopOnError) {CleanUp(); return kFALSE;}
+ if (!InitGRP()) {
+ Abort("InitGRP", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("InitGRP");
+
+ if (!LoadCDB()) {
+ Abort("LoadCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadCDB");
+
+ // Read the reconstruction parameters from OCDB
+ if (!InitRecoParams()) {
+ AliWarning("Not all detectors have correct RecoParam objects initialized");
+ }
+ AliSysInfo::AddStamp("InitRecoParams");
+
+ 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);
+ }
+
+}
+
+//_____________________________________________________________________________
+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("LoadLoader");
+
+ ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
// get vertexer
if (fRunVertexFinder && !CreateVertexer()) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
+ Abort("CreateVertexer", TSelector::kAbortProcess);
+ return;
}
- AliSysInfo::AddStamp("Vertexer");
+ AliSysInfo::AddStamp("CreateVertexer");
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
- }
- AliSysInfo::AddStamp("LoadTrackers");
+ Abort("CreateTrackers", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("CreateTrackers");
- // get the possibly already existing ESD file and tree
- fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
- if (!gSystem->AccessPathName("AliESDs.root")){
- gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
- ffileOld = TFile::Open("AliESDs.old.root");
- if (ffileOld && ffileOld->IsOpen()) {
- ftreeOld = (TTree*) ffileOld->Get("esdTree");
- if (ftreeOld)fesd->ReadFromTree(ftreeOld);
- fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
- if (fhlttreeOld) fhltesd->ReadFromTree(fhlttreeOld);
+ // create the ESD output file and tree
+ if (!outProofFile) {
+ ffile = TFile::Open("AliESDs.root", "RECREATE");
+ ffile->SetCompressionLevel(2);
+ if (!ffile->IsOpen()) {
+ Abort("OpenESDFile", TSelector::kAbortProcess);
+ return;
}
}
-
- // 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, ffileOld); return kFALSE;}
+ 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();
+ if (fWriteESDfriend) {
+ fesdf = new AliESDfriend();
+ TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
+ br->SetFile("AliESDfriends.root");
+ fesd->AddObject(fesdf);
+ }
fesd->WriteToTree(ftree);
+ ftree->GetUserInfo()->Add(fesd);
fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
fhltesd = new AliESDEvent();
fhltesd->CreateStdContent();
fhltesd->WriteToTree(fhlttree);
+ fhlttree->GetUserInfo()->Add(fhltesd);
- /* CKB Why?
- delete esd; delete hltesd;
- esd = NULL; hltesd = NULL;
- */
- // create the branch with ESD additions
-
-
-
- if (fWriteESDfriend) {
- fesdf = new AliESDfriend();
- TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
- br->SetFile("AliESDfriends.root");
- fesd->AddObject(fesdf);
+ ProcInfo_t ProcInfo;
+ gSystem->GetProcInfo(&ProcInfo);
+ AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+
+ //QA
+ //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) ;
}
-
- // 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!");
+ 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);
+ }
}
- // Get the diamond profile from OCDB
- AliCDBEntry* entry = AliCDBManager::Instance()
- ->Get("GRP/Calib/MeanVertex");
-
- if(entry) {
- fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
- } else {
- AliError("No diamond profile found in OCDB!");
+ //Initialize the Plane Efficiency framework
+ if (fRunPlaneEff && !InitPlaneEff()) {
+ Abort("InitPlaneEff", TSelector::kAbortProcess);
+ return;
}
- 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!");
- }
+ if (strcmp(gProgName,"alieve") == 0)
+ fRunAliEVE = InitAliEVE();
- ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
- if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
+ return;
+}
- if (fRawReader) fRawReader->RewindEvents();
+//_____________________________________________________________________________
+Bool_t AliReconstruction::Process(Long64_t entry)
+{
+ // run the reconstruction over a single entry
+ // from the chain with raw data
+ AliCodeTimerAuto("");
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
-
+ 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;
- //Initialize the QA and start of cycle for out-of-cycle QA
- //QA
- AliQADataMakerSteer qas ;
- if (fRunQA && fRawReader) {
- qas.SetEventRange(fFirstEvent, fLastEvent) ;
- qas.Run(fRunLocalReconstruction, fRawReader) ;
- fSameQACycle = kTRUE ;
- }
- // checking the QA of previous steps
- //CheckQA() ;
- if (fRunQA) {
- TString detStr(fFillESD);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliQADataMakerRec *qadm = GetQADataMaker(iDet);
- if (!qadm) continue;
- AliInfo(Form("Initializing the QA data maker for %s",
- fgkDetectorName[iDet]));
-
- qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- qadm->StartOfCycle(AliQA::kESDS,"same");
- }
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
- AliInfo(Form("Initializing the global QA data maker"));
- TObjArray *arr=
- qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
- AliTracker::SetResidualsArray(arr);
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- qadm->StartOfCycle(AliQA::kESDS, "same");
- }
- }
- if (!fInLoopQA)
- fSameQACycle = kTRUE;
- }
+ return fStatus;
+}
- //Initialize the Plane Efficiency framework
- if (fRunPlaneEff && !InitPlaneEff()) {
- if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+//_____________________________________________________________________________
+void AliReconstruction::Init(TTree *tree)
+{
+ if (tree == 0) {
+ AliError("The input tree is not found!");
+ return;
}
-
- return kTRUE;
+ 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))) {
- // copy old ESD to the new one
- if (ftreeOld) {
- fesd->ReadFromTree(ftreeOld);
- ftreeOld->GetEntry(iEvent);
- ftree->Fill();
- }
- if (fhlttreeOld) {
- fesd->ReadFromTree(fhlttreeOld);
- fhlttreeOld->GetEntry(iEvent);
- fhlttree->Fill();
- }
return kTRUE;
}
AliInfo(Form("processing event %d", iEvent));
- //Start of cycle for the in-loop QA
- if (fInLoopQA) {
- if (fRunQA) {
- TString detStr(fFillESD);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQADataMakerRec *qadm = GetQADataMaker(iDet);
- if (!qadm)
- continue;
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- qadm->StartOfCycle(AliQA::kESDS, "same") ;
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
- qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
- qadm->StartOfCycle(AliQA::kESDS, "same");
- }
- }
+ // Fill Event-info object
+ GetEventInfo();
+ fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
+
+ // Set the reco-params
+ {
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; 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);
+ }
}
+ }
- fRunLoader->GetEvent(iEvent);
+ 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;
+ // QA on single raw
+ if (fRunQA)
+ fQASteer->RunOneEvent(fRawReader) ;
- // local signle event reconstruction
+ // local single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
- TString detectors="HLT";
+ TString detectors=fRunLocalReconstruction;
// run HLT event reconstruction first
- if (IsSelected(detectors, fRunLocalReconstruction) &&
- !RunLocalEventReconstruction(detectors)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+ // ;-( IsSelected changes the string
+ if (IsSelected("HLT", detectors) &&
+ !RunLocalEventReconstruction("HLT")) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
detectors=fRunLocalReconstruction;
detectors.ReplaceAll("HLT", "");
if (!RunLocalEventReconstruction(detectors)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); 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(fgkNDetectors));
+ 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, ffileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
- }
- }
-
- // HLT tracking
- if (!fRunTracking.IsNull()) {
- if (fRunHLTTracking) {
- fhltesd->SetPrimaryVertexSPD(fesd->GetVertex());
- if (!RunHLTTracking(fhltesd)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
- }
+ if (!RunVertexFinder(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
if (!fRunTracking.IsNull()) {
if (fRunMuonTracking) {
if (!RunMuonTracking(fesd)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
}
// barrel tracking
if (!fRunTracking.IsNull()) {
- if (!ReadESD(fesd, "tracking")) {
- if (!RunTracking(fesd)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
+ if (!RunTracking(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
// fill ESD
if (!fFillESD.IsNull()) {
- if (!FillESD(fesd, fFillESD)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+ TString detectors=fFillESD;
+ // run HLT first and on hltesd
+ // ;-( IsSelected changes the string
+ if (IsSelected("HLT", detectors) &&
+ !FillESD(fhltesd, "HLT")) {
+ if (fStopOnError) {CleanUp(); 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){
+ detectors += fgkDetectorName[idet];
+ detectors += " ";
+ }
+ }
+ detectors.ReplaceAll("HLT", "");
+ if (!FillESD(fesd, detectors)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
// combined PID
AliESDpid::MakePID(fesd);
- if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
if (fFillTriggerESD) {
- if (!ReadESD(fesd, "trigger")) {
- if (!FillTriggerESD(fesd)) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
+ if (!FillTriggerESD(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
ffile->cd();
//
- // Propagate track to the beam pipe (if not laready done by ITS)
+ // Propagate track to the beam pipe (if not already done by ITS)
//
const Int_t ntracks = fesd->GetNumberOfTracks();
const Double_t kBz = fesd->GetMagneticField();
ok = AliTracker::
PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
-
-
if (ok) {
Int_t n=trkArray.GetEntriesFast();
selectedIdx[n]=track->GetID();
trkArray.AddLast(tpcTrack);
}
-
//Tracks refitted by ITS should already be at the SPD vertex
if (track->IsOn(AliESDtrack::kITSrefit)) continue;
-
AliTracker::
- PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
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) {
}
// 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) {
if (pvtx->GetStatus()) {
fesd->SetPrimaryVertexTPC(pvtx);
- Int_t nsel=trkArray.GetEntriesFast();
- for (Int_t i=0; i<nsel; i++) {
- AliExternalTrackParam *t =
- (AliExternalTrackParam *)trkArray.UncheckedAt(i);
- t->PropagateToDCA(pvtx, kBz, kRadius);
+ for (Int_t i=0; i<ntracks; i++) {
+ AliESDtrack *t = fesd->GetTrack(i);
+ t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
}
}
}
// write ESD
if (fCleanESD) CleanESD(fesd);
- if (fRunQA) {
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
- if (qadm) 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()) {
+ ftree->AutoSave("SaveSelf");
+ TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
+ if (friendfile) friendfile->Save();
+ }
+
// write HLT ESD
fhlttree->Fill();
- if (fCheckPointLevel > 0) WriteESD(fesd, "final");
+ // call AliEVE
+ if (fRunAliEVE) RunAliEVE();
+
fesd->Reset();
fhltesd->Reset();
if (fWriteESDfriend) {
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
-
- // End of cycle for the in-loop QA
- if (fInLoopQA) {
- if (fRunQA) {
- RunQA(fFillESD.Data(), fesd);
- TString detStr(fFillESD);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (!qadm)
- continue;
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
- if (qadm) {
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
- }
-
- return kTRUE;
+ fEventInfo.Reset();
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (fReconstructor[iDet])
+ 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();
TIter iter2(cdbList);
- AliCDBId* id=0;
- while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
+ AliCDBId* id=0;
+ while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
cdbListCopy->Add(new TObjString(id->ToString().Data()));
}
AliWarning("Finish PlaneEff evaluation failed");
}
- gROOT->cd();
- CleanUp(ffile, ffileOld);
-
- if (fWriteAOD) {
- AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
+ // End of cycle for the in-loop
+ if (fRunQA) {
+ fQASteer->EndOfCycle() ;
}
-
- // Create tags for the events in the ESD tree (the ESD tree is always present)
- // In case of empty events the tags will contain dummy values
- AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
- esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList);
- if (fWriteAOD) {
- AliWarning("AOD tag creation not supported anymore during reconstruction.");
- }
-
- //Finish QA and end of cycle for out-of-loop QA
- if (!fInLoopQA) {
- if (fRunQA) {
- AliQADataMakerSteer qas;
- qas.SetEventRange(fFirstEvent, fLastEvent) ;
- qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
- //qas.Reset() ;
- qas.Run(fRunTracking.Data(), AliQA::kESDS, fSameQACycle);
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
- if (qadm) {
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
- }
+ 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();
+ }
}
-
- // Cleanup of CDB manager: cache and active storages!
- AliCDBManager::Instance()->ClearCache();
-
- return kTRUE;
+ gROOT->cd();
+ CleanUp();
}
-
-
+
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
+void AliReconstruction::Terminate()
{
-// 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);
+ // 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("");
-// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-// AliError(Form("the following detectors were not found: %s",
-// detStr.Data()));
-// if (fStopOnError) return kFALSE;
-// }
+ AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
- eventNr++;
- return kTRUE;
+ // Cleanup of CDB manager: cache and active storages!
+ AliCDBManager::Instance()->ClearCache();
}
//_____________________________________________________________________________
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
AliLoader* loader = fLoader[iDet];
+ // Matthias April 2008: temporary fix to run HLT reconstruction
+ // although the HLT loader is missing
+ if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
+ if (fRawReader) {
+ reconstructor->Reconstruct(fRawReader, NULL);
+ } else {
+ TTree* dummy=NULL;
+ reconstructor->Reconstruct(dummy, NULL);
+ }
+ continue;
+ }
if (!loader) {
AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
continue;
if (fRawReader && reconstructor->HasDigitConversion()) {
AliInfo(Form("converting raw data digits into root objects for %s",
fgkDetectorName[iDet]));
- AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
- fgkDetectorName[iDet]));
+// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
+// fgkDetectorName[iDet]));
loader->LoadDigits("update");
loader->CleanDigits();
loader->MakeDigitsContainer();
}
// local reconstruction
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
loader->LoadRecPoints("update");
loader->CleanRecPoints();
loader->MakeRecPointsContainer();
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);
+ TString detQAStr(fQADetectors) ;
+ 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()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
}
if (fVertexer) {
- if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
AliInfo("running the ITS vertex finder");
- if (fLoader[0]) fLoader[0]->LoadRecPoints();
- vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
- if (fLoader[0]) fLoader[0]->UnloadRecPoints();
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ if(fDiamondProfileSPD) fVertexer->SetVtxStart(fDiamondProfileSPD);
+ vertex = fVertexer->FindVertexForCurrentEvent(cltree);
+ }
+ else {
+ AliError("Can't get the ITS cluster tree");
+ }
+ fLoader[0]->UnloadRecPoints();
+ }
+ else {
+ AliError("Can't get the ITS loader");
+ }
if(!vertex){
AliWarning("Vertex not found");
vertex = new AliESDVertex();
AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
return kFALSE;
}
- if (fCheckPointLevel > 1) {
- WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
- }
// preliminary PID in TPC needed by the ITS tracker
if (iDet == 1) {
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
// return kFALSE;
}
- if (fCheckPointLevel > 1) {
- WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
- }
// unload clusters
- if (iDet > 2) { // all except ITS, TPC, TRD
+ if (iDet > 3) { // all except ITS, TPC, TRD and TOF
fTracker[iDet]->UnloadClusters();
fLoader[iDet]->UnloadRecPoints();
}
//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
- if (fWriteAlignmentData)
- WriteAlignmentData(esd);
-
// pass 3: TRD + TPC + ITS refit inwards
for (Int_t iDet = 2; iDet >= 0; iDet--) {
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);
+ }
+
+ // write space-points to the ESD in case alignment data output
+ // is switched on
+ if (fWriteAlignmentData)
+ WriteAlignmentData(esd);
+
+ for (Int_t iDet = 3; iDet >= 0; iDet--) {
+ if (!fTracker[iDet]) continue;
// unload clusters
fTracker[iDet]->UnloadClusters();
AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
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();
- }
-
- if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
+ reconstructor->FillESD(digitsTree, clustersTree, esd);
+ if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
+ }
+ if (fLoader[iDet]) {
+ fLoader[iDet]->UnloadRecPoints();
}
}
AliInfo("Filling trigger information into the ESD");
- AliCentralTrigger *aCTP = NULL;
-
if (fRawReader) {
AliCTPRawStream input(fRawReader);
if (!input.Next()) {
- AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
- return kFALSE;
- }
- esd->SetTriggerMask(input.GetClassMask());
- esd->SetTriggerCluster(input.GetClusterMask());
-
- aCTP = new AliCentralTrigger();
- TString configstr("");
- if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
- AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
- delete aCTP;
- return kFALSE;
- }
- }
- else {
- AliRunLoader *runloader = AliRunLoader::GetRunLoader();
- if (runloader) {
- if (!runloader->LoadTrigger()) {
- aCTP = runloader->GetTrigger();
- esd->SetTriggerMask(aCTP->GetClassMask());
- esd->SetTriggerCluster(aCTP->GetClusterMask());
- }
- else {
- AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
- return kFALSE;
- }
+ AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
}
else {
- AliError("No run loader is available! The trigger information is not stored in the ESD !");
- return kFALSE;
+ if (esd->GetTriggerMask() != input.GetClassMask())
+ AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
+ input.GetClassMask(),esd->GetTriggerMask()));
+ if (esd->GetOrbitNumber() != input.GetOrbitID())
+ AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
+ input.GetOrbitID(),esd->GetOrbitNumber()));
+ if (esd->GetBunchCrossNumber() != input.GetBCID())
+ AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
+ input.GetBCID(),esd->GetBunchCrossNumber()));
}
- }
-
- // Now fill the trigger class names into AliESDRun object
- AliTriggerConfiguration *config = aCTP->GetConfiguration();
- if (!config) {
- AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
- if (fRawReader) delete aCTP;
- return kFALSE;
- }
- const TObjArray& classesArray = config->GetClasses();
- Int_t nclasses = classesArray.GetEntriesFast();
- for( Int_t j=0; j<nclasses; j++ ) {
- AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
- Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
- esd->SetTriggerClass(trclass->GetName(),trindex);
+ // Here one has to add the filling of trigger inputs and
+ // interaction records
+ // ...
}
-
- if (fRawReader) delete aCTP;
return kTRUE;
}
// Filling information from RawReader Header
//
+ if (!fRawReader) return kFALSE;
+
AliInfo("Filling information from RawReader Header");
- esd->SetBunchCrossNumber(0);
- esd->SetOrbitNumber(0);
- esd->SetPeriodNumber(0);
- esd->SetTimeStamp(0);
- esd->SetEventType(0);
- const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
- if (eventHeader){
- const UInt_t *id = eventHeader->GetP("Id");
- esd->SetBunchCrossNumber((id)[1]&0x00000fff);
- esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
- esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
+ esd->SetBunchCrossNumber(fRawReader->GetBCID());
+ esd->SetOrbitNumber(fRawReader->GetOrbitID());
+ esd->SetPeriodNumber(fRawReader->GetPeriod());
- esd->SetTimeStamp((eventHeader->Get("Timestamp")));
- esd->SetEventType((eventHeader->Get("Type")));
- }
+ esd->SetTimeStamp(fRawReader->GetTimestamp());
+ esd->SetEventType(fRawReader->GetType());
return kTRUE;
}
CleanUp();
return kFALSE;
}
+
fRunLoader->CdGAFile();
- if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
- if (fRunLoader->LoadgAlice() == 0) {
- gAlice = fRunLoader->GetAliRun();
- AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
- }
- }
- if (!gAlice && !fRawReader) {
- AliError(Form("no gAlice object found in file %s",
- fGAliceFileName.Data()));
- CleanUp();
- return kFALSE;
- }
+ fRunLoader->LoadgAlice();
//PH This is a temporary fix to give access to the kinematics
//PH that is needed for the labels of ITS clusters
} 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(),
{
// get the reconstructor object and the loader for a detector
- if (fReconstructor[iDet]) return fReconstructor[iDet];
+ if (fReconstructor[iDet]) {
+ if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ fReconstructor[iDet]->SetRecoParam(par);
+ }
+ return fReconstructor[iDet];
+ }
// load the reconstructor object
TPluginManager* pluginManager = gROOT->GetPluginManager();
TString detName = fgkDetectorName[iDet];
TString recName = "Ali" + detName + "Reconstructor";
- if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
+
+ if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
AliReconstructor* reconstructor = NULL;
// first check if a plugin is defined for the reconstructor
}
}
+ if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ reconstructor->SetRecoParam(par);
+ }
return reconstructor;
}
Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
{
// create the trackers
+ AliInfo("Creating trackers");
TString detStr = detectors;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
}
//_____________________________________________________________________________
-void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
+void AliReconstruction::CleanUp()
{
// delete trackers and the run loader and close and delete the file
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
-// delete fQADataMaker[iDet];
-// fQADataMaker[iDet] = NULL;
}
+ 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 fGRPList;
- fGRPList = 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 (fileOld) {
- fileOld->Close();
- delete fileOld;
- gSystem->Unlink("AliESDs.old.root");
- }
-
-}
-
-//_____________________________________________________________________________
-
-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();
+ if (ffile) {
+ ffile->Close();
+ delete ffile;
+ ffile = NULL;
}
- delete file;
}
-
void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
{
// Write space-points which are then used in the alignment procedures
- // For the moment only ITS, TRD and TPC
+ // For the moment only ITS, TPC, TRD and TOF
- // Load TOF clusters
- if (fTracker[3]){
- fLoader[3]->LoadRecPoints("read");
- TTree* tree = fLoader[3]->TreeR();
- if (!tree) {
- AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
- return;
- }
- fTracker[3]->LoadClusters(tree);
- }
Int_t ntracks = esd->GetNumberOfTracks();
for (Int_t itrack = 0; itrack < ntracks; itrack++)
{
AliESDtrack *track = esd->GetTrack(itrack);
Int_t nsp = 0;
Int_t idx[200];
- for (Int_t iDet = 3; iDet >= 0; iDet--)
- nsp += track->GetNcls(iDet);
+ for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
+ nsp += track->GetNcls(iDet);
+
+ if (iDet==0) { // ITS "extra" clusters
+ track->GetClusters(iDet,idx);
+ for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
+ }
+ }
+
if (nsp) {
AliTrackPointArray *sp = new AliTrackPointArray(nsp);
track->SetTrackPointArray(sp);
for (Int_t iDet = 3; iDet >= 0; iDet--) {
AliTracker *tracker = fTracker[iDet];
if (!tracker) continue;
- Int_t nspdet = track->GetNcls(iDet);
+ Int_t nspdet = track->GetClusters(iDet,idx);
+
+ if (iDet==0) // ITS "extra" clusters
+ for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
+
if (nspdet <= 0) continue;
- track->GetClusters(iDet,idx);
AliTrackPoint p;
Int_t isp = 0;
Int_t isp2 = 0;
while (isp2 < nspdet) {
- Bool_t isvalid;
+ Bool_t isvalid=kTRUE;
+
+ Int_t index=idx[isp++];
+ if (index < 0) continue;
+
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);
+ isvalid = tracker->GetTrackPointTrackingError(index,p,track);
} else {
- isvalid = tracker->GetTrackPoint(idx[isp2],p);
+ isvalid = tracker->GetTrackPoint(index,p);
}
isp2++;
- const Int_t kNTPCmax = 159;
- if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
if (!isvalid) continue;
- sp->AddPoint(isptrack,&p); isptrack++; isp++;
+ sp->AddPoint(isptrack,&p); isptrack++;
}
}
}
}
- if (fTracker[3]){
- fTracker[3]->UnloadClusters();
- fLoader[3]->UnloadRecPoints();
- }
}
//_____________________________________________________________________________
}
-TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
+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);
in.read (memblock, kBytes);
in.close();
TString fData(memblock,kBytes);
- fn = new TNamed(fName,fData);
+ fn = new TNamed(pName,fData);
printf("fData Size: %d \n",fData.Sizeof());
- printf("fName Size: %d \n",fName.Sizeof());
+ printf("pName Size: %d \n",pName.Sizeof());
printf("fn Size: %d \n",fn->Sizeof());
delete[] memblock;
}
return fn;
}
-void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
+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(fName.Data());
+ TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
printf("fn Size: %d \n",fn->Sizeof());
- TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
+ 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(fName.Data(),ios::out | ios::binary);
+ ofstream out(pName.Data(),ios::out | ios::binary);
out.write(cdata,size);
out.close();
}
-//_____________________________________________________________________________
-AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
-{
- // get the quality assurance data maker object and the loader for a detector
-
- if (fQADataMaker[iDet])
- return fQADataMaker[iDet];
-
- AliQADataMakerRec * qadm = NULL;
- if (iDet == fgkNDetectors) { //Global QA
- qadm = new AliGlobalQADataMaker();
- fQADataMaker[iDet] = qadm;
- return qadm;
- }
-
- // load the QA data maker object
- TPluginManager* pluginManager = gROOT->GetPluginManager();
- TString detName = fgkDetectorName[iDet];
- TString qadmName = "Ali" + detName + "QADataMakerRec";
- if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
- return NULL;
-
- // first check if a plugin is defined for the quality assurance data maker
- TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
- // if not, add a plugin for it
- if (!pluginHandler) {
- AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
- TString libs = gSystem->GetLibraries();
- if (libs.Contains("lib" + detName + "base.so") ||
- (gSystem->Load("lib" + detName + "base.so") >= 0)) {
- pluginManager->AddHandler("AliQADataMakerRec", detName,
- qadmName, detName + "qadm", qadmName + "()");
- } else {
- pluginManager->AddHandler("AliQADataMakerRec", detName,
- qadmName, detName, qadmName + "()");
- }
- pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
- }
- if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
- }
-
- fQADataMaker[iDet] = qadm;
-
- return qadm;
-}
-
-//_____________________________________________________________________________
-Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
-{
- // run the Quality Assurance data producer
-
- AliCodeTimerAuto("")
- TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (!qadm)
- continue;
- AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-
- qadm->Exec(AliQA::kESDS, esd) ;
- qadm->Increment() ;
-
- AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- }
- if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- AliError(Form("the following detectors were not found: %s",
- detStr.Data()));
- if (fStopOnError)
- return kFALSE;
- }
-
- return kTRUE;
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::CheckQA()
{
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.
+ // 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
+ // 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
+ 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();
+ AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
+ TString name=planeeff->GetName();
+ name+=".root";
+ TFile* pefile = TFile::Open(name, "RECREATE");
+ ret=(Bool_t)planeeff->Write();
+ pefile->Close();
if(planeeff->GetCreateHistos()) {
- TString name="PlaneEffHisto";
- name+=fgkDetectorName[iDet];
- name+=".root";
- ret*=planeeff->WriteHistosToFile(name,"RECREATE");
+ TString hname=planeeff->GetName();
+ hname+="Histo.root";
+ ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
}
}
}
AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
return kTRUE;
}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::InitAliEVE()
+{
+ // This method should be called only in case
+ // AliReconstruction is run
+ // within the alieve environment.
+ // It will initialize AliEVE in a way
+ // so that it can visualize event processed
+ // by AliReconstruction.
+ // The return flag shows whenever the
+ // AliEVE initialization was successful or not.
+
+ TString macroStr;
+ macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
+ AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
+ if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
+
+ 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;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::RunAliEVE()
+{
+ // Runs AliEVE visualisation of
+ // the current event.
+ // Should be executed only after
+ // successful initialization of AliEVE.
+
+ AliInfo("Running AliEVE...");
+ gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
+ gSystem->Run();
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetRunQA(TString detAndAction)
+{
+ // Allows to run QA for a selected set of detectors
+ // and a selected set of tasks among RAWS, RECPOINTS and ESDS
+ // all selected detectors run the same selected tasks
+
+ if (!detAndAction.Contains(":")) {
+ AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
+ fRunQA = kFALSE ;
+ return kFALSE ;
+ }
+ Int_t colon = detAndAction.Index(":") ;
+ fQADetectors = detAndAction(0, colon) ;
+ if (fQADetectors.Contains("ALL") )
+ fQADetectors = fFillESD ;
+ fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
+ if (fQATasks.Contains("ALL") ) {
+ fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
+ } else {
+ fQATasks.ToUpper() ;
+ TString tempo("") ;
+ if ( fQATasks.Contains("RAW") )
+ tempo = Form("%d ", AliQA::kRAWS) ;
+ if ( fQATasks.Contains("RECPOINT") )
+ tempo += Form("%d ", AliQA::kRECPOINTS) ;
+ if ( fQATasks.Contains("ESD") )
+ tempo += Form("%d ", AliQA::kESDS) ;
+ fQATasks = tempo ;
+ if (fQATasks.IsNull()) {
+ AliInfo("No QA requested\n") ;
+ fRunQA = kFALSE ;
+ return kTRUE ;
+ }
+ }
+ TString tempo(fQATasks) ;
+ 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)) ;
+ AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
+ fRunQA = kTRUE ;
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::InitRecoParams()
+{
+ // The method accesses OCDB and retrieves all
+ // the available reco-param objects from there.
+
+ Bool_t isOK = kTRUE;
+
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+
+ if (fRecoParam.GetDetRecoParamArray(iDet)) {
+ AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
+ continue;
+ }
+
+ AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
+
+ AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
+ AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
+ if(!entry){
+ AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
+ isOK = kFALSE;
+ }
+ else {
+ TObject *recoParamObj = entry->GetObject();
+ if (dynamic_cast<TObjArray*>(recoParamObj)) {
+ // The detector has a normal TobjArray of AliDetectorRecoParam objects
+ // Registering them in AliRecoParam
+ fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
+ }
+ else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
+ // The detector has only onse set of reco parameters
+ // Registering it in AliRecoParam
+ AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
+ dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
+ fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
+ }
+ else {
+ AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
+ isOK = kFALSE;
+ }
+ entry->SetOwner(0);
+ AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
+ }
+ }
+
+ if (AliDebugLevel() > 0) fRecoParam.Print();
+
+ return isOK;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::GetEventInfo()
+{
+ // Fill the event info object
+ // ...
+ AliCodeTimerAuto("")
+
+ AliCentralTrigger *aCTP = NULL;
+ if (fRawReader) {
+ fEventInfo.SetEventType(fRawReader->GetType());
+
+ ULong64_t mask = fRawReader->GetClassMask();
+ fEventInfo.SetTriggerMask(mask);
+ UInt_t clmask = fRawReader->GetDetectorPattern()[0];
+ fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
+
+ aCTP = new AliCentralTrigger();
+ TString configstr("");
+ if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
+ AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
+ delete aCTP;
+ return kFALSE;
+ }
+ aCTP->SetClassMask(mask);
+ aCTP->SetClusterMask(clmask);
+ }
+ else {
+ fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
+
+ if (fRunLoader && (!fRunLoader->LoadTrigger())) {
+ aCTP = fRunLoader->GetTrigger();
+ fEventInfo.SetTriggerMask(aCTP->GetClassMask());
+ fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
+ }
+ else {
+ AliWarning("No trigger can be loaded! The trigger information will not be used!");
+ return kFALSE;
+ }
+ }
+
+ AliTriggerConfiguration *config = aCTP->GetConfiguration();
+ if (!config) {
+ AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
+ if (fRawReader) delete aCTP;
+ return kFALSE;
+ }
+
+ UChar_t clustmask = 0;
+ TString trclasses;
+ ULong64_t trmask = fEventInfo.GetTriggerMask();
+ const TObjArray& classesArray = config->GetClasses();
+ Int_t nclasses = classesArray.GetEntriesFast();
+ 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());
+ fesd->SetTriggerClass(trclass->GetName(),trindex);
+ if (trmask & (1 << trindex)) {
+ trclasses += " ";
+ trclasses += trclass->GetName();
+ trclasses += " ";
+ clustmask |= trclass->GetCluster()->GetClusterMask();
+ }
+ }
+ }
+ fEventInfo.SetTriggerClasses(trclasses);
+
+ // Set the information in ESD
+ fesd->SetTriggerMask(trmask);
+ fesd->SetTriggerCluster(clustmask);
+
+ if (!aCTP->CheckTriggeredDetectors()) {
+ if (fRawReader) delete aCTP;
+ return kFALSE;
+ }
+
+ if (fRawReader) delete aCTP;
+
+ // We have to fill also the HLT decision here!!
+ // ...
+
+ return kTRUE;
+}
+
+const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
+{
+ // Match the detector list found in the rec.C or the default 'ALL'
+ // to the list found in the GRP (stored there by the shuttle PP which
+ // gets the information from ECS)
+ static TString resultList;
+ TString detList = detectorList;
+
+ resultList = "";
+
+ for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
+ if ((detectorMask >> iDet) & 0x1) {
+ TString det = AliDAQ::OfflineModuleName(iDet);
+ if ((detList.CompareTo("ALL") == 0) ||
+ detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ") ||
+ (detList.CompareTo(det) == 0) ||
+ detList.BeginsWith(det) ||
+ detList.EndsWith(det) ||
+ detList.Contains( " "+det+" " )) {
+ if (!resultList.EndsWith(det + " ")) {
+ resultList += det;
+ resultList += " ";
+ }
+ }
+ }
+ }
+
+ // HLT
+ 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.CompareTo(hltDet) == 0) ||
+ 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());
+}
+