// 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 <TArrayD.h>
#include <TArrayF.h>
+#include <TArrayS.h>
+#include <TChain.h>
#include <TFile.h>
-#include <TList.h>
-#include <TSystem.h>
-#include <TROOT.h>
-#include <TPluginManager.h>
+#include <TGeoGlobalMagField.h>
#include <TGeoManager.h>
+#include <TList.h>
#include <TLorentzVector.h>
-#include <TArrayS.h>
-#include <TArrayD.h>
-#include <TObjArray.h>
#include <TMap.h>
+#include <TObjArray.h>
+#include <TPRegexp.h>
+#include <TParameter.h>
+#include <TPluginManager.h>
+#include <TProof.h>
+#include <TProofOutputFile.h>
+#include <TROOT.h>
+#include <TSystem.h>
+#include <THashTable.h>
+#include <TGrid.h>
+#include <TMessage.h>
+#include <TUrl.h>
+#include <TRandom.h>
-#include "AliReconstruction.h"
+#include "AliAlignObj.h"
+#include "AliCDBEntry.h"
+#include "AliCDBManager.h"
+#include "AliCDBStorage.h"
+#include "AliCTPRawStream.h"
+#include "AliCascadeVertexer.h"
+#include "AliCentralTrigger.h"
#include "AliCodeTimer.h"
-#include "AliReconstructor.h"
-#include "AliLog.h"
-#include "AliRunLoader.h"
-#include "AliRun.h"
-#include "AliRawReaderFile.h"
-#include "AliRawReaderDate.h"
-#include "AliRawReaderRoot.h"
-#include "AliRawEventHeaderBase.h"
+#include "AliDAQ.h"
+#include "AliDetectorRecoParam.h"
+#include "AliESDCaloCells.h"
+#include "AliESDCaloCluster.h"
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
-#include "AliESDfriend.h"
+#include "AliESDPmdTrack.h"
+#include "AliESDTagCreator.h"
#include "AliESDVertex.h"
#include "AliESDcascade.h"
+#include "AliESDfriend.h"
#include "AliESDkink.h"
-#include "AliESDtrack.h"
-#include "AliESDCaloCluster.h"
-#include "AliESDCaloCells.h"
-#include "AliMultiplicity.h"
-#include "AliTracker.h"
-#include "AliVertexer.h"
-#include "AliVertexerTracks.h"
-#include "AliV0vertexer.h"
-#include "AliCascadeVertexer.h"
-#include "AliHeader.h"
-#include "AliGenEventHeader.h"
-#include "AliPID.h"
#include "AliESDpid.h"
#include "AliESDtrack.h"
-#include "AliESDPmdTrack.h"
-
-#include "AliESDTagCreator.h"
-#include "AliAODTagCreator.h"
-
+#include "AliESDtrack.h"
+#include "AliEventInfo.h"
+#include "AliGRPObject.h"
+#include "AliGRPRecoParam.h"
+#include "AliGenEventHeader.h"
#include "AliGeomManager.h"
-#include "AliTrackPointArray.h"
-#include "AliCDBManager.h"
-#include "AliCDBStorage.h"
-#include "AliCDBEntry.h"
-#include "AliAlignObj.h"
-
-#include "AliCentralTrigger.h"
-#include "AliTriggerConfiguration.h"
-#include "AliTriggerClass.h"
-#include "AliCTPRawStream.h"
-
-#include "AliQADataMakerRec.h"
#include "AliGlobalQADataMaker.h"
-#include "AliQA.h"
-#include "AliQADataMakerSteer.h"
-
+#include "AliHeader.h"
+#include "AliLog.h"
+#include "AliMagF.h"
+#include "AliMultiplicity.h"
+#include "AliPID.h"
#include "AliPlaneEff.h"
-
-#include "AliSysInfo.h" // memory snapshots
+#include "AliQAv1.h"
+#include "AliQADataMakerRec.h"
+#include "AliQAManager.h"
+#include "AliRawVEvent.h"
+#include "AliRawEventHeaderBase.h"
#include "AliRawHLTManager.h"
-
-#include "AliMagWrapCheb.h"
-
+#include "AliRawReaderDate.h"
+#include "AliRawReaderFile.h"
+#include "AliRawReaderRoot.h"
+#include "AliReconstruction.h"
+#include "AliReconstructor.h"
+#include "AliRun.h"
+#include "AliRunInfo.h"
+#include "AliRunLoader.h"
+#include "AliSysInfo.h" // memory snapshots
+#include "AliTrackPointArray.h"
+#include "AliTracker.h"
+#include "AliTriggerClass.h"
+#include "AliTriggerCluster.h"
+#include "AliTriggerIR.h"
+#include "AliTriggerConfiguration.h"
+#include "AliV0vertexer.h"
+#include "AliVertexer.h"
+#include "AliTrackleter.h"
+#include "AliVertexerTracks.h"
+#include "AliTriggerRunScalers.h"
+#include "AliCTPTimeParams.h"
+#include "AliESDHLTDecision.h"
+#include "AliTriggerInput.h"
+#include "AliLHCData.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),
-
- fUniformField(kFALSE),
- fForcedFieldMap(0x0),
+AliReconstruction::AliReconstruction(const char* gAliceFilename) :
+ TSelector(),
fRunVertexFinder(kTRUE),
fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
fRunMuonTracking(kFALSE),
fRunV0Finder(kTRUE),
fRunCascadeFinder(kTRUE),
- fStopOnError(kFALSE),
+ fRunMultFinder(kTRUE),
+ fStopOnError(kTRUE),
fWriteAlignmentData(kFALSE),
fWriteESDfriend(kFALSE),
- fWriteAOD(kFALSE),
fFillTriggerESD(kTRUE),
fCleanESD(kTRUE),
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fLoadCDB(""),
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
- fInput(""),
+ fRawInput(""),
+ fESDOutput(""),
+ fProofOutputFileName(""),
+ fProofOutputLocation(""),
+ fProofOutputDataset(kFALSE),
+ fProofOutputArchive(""),
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
- fNumberOfEventsPerFile(1),
- fCheckPointLevel(0),
+ fNumberOfEventsPerFile((UInt_t)-1),
+ fFractionFriends(0.04),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
- fESDPar(""),
fUseHLTData(),
+ fRunInfo(NULL),
+ fEventInfo(),
+ fRunScalers(NULL),
+ fCTPTimeParams(NULL),
+ fCTPTimeAlign(NULL),
fRunLoader(NULL),
fRawReader(NULL),
fParentRawReader(NULL),
- fVertexer(NULL),
+ fRecoParam(),
+
+ fSPDTrackleter(NULL),
+
+ fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(kTRUE),
-
+ fListOfCosmicTriggers(NULL),
+
fGRPData(NULL),
fAlignObjArray(NULL),
fCDBUri(),
+ fQARefUri(),
fSpecCDBUri(),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fQATasks("ALL"),
fRunQA(kTRUE),
fRunGlobalQA(kTRUE),
- fInLoopQA(kFALSE),
fSameQACycle(kFALSE),
-
+ fInitQACalled(kFALSE),
+ fWriteQAExpertData(kTRUE),
fRunPlaneEff(kFALSE),
fesd(NULL),
fhltesd(NULL),
fesdf(NULL),
ffile(NULL),
+ ffileF(NULL),
ftree(NULL),
+ ftreeF(NULL),
fhlttree(NULL),
- ffileOld(NULL),
- ftreeOld(NULL),
- fhlttreeOld(NULL),
ftVertexer(NULL),
fIsNewRunLoader(kFALSE),
- fRunAliEVE(kFALSE)
+ fRunAliEVE(kFALSE),
+ fChain(NULL),
+ fNall(0),
+ fNspecie(0),
+ fSspecie(0),
+ fNhighPt(0),
+ fShighPt(0)
{
// 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;
- fQADataMaker[iDet] = NULL;
- fQACycles[iDet] = 999999;
}
- fQADataMaker[fgkNDetectors]=NULL; //Global QA
+ for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
+ fQACycles[iDet] = 999999 ;
+ fQAWriteExpert[iDet] = kFALSE ;
+ }
+ fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
+
AliPID pid;
}
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
- TNamed(rec),
-
- fUniformField(rec.fUniformField),
- fForcedFieldMap(0x0),
+ TSelector(),
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
fRunMuonTracking(rec.fRunMuonTracking),
fRunV0Finder(rec.fRunV0Finder),
fRunCascadeFinder(rec.fRunCascadeFinder),
+ fRunMultFinder(rec.fRunMultFinder),
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),
+ fESDOutput(rec.fESDOutput),
+ fProofOutputFileName(rec.fProofOutputFileName),
+ fProofOutputLocation(rec.fProofOutputLocation),
+ fProofOutputDataset(rec.fProofOutputDataset),
+ fProofOutputArchive(rec.fProofOutputArchive),
fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
- fCheckPointLevel(0),
+ fFractionFriends(rec.fFractionFriends),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
- fESDPar(rec.fESDPar),
fUseHLTData(rec.fUseHLTData),
+ fRunInfo(NULL),
+ fEventInfo(),
+ fRunScalers(NULL),
+ fCTPTimeParams(NULL),
+ fCTPTimeAlign(NULL),
fRunLoader(NULL),
fRawReader(NULL),
fParentRawReader(NULL),
- fVertexer(NULL),
- fDiamondProfile(NULL),
- fDiamondProfileTPC(NULL),
- fMeanVertexConstraint(rec.fMeanVertexConstraint),
+ fRecoParam(rec.fRecoParam),
+ fSPDTrackleter(NULL),
+
+ fDiamondProfileSPD(rec.fDiamondProfileSPD),
+ fDiamondProfile(rec.fDiamondProfile),
+ fDiamondProfileTPC(rec.fDiamondProfileTPC),
+ fListOfCosmicTriggers(NULL),
+
fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
+ fQARefUri(rec.fQARefUri),
fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
- fInLoopQA(rec.fInLoopQA),
fSameQACycle(rec.fSameQACycle),
+ fInitQACalled(rec.fInitQACalled),
+ fWriteQAExpertData(rec.fWriteQAExpertData),
fRunPlaneEff(rec.fRunPlaneEff),
fesd(NULL),
fhltesd(NULL),
fesdf(NULL),
ffile(NULL),
+ ffileF(NULL),
ftree(NULL),
+ ftreeF(NULL),
fhlttree(NULL),
- ffileOld(NULL),
- ftreeOld(NULL),
- fhlttreeOld(NULL),
ftVertexer(NULL),
fIsNewRunLoader(rec.fIsNewRunLoader),
- fRunAliEVE(kFALSE)
+ fRunAliEVE(kFALSE),
+ fChain(NULL),
+ fNall(0),
+ fNspecie(0),
+ fSspecie(0),
+ fNhighPt(0),
+ fShighPt(0)
{
// 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;
- fQADataMaker[iDet] = NULL;
- fQACycles[iDet] = rec.fQACycles[iDet];
+ }
+
+ for (Int_t iDet = 0; iDet < AliQAv1::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());
}
- fForcedFieldMap=new AliMagWrapCheb(*((AliMagWrapCheb*)rec.fForcedFieldMap));
+ for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
+
}
//_____________________________________________________________________________
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;
+
+ fRunVertexFinder = rec.fRunVertexFinder;
+ fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
+ fRunHLTTracking = rec.fRunHLTTracking;
+ fRunMuonTracking = rec.fRunMuonTracking;
+ fRunV0Finder = rec.fRunV0Finder;
+ fRunCascadeFinder = rec.fRunCascadeFinder;
+ fRunMultFinder = rec.fRunMultFinder;
+ 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;
+ fESDOutput = rec.fESDOutput;
+ fProofOutputFileName = rec.fProofOutputFileName;
+ fProofOutputLocation = rec.fProofOutputLocation;
+ fProofOutputDataset = rec.fProofOutputDataset;
+ fProofOutputArchive = rec.fProofOutputArchive;
+ fEquipIdMap = rec.fEquipIdMap;
+ fFirstEvent = rec.fFirstEvent;
+ fLastEvent = rec.fLastEvent;
+ fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
+ fFractionFriends = rec.fFractionFriends;
+
+ 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;
+
+ delete fRunScalers; fRunScalers = NULL;
+ if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
+
+ delete fCTPTimeParams; fCTPTimeParams = NULL;
+ if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
+ delete fCTPTimeAlign; fCTPTimeAlign = NULL;
+ if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
+
+ 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 < AliQAv1::kNDET; iDet++) {
+ fQACycles[iDet] = rec.fQACycles[iDet];
+ fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
+ }
+
+ delete fSPDTrackleter; fSPDTrackleter = 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 fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
+ if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
+
+ 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 = "";
+ fQARefUri = rec.fQARefUri;
+ fSpecCDBUri.Delete();
+ fInitCDBCalled = rec.fInitCDBCalled;
+ fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
+ fQADetectors = rec.fQADetectors;
+ fQATasks = rec.fQATasks;
+ fRunQA = rec.fRunQA;
+ fRunGlobalQA = rec.fRunGlobalQA;
+ fSameQACycle = rec.fSameQACycle;
+ fInitQACalled = rec.fInitQACalled;
+ fWriteQAExpertData = rec.fWriteQAExpertData;
+ fRunPlaneEff = rec.fRunPlaneEff;
+ for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
+ fesd = NULL;
+ fhltesd = NULL;
+ fesdf = NULL;
+ ffile = NULL;
+ ffileF = NULL;
+ ftree = NULL;
+ ftreeF = NULL;
+ fhlttree = NULL;
+ ftVertexer = NULL;
+ fIsNewRunLoader = rec.fIsNewRunLoader;
+ fRunAliEVE = kFALSE;
+ fChain = NULL;
+ fNall = 0;
+ fNspecie = 0;
+ fSspecie = 0;
+ fNhighPt = 0;
+ fShighPt = 0;
- this->~AliReconstruction();
- new(this) AliReconstruction(rec);
return *this;
}
// clean up
CleanUp();
+ if (fListOfCosmicTriggers) {
+ fListOfCosmicTriggers->Delete();
+ delete fListOfCosmicTriggers;
+ }
+ delete fGRPData;
+ delete fRunScalers;
+ delete fCTPTimeParams;
+ delete fCTPTimeAlign;
fOptions.Delete();
+ if (fAlignObjArray) {
+ fAlignObjArray->Delete();
+ delete fAlignObjArray;
+ }
fSpecCDBUri.Delete();
- delete fForcedFieldMap;
AliCodeTimer::Instance()->Print();
}
+//_____________________________________________________________________________
+void AliReconstruction::InitQA()
+{
+ //Initialize the QA and start of cycle
+ AliCodeTimerAuto("",0);
+
+ if (fInitQACalled) return;
+ fInitQACalled = kTRUE;
+
+ AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
+ if (fWriteQAExpertData)
+ qam->SetWriteExpert() ;
+
+ if (qam->IsDefaultStorageSet()) {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default QA reference storage has been already set !");
+ AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ fQARefUri = qam->GetDefaultStorage()->GetURI();
+ } else {
+ if (fQARefUri.Length() > 0) {
+ AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
+ AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ } else {
+ fQARefUri="local://$ALICE_ROOT/QAref";
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default QA refeference storage not yet set !!!!");
+ AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+
+ }
+ qam->SetDefaultStorage(fQARefUri);
+ }
+
+ if (fRunQA) {
+ qam->SetActiveDetectors(fQADetectors) ;
+ for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
+ qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
+ qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
+ }
+ if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
+ fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
+ qam->SetTasks(fQATasks) ;
+ qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
+ }
+ if (fRunGlobalQA) {
+ Bool_t sameCycle = kFALSE ;
+ AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
+ AliInfo(Form("Initializing the global QA data maker"));
+ if (IsInTasks(AliQAv1::kRECPOINTS)) {
+ qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
+ AliTracker::SetResidualsArray(arr);
+ sameCycle = kTRUE ;
+ }
+ if (IsInTasks(AliQAv1::kESDS)) {
+ qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
+ qadm->Init(AliQAv1::kESDS);
+ }
+ }
+ AliSysInfo::AddStamp("InitQA") ;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::MergeQA(const char *fileName)
+{
+ //Initialize the QA and start of cycle
+ AliCodeTimerAuto("",0) ;
+ AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
+ AliSysInfo::AddStamp("MergeQA") ;
+}
+
//_____________________________________________________________________________
void AliReconstruction::InitCDB()
{
// activate a default CDB storage
// First check if we have any CDB storage set, because it is used
// to retrieve the calibration and alignment constants
+ AliCodeTimerAuto("",0);
if (fInitCDBCalled) return;
fInitCDBCalled = kTRUE;
AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
- } else {
- fCDBUri="local://$ALICE_ROOT";
+ man->SetDefaultStorage(fCDBUri);
+ }
+ else if (!man->GetRaw()){
+ fCDBUri="local://$ALICE_ROOT/OCDB";
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
AliWarning("Default CDB storage not yet set !!!!");
AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-
+ man->SetDefaultStorage(fCDBUri);
+ }
+ else {
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+ AliWarning("Default storage will be set after setting the Run Number!!!");
+ AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
}
- man->SetDefaultStorage(fCDBUri);
}
// Now activate the detector specific CDB storage locations
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
}
-
+ AliSysInfo::AddStamp("InitCDB");
}
//_____________________________________________________________________________
}
+//_____________________________________________________________________________
+void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
+ // Store the desired default CDB storage location
+ // Activate it later within the Run() method
+
+ fQARefUri = uri;
+ AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
+
+}
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
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;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SetOutput(const char* output)
+{
+ // Set the output ESD filename
+ // 'output' is a normalt ROOT url
+ // The method is used in case of raw-data reco with PROOF
+ if (output) fESDOutput = output;
}
//_____________________________________________________________________________
}
//_____________________________________________________________________________
-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: +";
-
- 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 (TMath::Abs(l3Current) < zero) {
- map=AliMagWrapCheb::k2kG;
- s+="0.0 T; ";
- factor=0.; // in fact, this is a global factor...
- } else {
- AliError("Wrong L3 current !");
- return kFALSE;
- }
+void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
+{
+ // Set custom reconstruction parameters for a given detector
+ // Single set of parameters for all the events
- if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
- // 3% current tolerance...
- dipoleON=kTRUE;
- s+="Dipole ON";
- } else
- if (TMath::Abs(diCurrent) < zero) { // some small current..
- dipoleON=kFALSE;
- s+="Dipole OFF";
- } else {
- AliError("Wrong dipole current !");
- return kFALSE;
+ // First check if the reco-params are global
+ if(!strcmp(detector, "GRP")) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(kNDetectors,par);
+ return;
}
- delete fForcedFieldMap;
- fForcedFieldMap=
- new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path);
-
- fForcedFieldMap->Print();
-
- AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if(!strcmp(detector, fgkDetectorName[iDet])) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(iDet,par);
+ break;
+ }
+ }
- return kTRUE;
}
-
+//_____________________________________________________________________________
Bool_t AliReconstruction::InitGRP() {
//------------------------------------
// Initialization of the GRP entry
//------------------------------------
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);
+ }
+
+ // FIX ME: The unloading of GRP entry is temporarily disabled
+ // because ZDC and VZERO are using it in order to initialize
+ // their reconstructor objects. In the future one has to think
+ // of propagating AliRunInfo to the reconstructors.
+ // 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;
+ fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
+ fRunTracking = MatchDetectorList(fRunTracking,detMask);
+ fFillESD = MatchDetectorList(fFillESD,detMask);
+ fQADetectors = MatchDetectorList(fQADetectors,detMask);
+ fLoadCDB.Form("%s %s %s %s",
+ fRunLocalReconstruction.Data(),
+ fRunTracking.Data(),
+ fFillESD.Data(),
+ fQADetectors.Data());
+ fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
+ if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
+ !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
+ !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
+ // switch off the vertexer
+ AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
+ fRunVertexFinder = kFALSE;
+ fRunMultFinder = 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 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 {
+ if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
+ if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
+ AliInfo("ExpertMode!!! GRP information will be ignored !");
+ AliInfo("ExpertMode!!! Running with the externally locked B field !");
+ }
+ else {
+ AliInfo("Destroying existing B field instance!");
+ delete TGeoGlobalMagField::Instance();
+ }
+ }
+ if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
// Construct the field map out of the information retrieved from GRP.
-
Bool_t ok = kTRUE;
-
// L3
- TObjString *l3Current=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
- if (!l3Current) {
+ 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;
}
- TObjString *l3Polarity=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
- if (!l3Polarity) {
+
+ Char_t l3Polarity = fGRPData->GetL3Polarity();
+ if (l3Polarity == AliGRPObject::GetInvalidChar()) {
AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
ok = kFALSE;
}
// Dipole
- TObjString *diCurrent=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
- if (!diCurrent) {
+ 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;
}
- TObjString *diPolarity=
- dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
- if (!diPolarity) {
+
+ Char_t diPolarity = fGRPData->GetDipolePolarity();
+ if (diPolarity == AliGRPObject::GetInvalidChar()) {
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 factor=1.;
- if (l3Pol != 0.) factor=-1.;
-
+ // read special bits for the polarity convention and map type
+ Int_t polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
+ Bool_t uniformB = fGRPData->IsUniformBMap();
- if (!SetFieldMap(l3Cur, diCur, factor)) {
- AliFatal("Failed to creat a B field map ! Exiting...");
+ if (ok) {
+ AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
+ TMath::Abs(diCurrent) * (diPolarity ? -1:1),
+ polConvention,uniformB,beamEnergy, beamType.Data());
+ if (fld) {
+ TGeoGlobalMagField::Instance()->SetField( fld );
+ TGeoGlobalMagField::Instance()->Lock();
+ AliInfo("Running with the B field constructed out of GRP !");
}
- AliInfo("Running with the B field constructed out of GRP !");
+ else AliFatal("Failed to create a B field map !");
}
- else {
- AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
- }
-
+ 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!");
}
-
- //*** 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;
-}
-
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
+ if (entry) {
+ fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
+ entry->SetOwner(0);
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
+ }
+
+ if (!fListOfCosmicTriggers) {
+ AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
+ }
+
+ return kTRUE;
+}
+
//_____________________________________________________________________________
-Bool_t AliReconstruction::Run(const char* input)
+Bool_t AliReconstruction::LoadCDB()
{
- // Run Run Run
- AliCodeTimerAuto("");
+ // Load CDB entries for all active detectors.
+ // By default we load all the entries in <det>/Calib
+ // folder.
+
+ AliCodeTimerAuto("",0);
+
+ AliCDBManager::Instance()->Get("GRP/CTP/Config");
- 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++;
+ AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
+
+ 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]));
}
- if (!FinishRun()) return kFALSE;
+ // Temporary fix - one has to define the correct policy in order
+ // to load the trigger OCDB entries only for the detectors that
+ // in the trigger or that are needed in order to put correct
+ // information in ESD
+ AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
return kTRUE;
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::LoadTriggerScalersCDB()
+{
+ // Load CTP scalers from OCDB.
+ // The scalers are checked for consistency.
+ AliCodeTimerAuto("",0);
+
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
+
+ if (entry) {
+
+ AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
+ fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
+ entry->SetOwner(0);
+ if (fRunScalers->CorrectScalersOverflow() == 0) AliInfo("32bit Trigger counters corrected for overflow");
+
+ }
+ return kTRUE;
+}
//_____________________________________________________________________________
-Bool_t AliReconstruction::InitRun(const char* input)
+Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
{
- // 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("");
+ // Load CTP timing information (alignment)
+ // from OCDB.
+
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
+ if (!entry) return kFALSE;
+
+ AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
+ fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
+ entry->SetOwner(0);
+
+ AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
+ if (!entry2) return kFALSE;
+
+ AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
+ fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
+ entry2->SetOwner(0);
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::ReadIntensityInfoCDB()
+{
+ // Load LHC DIP data
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
+
+ if (entry) {
+ AliInfo("Found an AliLHCData in GRP/GRP/LHCData, reading it");
+ AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
+ for (int ib=2;ib--;) {
+ double intI,intNI;
+ if (dipData->GetMeanIntensity(ib,intI,intNI)>=0) {
+ fBeamInt[ib][0] = intI;
+ fBeamInt[ib][1] = intNI;
+ }
+ }
+ return kTRUE;
+ }
+ return kFALSE;
+}
+
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::Run(const char* input)
+{
+ // Run Run Run
+ AliCodeTimerAuto("",0);
+
+ InitRun(input);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+
+ TChain *chain = NULL;
+ if (fRawReader && (chain = fRawReader->GetChain())) {
+ Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
+ // Proof mode
+ if (gProof) {
+ // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
+ gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
+
+ if (gGrid)
+ gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
+
+ TMessage::EnableSchemaEvolutionForAll(kTRUE);
+ gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
- // Overwrite the previous setting
- if (input) fInput = input;
+ gProof->AddInput(this);
+ if (!ParseOutput()) return kFALSE;
+
+ gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
+ chain->SetProof();
+ chain->Process("AliReconstruction","",nEntries,fFirstEvent);
+ }
+ else {
+ chain->Process(this,"",nEntries,fFirstEvent);
+ }
+ }
+ 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;
+ }
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::InitRawReader(const char* input)
+{
+ // Init raw-reader and
// set the input in case of raw data
- fRawReader = AliRawReader::Create(fInput.Data());
- if (!fRawReader)
- AliInfo("Reconstruction will run over digits");
+
+ AliCodeTimerAuto("",0);
+
+ if (input) fRawInput = input;
+ fRawReader = AliRawReader::Create(fRawInput.Data());
+ if (!fRawReader) {
+ if (fRawInput.IsNull()) {
+ AliInfo("Reconstruction will run over digits");
+ }
+ else {
+ AliFatal("Can not create raw-data reader ! Exiting...");
+ }
+ }
if (!fEquipIdMap.IsNull() && fRawReader)
fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
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("",0);
+ 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("",0);
+
+ 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)) {
+ Abort("MisalignGeometry", TSelector::kAbortProcess);
+ return;
}
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
+ AliSysInfo::AddStamp("MisalignGeom");
- if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
- AliSysInfo::AddStamp("LoadGeom");
+ if (!InitGRP()) {
+ Abort("InitGRP", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("InitGRP");
+ if (!LoadCDB()) {
+ Abort("LoadCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadCDB");
- if (!InitGRP()) return kFALSE;
+ if (!LoadTriggerScalersCDB()) {
+ Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadTriggerScalersCDB");
+ if (!LoadCTPTimeParamsCDB()) {
+ Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
- ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
- if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
+ if (!ReadIntensityInfoCDB()) {
+ Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("ReadIntensityInfoCDB");
- // get vertexer
- if (fRunVertexFinder && !CreateVertexer()) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
+ // Read the reconstruction parameters from OCDB
+ if (!InitRecoParams()) {
+ AliWarning("Not all detectors have correct RecoParam objects initialized");
}
- AliSysInfo::AddStamp("Vertexer");
+ AliSysInfo::AddStamp("InitRecoParams");
- // get trackers
- if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
+ if (fInput && gProof) {
+ if (reco) *reco = *this;
+
+ gGeoManager->SetName("Geometry");
+ gProof->AddInputData(gGeoManager,kTRUE);
+ gGeoManager = NULL;
+ gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
+ fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
+ AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
+ magFieldMap->SetName("MagneticFieldMap");
+ gProof->AddInputData(magFieldMap,kTRUE);
}
- AliSysInfo::AddStamp("LoadTrackers");
- // 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);
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SlaveBegin(TTree*)
+{
+ // Initialization related to run-loader,
+ // vertexer, trackers, recontructors
+ // In proof mode it is executed on the slave
+ AliCodeTimerAuto("",0);
+
+ TProofOutputFile *outProofFile = NULL;
+ if (fInput) {
+ if (AliDebugLevel() > 0) fInput->Print();
+ if (AliDebugLevel() > 10) fInput->Dump();
+ 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")) {
+ AliMagF *newMap = new AliMagF(*map);
+ if (!newMap->LoadParameterization()) {
+ Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
+ return;
+ }
+ TGeoGlobalMagField::Instance()->SetField(newMap);
+ TGeoGlobalMagField::Instance()->Lock();
+ }
+ if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
+ fProofOutputFileName = outputFileName->GetTitle();
+ if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
+ fProofOutputLocation = outputLocation->GetTitle();
+ if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
+ fProofOutputDataset = kTRUE;
+ if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
+ fProofOutputArchive = archiveList->GetTitle();
+ if (!fProofOutputFileName.IsNull() &&
+ !fProofOutputLocation.IsNull() &&
+ fProofOutputArchive.IsNull()) {
+ if (!fProofOutputDataset) {
+ outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
+ outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
+ }
+ else {
+ outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
+ }
+ if (AliDebugLevel() > 0) outProofFile->Dump();
+ 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 trackers
+ if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
+ 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, ffileOld); return kFALSE;}
+ if (!outProofFile) {
+ ffile = TFile::Open("AliESDs.root", "RECREATE");
+ ffile->SetCompressionLevel(2);
+ if (!ffile->IsOpen()) {
+ Abort("OpenESDFile", TSelector::kAbortProcess);
+ return;
+ }
+ }
+ else {
+ AliInfo(Form("Opening output PROOF file: %s/%s",
+ outProofFile->GetDir(), outProofFile->GetFileName()));
+ 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();
+ // add a so far non-std object to the ESD, this will
+ // become part of the std content
+ fesd->AddObject(new AliESDHLTDecision);
+
fesd->WriteToTree(ftree);
+ if (fWriteESDfriend) {
+ ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
+ ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
+ fesdf = new AliESDfriend();
+ ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
+ fesd->AddObject(fesdf);
+ ffile->cd();
+ }
+ ftree->GetUserInfo()->Add(fesd);
fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
fhltesd = new AliESDEvent();
fhltesd->CreateStdContent();
- fhltesd->WriteToTree(fhlttree);
-
-
- if (fWriteESDfriend) {
- fesdf = new AliESDfriend();
- TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
- br->SetFile("AliESDfriends.root");
- fesd->AddObject(fesdf);
+ // 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()));
+ }
}
+ fhltesd->WriteToTree(fhlttree);
+ fhlttree->GetUserInfo()->Add(fhltesd);
-
- if (fRawReader) fRawReader->RewindEvents();
-
- 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 %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
//QA
- if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) {
- AliQADataMakerSteer qas ;
- qas.Run(fRunLocalReconstruction, fRawReader) ;
- fSameQACycle = kTRUE ;
- }
- //Initialize the QA and start of cycle for out-of-cycle QA
- if (fRunQA) {
- TString detStr(fQADetectors) ;
- 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]));
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- 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;
- }
- }
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = 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 (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- }
- if (!fInLoopQA) {
- fSameQACycle = kFALSE;
- 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;
- }
- }
- }
- }
+ //Initialize the QA and start of cycle
+ if (fRunQA || fRunGlobalQA)
+ InitQA() ;
//Initialize the Plane Efficiency framework
if (fRunPlaneEff && !InitPlaneEff()) {
- if(fStopOnError) {CleanUp(ffile, ffileOld); 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("",0);
+
+ TTree *currTree = fChain->GetTree();
+ AliRawVEvent *event = NULL;
+ 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)
+{
+ // Implementation of TSelector::Init()
+ // method
+ 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
- AliCodeTimerAuto("");
+
+ static Long_t oldMres=0;
+ static Long_t oldMvir=0;
+ static Float_t oldCPU=0;
+ static Long_t aveDMres=0;
+ static Long_t aveDMvir=0;
+ static Float_t aveDCPU=0;
+
+ AliCodeTimerAuto("",0);
+
+ AliESDpid pid;
if (iEvent >= fRunLoader->GetNumberOfEvents()) {
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) {
- fhltesd->ReadFromTree(fhlttreeOld);
- fhlttreeOld->GetEntry(iEvent);
- fhlttree->Fill();
- }
return kTRUE;
}
- AliInfo(Form("processing event %d", iEvent));
-
- //Start of cycle for the in-loop QA
- if (fInLoopQA) {
- if (fRunQA) {
- fSameQACycle = kFALSE ;
- TString detStr(fQADetectors);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQADataMakerRec *qadm = GetQADataMaker(iDet);
- if (!qadm)
- continue;
- 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;
- }
- }
- if (fRunGlobalQA) {
- fSameQACycle = kFALSE;
- AliQADataMakerRec *qadm = 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);
+ 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;
+ // Fill Event-info object
+ GetEventInfo();
+ fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
+
+ ProcInfo_t procInfo;
+ if(iEvent==fFirstEvent) {
+ gSystem->GetProcInfo(&procInfo);
+ oldMres=procInfo.fMemResident;
+ oldMvir=procInfo.fMemVirtual;
+ oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
+ }
+ AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
+
+ // 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);
+ reconstructor->GetPidSettings(&pid);
+ reconstructor->SetEventInfo(&fEventInfo);
+ if (fRunQA) {
+ AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
+ if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
+ }
+ }
+ }
+ if (fRunQA) {
+ const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
+ AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
+ AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
+ }
+ }
+ // QA on single raw
+ if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
+ }
// local single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
TString detectors=fRunLocalReconstruction;
// ;-( IsSelected changes the string
if (IsSelected("HLT", detectors) &&
!RunLocalEventReconstruction("HLT")) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
+ 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;
+ }
}
}
+
+ // fill Event header information from the RawEventHeader
+ if (fRawReader){FillRawEventHeaderESD(fesd);}
+ if (fRawReader){FillRawEventHeaderESD(fhltesd);}
+
fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+
+ ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
+ ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
+ ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
+ ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
+
fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+
+ fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
+ fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
// Set magnetic field from the tracker
fesd->SetMagneticField(AliTracker::GetBz());
fhltesd->SetMagneticField(AliTracker::GetBz());
-
-
+ //
+ AliESDRun *esdRun,*esdRunH;
+ esdRun = (AliESDRun*)fesd->GetESDRun();
+ esdRunH = (AliESDRun*)fhltesd->GetESDRun();
+ esdRun->SetBeamEnergyIsSqrtSHalfGeV();
+ esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
+ //
+ for (int ib=2;ib--;) for (int it=2;it--;) {
+ esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
+ esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
+ }
+ //
+ AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
+ if (fld) { // set info needed for field initialization
+ fesd->SetCurrentL3(fld->GetCurrentSol());
+ fesd->SetCurrentDip(fld->GetCurrentDip());
+ fesd->SetBeamEnergy(fld->GetBeamEnergy());
+ fesd->SetBeamType(fld->GetBeamTypeText());
+ fesd->SetUniformBMap(fld->IsUniform());
+ fesd->SetBInfoStored();
+ //
+ fhltesd->SetCurrentL3(fld->GetCurrentSol());
+ fhltesd->SetCurrentDip(fld->GetCurrentDip());
+ fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
+ fhltesd->SetBeamType(fld->GetBeamTypeText());
+ fhltesd->SetUniformBMap(fld->IsUniform());
+ fhltesd->SetBInfoStored();
+ }
+ //
+ // 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, ffileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
+ if (!RunVertexFinder(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+ }
+
+ // For Plane Efficiency: run the SPD trackleter
+ if (fRunPlaneEff && fSPDTrackleter) {
+ if (!RunSPDTrackleting(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,pid)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
// ;-( IsSelected changes the string
if (IsSelected("HLT", detectors) &&
!FillESD(fhltesd, "HLT")) {
- if (fStopOnError) {CleanUp(ffile, ffileOld); 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, ffileOld); return kFALSE;}
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
-
- // fill Event header information from the RawEventHeader
- if (fRawReader){FillRawEventHeaderESD(fesd);}
+
+ // AdC+FN
+ GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
// combined PID
- AliESDpid::MakePID(fesd);
- if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
+ pid.MakePID(fesd);
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;}
}
}
+ // Always fill scalers
+ if (!FillTriggerScalers(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+
ffile->cd();
// Propagate track to the beam pipe (if not already done by ITS)
//
const Int_t ntracks = fesd->GetNumberOfTracks();
- const Double_t kBz = fesd->GetMagneticField();
const Double_t kRadius = 2.8; //something less than the beam pipe radius
TObjArray trkArray;
UShort_t *selectedIdx=new UShort_t[ntracks];
for (Int_t itrack=0; itrack<ntracks; itrack++){
- const Double_t kMaxStep = 5; //max step over the material
+ 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);
+ PropagateTrackToBxByBz(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);
- track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
+ PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
+ Double_t x[3]; track->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, 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
+ Bool_t constrSPD=kFALSE;
+ 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(grpRecoParam->GetVertexerTracksConstraintITS()) {
+ if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
+ ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
+ }else{
+ if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
+ ftVertexer->SetVtxStart(fDiamondProfileSPD);
+ constrSPD=kTRUE;
+ }
+ }
+ }
}
AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
+ if(constrSPD){
+ TString title=pvtx->GetTitle();
+ title.Append("SPD");
+ pvtx->SetTitle(title);
+ }
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);
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
}
}
+ delete pvtx; pvtx=NULL;
}
// 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()) {
+ if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
+ }
}
pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
if (pvtx) {
fesd->SetPrimaryVertexTPC(pvtx);
for (Int_t i=0; i<ntracks; i++) {
AliESDtrack *t = fesd->GetTrack(i);
- t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
+ Double_t x[3]; t->GetXYZ(x);
+ Double_t b[3]; AliTracker::GetBxByBz(x,b);
+ t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
}
}
+ delete pvtx; pvtx=NULL;
}
}
delete[] selectedIdx;
- if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
-
+ if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
+ else fesd->SetDiamond(fDiamondProfileSPD);
if (fRunV0Finder) {
// V0 finding
cvtxer.V0sTracks2CascadeVertices(fesd);
}
}
-
+
// write ESD
if (fCleanESD) CleanESD(fesd);
+ //
+ // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
+ // tracks interpreted as primary, this step should be done in the very end, when full
+ // ESD info is available (particulalry, V0s)
+ // vertex finder
+ if (fRunMultFinder) {
+ if (!RunMultFinder(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+ }
- if (fRunQA) {
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
- if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->Exec(AliQA::kESDS, fesd);
- }
- }
+ if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
+ }
+ if (fRunGlobalQA) {
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ if (qadm && IsInTasks(AliQAv1::kESDS))
+ qadm->Exec(AliQAv1::kESDS, fesd);
+ }
- if (fWriteESDfriend) {
- fesdf->~AliESDfriend();
- new (fesdf) AliESDfriend(); // Reset...
+ // copy HLT decision from HLTesd to esd
+ // the most relevant information is stored in a reduced container in the esd,
+ // while the full information can be found in the HLTesd
+ TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
+ TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
+ if (pHLTSrc && pHLTTgt) {
+ pHLTSrc->Copy(*pHLTTgt);
+ }
+
+ if (fWriteESDfriend)
fesd->GetESDfriend(fesdf);
- }
+
ftree->Fill();
+ if (fWriteESDfriend) {
+ WriteESDfriend();
+ }
+
+ // Auto-save the ESD tree in case of prompt reco @P2
+ if (fRawReader && fRawReader->UseAutoSaveESD()) {
+ ftree->AutoSave("SaveSelf");
+ if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
+ TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
+ if (friendfile) friendfile->Save();
+ }
// write HLT ESD
fhlttree->Fill();
// call AliEVE
if (fRunAliEVE) RunAliEVE();
- if (fCheckPointLevel > 0) WriteESD(fesd, "final");
fesd->Reset();
fhltesd->Reset();
if (fWriteESDfriend) {
new (fesdf) AliESDfriend(); // Reset...
}
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
+ gSystem->GetProcInfo(&procInfo);
+ Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
+ Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
+ Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
+ aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
+ aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
+ aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
+ AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
+ iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
+ oldMres=procInfo.fMemResident;
+ oldMvir=procInfo.fMemVirtual;
+ oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
-
- // End of cycle for the in-loop
- if (fInLoopQA) {
- if (fRunQA) {
- RunQA(fesd);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], fQADetectors))
- continue;
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (!qadm)
- continue;
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = 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();
- }
- }
- }
-
- return kTRUE;
+ fEventInfo.Reset();
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (fReconstructor[iDet]) {
+ fReconstructor[iDet]->SetRecoParam(NULL);
+ fReconstructor[iDet]->SetEventInfo(NULL);
+ }
+ if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
+ }
+
+ if (fRunQA || fRunGlobalQA)
+ AliQAManager::QAManager()->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("");
+ AliCodeTimerAuto("",0);
if (fIsNewRunLoader) { // galice.root didn't exist
fRunLoader->WriteHeader("OVERWRITE");
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()));
}
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)
- ftree->SetBranchStatus("ESDfriend*",0);
// we want to have only one tree version number
ftree->Write(ftree->GetName(),TObject::kOverwrite);
- fhlttree->Write();
+ fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
+
+ if (fWriteESDfriend) {
+ ffileF->cd();
+ ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
+ }
// Finish with Plane Efficiency evaluation: before of CleanUp !!!
if (fRunPlaneEff && !FinishPlaneEff()) {
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
- // 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,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) {
- if (fRunQA) {
- AliQADataMakerSteer qas;
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
- //qas.Reset() ;
- if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
- qas.Run(fRunLocalReconstruction.Data(), AliQA::kESDS, fSameQACycle);
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = 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();
- }
- }
- }
+ if (fRunQA || fRunGlobalQA) {
+ AliQAManager::QAManager()->EndOfCycle() ;
+ if (fInput &&
+ !fProofOutputLocation.IsNull() &&
+ fProofOutputArchive.IsNull() &&
+ !fProofOutputDataset) {
+ TString qaOutputFile(Form("%sMerged.%s.Data.root",
+ fProofOutputLocation.Data(),
+ AliQAv1::GetQADataFileName()));
+ TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
+ AliQAv1::GetQADataFileName()));
+ qaProofFile->SetOutputFileName(qaOutputFile.Data());
+ if (AliDebugLevel() > 0) qaProofFile->Dump();
+ fOutput->Add(qaProofFile);
+ MergeQA(qaProofFile->GetFileName());
+ }
+ else {
+ MergeQA();
+ }
}
-
- // Cleanup of CDB manager: cache and active storages!
- AliCDBManager::Instance()->ClearCache();
-
- return kTRUE;
-}
+ gROOT->cd();
+ CleanUp();
+ if (fInput) {
+ if (!fProofOutputFileName.IsNull() &&
+ !fProofOutputLocation.IsNull() &&
+ fProofOutputDataset &&
+ !fProofOutputArchive.IsNull()) {
+ TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
+ "DROV",
+ fProofOutputLocation.Data());
+ if (AliDebugLevel() > 0) zipProofFile->Dump();
+ fOutput->Add(zipProofFile);
+ TString fileList(fProofOutputArchive.Data());
+ fileList.ReplaceAll(","," ");
+ TString command;
+#if ROOT_SVN_REVISION >= 30174
+ command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
+#else
+ command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
+#endif
+ AliInfo(Form("Executing: %s",command.Data()));
+ gSystem->Exec(command.Data());
+ }
+ }
+}
+
//_____________________________________________________________________________
-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("",0);
-// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-// AliError(Form("the following detectors were not found: %s",
-// detStr.Data()));
-// if (fStopOnError) return kFALSE;
-// }
+ // Do not call the ESD tag creator in case of PROOF-based reconstruction
+ if (!fInput) {
+ AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
+ delete esdtagCreator;
+ }
- eventNr++;
- return kTRUE;
+ // Cleanup of CDB manager: cache and active storages!
+ AliCDBManager::Instance()->ClearCache();
}
//_____________________________________________________________________________
// run the local reconstruction
static Int_t eventNr=0;
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",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;
// although the HLT loader is missing
if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
if (fRawReader) {
- reconstructor->Reconstruct(fRawReader, NULL);
+ reconstructor->Reconstruct(fRawReader, NULL);
} else {
- TTree* dummy=NULL;
- reconstructor->Reconstruct(dummy, NULL);
+ TTree* dummy=NULL;
+ reconstructor->Reconstruct(dummy, NULL);
}
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]),0);
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]),0);
loader->LoadRecPoints("update");
loader->CleanRecPoints();
loader->MakeRecPointsContainer();
loader->LoadDigits("read");
TTree* digitsTree = loader->TreeD();
if (!digitsTree) {
- AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
- if (fStopOnError) return kFALSE;
+ AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
+ if (fStopOnError)
+ return kFALSE;
} else {
- reconstructor->Reconstruct(digitsTree, clustersTree);
+ reconstructor->Reconstruct(digitsTree, clustersTree);
+ if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
+ }
}
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]));
-
- if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
- qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
- //AliCodeTimerStop
- //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
- }
+ if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
+ AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
+ AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
}
-
loader->WriteRecPoints("OVERWRITE");
loader->UnloadRecPoints();
AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
}
-
+ IsSelected("CTP", detStr);
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
- if (fStopOnError) return kFALSE;
+ if (fStopOnError)
+ return kFALSE;
}
eventNr++;
return kTRUE;
}
-
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
+Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
{
-// run the barrel tracking
+// run the SPD trackleting (for SPD efficiency purpouses)
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
- AliESDVertex* vertex = NULL;
Double_t vtxPos[3] = {0, 0, 0};
- Double_t vtxErr[3] = {0.07, 0.07, 0.1};
- TArrayF mcVertex(3);
+ Double_t vtxErr[3] = {0.0, 0.0, 0.0};
+/*
+ TArrayF mcVertex(3);
+ // if(MC)
if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
}
+*/
+ const AliESDVertex *vertex = esd->GetVertex();
+ if(!vertex){
+ AliWarning("Vertex not found");
+ return kFALSE;
+ }
+ vertex->GetXYZ(vtxPos);
+ vertex->GetSigmaXYZ(vtxErr);
+ if (fSPDTrackleter) {
+ AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
- 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();
+ // load clusters
+ fLoader[0]->LoadRecPoints("read");
+ TTree* tree = fLoader[0]->TreeR();
+ if (!tree) {
+ AliError("Can't get the ITS cluster tree");
+ return kFALSE;
}
- else {
- AliError("Can't get the ITS loader");
+ fSPDTrackleter->LoadClusters(tree);
+ fSPDTrackleter->SetVertex(vtxPos, vtxErr);
+ // run trackleting
+ if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
+ AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
+ // fLoader[0]->UnloadRecPoints();
+ return kFALSE;
}
- if(!vertex){
- AliWarning("Vertex not found");
- vertex = new AliESDVertex();
- vertex->SetName("default");
+//fSPDTrackleter->UnloadRecPoints();
+ } else {
+ AliWarning("SPDTrackleter not available");
+ return kFALSE;
+ }
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
+{
+// run the barrel tracking
+
+ AliCodeTimerAuto("",0)
+
+ AliVertexer *vertexer = CreateVertexer();
+ if (!vertexer) return kFALSE;
+
+ AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
+ AliESDVertex* vertex = NULL;
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
+ vertex = vertexer->FindVertexForCurrentEvent(cltree);
}
else {
- vertex->SetName("reconstructed");
+ AliError("Can't get the ITS cluster tree");
}
-
- } 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);
+ AliESDVertex *vpileup = NULL;
+ Int_t novertices = 0;
+ vpileup = vertexer->GetAllVertices(novertices);
+ if(novertices>1){
+ for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
+ }
+ /*
// 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;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
+{
+ // run the trackleter for multiplicity study
+
+ AliCodeTimerAuto("",0)
+
+ AliTrackleter *trackleter = CreateMultFinder();
+ if (!trackleter) return kFALSE;
+
+ AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
+
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ trackleter->Reconstruct(esd,cltree);
+ AliMultiplicity *mult = trackleter->GetMultiplicity();
+ if(mult) esd->SetMultiplicity(mult);
+ }
+ else {
+ AliError("Can't get the ITS cluster tree");
+ }
+ fLoader[0]->UnloadRecPoints();
+ }
+ else {
+ AliError("Can't get the ITS loader");
+ }
+
+ delete trackleter;
+
return kTRUE;
}
{
// run the HLT barrel tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
if (!fRunLoader) {
AliError("Missing runLoader!");
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
{
// run the muon spectrometer tracking
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
if (!fRunLoader) {
AliError("Missing runLoader!");
Int_t rv = tracker->Clusters2Tracks(esd);
- if ( rv )
- {
- AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
- return kFALSE;
- }
-
fLoader[iDet]->UnloadRecPoints();
tracker->UnloadClusters();
delete tracker;
+ if ( rv )
+ {
+ AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
+ return kFALSE;
+ }
+
return kTRUE;
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
+Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
{
// run the barrel tracking
static Int_t eventNr=0;
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliInfo("running tracking");
+ // Set the event info which is used
+ // by the trackers in order to obtain
+ // information about read-out detectors,
+ // trigger etc.
+ AliDebug(1, "Setting event info");
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (!fTracker[iDet]) continue;
+ fTracker[iDet]->SetEventInfo(&fEventInfo);
+ }
+
//Fill the ESD with the T0 info (will be used by the TOF)
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
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);
- AliESDpid::MakePID(esd);
+ PID.MakePID(esd,kTRUE);
}
AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
}
// 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]));
AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
tree = fLoader[iDet]->TreeR();
if (!tree) {
- AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
- return kFALSE;
+ AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
+ return kFALSE;
}
fTracker[iDet]->LoadClusters(tree);
AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
// run tracking
if (iDet>1) // start filling residuals for the "outer" detectors
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
-
+ if (fRunGlobalQA) {
+ AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
+ TObjArray ** arr = AliTracker::GetResidualsArray() ;
+ if (arr) {
+ AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
+ TObjArray * elem = arr[AliRecoParam::AConvert(es)];
+ if ( elem && (! elem->At(0)) ) {
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ if (qadm) qadm->InitRecPointsForTracker() ;
+ }
+ }
+ }
if (fTracker[iDet]->PropagateBack(esd) != 0) {
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();
}
// updated PID in TPC needed by the ITS tracker -MI
if (iDet == 1) {
- GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
- AliESDpid::MakePID(esd);
+ //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
+ //AliESDpid::MakePID(esd);
+ PID.MakePID(esd,kTRUE);
}
AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
}
//stop filling residuals for the "outer" detectors
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
-
- // write space-points to the ESD in case alignment data output
- // is switched on
- if (fWriteAlignmentData)
- WriteAlignmentData(esd);
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
// pass 3: TRD + TPC + ITS refit inwards
// run tracking
if (iDet<2) // start filling residuals for TPC and ITS
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
-
+ if (fRunGlobalQA) {
+ AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
+ TObjArray ** arr = AliTracker::GetResidualsArray() ;
+ if (arr) {
+ AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
+ TObjArray * elem = arr[AliRecoParam::AConvert(es)];
+ if ( elem && (! elem->At(0)) ) {
+ AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
+ if (qadm) qadm->InitRecPointsForTracker() ;
+ }
+ }
+ }
+
if (fTracker[iDet]->RefitInward(esd) != 0) {
AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
// return kFALSE;
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);
AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
}
// stop filling residuals for TPC and ITS
- if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
eventNr++;
return kTRUE;
{
// fill the event summary data
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
static Int_t eventNr=0;
TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
+ 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();
- }
-
- if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
+ reconstructor->FillESD(digitsTree, clustersTree, esd);
+ if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
+ }
+ if (fLoader[iDet]) {
+ fLoader[iDet]->UnloadRecPoints();
}
}
-
+
+ IsSelected("CTP", detStr);
if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
if (fStopOnError) return kFALSE;
}
- AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
+ AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
eventNr++;
return kTRUE;
}
// stored in Trigger.root file and fills
// the corresponding esd entries
- AliCodeTimerAuto("")
+ AliCodeTimerAuto("",0)
AliInfo("Filling trigger information into the ESD");
- AliCentralTrigger *aCTP = NULL;
-
if (fRawReader) {
AliCTPRawStream input(fRawReader);
if (!input.Next()) {
- AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger mask will be taken from the event header, trigger cluster mask will be empty !");
- ULong64_t mask = (((ULong64_t)fRawReader->GetTriggerPattern()[1]) << 32) +
- fRawReader->GetTriggerPattern()[0];
- esd->SetTriggerMask(mask);
- esd->SetTriggerCluster(0);
+ AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
}
else {
- 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;
- }
- }
- 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()));
+ AliESDHeader* esdheader = esd->GetHeader();
+ esdheader->SetL0TriggerInputs(input.GetL0Inputs());
+ esdheader->SetL1TriggerInputs(input.GetL1Inputs());
+ esdheader->SetL2TriggerInputs(input.GetL2Inputs());
+ // IR
+ UInt_t orbit=input.GetOrbitID();
+ for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
+ if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
+ esdheader->AddTriggerIR(input.GetIR(i));
+ }
}
}
-
- // 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 not 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);
+ return kTRUE;
+}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
+{
+ //Scalers
+ //fRunScalers->Print();
+ if(fRunScalers && fRunScalers->CheckRunScalers()){
+ AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
+ //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
+ AliESDHeader* esdheader = fesd->GetHeader();
+ for(Int_t i=0;i<50;i++){
+ if((1ull<<i) & esd->GetTriggerMask()){
+ AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
+ if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
+ }
+ }
}
-
- if (fRawReader) delete aCTP;
return kTRUE;
}
-
-
-
-
-
//_____________________________________________________________________________
Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
{
// 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;
}
if (gAlice) delete gAlice;
gAlice = NULL;
- if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+ TFile *gafile = TFile::Open(fGAliceFileName.Data());
+ // if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
+ if (gafile) { // galice.root exists
+ gafile->Close();
+ delete gafile;
+
// 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(),
{
// 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);
+ fReconstructor[iDet]->SetRunInfo(fRunInfo);
+ }
+ return fReconstructor[iDet];
+ }
// load the reconstructor object
TPluginManager* pluginManager = gROOT->GetPluginManager();
if (reconstructor) {
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
+ reconstructor->SetRunInfo(fRunInfo);
reconstructor->Init();
fReconstructor[iDet] = reconstructor;
}
}
}
+ if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ reconstructor->SetRecoParam(par);
+ reconstructor->SetRunInfo(fRunInfo);
+ }
return reconstructor;
}
//_____________________________________________________________________________
-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();
+ if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
+ fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
+ vertexer = itsReconstructor->CreateVertexer();
}
- if (!fVertexer) {
+ if (!vertexer) {
AliWarning("couldn't create a vertexer for ITS");
- if (fStopOnError) return kFALSE;
}
- return kTRUE;
+ return vertexer;
+}
+
+//_____________________________________________________________________________
+AliTrackleter* AliReconstruction::CreateMultFinder()
+{
+// create the ITS trackleter for mult. estimation
+// Please note that the caller is the owner of the
+// trackleter
+
+ AliTrackleter* trackleter = NULL;
+ AliReconstructor* itsReconstructor = GetReconstructor(0);
+ if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
+ fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
+ trackleter = itsReconstructor->CreateMultFinder();
+ }
+ else {
+ AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
+ fRunMultFinder = kFALSE;
+ }
+
+ return trackleter;
}
//_____________________________________________________________________________
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;
continue;
}
-
fTracker[iDet] = reconstructor->CreateTracker();
if (!fTracker[iDet] && (iDet < 7)) {
AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
}
//_____________________________________________________________________________
-void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
+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;
-// delete fQADataMaker[iDet];
-// fQADataMaker[iDet] = NULL;
}
- delete fVertexer;
- fVertexer = NULL;
+ delete fRunInfo;
+ fRunInfo = NULL;
- if (ftVertexer) delete ftVertexer;
+ delete fSPDTrackleter;
+ fSPDTrackleter = NULL;
+
+ delete ftVertexer;
ftVertexer = NULL;
- if(!(AliCDBManager::Instance()->GetCacheFlag())) {
- delete fDiamondProfile;
- fDiamondProfile = NULL;
- delete fDiamondProfileTPC;
- fDiamondProfileTPC = NULL;
- delete fGRPData;
- fGRPData = 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;
}
- 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();
- }
- delete file;
+ if (AliQAManager::QAManager())
+ AliQAManager::QAManager()->ShowQA() ;
+ AliQAManager::Destroy() ;
+
}
-
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 i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
+ for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
+ nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
+
+ if (iDet==GetDetIndex("ITS")) { // 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);
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->GetNcls(iDet);
+ Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
+
+ if (iDet==GetDetIndex("ITS")) // 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++;
+ if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
+ sp->AddPoint(isptrack,&p); isptrack++;
}
}
}
}
- if (fTracker[3]){
- fTracker[3]->UnloadClusters();
- fLoader[3]->UnloadRecPoints();
- }
}
//_____________________________________________________________________________
}
-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();
-
-}
-
//_____________________________________________________________________________
-AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
-{
- // get the quality assurance data maker object and the loader for a detector
-
- if (fQADataMaker[iDet])
- return fQADataMaker[iDet];
-
- AliQADataMakerRec * qadm = NULL;
- if (iDet == fgkNDetectors) { //Global QA
- qadm = new AliGlobalQADataMaker();
- fQADataMaker[iDet] = qadm;
- return qadm;
- }
-
- // load the QA data maker object
- TPluginManager* pluginManager = gROOT->GetPluginManager();
- TString detName = fgkDetectorName[iDet];
- TString qadmName = "Ali" + detName + "QADataMakerRec";
- if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT"))
- return NULL;
-
- // first check if a plugin is defined for the quality assurance data maker
- TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
- // if not, add a plugin for it
- if (!pluginHandler) {
- AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
- TString libs = gSystem->GetLibraries();
- if (libs.Contains("lib" + detName + "base.so") ||
- (gSystem->Load("lib" + detName + "base.so") >= 0)) {
- pluginManager->AddHandler("AliQADataMakerRec", detName,
- qadmName, detName + "qadm", qadmName + "()");
- } else {
- pluginManager->AddHandler("AliQADataMakerRec", detName,
- qadmName, detName, qadmName + "()");
- }
- pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
- }
- if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
- }
-
- fQADataMaker[iDet] = qadm;
-
- return qadm;
-}
-
-//_____________________________________________________________________________
-Bool_t AliReconstruction::RunQA(AliESDEvent *& esd)
-{
- // run the Quality Assurance data producer
-
- AliCodeTimerAuto("")
- TString detStr = fQADetectors ;
- 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]));
-
- if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
- 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()
-{
+// void AliReconstruction::CheckQA()
+// {
// check the QA of SIM for this run and remove the detectors
// with status Fatal
- TString newRunLocalReconstruction ;
- TString newRunTracking ;
- TString newFillESD ;
-
- for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
- TString detName(AliQA::GetDetName(iDet)) ;
- AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
- if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
- AliInfo(Form("QA status for %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
- } else {
- if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
- fRunLocalReconstruction.Contains("ALL") ) {
- newRunLocalReconstruction += detName ;
- newRunLocalReconstruction += " " ;
- }
- if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
- fRunTracking.Contains("ALL") ) {
- newRunTracking += detName ;
- newRunTracking += " " ;
- }
- if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
- fFillESD.Contains("ALL") ) {
- newFillESD += detName ;
- newFillESD += " " ;
- }
- }
- }
- fRunLocalReconstruction = newRunLocalReconstruction ;
- fRunTracking = newRunTracking ;
- fFillESD = newFillESD ;
-}
+// TString newRunLocalReconstruction ;
+// TString newRunTracking ;
+// TString newFillESD ;
+//
+// for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
+// TString detName(AliQAv1::GetDetName(iDet)) ;
+// AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
+// if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
+// AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS and/or Digits was Fatal; No reconstruction performed",
+// detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
+// } else {
+// if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
+// fRunLocalReconstruction.Contains("ALL") ) {
+// newRunLocalReconstruction += detName ;
+// newRunLocalReconstruction += " " ;
+// }
+// if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
+// fRunTracking.Contains("ALL") ) {
+// newRunTracking += detName ;
+// newRunTracking += " " ;
+// }
+// if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
+// fFillESD.Contains("ALL") ) {
+// newFillESD += detName ;
+// newFillESD += " " ;
+// }
+// }
+// }
+// fRunLocalReconstruction = newRunLocalReconstruction ;
+// fRunTracking = newRunTracking ;
+// fFillESD = newFillESD ;
+// }
//_____________________________________________________________________________
Int_t AliReconstruction::GetDetIndex(const char* detector)
{
// return the detector index corresponding to detector
Int_t index = -1 ;
- for (index = 0; index < fgkNDetectors ; index++) {
+ for (index = 0; index < kNDetectors ; index++) {
if ( strcmp(detector, fgkDetectorName[index]) == 0 )
break ;
}
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;
+ TString detStr = fLoadCDB;
//for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
- //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- if(fTracker[iDet]) {
- AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
- ret=planeeff->WriteIntoCDB();
+ for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
+ 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");
}
}
+ if(fSPDTrackleter) {
+ AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
+ TString name="AliITSPlaneEffSPDtracklet.root";
+ TFile* pefile = TFile::Open(name, "RECREATE");
+ ret=(Bool_t)planeeff->Write();
+ pefile->Close();
+ AliESDEvent *dummy=NULL;
+ ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
+ }
}
return ret;
}
//
// Here execute all the necessary operations, before of the tracking phase,
// for the evaluation of PlaneEfficiencies, in case required for some detectors.
- // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
+ // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
// which should be updated/recalculated.
//
// This Preliminary version will work only FOR ITS !!!!!
// Input: none
// Return: kTRUE if all operations have been done properly, kFALSE otherwise
//
- AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
+
+ fSPDTrackleter = NULL;
+ TString detStr = fLoadCDB;
+ if (IsSelected(fgkDetectorName[0], detStr)) {
+ AliReconstructor* itsReconstructor = GetReconstructor(0);
+ if (itsReconstructor) {
+ fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
+ }
+ if (fSPDTrackleter) {
+ AliInfo("Trackleter for SPD has been created");
+ }
+ }
return kTRUE;
}
// 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()));
+ TString macroPath;
+ macroPath.Form(".:%s:%s/EVE/macros/",
+ gROOT->GetMacroPath(),
+ gSystem->ExpandPathName("$ALICE_ROOT"));
+ gROOT->SetMacroPath(macroPath.Data());
+
+ TString macroStr("alieve_online.C");
+ AliInfo(Form("Loading AliEVE macro: %s (%s)",macroStr.Data(),
+ gSystem->Which(gROOT->GetMacroPath(), 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*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
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
+ // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
// all selected detectors run the same selected tasks
if (!detAndAction.Contains(":")) {
}
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) ;
+ fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
} else {
fQATasks.ToUpper() ;
TString tempo("") ;
if ( fQATasks.Contains("RAW") )
- tempo = Form("%d ", AliQA::kRAWS) ;
+ tempo = Form("%d ", AliQAv1::kRAWS) ;
+ if ( fQATasks.Contains("DIGIT") )
+ tempo += Form("%d ", AliQAv1::kDIGITSR) ;
if ( fQATasks.Contains("RECPOINT") )
- tempo += Form("%d ", AliQA::kRECPOINTS) ;
+ tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
if ( fQATasks.Contains("ESD") )
- tempo += Form("%d ", AliQA::kESDS) ;
+ tempo += Form("%d ", AliQAv1::kESDS) ;
fQATasks = tempo ;
if (fQATasks.IsNull()) {
AliInfo("No QA requested\n") ;
}
}
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)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
+ tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::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;
+
+ if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
+ AliInfo("Using custom GRP reconstruction parameters");
+ }
+ else {
+ AliInfo("Loading GRP reconstruction parameter objects");
+
+ AliCDBPath path("GRP","Calib","RecoParam");
+ AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
+ if(!entry){
+ AliWarning("Couldn't find GRP RecoParam entry in OCDB");
+ isOK = kFALSE;
+ }
+ else {
+ TObject *recoParamObj = entry->GetObject();
+ if (dynamic_cast<TObjArray*>(recoParamObj)) {
+ // GRP has a normal TobjArray of AliDetectorRecoParam objects
+ // Registering them in AliRecoParam
+ fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
+ }
+ else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
+ // GRP has only onse set of reco parameters
+ // Registering it in AliRecoParam
+ AliInfo("Single set of GRP reconstruction parameters found");
+ dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
+ fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
+ }
+ else {
+ AliError("No valid GRP RecoParam object found in the OCDB");
+ isOK = kFALSE;
+ }
+ entry->SetOwner(0);
+ }
+ }
+
+ 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]));
+ 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);
+ // FIX ME: We have to disable the unloading of reco-param CDB
+ // entries because QA framework is using them. Has to be fix in
+ // a way that the QA takes the objects already constructed in
+ // this method.
+ // AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
+ }
+ }
+
+ if (AliDebugLevel() > 0) fRecoParam.Print();
+
+ return isOK;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::GetEventInfo()
+{
+ // Fill the event info object
+ // ...
+ AliCodeTimerAuto("",0)
+
+ 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());
+ // get inputs from actp - just get
+ AliESDHeader* esdheader = fesd->GetHeader();
+ esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
+ esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
+ esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
+ 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 && trclass->GetMask()>0) {
+ Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
+ fesd->SetTriggerClass(trclass->GetName(),trindex);
+ if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
+ if (trmask & (1ull << trindex)) {
+ trclasses += " ";
+ trclasses += trclass->GetName();
+ trclasses += " ";
+ clustmask |= trclass->GetCluster()->GetClusterMask();
+ }
+ }
+ }
+ fEventInfo.SetTriggerClasses(trclasses);
+
+ // Write names of active trigger inputs in ESD Header
+ const TObjArray& inputsArray = config->GetInputs();
+ Int_t ninputs = inputsArray.GetEntriesFast();
+ for( Int_t iinput=0; iinput < ninputs; iinput++ ) {
+ AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
+ if (trginput && trginput->GetMask()>0) {
+ Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
+ AliESDHeader* headeresd = fesd->GetHeader();
+ Int_t trglevel = (Int_t)trginput->GetLevel();
+ if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
+ if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
+ if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
+ }
+ }
+
+ // 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.BeginsWith("-"+det+" ") ||
+ detList.EndsWith(" -"+det) ||
+ detList.Contains(" -"+det+" "))) ||
+ (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.BeginsWith("-"+hltDet+" ") ||
+ detList.EndsWith(" -"+hltDet) ||
+ detList.Contains(" -"+hltDet+" "))) ||
+ (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());
+}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::ProcessEvent(void* event)
+{
+ // Method that is used in case the event loop
+ // is steered from outside, for example by AMORE
+ // 'event' is a pointer to the DATE event in the memory
+
+ if (fRawReader) delete fRawReader;
+ fRawReader = new AliRawReaderDate(event);
+ fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
+ delete fRawReader;
+ fRawReader = NULL;
+
+ return fStatus;
+}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::ParseOutput()
+{
+ // The method parses the output file
+ // location string in order to steer
+ // properly the selector
+
+ TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
+ TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
+
+ if (re1.Match(fESDOutput) == 4) {
+ // root archive with output files stored and regustered
+ // in proof dataset
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
+ AliInfo(Form("%s files will be stored within %s in dataset %s",
+ re1[2].Data(),
+ re1[1].Data(),
+ re1[3].Data()));
+ }
+ else if (re2.Match(fESDOutput) == 3) {
+ // output file stored and registered
+ // in proof dataset
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
+ AliInfo(Form("%s will be stored in dataset %s",
+ (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
+ re2[2].Data()));
+ }
+ else {
+ if (fESDOutput.IsNull()) {
+ // Output location not given.
+ // Assuming xrootd has been already started and
+ // the output file has to be sent back
+ // to the client machine
+ TString esdUrl(Form("root://%s/%s/",
+ TUrl(gSystem->HostName()).GetHostFQDN(),
+ gSystem->pwd()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
+ AliInfo(Form("AliESDs.root will be stored in %s",
+ esdUrl.Data()));
+ }
+ else {
+ // User specified an output location.
+ // Ones has just to parse it here
+ TUrl outputUrl(fESDOutput.Data());
+ TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
+ TString outputLocation(outputUrl.GetUrl());
+ outputLocation.ReplaceAll(outputFile.Data(),"");
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
+ AliInfo(Form("%s will be stored in %s",
+ outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
+ outputLocation.Data()));
+ }
+ }
+
+ return kTRUE;
+}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::IsHighPt() const {
+ // Selection of events containing "high" pT tracks
+ // If at least one track is found within 1.5 and 100 GeV (pT)
+ // that was reconstructed by both ITS and TPC, the event is accepted
+
+ // Track cuts
+
+ const Double_t pTmin = 1.5;
+ const Double_t pTmax = 100;
+ ULong_t mask = 0;
+ mask |= (AliESDtrack::kITSrefit);
+ mask |= (AliESDtrack::kTPCrefit);
+
+ Bool_t isOK = kFALSE;
+
+ if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
+ // Check if this ia a physics event (code 7)
+ Int_t ntrk = fesd->GetNumberOfTracks();
+ for (Int_t itrk=0; itrk<ntrk; ++itrk) {
+
+ AliESDtrack * trk = fesd->GetTrack(itrk);
+ if (trk
+ && trk->Pt() > pTmin
+ && trk->Pt() < pTmax
+ && (trk->GetStatus() & mask) == mask ) {
+ isOK = kTRUE;
+ break;
+ }
+ }
+ }
+ return isOK;
+}
+
+//______________________________________________________________________________
+Bool_t AliReconstruction::IsCosmicOrCalibSpecie() const {
+ // Select cosmic or calibration events
+
+ Bool_t isOK = kFALSE;
+
+ if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
+ // Check if this ia a physics event (code 7)
+
+ UInt_t specie = fesd->GetEventSpecie();
+ if (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib) {
+ isOK = kTRUE;
+ }
+ }
+ return isOK;
+}
+
+//______________________________________________________________________________
+void AliReconstruction::WriteESDfriend() {
+ // Fill the ESD friend in the tree. The required fraction of ESD friends is stored
+ // in fFractionFriends. We select events where we store the ESD friends according
+ // to the following algorithm:
+ // 1. Store all Cosmic or Calibration events within the required fraction
+ // 2. Sample "high Pt" events within the remaining fraction after step 1.
+ // 3. Sample randomly events if we still have remaining slot
+
+ fNall++;
+
+ Bool_t isSelected = kFALSE;
+
+ if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
+ fNspecie++;
+ Double_t curentSpecieFraction = ((Double_t)(fNspecie+1))/((Double_t)(fNall+1));
+ // "Bayesian" estimate supposing that without events all the events are of the required type
+
+ Double_t rnd = gRandom->Rndm()*curentSpecieFraction;
+ if (rnd<fFractionFriends) {
+ isSelected = kTRUE;
+ fSspecie++;
+ }
+ }
+
+ Double_t remainingFraction = fFractionFriends;
+ remainingFraction -= ((Double_t)(fSspecie)/(Double_t)(fNall));
+
+ if (IsHighPt()) { // Selection of "high Pt" events
+ fNhighPt++;
+ Double_t curentHighPtFraction = ((Double_t)(fNhighPt+1))/((Double_t)(fNall+1));
+ // "Bayesian" estimate supposing that without events all the events are of the required type
+
+ if (!isSelected) {
+ Double_t rnd = gRandom->Rndm()*curentHighPtFraction;
+ if (rnd<remainingFraction) {
+ isSelected = kTRUE;
+ fShighPt++;
+ }
+ }
+ }
+ remainingFraction -= ((Double_t)(fShighPt)/(Double_t)(fNall));
+
+ // Random selection to fill the remaining fraction (if any)
+ if (!isSelected) {
+ Double_t rnd = gRandom->Rndm();
+ if (rnd<remainingFraction) {
+ isSelected = kTRUE;
+ }
+ }
+
+ if (!isSelected) {
+ fesdf->~AliESDfriend();
+ new (fesdf) AliESDfriend(); // Reset...
+ fesdf->SetSkipBit(kTRUE);
+ }
+
+ ftreeF->Fill();
+}