// data by calling (usual detector string) //
// SetUseHLTData("..."); //
// //
-// For debug purposes the method SetCheckPointLevel can be used. If the //
-// argument is greater than 0, files with ESD events will be written after //
-// selected steps of the reconstruction for each event: //
-// level 1: after tracking and after filling of ESD (final) //
-// level 2: in addition after each tracking step //
-// level 3: in addition after the filling of ESD for each detector //
-// If a final check point file exists for an event, this event will be //
-// skipped in the reconstruction. The tracking and the filling of ESD for //
-// a detector will be skipped as well, if the corresponding check point //
-// file exists. The ESD event will then be loaded from the file instead. //
// //
///////////////////////////////////////////////////////////////////////////////
#include <TArrayS.h>
#include <TArrayD.h>
#include <TObjArray.h>
+#include <TMap.h>
+#include <TChain.h>
+#include <TProof.h>
+#include <TProofOutputFile.h>
+#include <TParameter.h>
#include "AliReconstruction.h"
#include "AliCodeTimer.h"
#include "AliRawReaderDate.h"
#include "AliRawReaderRoot.h"
#include "AliRawEventHeaderBase.h"
+#include "AliRawEvent.h"
#include "AliESDEvent.h"
#include "AliESDMuonTrack.h"
#include "AliESDfriend.h"
#include "AliESDPmdTrack.h"
#include "AliESDTagCreator.h"
-#include "AliAODTagCreator.h"
#include "AliGeomManager.h"
#include "AliTrackPointArray.h"
#include "AliCentralTrigger.h"
#include "AliTriggerConfiguration.h"
#include "AliTriggerClass.h"
+#include "AliTriggerCluster.h"
#include "AliCTPRawStream.h"
-#include "AliAODEvent.h"
-#include "AliAODHeader.h"
-#include "AliAODTrack.h"
-#include "AliAODVertex.h"
-#include "AliAODv0.h"
-#include "AliAODJet.h"
-#include "AliAODCaloCells.h"
-#include "AliAODCaloCluster.h"
-#include "AliAODPmdCluster.h"
-#include "AliAODFmdCluster.h"
-#include "AliAODTracklets.h"
-
#include "AliQADataMakerRec.h"
#include "AliGlobalQADataMaker.h"
#include "AliQA.h"
#include "AliSysInfo.h" // memory snapshots
#include "AliRawHLTManager.h"
+#include "AliMagWrapCheb.h"
-ClassImp(AliReconstruction)
+#include "AliDetectorRecoParam.h"
+#include "AliRunInfo.h"
+#include "AliEventInfo.h"
+#include "AliDAQ.h"
+
+ClassImp(AliReconstruction)
//_____________________________________________________________________________
const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
//_____________________________________________________________________________
-AliReconstruction::AliReconstruction(const char* gAliceFilename,
- const char* name, const char* title) :
- TNamed(name, title),
-
- fUniformField(kTRUE),
+AliReconstruction::AliReconstruction(const char* gAliceFilename) :
+ TSelector(),
+ fUniformField(kFALSE),
+ fForcedFieldMap(NULL),
fRunVertexFinder(kTRUE),
fRunVertexFinderTracks(kTRUE),
fRunHLTTracking(kFALSE),
fStopOnError(kFALSE),
fWriteAlignmentData(kFALSE),
fWriteESDfriend(kFALSE),
- fWriteAOD(kFALSE),
fFillTriggerESD(kTRUE),
fCleanESD(kTRUE),
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fLoadCDB(""),
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
- fInput(""),
+ fRawInput(""),
fEquipIdMap(""),
fFirstEvent(0),
fLastEvent(-1),
fNumberOfEventsPerFile(1),
- fCheckPointLevel(0),
fOptions(),
fLoadAlignFromCDB(kTRUE),
fLoadAlignData("ALL"),
fESDPar(""),
fUseHLTData(),
+ fRunInfo(NULL),
+ fEventInfo(),
fRunLoader(NULL),
fRawReader(NULL),
fParentRawReader(NULL),
+ fRecoParam(),
+
fVertexer(NULL),
fDiamondProfile(NULL),
+ fDiamondProfileTPC(NULL),
fMeanVertexConstraint(kTRUE),
- fGRPList(NULL),
+ fGRPData(NULL),
fAlignObjArray(NULL),
fCDBUri(),
fSpecCDBUri(),
fInitCDBCalled(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
+ fQADetectors("ALL"),
+ fQASteer(NULL),
+ fQATasks("ALL"),
fRunQA(kTRUE),
- fRunGlobalQA(kFALSE),
+ fRunGlobalQA(kTRUE),
fInLoopQA(kFALSE),
-
- fRunPlaneEff(kFALSE)
+ fSameQACycle(kFALSE),
+
+ fRunPlaneEff(kFALSE),
+
+ fesd(NULL),
+ fhltesd(NULL),
+ fesdf(NULL),
+ ffile(NULL),
+ ftree(NULL),
+ fhlttree(NULL),
+ ftVertexer(NULL),
+ fIsNewRunLoader(kFALSE),
+ fRunAliEVE(kFALSE),
+ fChain(NULL)
{
// create reconstruction object with default parameters
+ gGeoManager = NULL;
for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQADataMaker[iDet] = NULL;
- fQACycles[iDet] = 999999;
+ fQACycles[iDet] = 999999;
}
- fQADataMaker[fgkNDetectors]=NULL; //Global QA
+ fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
AliPID pid;
}
//_____________________________________________________________________________
AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
- TNamed(rec),
-
+ TSelector(),
fUniformField(rec.fUniformField),
+ fForcedFieldMap(NULL),
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunHLTTracking(rec.fRunHLTTracking),
fStopOnError(rec.fStopOnError),
fWriteAlignmentData(rec.fWriteAlignmentData),
fWriteESDfriend(rec.fWriteESDfriend),
- fWriteAOD(rec.fWriteAOD),
fFillTriggerESD(rec.fFillTriggerESD),
fCleanESD(rec.fCleanESD),
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
+ fLoadCDB(rec.fLoadCDB),
fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
- fInput(rec.fInput),
+ fRawInput(rec.fRawInput),
fEquipIdMap(rec.fEquipIdMap),
fFirstEvent(rec.fFirstEvent),
fLastEvent(rec.fLastEvent),
fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
- fCheckPointLevel(0),
fOptions(),
fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
fLoadAlignData(rec.fLoadAlignData),
fESDPar(rec.fESDPar),
+ fUseHLTData(rec.fUseHLTData),
+ fRunInfo(NULL),
+ fEventInfo(),
fRunLoader(NULL),
fRawReader(NULL),
+ fParentRawReader(NULL),
+
+ fRecoParam(rec.fRecoParam),
fVertexer(NULL),
- fDiamondProfile(NULL),
+ fDiamondProfile(rec.fDiamondProfile),
+ fDiamondProfileTPC(rec.fDiamondProfileTPC),
fMeanVertexConstraint(rec.fMeanVertexConstraint),
- fGRPList(NULL),
+ fGRPData(NULL),
fAlignObjArray(rec.fAlignObjArray),
fCDBUri(rec.fCDBUri),
fSpecCDBUri(),
fInitCDBCalled(rec.fInitCDBCalled),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
+ fQADetectors(rec.fQADetectors),
+ fQASteer(NULL),
+ fQATasks(rec.fQATasks),
fRunQA(rec.fRunQA),
fRunGlobalQA(rec.fRunGlobalQA),
fInLoopQA(rec.fInLoopQA),
- fRunPlaneEff(rec.fRunPlaneEff)
+ fSameQACycle(rec.fSameQACycle),
+ fRunPlaneEff(rec.fRunPlaneEff),
+
+ fesd(NULL),
+ fhltesd(NULL),
+ fesdf(NULL),
+ ffile(NULL),
+ ftree(NULL),
+ fhlttree(NULL),
+ ftVertexer(NULL),
+ fIsNewRunLoader(rec.fIsNewRunLoader),
+ fRunAliEVE(kFALSE),
+ fChain(NULL)
{
// copy constructor
fReconstructor[iDet] = NULL;
fLoader[iDet] = NULL;
fTracker[iDet] = NULL;
- fQADataMaker[iDet] = NULL;
- fQACycles[iDet] = rec.fQACycles[iDet];
+ fQACycles[iDet] = rec.fQACycles[iDet];
}
- fQADataMaker[fgkNDetectors]=NULL; //Global QA
for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
}
+
}
//_____________________________________________________________________________
AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
{
// assignment operator
+// Used in PROOF mode
+// Be very careful while modifing it!
+// Simple rules to follow:
+// for persistent data members - use their assignment operators
+// for non-persistent ones - do nothing or take the default values from constructor
+// TSelector members should not be touched
+ if(&rec == this) return *this;
+
+ fUniformField = rec.fUniformField;
+ fForcedFieldMap = NULL;
+ fRunVertexFinder = rec.fRunVertexFinder;
+ fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
+ fRunHLTTracking = rec.fRunHLTTracking;
+ fRunMuonTracking = rec.fRunMuonTracking;
+ fRunV0Finder = rec.fRunV0Finder;
+ fRunCascadeFinder = rec.fRunCascadeFinder;
+ fStopOnError = rec.fStopOnError;
+ fWriteAlignmentData = rec.fWriteAlignmentData;
+ fWriteESDfriend = rec.fWriteESDfriend;
+ fFillTriggerESD = rec.fFillTriggerESD;
+
+ fCleanESD = rec.fCleanESD;
+ fV0DCAmax = rec.fV0DCAmax;
+ fV0CsPmin = rec.fV0CsPmin;
+ fDmax = rec.fDmax;
+ fZmax = rec.fZmax;
+
+ fRunLocalReconstruction = rec.fRunLocalReconstruction;
+ fRunTracking = rec.fRunTracking;
+ fFillESD = rec.fFillESD;
+ fLoadCDB = rec.fLoadCDB;
+ fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
+ fGAliceFileName = rec.fGAliceFileName;
+ fRawInput = rec.fRawInput;
+ fEquipIdMap = rec.fEquipIdMap;
+ fFirstEvent = rec.fFirstEvent;
+ fLastEvent = rec.fLastEvent;
+ fNumberOfEventsPerFile = rec.fNumberOfEventsPerFile;
+
+ for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
+ if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
+ }
+
+ fLoadAlignFromCDB = rec.fLoadAlignFromCDB;
+ fLoadAlignData = rec.fLoadAlignData;
+ fESDPar = rec.fESDPar;
+ fUseHLTData = rec.fUseHLTData;
+
+ delete fRunInfo; fRunInfo = NULL;
+ if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
+
+ fEventInfo = rec.fEventInfo;
+
+ fRunLoader = NULL;
+ fRawReader = NULL;
+ fParentRawReader = NULL;
+
+ fRecoParam = rec.fRecoParam;
+
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
+ delete fLoader[iDet]; fLoader[iDet] = NULL;
+ delete fTracker[iDet]; fTracker[iDet] = NULL;
+ fQACycles[iDet] = rec.fQACycles[iDet];
+ }
+
+ fVertexer = NULL;
+ delete fDiamondProfile; fDiamondProfile = NULL;
+ if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
+ delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
+ if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
+ fMeanVertexConstraint = rec.fMeanVertexConstraint;
+
+ delete fGRPData; fGRPData = NULL;
+ if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
+
+ delete fAlignObjArray; fAlignObjArray = NULL;
+
+ fCDBUri = "";
+ fSpecCDBUri.Delete();
+ fInitCDBCalled = rec.fInitCDBCalled;
+ fSetRunNumberFromDataCalled = rec.fSetRunNumberFromDataCalled;
+ fQADetectors = rec.fQADetectors;
+ fQASteer = NULL;
+ fQATasks = rec.fQATasks;
+ fRunQA = rec.fRunQA;
+ fRunGlobalQA = rec.fRunGlobalQA;
+ fInLoopQA = rec.fInLoopQA;
+ fSameQACycle = rec.fSameQACycle;
+ fRunPlaneEff = rec.fRunPlaneEff;
+
+ fesd = NULL;
+ fhltesd = NULL;
+ fesdf = NULL;
+ ffile = NULL;
+ ftree = NULL;
+ fhlttree = NULL;
+ ftVertexer = NULL;
+ fIsNewRunLoader = rec.fIsNewRunLoader;
+ fRunAliEVE = kFALSE;
+ fChain = NULL;
- this->~AliReconstruction();
- new(this) AliReconstruction(rec);
return *this;
}
// clean up
CleanUp();
+ delete fForcedFieldMap;
fOptions.Delete();
+ if (fAlignObjArray) {
+ fAlignObjArray->Delete();
+ delete fAlignObjArray;
+ }
fSpecCDBUri.Delete();
-
+ delete fQASteer;
AliCodeTimer::Instance()->Print();
}
// activate a default CDB storage
// First check if we have any CDB storage set, because it is used
// to retrieve the calibration and alignment constants
+ AliCodeTimerAuto("");
if (fInitCDBCalled) return;
fInitCDBCalled = kTRUE;
AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
}
-
+ AliSysInfo::AddStamp("InitCDB");
}
//_____________________________________________________________________________
fSetRunNumberFromDataCalled = kTRUE;
AliCDBManager* man = AliCDBManager::Instance();
-
- if(man->GetRun() > 0) {
- AliWarning("Run number is taken from event header! Ignoring settings in AliCDBManager!");
- }
-
- if (!fRunLoader) {
- AliError("No run loader is found !");
+
+ if(fRawReader) {
+ if(fRawReader->NextEvent()) {
+ if(man->GetRun() > 0) {
+ AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
+ }
+ 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 {
- AliError("No raw-data events 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();
} // end loop over detectors
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;
}
fGAliceFileName = fileName;
}
+//_____________________________________________________________________________
+void AliReconstruction::SetInput(const char* input)
+{
+ // In case the input string starts with 'mem://', we run in an online mode
+ // and AliRawReaderDateOnline object is created. In all other cases a raw-data
+ // file is assumed. One can give as an input:
+ // mem://: - events taken from DAQ monitoring libs online
+ // or
+ // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
+ if (input) fRawInput = input;
+}
+
//_____________________________________________________________________________
void AliReconstruction::SetOption(const char* detector, const char* option)
{
fOptions.Add(new TNamed(detector, option));
}
+//_____________________________________________________________________________
+void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
+{
+ // Set custom reconstruction parameters for a given detector
+ // Single set of parameters for all the events
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if(!strcmp(detector, fgkDetectorName[iDet])) {
+ par->SetAsDefault();
+ fRecoParam.AddDetRecoParam(iDet,par);
+ break;
+ }
+ }
+
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) {
+ //------------------------------------------------
+ // The magnetic field map, defined externally...
+ // L3 current 30000 A -> 0.5 T
+ // L3 current 12000 A -> 0.2 T
+ // dipole current 6000 A
+ // The polarities must be the same
+ //------------------------------------------------
+ const Float_t l3NominalCurrent1=30000.; // (A)
+ const Float_t l3NominalCurrent2=12000.; // (A)
+ const Float_t diNominalCurrent =6000. ; // (A)
+
+ const Float_t tolerance=0.03; // relative current tolerance
+ const Float_t zero=77.; // "zero" current (A)
+
+ Int_t map=0;
+ Bool_t dipoleON=kFALSE;
+
+ TString s=(factor < 0) ? "L3: -" : "L3: +";
+
+ l3Current = TMath::Abs(l3Current);
+ if (TMath::Abs(l3Current-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
+ map=AliMagWrapCheb::k5kG;
+ s+="0.5 T; ";
+ } else
+ if (TMath::Abs(l3Current-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
+ map=AliMagWrapCheb::k2kG;
+ s+="0.2 T; ";
+ } else
+ if (l3Current < zero) {
+ map=AliMagWrapCheb::k2kG;
+ s+="0.0 T; ";
+ factor=0.; // in fact, this is a global factor...
+ fUniformField=kTRUE; // track with the uniform (zero) B field
+ } else {
+ AliError(Form("Wrong L3 current (%f A)!",l3Current));
+ return kFALSE;
+ }
+
+ diCurrent = TMath::Abs(diCurrent);
+ if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
+ // 3% current tolerance...
+ dipoleON=kTRUE;
+ s+="Dipole ON";
+ } else
+ if (diCurrent < zero) { // some small current..
+ dipoleON=kFALSE;
+ s+="Dipole OFF";
+ } else {
+ AliError(Form("Wrong dipole current (%f A)!",diCurrent));
+ return kFALSE;
+ }
+
+ delete fForcedFieldMap;
+ fForcedFieldMap=
+ new AliMagWrapCheb("B field map ",s,2,factor,10.,map,dipoleON,path);
+
+ fForcedFieldMap->Print();
+
+ AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
+
+ return kTRUE;
+}
+
+
+Bool_t AliReconstruction::InitGRP() {
+ //------------------------------------
+ // Initialization of the GRP entry
+ //------------------------------------
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+
+ if (entry) {
+ fGRPData = dynamic_cast<TMap*>(entry->GetObject());
+ entry->SetOwner(0);
+ AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
+ }
+
+ if (!fGRPData) {
+ AliError("No GRP entry found in OCDB!");
+ return kFALSE;
+ }
+
+ TObjString *lhcState=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fLHCState"));
+ if (!lhcState) {
+ AliError("GRP/GRP/Data entry: missing value for the LHC state ! Using UNKNOWN");
+ }
+
+ TObjString *beamType=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamType"));
+ if (!beamType) {
+ AliError("GRP/GRP/Data entry: missing value for the beam type ! Using UNKNOWN");
+ }
+
+ TObjString *beamEnergyStr=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamEnergy"));
+ if (!beamEnergyStr) {
+ AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
+ }
+
+ TObjString *runType=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fRunType"));
+ if (!runType) {
+ AliError("GRP/GRP/Data entry: missing value for the run type ! Using UNKNOWN");
+ }
+
+ TObjString *activeDetectors=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fDetectorMask"));
+ if (!activeDetectors) {
+ AliError("GRP/GRP/Data entry: missing value for the detector mask ! Using 1074790399");
+ }
+
+ fRunInfo = new AliRunInfo(lhcState ? lhcState->GetString().Data() : "UNKNOWN",
+ beamType ? beamType->GetString().Data() : "UNKNOWN",
+ beamEnergyStr ? beamEnergyStr->GetString().Atof() : 0,
+ runType ? runType->GetString().Data() : "UNKNOWN",
+ activeDetectors ? activeDetectors->GetString().Atoi() : 1074790399);
+
+ // Process the list of active detectors
+ if (activeDetectors && activeDetectors->GetString().IsDigit()) {
+ UInt_t detMask = activeDetectors->GetString().Atoi();
+ fLoadCDB.Form("%s %s %s %s",
+ fRunLocalReconstruction.Data(),
+ fRunTracking.Data(),
+ fFillESD.Data(),
+ fQADetectors.Data());
+ fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
+ fRunTracking = MatchDetectorList(fRunTracking,detMask);
+ fFillESD = MatchDetectorList(fFillESD,detMask);
+ fQADetectors = MatchDetectorList(fQADetectors,detMask);
+ fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
+ }
+
+ AliInfo("===================================================================================");
+ AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
+ AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
+ AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
+ AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
+ AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
+ AliInfo("===================================================================================");
+
+ //*** Dealing with the magnetic field map
+ if (AliTracker::GetFieldMap()) {
+ AliInfo("Running with the externally set B field !");
+ } else {
+ // Construct the field map out of the information retrieved from GRP.
+
+ Bool_t ok = kTRUE;
+
+ // L3
+ TObjString *l3Current=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
+ if (!l3Current) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 current !");
+ ok = kFALSE;
+ }
+ TObjString *l3Polarity=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
+ if (!l3Polarity) {
+ AliError("GRP/GRP/Data entry: missing value for the L3 polarity !");
+ ok = kFALSE;
+ }
+
+ // Dipole
+ TObjString *diCurrent=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
+ if (!diCurrent) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole current !");
+ ok = kFALSE;
+ }
+ TObjString *diPolarity=
+ dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
+ if (!diPolarity) {
+ AliError("GRP/GRP/Data entry: missing value for the dipole polarity !");
+ ok = kFALSE;
+ }
+
+ if (ok) {
+ Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
+ Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
+ Float_t l3Pol=atof(l3Polarity->GetName());
+ Float_t factor=1.;
+ if (l3Pol != 0.) factor=-1.;
+
+
+ if (!SetFieldMap(l3Cur, diCur, factor)) {
+ AliFatal("Failed to creat a B field map ! Exiting...");
+ }
+ AliInfo("Running with the B field constructed out of GRP !");
+ }
+ else {
+ AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
+ }
+
+ }
+
+ //*** Get the diamond profile from OCDB
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
+ if (entry) {
+ if (fMeanVertexConstraint)
+ fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ AliError("No diamond profile found in OCDB!");
+ }
+
+ entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
+ if (entry) {
+ if (fMeanVertexConstraint)
+ fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
+ } else {
+ AliError("No diamond profile found in OCDB!");
+ }
+
+ return kTRUE;
+}
//_____________________________________________________________________________
-Bool_t AliReconstruction::Run(const char* input, Bool_t IsOnline)
+Bool_t AliReconstruction::LoadCDB()
{
-// run the reconstruction
+ AliCodeTimerAuto("");
- AliCodeTimerAuto("")
-
- // set the input
- if (!IsOnline) {
- if (!input) input = fInput.Data();
- TString fileName(input);
- if (fileName.EndsWith("/")) {
- fRawReader = new AliRawReaderFile(fileName);
- } else if (fileName.EndsWith(".root")) {
- fRawReader = new AliRawReaderRoot(fileName);
- } else if (!fileName.IsNull()) {
- fRawReader = new AliRawReaderDate(fileName);
+ AliCDBManager::Instance()->Get("GRP/CTP/Config");
+
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
+ }
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::Run(const char* input)
+{
+ // Run Run Run
+ AliCodeTimerAuto("");
+
+ InitRun(input);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+
+ TChain *chain = NULL;
+ if (fRawReader && (chain = fRawReader->GetChain())) {
+ // Proof mode
+ if (gProof) {
+ gProof->AddInput(this);
+ TUrl outputFile;
+ outputFile.SetProtocol("root",kTRUE);
+ outputFile.SetHost(gSystem->HostName());
+ outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
+ AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl()));
+ gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl()));
+ chain->SetProof();
+ chain->Process("AliReconstruction");
+ }
+ else {
+ chain->Process(this);
}
}
else {
- if (!input) {
- AliError("Null pointer to the event structure!");
- return kFALSE;
+ Begin(NULL);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+ SlaveBegin(NULL);
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+ //******* The loop over events
+ Int_t iEvent = 0;
+ while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
+ (fRawReader && fRawReader->NextEvent())) {
+ if (!ProcessEvent(iEvent)) {
+ Abort("ProcessEvent",TSelector::kAbortFile);
+ return kFALSE;
+ }
+ iEvent++;
}
- fRawReader = new AliRawReaderDate((void *)input);
+ SlaveTerminate();
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
+ Terminate();
+ if (GetAbort() != TSelector::kContinue) return kFALSE;
}
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::InitRawReader(const char* input)
+{
+ AliCodeTimerAuto("");
+
+ // Init raw-reader and
+ // set the input in case of raw data
+ if (input) fRawInput = input;
+ fRawReader = AliRawReader::Create(fRawInput.Data());
+ if (!fRawReader)
+ AliInfo("Reconstruction will run over digits");
+
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("");
+ AliSysInfo::AddStamp("Start");
+
+ // Initialize raw-reader if any
+ InitRawReader(input);
// Initialize the CDB storage
InitCDB();
-
- AliSysInfo::AddStamp("LoadCDB");
// Set run number in CDBManager (if it is not already set by the user)
- if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
-
+ if (!SetRunNumberFromData()) {
+ Abort("SetRunNumberFromData", TSelector::kAbortProcess);
+ return;
+ }
+
// Set CDB lock: from now on it is forbidden to reset the run number
// or the default storage or to activate any further storage!
SetCDBLock();
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::Begin(TTree *)
+{
+ // Initialize AlReconstruction before
+ // going into the event loop
+ // Should follow the TSelector convention
+ // i.e. initialize only the object on the client side
+ AliCodeTimerAuto("");
+
+ AliReconstruction *reco = NULL;
+ if (fInput) {
+ if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
+ *this = *reco;
+ }
+ AliSysInfo::AddStamp("ReadInputInBegin");
+ }
+
// Import ideal TGeo geometry and apply misalignment
if (!gGeoManager) {
TString geom(gSystem->DirName(fGAliceFileName));
geom += "/geometry.root";
AliGeomManager::LoadGeometry(geom.Data());
- if (!gGeoManager) if (fStopOnError) return kFALSE;
+ if (!gGeoManager) {
+ Abort("LoadGeometry", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadGeom");
+ TString detsToCheck=fRunLocalReconstruction;
+ if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
+ Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("CheckGeom");
+ }
+
+ if (!MisalignGeometry(fLoadAlignData)) {
+ 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");
- //QA
- AliQADataMakerSteer qas ;
- if (fRunQA && fRawReader) qas.Run(fRunLocalReconstruction, fRawReader) ;
- // checking the QA of previous steps
- //CheckQA() ;
-
- /*
- // local reconstruction
- if (!fRunLocalReconstruction.IsNull()) {
- if (!RunLocalReconstruction(fRunLocalReconstruction)) {
- if (fStopOnError) {CleanUp(); return kFALSE;}
+ if (!LoadCDB()) {
+ Abort("LoadCDB", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("LoadCDB");
+
+ // Read the reconstruction parameters from OCDB
+ if (!InitRecoParams()) {
+ AliWarning("Not all detectors have correct RecoParam objects initialized");
+ }
+ AliSysInfo::AddStamp("InitRecoParams");
+
+ if (fInput) {
+ if (reco) *reco = *this;
+ fInput->Add(gGeoManager);
+ gGeoManager = NULL;
+ fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
+ fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
+ AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap();
+ magFieldMap->SetName("MagneticFieldMap");
+ fInput->Add(magFieldMap);
+ }
+
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::SlaveBegin(TTree*)
+{
+ // Initialization related to run-loader,
+ // vertexer, trackers, recontructors
+ // In proof mode it is executed on the slave
+ AliCodeTimerAuto("");
+
+ TProofOutputFile *outProofFile = NULL;
+ if (fInput) {
+ if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
+ *this = *reco;
+ }
+ if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
+ gGeoManager = tgeo;
+ AliGeomManager::SetGeometry(tgeo);
+ }
+ if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
+ Int_t runNumber = -1;
+ if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
+ AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
+ man->SetCacheFlag(kTRUE);
+ man->SetLock(kTRUE);
+ man->Print();
+ }
+ }
+ if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
+ AliTracker::SetFieldMap(map,fUniformField);
}
+ if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
+ outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
+ outProofFile->SetOutputFileName(outputFileName->GetTitle());
+ fOutput->Add(outProofFile);
+ }
+ AliSysInfo::AddStamp("ReadInputInSlaveBegin");
+ }
+
+ // get the run loader
+ if (!InitRunLoader()) {
+ Abort("InitRunLoader", TSelector::kAbortProcess);
+ return;
}
- */
+ AliSysInfo::AddStamp("LoadLoader");
+
+ ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
+ if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
// get vertexer
if (fRunVertexFinder && !CreateVertexer()) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
+ Abort("CreateVertexer", TSelector::kAbortProcess);
+ return;
}
- AliSysInfo::AddStamp("Vertexer");
+ AliSysInfo::AddStamp("CreateVertexer");
// get trackers
if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
- if (fStopOnError) {
- CleanUp();
- return kFALSE;
- }
- }
- AliSysInfo::AddStamp("LoadTrackers");
+ Abort("CreateTrackers", TSelector::kAbortProcess);
+ return;
+ }
+ AliSysInfo::AddStamp("CreateTrackers");
- // get the possibly already existing ESD file and tree
- AliESDEvent* esd = new AliESDEvent(); AliESDEvent* hltesd = new AliESDEvent();
- TFile* fileOld = NULL;
- TTree* treeOld = NULL; TTree *hlttreeOld = NULL;
- if (!gSystem->AccessPathName("AliESDs.root")){
- gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
- fileOld = TFile::Open("AliESDs.old.root");
- if (fileOld && fileOld->IsOpen()) {
- treeOld = (TTree*) fileOld->Get("esdTree");
- if (treeOld)esd->ReadFromTree(treeOld);
- hlttreeOld = (TTree*) fileOld->Get("HLTesdTree");
- if (hlttreeOld) hltesd->ReadFromTree(hlttreeOld);
+ // create the ESD output file and tree
+ if (!outProofFile) {
+ ffile = TFile::Open("AliESDs.root", "RECREATE");
+ ffile->SetCompressionLevel(2);
+ if (!ffile->IsOpen()) {
+ Abort("OpenESDFile", TSelector::kAbortProcess);
+ return;
}
}
-
- // create the ESD output file and tree
- TFile* file = TFile::Open("AliESDs.root", "RECREATE");
- file->SetCompressionLevel(2);
- if (!file->IsOpen()) {
- AliError("opening AliESDs.root failed");
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ else {
+ if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
+ Abort(Form("Problems opening output PROOF file: %s/%s",
+ outProofFile->GetDir(), outProofFile->GetFileName()),
+ TSelector::kAbortProcess);
+ return;
+ }
}
- TTree* tree = new TTree("esdTree", "Tree with ESD objects");
- esd = new AliESDEvent();
- esd->CreateStdContent();
- esd->WriteToTree(tree);
+ ftree = new TTree("esdTree", "Tree with ESD objects");
+ fesd = new AliESDEvent();
+ fesd->CreateStdContent();
+ fesd->WriteToTree(ftree);
- TTree* hlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
- hltesd = new AliESDEvent();
- hltesd->CreateStdContent();
- hltesd->WriteToTree(hlttree);
+ fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
+ fhltesd = new AliESDEvent();
+ fhltesd->CreateStdContent();
+ fhltesd->WriteToTree(fhlttree);
- /* CKB Why?
- delete esd; delete hltesd;
- esd = NULL; hltesd = NULL;
- */
- // create the branch with ESD additions
-
-
- AliESDfriend *esdf = 0;
if (fWriteESDfriend) {
- esdf = new AliESDfriend();
- TBranch *br=tree->Branch("ESDfriend.","AliESDfriend", &esdf);
+ fesdf = new AliESDfriend();
+ TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
br->SetFile("AliESDfriends.root");
- esd->AddObject(esdf);
+ fesd->AddObject(fesdf);
}
+ ProcInfo_t ProcInfo;
+ gSystem->GetProcInfo(&ProcInfo);
+ AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
- // Get the GRP CDB entry
- AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
+ //QA
+ fQASteer = new AliQADataMakerSteer("rec") ;
+ fQASteer->SetActiveDetectors(fQADetectors) ;
+ fQASteer->SetTasks(fQATasks) ;
+
+ if ( !fInLoopQA ) {
+ if (fRunQA && fRawReader && fQATasks.Contains(Form("%d", AliQA::kRAWS))) {
+ fQASteer->Run(fQADetectors, fRawReader) ;
+ fSameQACycle = kTRUE ;
+ }
+ }
- if(entryGRP) {
- fGRPList = dynamic_cast<TList*> (entryGRP->GetObject());
- } else {
- AliError("No GRP entry found in OCDB!");
+ //Initialize the QA and start of cycle for out-of-loop QA
+ if (fRunQA) {
+ fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, !fInLoopQA) ;
}
-
- // Get the diamond profile from OCDB
- AliCDBEntry* entry = AliCDBManager::Instance()
- ->Get("GRP/Calib/MeanVertex");
- if(entry) {
- fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
- } else {
- AliError("No diamond profile found in OCDB!");
+ if (fRunGlobalQA) {
+ fSameQACycle = kFALSE;
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ AliInfo(Form("Initializing the global QA data maker"));
+ if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
+ TObjArray *arr=qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
+ AliTracker::SetResidualsArray(arr);
+ if (!fInLoopQA) {
+ qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
+ fSameQACycle = kTRUE;
+ }
+ }
+ if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
+ qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
+ if (!fInLoopQA) {
+ qadm->StartOfCycle(AliQA::kESDS, fSameQACycle);
+ fSameQACycle = kTRUE;
+ }
+ }
}
- AliVertexerTracks tVertexer(AliTracker::GetBz());
- if(fDiamondProfile && fMeanVertexConstraint) tVertexer.SetVtxStart(fDiamondProfile);
+ //Initialize the Plane Efficiency framework
+ if (fRunPlaneEff && !InitPlaneEff()) {
+ Abort("InitPlaneEff", TSelector::kAbortProcess);
+ return;
+ }
- if (fRawReader) fRawReader->RewindEvents();
+ if (strcmp(gProgName,"alieve") == 0)
+ fRunAliEVE = InitAliEVE();
- ProcInfo_t ProcInfo;
- gSystem->GetProcInfo(&ProcInfo);
- AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
-
+ return;
+}
- //Initialize the QA and start of cycle for out-of-cycle QA
- if (fRunQA) {
- TString detStr(fFillESD);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliQADataMakerRec *qadm = GetQADataMaker(iDet);
- if (!qadm) continue;
- AliInfo(Form("Initializing the QA data maker for %s",
- fgkDetectorName[iDet]));
- qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS,"same");
- }
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- AliInfo(Form("Initializing the global QA data maker"));
- TObjArray *arr=
- qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
- AliTracker::SetResidualsArray(arr);
- qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
- if (!fInLoopQA) {
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS,"same");
- }
- }
+//_____________________________________________________________________________
+Bool_t AliReconstruction::Process(Long64_t entry)
+{
+ // run the reconstruction over a single entry
+ // from the chain with raw data
+ AliCodeTimerAuto("");
+
+ TTree *currTree = fChain->GetTree();
+ AliRawEvent *event = new AliRawEvent;
+ currTree->SetBranchAddress("rawevent",&event);
+ currTree->GetEntry(entry);
+ fRawReader = new AliRawReaderRoot(event);
+ fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
+ delete fRawReader;
+ fRawReader = NULL;
+ delete event;
+
+ return fStatus;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::Init(TTree *tree)
+{
+ if (tree == 0) {
+ AliError("The input tree is not found!");
+ return;
}
+ fChain = tree;
+}
- //Initialize the Plane Efficiency framework
- if (fRunPlaneEff && !InitPlaneEff()) {
- if(fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
+{
+ // run the reconstruction over a single event
+ // The event loop is steered in Run method
+
+ AliCodeTimerAuto("");
+
+ if (iEvent >= fRunLoader->GetNumberOfEvents()) {
+ fRunLoader->SetEventNumber(iEvent);
+ fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
+ iEvent, iEvent);
+ fRunLoader->TreeE()->Fill();
+ if (fRawReader && fRawReader->UseAutoSaveESD())
+ fRunLoader->TreeE()->AutoSave("SaveSelf");
}
- //******* The loop over events
- for (Int_t iEvent = 0; iEvent < fRunLoader->GetNumberOfEvents(); iEvent++) {
- if (fRawReader) fRawReader->NextEvent();
- if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
- // copy old ESD to the new one
- if (treeOld) {
- esd->ReadFromTree(treeOld);
- treeOld->GetEntry(iEvent);
- }
- tree->Fill();
- if (hlttreeOld) {
- esd->ReadFromTree(hlttreeOld);
- hlttreeOld->GetEntry(iEvent);
- }
- hlttree->Fill();
- continue;
+ if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
+ return kTRUE;
+ }
+
+ AliInfo(Form("processing event %d", iEvent));
+
+ // Fill Event-info object
+ GetEventInfo();
+ fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
+
+ //Start of cycle for the in-loop QA
+ if (fInLoopQA && fRunQA) {
+ fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam, fSameQACycle, fInLoopQA) ;
+ }
+ if (fInLoopQA && fRunGlobalQA) {
+ fSameQACycle = kFALSE;
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
+ qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
+ fSameQACycle = kTRUE;
}
-
- AliInfo(Form("processing event %d", iEvent));
-
- //Start of cycle for the in-loop QA
- if (fRunQA && fInLoopQA) {
- TString detStr(fFillESD);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliQADataMakerRec *qadm = GetQADataMaker(iDet);
- if (!qadm) continue;
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS, "same") ;
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- qadm->StartOfCycle(AliQA::kRECPOINTS);
- qadm->StartOfCycle(AliQA::kESDS,"same");
- }
+ 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)) continue;
+ // QA on single raw
+ if (fInLoopQA && fRunQA)
+ fQASteer->RunOneEvent(fRawReader) ;
- // local signle event reconstruction
+ // local single event reconstruction
if (!fRunLocalReconstruction.IsNull()) {
- if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ TString detectors=fRunLocalReconstruction;
+ // run HLT event reconstruction first
+ // ;-( IsSelected changes the string
+ if (IsSelected("HLT", detectors) &&
+ !RunLocalEventReconstruction("HLT")) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+ detectors=fRunLocalReconstruction;
+ detectors.ReplaceAll("HLT", "");
+ if (!RunLocalEventReconstruction(detectors)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
- esd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
- hltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
- esd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
- hltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+ fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+ fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
+ fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
+ fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
// Set magnetic field from the tracker
- esd->SetMagneticField(AliTracker::GetBz());
- hltesd->SetMagneticField(AliTracker::GetBz());
+ fesd->SetMagneticField(AliTracker::GetBz());
+ fhltesd->SetMagneticField(AliTracker::GetBz());
// Fill raw-data error log into the ESD
- if (fRawReader) FillRawDataErrorLog(iEvent,esd);
+ if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
// vertex finder
if (fRunVertexFinder) {
- if (!ReadESD(esd, "vertex")) {
- if (!RunVertexFinder(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 0) WriteESD(esd, "vertex");
+ if (!RunVertexFinder(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
- // HLT tracking
+ // Muon tracking
if (!fRunTracking.IsNull()) {
- if (fRunHLTTracking) {
- hltesd->SetPrimaryVertexSPD(esd->GetVertex());
- if (!RunHLTTracking(hltesd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
- }
- }
- }
-
- // Muon tracking
- if (!fRunTracking.IsNull()) {
- if (fRunMuonTracking) {
- if (!RunMuonTracking(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ if (fRunMuonTracking) {
+ if (!RunMuonTracking(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
}
// barrel tracking
if (!fRunTracking.IsNull()) {
- if (!ReadESD(esd, "tracking")) {
- if (!RunTracking(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 0) WriteESD(esd, "tracking");
+ if (!RunTracking(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
// fill ESD
if (!fFillESD.IsNull()) {
- if (!FillESD(esd, fFillESD)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
+ TString detectors=fFillESD;
+ // run HLT first and on hltesd
+ // ;-( IsSelected changes the string
+ if (IsSelected("HLT", detectors) &&
+ !FillESD(fhltesd, "HLT")) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
+ }
+ detectors=fFillESD;
+ // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
+ if (detectors.Contains("ALL")) {
+ detectors="";
+ for (Int_t idet=0; idet<fgkNDetectors; ++idet){
+ detectors += fgkDetectorName[idet];
+ detectors += " ";
+ }
+ }
+ detectors.ReplaceAll("HLT", "");
+ if (!FillESD(fesd, detectors)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
// fill Event header information from the RawEventHeader
- if (fRawReader){FillRawEventHeaderESD(esd);}
+ if (fRawReader){FillRawEventHeaderESD(fesd);}
// combined PID
- AliESDpid::MakePID(esd);
- if (fCheckPointLevel > 1) WriteESD(esd, "PID");
+ AliESDpid::MakePID(fesd);
if (fFillTriggerESD) {
- if (!ReadESD(esd, "trigger")) {
- if (!FillTriggerESD(esd)) {
- if (fStopOnError) {CleanUp(file, fileOld); return kFALSE;}
- }
- if (fCheckPointLevel > 1) WriteESD(esd, "trigger");
+ if (!FillTriggerESD(fesd)) {
+ if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
- file->cd();
+ ffile->cd();
//
- // Propagate track to the beam pipe (if not laready done by ITS)
+ // Propagate track to the beam pipe (if not already done by ITS)
//
- const Int_t ntracks = esd->GetNumberOfTracks();
- const Double_t kBz = esd->GetMagneticField();
+ 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;
const Double_t kMaxStep = 5; //max step over the material
Bool_t ok;
- AliESDtrack *track = esd->GetTrack(itrack);
+ AliESDtrack *track = fesd->GetTrack(itrack);
if (!track) continue;
AliExternalTrackParam *tpcTrack =
(AliExternalTrackParam *)track->GetTPCInnerParam();
- ok = AliTracker::
- PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ ok = kFALSE;
+ if (tpcTrack)
+ ok = AliTracker::
+ PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
+
if (ok) {
Int_t n=trkArray.GetEntriesFast();
selectedIdx[n]=track->GetID();
trkArray.AddLast(tpcTrack);
}
- if (track->GetX() < kRadius) continue;
+ //Tracks refitted by ITS should already be at the SPD vertex
+ if (track->IsOn(AliESDtrack::kITSrefit)) continue;
+
+ AliTracker::
+ PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
+ track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
- ok = AliTracker::
- PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
- if (ok) {
- track->RelateToVertex(esd->GetPrimaryVertexSPD(), kBz, kRadius);
- }
}
//
// Improve the reconstructed primary vertex position using the tracks
//
- TObject *obj = fOptions.FindObject("ITS");
- if (obj) {
- TString optITS = obj->GetTitle();
- if (optITS.Contains("cosmics") || optITS.Contains("COSMICS"))
- 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
- AliESDVertex *pvtx=tVertexer.FindPrimaryVertex(esd);
+ ftVertexer->SetITSMode();
+ if(fDiamondProfile && fMeanVertexConstraint) {
+ ftVertexer->SetVtxStart(fDiamondProfile);
+ } else {
+ ftVertexer->SetConstraintOff();
+ }
+ AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
if (pvtx) {
if (pvtx->GetStatus()) {
- esd->SetPrimaryVertex(pvtx);
+ fesd->SetPrimaryVertex(pvtx);
for (Int_t i=0; i<ntracks; i++) {
- AliESDtrack *t = esd->GetTrack(i);
- t->RelateToVertex(pvtx, kBz, kRadius);
+ AliESDtrack *t = fesd->GetTrack(i);
+ t->RelateToVertex(pvtx, kBz, kVeryBig);
}
}
}
// TPC-only primary vertex
- pvtx=tVertexer.FindPrimaryVertex(&trkArray,selectedIdx);
+ ftVertexer->SetTPCMode();
+ if(fDiamondProfileTPC && fMeanVertexConstraint) {
+ ftVertexer->SetVtxStart(fDiamondProfileTPC);
+ } else {
+ ftVertexer->SetConstraintOff();
+ }
+ pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
if (pvtx) {
if (pvtx->GetStatus()) {
- esd->SetPrimaryVertexTPC(pvtx);
- Int_t nsel=trkArray.GetEntriesFast();
- for (Int_t i=0; i<nsel; i++) {
- AliExternalTrackParam *t =
- (AliExternalTrackParam *)trkArray.UncheckedAt(i);
- t->PropagateToDCA(pvtx, kBz, kRadius);
+ fesd->SetPrimaryVertexTPC(pvtx);
+ for (Int_t i=0; i<ntracks; i++) {
+ AliESDtrack *t = fesd->GetTrack(i);
+ t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
}
}
}
}
delete[] selectedIdx;
- if(fDiamondProfile) esd->SetDiamond(fDiamondProfile);
+ if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
if (fRunV0Finder) {
// V0 finding
AliV0vertexer vtxer;
- vtxer.Tracks2V0vertices(esd);
+ vtxer.Tracks2V0vertices(fesd);
if (fRunCascadeFinder) {
// Cascade finding
AliCascadeVertexer cvtxer;
- cvtxer.V0sTracks2CascadeVertices(esd);
+ cvtxer.V0sTracks2CascadeVertices(fesd);
}
}
// write ESD
- if (fCleanESD) CleanESD(esd);
+ if (fCleanESD) CleanESD(fesd);
- if (fRunQA && fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- if (qadm) qadm->Exec(AliQA::kESDS, esd);
+ if (fRunGlobalQA) {
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
+ qadm->Exec(AliQA::kESDS, fesd);
}
if (fWriteESDfriend) {
- esdf->~AliESDfriend();
- new (esdf) AliESDfriend(); // Reset...
- esd->GetESDfriend(esdf);
+ fesdf->~AliESDfriend();
+ new (fesdf) AliESDfriend(); // Reset...
+ fesd->GetESDfriend(fesdf);
}
- tree->Fill();
+ ftree->Fill();
+
+ // Auto-save the ESD tree in case of prompt reco @P2
+ if (fRawReader && fRawReader->UseAutoSaveESD())
+ ftree->AutoSave("SaveSelf");
// write HLT ESD
- hlttree->Fill();
+ fhlttree->Fill();
- if (fCheckPointLevel > 0) WriteESD(esd, "final");
- esd->Reset();
- hltesd->Reset();
+ // call AliEVE
+ if (fRunAliEVE) RunAliEVE();
+
+ fesd->Reset();
+ fhltesd->Reset();
if (fWriteESDfriend) {
- esdf->~AliESDfriend();
- new (esdf) AliESDfriend(); // Reset...
+ fesdf->~AliESDfriend();
+ new (fesdf) AliESDfriend(); // Reset...
}
+ ProcInfo_t ProcInfo;
gSystem->GetProcInfo(&ProcInfo);
AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
- // End of cycle for the in-loop QA
- if (fRunQA && fInLoopQA) {
- RunQA(fFillESD.Data(), esd);
- TString detStr(fFillESD);
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (!qadm) continue;
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- if (qadm) {
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
- }
- }
- //******** End of the loop over events
+ // End of cycle for the in-loop
+ if (fInLoopQA && fRunQA) {
+ fQASteer->RunOneEvent(fesd) ;
+ fQASteer->EndOfCycle() ;
+ }
+ if (fInLoopQA && fRunGlobalQA) {
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ if (qadm) {
+ if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
+ }
+
+ fEventInfo.Reset();
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+ if (fReconstructor[iDet])
+ fReconstructor[iDet]->SetRecoParam(NULL);
+ }
+
+ return kTRUE;
+}
+//_____________________________________________________________________________
+void AliReconstruction::SlaveTerminate()
+{
+ // Finalize the run on the slave side
+ // Called after the exit
+ // from the event loop
+ AliCodeTimerAuto("");
+ if (fIsNewRunLoader) { // galice.root didn't exist
+ fRunLoader->WriteHeader("OVERWRITE");
+ fRunLoader->CdGAFile();
+ fRunLoader->Write(0, TObject::kOverwrite);
+ }
- tree->GetUserInfo()->Add(esd);
- hlttree->GetUserInfo()->Add(hltesd);
+ 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()));
}
- tree->GetUserInfo()->Add(cdbMapCopy);
- tree->GetUserInfo()->Add(cdbListCopy);
+ ftree->GetUserInfo()->Add(cdbMapCopy);
+ ftree->GetUserInfo()->Add(cdbListCopy);
if(fESDPar.Contains("ESD.par")){
AliInfo("Attaching ESD.par to Tree");
TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
- tree->GetUserInfo()->Add(fn);
+ ftree->GetUserInfo()->Add(fn);
}
- file->cd();
+ ffile->cd();
if (fWriteESDfriend)
- tree->SetBranchStatus("ESDfriend*",0);
+ ftree->SetBranchStatus("ESDfriend*",0);
// we want to have only one tree version number
- tree->Write(tree->GetName(),TObject::kOverwrite);
- hlttree->Write();
+ ftree->Write(ftree->GetName(),TObject::kOverwrite);
+ fhlttree->Write();
// Finish with Plane Efficiency evaluation: before of CleanUp !!!
if (fRunPlaneEff && !FinishPlaneEff()) {
AliWarning("Finish PlaneEff evaluation failed");
}
- gROOT->cd();
- CleanUp(file, fileOld);
-
- if (fWriteAOD) {
- TFile *esdFile = TFile::Open("AliESDs.root", "READONLY");
- TFile *aodFile = TFile::Open("AliAOD.root", "RECREATE");
- ESDFile2AODFile(esdFile, aodFile);
- aodFile->Close();
- esdFile->Close();
+ //Finish QA and end of cycle for out-of-loop QA
+ if (!fInLoopQA && fRunQA)
+ fQASteer->Run(fRunLocalReconstruction.Data(), AliQA::kNULLTASKINDEX, fSameQACycle) ;
+ if (!fInLoopQA && fRunGlobalQA) {
+ AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
+ if (qadm) {
+ if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
+ qadm->EndOfCycle(AliQA::kRECPOINTS);
+ if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
+ qadm->EndOfCycle(AliQA::kESDS);
+ qadm->Finish();
+ }
}
+ gROOT->cd();
+ CleanUp();
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::Terminate()
+{
// Create tags for the events in the ESD tree (the ESD tree is always present)
// In case of empty events the tags will contain dummy values
+ AliCodeTimerAuto("");
+
AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
- esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList);
- if (fWriteAOD) {
- AliAODTagCreator *aodtagCreator = new AliAODTagCreator();
- aodtagCreator->CreateAODTags(fFirstEvent,fLastEvent,fGRPList);
- }
+ esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
- //Finish QA and end of cycle for out-of-loop QA
- if (fRunQA && !fInLoopQA) {
- qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS);
- //qas.Reset() ;
- qas.Run(fRunTracking.Data(), AliQA::kESDS);
-
- if (fRunGlobalQA) {
- AliQADataMakerRec *qadm = GetQADataMaker(fgkNDetectors);
- if (qadm) {
- qadm->EndOfCycle(AliQA::kRECPOINTS);
- qadm->EndOfCycle(AliQA::kESDS);
- qadm->Finish();
- }
- }
- }
-
// Cleanup of CDB manager: cache and active storages!
AliCDBManager::Instance()->ClearCache();
-
-
- return kTRUE;
-}
-
-
-//_____________________________________________________________________________
-Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
-{
-// run the local reconstruction
- static Int_t eventNr=0;
- AliCodeTimerAuto("")
-
- // AliCDBManager* man = AliCDBManager::Instance();
-// Bool_t origCache = man->GetCacheFlag();
-
-// TString detStr = detectors;
-// for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
-// if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
-// AliReconstructor* reconstructor = GetReconstructor(iDet);
-// if (!reconstructor) continue;
-// if (reconstructor->HasLocalReconstruction()) continue;
-
-// AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
-// AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
-
-// AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
-// AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
-
-// man->SetCacheFlag(kTRUE);
-// TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
-// man->GetAll(calibPath); // entries are cached!
-
-// AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
-
-// if (fRawReader) {
-// fRawReader->RewindEvents();
-// reconstructor->Reconstruct(fRunLoader, fRawReader);
-// } else {
-// reconstructor->Reconstruct(fRunLoader);
-// }
-
-// AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
-
-// // unload calibration data
-// man->UnloadFromCache(calibPath);
-// //man->ClearCache();
-// }
-
-// man->SetCacheFlag(origCache);
-
-// if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
-// AliError(Form("the following detectors were not found: %s",
-// detStr.Data()));
-// if (fStopOnError) return kFALSE;
-// }
-
- eventNr++;
- return kTRUE;
}
//_____________________________________________________________________________
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
AliLoader* loader = fLoader[iDet];
+ // Matthias April 2008: temporary fix to run HLT reconstruction
+ // although the HLT loader is missing
+ if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
+ if (fRawReader) {
+ reconstructor->Reconstruct(fRawReader, NULL);
+ } else {
+ TTree* dummy=NULL;
+ reconstructor->Reconstruct(dummy, NULL);
+ }
+ continue;
+ }
if (!loader) {
AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
continue;
if (fRawReader && reconstructor->HasDigitConversion()) {
AliInfo(Form("converting raw data digits into root objects for %s",
fgkDetectorName[iDet]));
- AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
- fgkDetectorName[iDet]));
+// AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
+// fgkDetectorName[iDet]));
loader->LoadDigits("update");
loader->CleanDigits();
loader->MakeDigitsContainer();
}
// local reconstruction
AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
- AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
+ //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
loader->LoadRecPoints("update");
loader->CleanRecPoints();
loader->MakeRecPointsContainer();
}
// In-loop QA for local reconstrucion
- if (fRunQA && fInLoopQA) {
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (qadm) {
- //AliCodeTimerStart
- //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
- //AliInfo
- //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
-
- qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
-
- //AliCodeTimerStop
- //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
- }
- }
-
- loader->WriteRecPoints("OVERWRITE");
- loader->UnloadRecPoints();
- AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
- }
-
- if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
+ TString detQAStr(fQADetectors) ;
+ if (fRunQA && fInLoopQA)
+ fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
+
+ loader->WriteRecPoints("OVERWRITE");
+ loader->UnloadRecPoints();
+ AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
+ }
+ if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
AliError(Form("the following detectors were not found: %s",
detStr.Data()));
if (fStopOnError) return kFALSE;
}
if (fVertexer) {
- if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
AliInfo("running the ITS vertex finder");
- if (fLoader[0]) fLoader[0]->LoadRecPoints();
- vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
- if (fLoader[0]) fLoader[0]->UnloadRecPoints();
+ if (fLoader[0]) {
+ fLoader[0]->LoadRecPoints();
+ TTree* cltree = fLoader[0]->TreeR();
+ if (cltree) {
+ if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
+ vertex = fVertexer->FindVertexForCurrentEvent(cltree);
+ }
+ else {
+ AliError("Can't get the ITS cluster tree");
+ }
+ fLoader[0]->UnloadRecPoints();
+ }
+ else {
+ AliError("Can't get the ITS loader");
+ }
if(!vertex){
AliWarning("Vertex not found");
vertex = new AliESDVertex();
AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
return kFALSE;
}
- if (fCheckPointLevel > 1) {
- WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
- }
// preliminary PID in TPC needed by the ITS tracker
if (iDet == 1) {
GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
}
// run tracking
+ if (iDet>1) // start filling residuals for the "outer" detectors
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
+
if (fTracker[iDet]->PropagateBack(esd) != 0) {
AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
// return kFALSE;
}
- 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();
}
}
AliSysInfo::AddStamp(Form("Tracking1%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);
+ //stop filling residuals for the "outer" detectors
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
// pass 3: TRD + TPC + ITS refit inwards
- if (fRunQA && fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
-
for (Int_t iDet = 2; iDet >= 0; iDet--) {
if (!fTracker[iDet]) continue;
AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
// run tracking
+ if (iDet<2) // start filling residuals for TPC and ITS
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
+
if (fTracker[iDet]->RefitInward(esd) != 0) {
AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
// return kFALSE;
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);
fLoader[iDet]->UnloadRecPoints();
AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
}
-
- if (fRunQA && fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
+ // stop filling residuals for TPC and ITS
+ if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
eventNr++;
return kTRUE;
if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
AliReconstructor* reconstructor = GetReconstructor(iDet);
if (!reconstructor) continue;
- if (!ReadESD(esd, fgkDetectorName[iDet])) {
- AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
- TTree* clustersTree = NULL;
+ AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
+ TTree* clustersTree = NULL;
+ if (fLoader[iDet]) {
+ fLoader[iDet]->LoadRecPoints("read");
+ clustersTree = fLoader[iDet]->TreeR();
+ if (!clustersTree) {
+ AliError(Form("Can't get the %s clusters tree",
+ fgkDetectorName[iDet]));
+ if (fStopOnError) return kFALSE;
+ }
+ }
+ if (fRawReader && !reconstructor->HasDigitConversion()) {
+ reconstructor->FillESD(fRawReader, clustersTree, esd);
+ } else {
+ TTree* digitsTree = NULL;
if (fLoader[iDet]) {
- fLoader[iDet]->LoadRecPoints("read");
- clustersTree = fLoader[iDet]->TreeR();
- if (!clustersTree) {
- AliError(Form("Can't get the %s clusters tree",
+ fLoader[iDet]->LoadDigits("read");
+ digitsTree = fLoader[iDet]->TreeD();
+ if (!digitsTree) {
+ AliError(Form("Can't get the %s digits tree",
fgkDetectorName[iDet]));
if (fStopOnError) return kFALSE;
}
}
- if (fRawReader && !reconstructor->HasDigitConversion()) {
- reconstructor->FillESD(fRawReader, clustersTree, esd);
- } else {
- TTree* digitsTree = NULL;
- if (fLoader[iDet]) {
- fLoader[iDet]->LoadDigits("read");
- digitsTree = fLoader[iDet]->TreeD();
- if (!digitsTree) {
- AliError(Form("Can't get the %s digits tree",
- fgkDetectorName[iDet]));
- if (fStopOnError) return kFALSE;
- }
- }
- reconstructor->FillESD(digitsTree, clustersTree, esd);
- if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
- }
- if (fLoader[iDet]) {
- fLoader[iDet]->UnloadRecPoints();
- }
-
- if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
+ reconstructor->FillESD(digitsTree, clustersTree, esd);
+ if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
+ }
+ if (fLoader[iDet]) {
+ fLoader[iDet]->UnloadRecPoints();
}
}
AliInfo("Filling trigger information into the ESD");
- AliCentralTrigger *aCTP = NULL;
-
if (fRawReader) {
AliCTPRawStream input(fRawReader);
if (!input.Next()) {
- AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
- return kFALSE;
- }
- esd->SetTriggerMask(input.GetClassMask());
- esd->SetTriggerCluster(input.GetClusterMask());
-
- aCTP = new AliCentralTrigger();
- TString configstr("");
- if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
- AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
- return kFALSE;
- }
- }
- else {
- AliRunLoader *runloader = AliRunLoader::GetRunLoader();
- if (runloader) {
- if (!runloader->LoadTrigger()) {
- aCTP = runloader->GetTrigger();
- esd->SetTriggerMask(aCTP->GetClassMask());
- esd->SetTriggerCluster(aCTP->GetClusterMask());
- }
- else {
- AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
- return kFALSE;
- }
+ AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
}
else {
- AliError("No run loader is available! The trigger information is not stored in the ESD !");
- return kFALSE;
+ if (esd->GetTriggerMask() != input.GetClassMask())
+ AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
+ input.GetClassMask(),esd->GetTriggerMask()));
+ if (esd->GetOrbitNumber() != input.GetOrbitID())
+ AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
+ input.GetOrbitID(),esd->GetOrbitNumber()));
+ if (esd->GetBunchCrossNumber() != input.GetBCID())
+ AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
+ input.GetBCID(),esd->GetBunchCrossNumber()));
}
- }
-
- // Now fill the trigger class names into AliESDRun object
- AliTriggerConfiguration *config = aCTP->GetConfiguration();
- if (!config) {
- AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
- return kFALSE;
- }
- const TObjArray& classesArray = config->GetClasses();
- Int_t nclasses = classesArray.GetEntriesFast();
- for( Int_t j=0; j<nclasses; j++ ) {
- AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
- Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
- esd->SetTriggerClass(trclass->GetName(),trindex);
+ // Here one has to add the filling of trigger inputs and
+ // interaction records
+ // ...
}
-
return kTRUE;
}
// Filling information from RawReader Header
//
+ if (!fRawReader) return kFALSE;
+
AliInfo("Filling information from RawReader Header");
- esd->SetBunchCrossNumber(0);
- esd->SetOrbitNumber(0);
- esd->SetPeriodNumber(0);
- esd->SetTimeStamp(0);
- esd->SetEventType(0);
- const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
- if (eventHeader){
- const UInt_t *id = eventHeader->GetP("Id");
- esd->SetBunchCrossNumber((id)[1]&0x00000fff);
- esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
- esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
+ esd->SetBunchCrossNumber(fRawReader->GetBCID());
+ esd->SetOrbitNumber(fRawReader->GetOrbitID());
+ esd->SetPeriodNumber(fRawReader->GetPeriod());
- esd->SetTimeStamp((eventHeader->Get("Timestamp")));
- esd->SetEventType((eventHeader->Get("Type")));
- }
+ esd->SetTimeStamp(fRawReader->GetTimestamp());
+ esd->SetEventType(fRawReader->GetType());
return kTRUE;
}
CleanUp();
return kFALSE;
}
+
fRunLoader->CdGAFile();
- if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
- if (fRunLoader->LoadgAlice() == 0) {
- gAlice = fRunLoader->GetAliRun();
- AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
- }
- }
- if (!gAlice && !fRawReader) {
- AliError(Form("no gAlice object found in file %s",
- fGAliceFileName.Data()));
- CleanUp();
- return kFALSE;
- }
+ fRunLoader->LoadgAlice();
//PH This is a temporary fix to give access to the kinematics
//PH that is needed for the labels of ITS clusters
} else { // galice.root does not exist
if (!fRawReader) {
AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
- CleanUp();
- return kFALSE;
}
fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
AliConfig::GetDefaultEventFolderName(),
CleanUp();
return kFALSE;
}
+ fIsNewRunLoader = kTRUE;
fRunLoader->MakeTree("E");
- Int_t iEvent = 0;
- while (fRawReader->NextEvent()) {
- fRunLoader->SetEventNumber(iEvent);
- fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
- iEvent, iEvent);
- fRunLoader->MakeTree("H");
- fRunLoader->TreeE()->Fill();
- iEvent++;
- }
- fRawReader->RewindEvents();
+
if (fNumberOfEventsPerFile > 0)
fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
else
- fRunLoader->SetNumberOfEventsPerFile(iEvent);
- fRunLoader->WriteHeader("OVERWRITE");
- fRunLoader->CdGAFile();
- fRunLoader->Write(0, TObject::kOverwrite);
-// AliTracker::SetFieldMap(???);
+ fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
}
return kTRUE;
{
// get the reconstructor object and the loader for a detector
- if (fReconstructor[iDet]) return fReconstructor[iDet];
+ if (fReconstructor[iDet]) {
+ if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ fReconstructor[iDet]->SetRecoParam(par);
+ }
+ return fReconstructor[iDet];
+ }
// load the reconstructor object
TPluginManager* pluginManager = gROOT->GetPluginManager();
TString detName = fgkDetectorName[iDet];
TString recName = "Ali" + detName + "Reconstructor";
- if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
+
+ if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
AliReconstructor* reconstructor = NULL;
// first check if a plugin is defined for the reconstructor
}
}
+ if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
+ const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
+ reconstructor->SetRecoParam(par);
+ }
return reconstructor;
}
}
//_____________________________________________________________________________
-void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
+void AliReconstruction::CleanUp()
{
// delete trackers and the run loader and close and delete the file
fLoader[iDet] = NULL;
delete fTracker[iDet];
fTracker[iDet] = NULL;
-// delete fQADataMaker[iDet];
-// fQADataMaker[iDet] = NULL;
}
+ delete fRunInfo;
+ fRunInfo = NULL;
+
delete fVertexer;
fVertexer = NULL;
+
+ delete ftVertexer;
+ ftVertexer = NULL;
if(!(AliCDBManager::Instance()->GetCacheFlag())) {
- delete fDiamondProfile;
- fDiamondProfile = NULL;
+ delete fDiamondProfile;
+ fDiamondProfile = NULL;
+ delete fDiamondProfileTPC;
+ fDiamondProfileTPC = NULL;
}
-
- delete fGRPList;
- fGRPList = 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 (fileOld) {
- fileOld->Close();
- delete fileOld;
- gSystem->Unlink("AliESDs.old.root");
+ if (ffile) {
+ ffile->Close();
+ delete ffile;
+ ffile = NULL;
}
}
-//_____________________________________________________________________________
-
-Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
+void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
{
-// 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;
- }
+ // Write space-points which are then used in the alignment procedures
+ // For the moment only ITS, TPC, TRD and TOF
- gROOT->cd();
- delete esd;
- esd = (AliESDEvent*) file->Get("ESD");
- file->Close();
- delete file;
- return kTRUE;
+ 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--) {// TOF, TRD, TPC, ITS clusters
+ nsp += track->GetNcls(iDet);
-}
+ if (iDet==0) { // ITS "extra" clusters
+ track->GetClusters(iDet,idx);
+ for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
+ }
+ }
+ if (nsp) {
+ AliTrackPointArray *sp = new AliTrackPointArray(nsp);
+ track->SetTrackPointArray(sp);
+ Int_t isptrack = 0;
+ for (Int_t iDet = 3; iDet >= 0; iDet--) {
+ AliTracker *tracker = fTracker[iDet];
+ if (!tracker) continue;
+ Int_t nspdet = track->GetClusters(iDet,idx);
+ if (iDet==0) // ITS "extra" clusters
+ for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
-//_____________________________________________________________________________
-void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
-{
-// write the ESD event to a file
+ if (nspdet <= 0) continue;
+ AliTrackPoint p;
+ Int_t isp = 0;
+ Int_t isp2 = 0;
+ while (isp2 < nspdet) {
+ Bool_t isvalid=kTRUE;
- if (!esd) return;
- char fileName[256];
- sprintf(fileName, "ESD_%d.%d_%s.root",
- esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
+ Int_t index=idx[isp++];
+ if (index < 0) continue;
- 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;
+ TString dets = fgkDetectorName[iDet];
+ if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
+ fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
+ fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
+ fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
+ isvalid = tracker->GetTrackPointTrackingError(index,p,track);
+ } else {
+ isvalid = tracker->GetTrackPoint(index,p);
+ }
+ isp2++;
+ if (!isvalid) continue;
+ sp->AddPoint(isptrack,&p); isptrack++;
+ }
+ }
+ }
+ }
}
-
-
-
-
//_____________________________________________________________________________
-void AliReconstruction::ESDFile2AODFile(TFile* esdFile, TFile* aodFile)
+void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
{
- // write all files from the given esd file to an aod file
-
- // create an AliAOD object
- AliAODEvent *aod = new AliAODEvent();
- aod->CreateStdContent();
-
- // go to the file
- aodFile->cd();
-
- // create the tree
- TTree *aodTree = new TTree("aodTree", "AliAOD tree");
- aodTree->Branch(aod->GetList());
-
- // connect to ESD
- TTree *t = (TTree*) esdFile->Get("esdTree");
- AliESDEvent *esd = new AliESDEvent();
- esd->ReadFromTree(t);
-
- Int_t nEvents = t->GetEntries();
-
- // set arrays and pointers
- Float_t posF[3];
- Double_t pos[3];
- Double_t p[3];
- Double_t p_pos[3];
- Double_t p_neg[3];
- Double_t covVtx[6];
- Double_t covTr[21];
- Double_t pid[10];
-
- // loop over events and fill them
- for (Int_t iEvent = 0; iEvent < nEvents; ++iEvent) {
- //cout << "event: " << iEvent << endl;
- t->GetEntry(iEvent);
-
- // Multiplicity information needed by the header (to be revised!)
- Int_t nTracks = esd->GetNumberOfTracks();
- Int_t nPosTracks = 0;
- for (Int_t iTrack=0; iTrack<nTracks; ++iTrack)
- if (esd->GetTrack(iTrack)->Charge()> 0) nPosTracks++;
-
- // Access the header
- AliAODHeader *header = aod->GetHeader();
-
- // fill the header
- header->SetRunNumber (esd->GetRunNumber() );
- header->SetBunchCrossNumber(esd->GetBunchCrossNumber());
- header->SetOrbitNumber (esd->GetOrbitNumber() );
- header->SetPeriodNumber (esd->GetPeriodNumber() );
- header->SetTriggerMask (esd->GetTriggerMask() );
- header->SetTriggerCluster (esd->GetTriggerCluster() );
- header->SetEventType (esd->GetEventType() );
- header->SetMagneticField (esd->GetMagneticField() );
- header->SetZDCN1Energy (esd->GetZDCN1Energy() );
- header->SetZDCP1Energy (esd->GetZDCP1Energy() );
- header->SetZDCN2Energy (esd->GetZDCN2Energy() );
- header->SetZDCP2Energy (esd->GetZDCP2Energy() );
- header->SetZDCEMEnergy (esd->GetZDCEMEnergy(0),esd->GetZDCEMEnergy(1));
- header->SetRefMultiplicity (nTracks);
- header->SetRefMultiplicityPos(nPosTracks);
- header->SetRefMultiplicityNeg(nTracks - nPosTracks);
- header->SetMuonMagFieldScale(-999.); // FIXME
- header->SetCentrality(-999.); // FIXME
-
- Int_t nV0s = esd->GetNumberOfV0s();
- Int_t nCascades = esd->GetNumberOfCascades();
- Int_t nKinks = esd->GetNumberOfKinks();
- Int_t nVertices = nV0s + 2*nCascades /*could lead to two vertices, one V0 and the Xi */+ nKinks + 1 /* = prim. vtx*/;
- Int_t nJets = 0;
- Int_t nCaloClus = esd->GetNumberOfCaloClusters();
- Int_t nFmdClus = 0;
- Int_t nPmdClus = esd->GetNumberOfPmdTracks();
-
- aod->ResetStd(nTracks, nVertices, nV0s+nCascades, nJets, nCaloClus, nFmdClus, nPmdClus);
-
- // Array to take into account the tracks already added to the AOD
- Bool_t * usedTrack = NULL;
- if (nTracks>0) {
- usedTrack = new Bool_t[nTracks];
- for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) usedTrack[iTrack]=kFALSE;
- }
- // Array to take into account the V0s already added to the AOD
- Bool_t * usedV0 = NULL;
- if (nV0s>0) {
- usedV0 = new Bool_t[nV0s];
- for (Int_t iV0=0; iV0<nV0s; ++iV0) usedV0[iV0]=kFALSE;
- }
- // Array to take into account the kinks already added to the AOD
- Bool_t * usedKink = NULL;
- if (nKinks>0) {
- usedKink = new Bool_t[nKinks];
- for (Int_t iKink=0; iKink<nKinks; ++iKink) usedKink[iKink]=kFALSE;
- }
-
- // Access to the AOD container of vertices
- TClonesArray &vertices = *(aod->GetVertices());
- Int_t jVertices=0;
-
- // Access to the AOD container of tracks
- TClonesArray &tracks = *(aod->GetTracks());
- Int_t jTracks=0;
-
- // Access to the AOD container of V0s
- TClonesArray &V0s = *(aod->GetV0s());
- Int_t jV0s=0;
-
- // Add primary vertex. The primary tracks will be defined
- // after the loops on the composite objects (V0, cascades, kinks)
- const AliESDVertex *vtx = esd->GetPrimaryVertex();
-
- vtx->GetXYZ(pos); // position
- vtx->GetCovMatrix(covVtx); //covariance matrix
+ // The method reads the raw-data error log
+ // accumulated within the rawReader.
+ // It extracts the raw-data errors related to
+ // the current event and stores them into
+ // a TClonesArray inside the esd object.
- AliAODVertex * primary = new(vertices[jVertices++])
- AliAODVertex(pos, covVtx, vtx->GetChi2toNDF(), NULL, -1, AliAODVertex::kPrimary);
-
+ if (!fRawReader) return;
- AliAODTrack *aodTrack = 0x0;
-
- // Create vertices starting from the most complex objects
+ for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
- // Cascades
- for (Int_t nCascade = 0; nCascade < nCascades; ++nCascade) {
- AliESDcascade *cascade = esd->GetCascade(nCascade);
-
- cascade->GetXYZ(pos[0], pos[1], pos[2]);
- cascade->GetPosCovXi(covVtx);
-
- // Add the cascade vertex
- AliAODVertex * vcascade = new(vertices[jVertices++]) AliAODVertex(pos,
- covVtx,
- cascade->GetChi2Xi(), // = chi2/NDF since NDF = 2*2-3
- primary,
- nCascade,
- AliAODVertex::kCascade);
-
- primary->AddDaughter(vcascade); // the cascade 'particle' (represented by a vertex) is added as a daughter to the primary vertex
-
- // Add the V0 from the cascade. The ESD class have to be optimized...
- // Now we have to search for the corresponding V0 in the list of V0s
- // using the indeces of the positive and negative tracks
-
- Int_t posFromV0 = cascade->GetPindex();
- Int_t negFromV0 = cascade->GetNindex();
-
-
- AliESDv0 * v0 = 0x0;
- Int_t indV0 = -1;
-
- for (Int_t iV0=0; iV0<nV0s; ++iV0) {
-
- v0 = esd->GetV0(iV0);
- Int_t posV0 = v0->GetPindex();
- Int_t negV0 = v0->GetNindex();
-
- if (posV0==posFromV0 && negV0==negFromV0) {
- indV0 = iV0;
- break;
- }
- }
-
- AliAODVertex * vV0FromCascade = 0x0;
-
- if (indV0>-1 && !usedV0[indV0]) {
-
- // the V0 exists in the array of V0s and is not used
-
- usedV0[indV0] = kTRUE;
-
- v0->GetXYZ(pos[0], pos[1], pos[2]);
- v0->GetPosCov(covVtx);
-
- vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
- covVtx,
- v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
- vcascade,
- indV0,
- AliAODVertex::kV0);
- } else {
-
- // the V0 doesn't exist in the array of V0s or was used
- cerr << "Error: event " << iEvent << " cascade " << nCascade
- << " The V0 " << indV0
- << " doesn't exist in the array of V0s or was used!" << endl;
-
- cascade->GetXYZ(pos[0], pos[1], pos[2]);
- cascade->GetPosCov(covVtx);
-
- vV0FromCascade = new(vertices[jVertices++]) AliAODVertex(pos,
- covVtx,
- v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
- vcascade,
- indV0,
- AliAODVertex::kV0);
- vcascade->AddDaughter(vV0FromCascade);
-
- }
-
- // Add the positive tracks from the V0
-
- if (! usedTrack[posFromV0]) {
-
- usedTrack[posFromV0] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
- esdTrack->GetPxPyPz(p_pos);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0FromCascade->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_pos,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- vV0FromCascade,
- kTRUE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kSecondary)
- );
- aodTrack->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " cascade " << nCascade
- << " track " << posFromV0 << " has already been used!" << endl;
- }
-
- // Add the negative tracks from the V0
-
- if (!usedTrack[negFromV0]) {
-
- usedTrack[negFromV0] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
- esdTrack->GetPxPyPz(p_neg);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0FromCascade->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_neg,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- vV0FromCascade,
- kTRUE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kSecondary)
- );
- aodTrack->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " cascade " << nCascade
- << " track " << negFromV0 << " has already been used!" << endl;
- }
-
- // add it to the V0 array as well
- Double_t d0[2] = { -999., -99.};
- // counting is probably wrong
- new(V0s[jV0s++]) AliAODv0(vV0FromCascade, -999., -99., p_pos, p_neg, d0); // to be refined
-
- // Add the bachelor track from the cascade
-
- Int_t bachelor = cascade->GetBindex();
-
- if(!usedTrack[bachelor]) {
-
- usedTrack[bachelor] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(bachelor);
- esdTrack->GetPxPyPz(p);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vcascade->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- vcascade,
- kTRUE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kSecondary)
- );
- aodTrack->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " cascade " << nCascade
- << " track " << bachelor << " has already been used!" << endl;
- }
-
- // Add the primary track of the cascade (if any)
-
- } // end of the loop on cascades
-
- // V0s
-
- for (Int_t nV0 = 0; nV0 < nV0s; ++nV0) {
-
- if (usedV0[nV0]) continue; // skip if aready added to the AOD
-
- AliESDv0 *v0 = esd->GetV0(nV0);
-
- v0->GetXYZ(pos[0], pos[1], pos[2]);
- v0->GetPosCov(covVtx);
-
- AliAODVertex * vV0 =
- new(vertices[jVertices++]) AliAODVertex(pos,
- covVtx,
- v0->GetChi2V0(), // = chi2/NDF since NDF = 2*2-3
- primary,
- nV0,
- AliAODVertex::kV0);
- primary->AddDaughter(vV0);
-
- Int_t posFromV0 = v0->GetPindex();
- Int_t negFromV0 = v0->GetNindex();
-
- // Add the positive tracks from the V0
-
- if (!usedTrack[posFromV0]) {
-
- usedTrack[posFromV0] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(posFromV0);
- esdTrack->GetPxPyPz(p_pos);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_pos,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- vV0,
- kTRUE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kSecondary)
- );
- aodTrack->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " V0 " << nV0
- << " track " << posFromV0 << " has already been used!" << endl;
- }
-
- // Add the negative tracks from the V0
-
- if (!usedTrack[negFromV0]) {
-
- usedTrack[negFromV0] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(negFromV0);
- esdTrack->GetPxPyPz(p_neg);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- vV0->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p_neg,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- vV0,
- kTRUE, // check if this is right
- kFALSE, // check if this is right
- AliAODTrack::kSecondary)
- );
- aodTrack->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " V0 " << nV0
- << " track " << negFromV0 << " has already been used!" << endl;
- }
-
- // add it to the V0 array as well
- Double_t d0[2] = { 999., 99.};
- new(V0s[jV0s++]) AliAODv0(vV0, 999., 99., p_pos, p_neg, d0); // to be refined
- }
- V0s.Expand(jV0s);
- // end of the loop on V0s
-
- // Kinks: it is a big mess the access to the information in the kinks
- // The loop is on the tracks in order to find the mother and daugther of each kink
-
-
- for (Int_t iTrack=0; iTrack<nTracks; ++iTrack) {
-
- AliESDtrack * esdTrack = esd->GetTrack(iTrack);
-
- Int_t ikink = esdTrack->GetKinkIndex(0);
-
- if (ikink) {
- // Negative kink index: mother, positive: daughter
-
- // Search for the second track of the kink
-
- for (Int_t jTrack = iTrack+1; jTrack<nTracks; ++jTrack) {
-
- AliESDtrack * esdTrack1 = esd->GetTrack(jTrack);
-
- Int_t jkink = esdTrack1->GetKinkIndex(0);
-
- if ( TMath::Abs(ikink)==TMath::Abs(jkink) ) {
-
- // The two tracks are from the same kink
-
- if (usedKink[TMath::Abs(ikink)-1]) continue; // skip used kinks
-
- Int_t imother = -1;
- Int_t idaughter = -1;
-
- if (ikink<0 && jkink>0) {
-
- imother = iTrack;
- idaughter = jTrack;
- }
- else if (ikink>0 && jkink<0) {
-
- imother = jTrack;
- idaughter = iTrack;
- }
- else {
- cerr << "Error: Wrong combination of kink indexes: "
- << ikink << " " << jkink << endl;
- continue;
- }
-
- // Add the mother track
-
- AliAODTrack * mother = NULL;
-
- if (!usedTrack[imother]) {
-
- usedTrack[imother] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(imother);
- esdTrack->GetPxPyPz(p);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- mother =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- primary,
- kTRUE, // check if this is right
- kTRUE, // check if this is right
- AliAODTrack::kPrimary);
- primary->AddDaughter(mother);
- mother->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
- << " track " << imother << " has already been used!" << endl;
- }
-
- // Add the kink vertex
- AliESDkink * kink = esd->GetKink(TMath::Abs(ikink)-1);
-
- AliAODVertex * vkink =
- new(vertices[jVertices++]) AliAODVertex(kink->GetPosition(),
- NULL,
- 0.,
- mother,
- esdTrack->GetID(), // This is the track ID of the mother's track!
- AliAODVertex::kKink);
- // Add the daughter track
-
- AliAODTrack * daughter = NULL;
-
- if (!usedTrack[idaughter]) {
-
- usedTrack[idaughter] = kTRUE;
-
- AliESDtrack *esdTrack = esd->GetTrack(idaughter);
- esdTrack->GetPxPyPz(p);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- daughter =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- vkink,
- kTRUE, // check if this is right
- kTRUE, // check if this is right
- AliAODTrack::kPrimary);
- vkink->AddDaughter(daughter);
- daughter->ConvertAliPIDtoAODPID();
- }
- else {
- cerr << "Error: event " << iEvent << " kink " << TMath::Abs(ikink)-1
- << " track " << idaughter << " has already been used!" << endl;
- }
- }
- }
- }
- }
- vertices.Expand(jVertices);
-
- // Tracks (primary and orphan)
- for (Int_t nTrack = 0; nTrack < nTracks; ++nTrack) {
-
- if (usedTrack[nTrack]) continue;
-
- AliESDtrack *esdTrack = esd->GetTrack(nTrack);
- esdTrack->GetPxPyPz(p);
- esdTrack->GetXYZ(pos);
- esdTrack->GetCovarianceXYZPxPyPz(covTr);
- esdTrack->GetESDpid(pid);
-
- Float_t impactXY, impactZ;
-
- esdTrack->GetImpactParameters(impactXY,impactZ);
-
- if (impactXY<3.) {
- // track inside the beam pipe
-
- primary->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(esdTrack->GetID(),
- esdTrack->GetLabel(),
- p,
- kTRUE,
- pos,
- kFALSE,
- covTr,
- (Short_t)esdTrack->Charge(),
- esdTrack->GetITSClusterMap(),
- pid,
- primary,
- kTRUE, // check if this is right
- kTRUE, // check if this is right
- AliAODTrack::kPrimary)
- );
- aodTrack->ConvertAliPIDtoAODPID();
- }
- else {
- // outside the beam pipe: orphan track
- // Don't write them anymore!
- continue;
- }
- } // end of loop on tracks
-
- // muon tracks
- Int_t nMuTracks = esd->GetNumberOfMuonTracks();
- for (Int_t nMuTrack = 0; nMuTrack < nMuTracks; ++nMuTrack) {
-
- AliESDMuonTrack *esdMuTrack = esd->GetMuonTrack(nMuTrack);
- p[0] = esdMuTrack->Px();
- p[1] = esdMuTrack->Py();
- p[2] = esdMuTrack->Pz();
- pos[0] = primary->GetX();
- pos[1] = primary->GetY();
- pos[2] = primary->GetZ();
-
- // has to be changed once the muon pid is provided by the ESD
- for (Int_t i = 0; i < 10; pid[i++] = 0.); pid[AliAODTrack::kMuon]=1.;
-
- primary->AddDaughter(aodTrack =
- new(tracks[jTracks++]) AliAODTrack(0, // no ID provided
- 0, // no label provided
- p,
- kTRUE,
- pos,
- kFALSE,
- NULL, // no covariance matrix provided
- esdMuTrack->Charge(),
- 0, // ITSClusterMap is set below
- pid,
- primary,
- kFALSE, // muon tracks are not used to fit the primary vtx
- kFALSE, // not used for vertex fit
- AliAODTrack::kPrimary)
- );
-
- aodTrack->SetHitsPatternInTrigCh(esdMuTrack->GetHitsPatternInTrigCh());
- Int_t track2Trigger = esdMuTrack->GetMatchTrigger();
- aodTrack->SetMatchTrigger(track2Trigger);
- if (track2Trigger)
- aodTrack->SetChi2MatchTrigger(esdMuTrack->GetChi2MatchTrigger());
- else
- aodTrack->SetChi2MatchTrigger(0.);
- }
- tracks.Expand(jTracks); // remove 'empty slots' due to unwritten tracks
-
- // Access to the AOD container of PMD clusters
- TClonesArray &pmdClusters = *(aod->GetPmdClusters());
- Int_t jPmdClusters=0;
-
- for (Int_t iPmd = 0; iPmd < nPmdClus; ++iPmd) {
- // file pmd clusters, to be revised!
- AliESDPmdTrack *pmdTrack = esd->GetPmdTrack(iPmd);
- Int_t nLabel = 0;
- Int_t *label = 0x0;
- Double_t pos[3] = { pmdTrack->GetClusterX(), pmdTrack->GetClusterY(), pmdTrack->GetClusterZ() };
- Double_t pid[9] = { 0., 0., 0., 0., 0., 0., 0., 0., 0. }; // to be revised!
- // type not set!
- // assoc cluster not set
- new(pmdClusters[jPmdClusters++]) AliAODPmdCluster(iPmd, nLabel, label, pmdTrack->GetClusterADC(), pos, pid);
- }
-
- // Access to the AOD container of clusters
- TClonesArray &caloClusters = *(aod->GetCaloClusters());
- Int_t jClusters=0;
-
- for (Int_t iClust=0; iClust<nCaloClus; ++iClust) {
-
- AliESDCaloCluster * cluster = esd->GetCaloCluster(iClust);
-
- Int_t id = cluster->GetID();
- Int_t nLabel = 0;
- Int_t *label = 0x0;
- Float_t energy = cluster->E();
- cluster->GetPosition(posF);
- Char_t ttype=AliAODCluster::kUndef;
-
- if (cluster->GetClusterType() == AliESDCaloCluster::kPHOSCluster) {
- ttype=AliAODCluster::kPHOSNeutral;
- }
- else if (cluster->GetClusterType() == AliESDCaloCluster::kEMCALClusterv1) {
- ttype = AliAODCluster::kEMCALClusterv1;
- }
-
-
- AliAODCaloCluster *caloCluster = new(caloClusters[jClusters++]) AliAODCaloCluster(id,
- nLabel,
- label,
- energy,
- pos,
- NULL,
- ttype);
-
- caloCluster->SetCaloCluster(); // to be refined!
-
- }
- caloClusters.Expand(jClusters); // resize TObjArray to 'remove' slots for pseudo clusters
- // end of loop on calo clusters
-
- // fill EMCAL cell info
- if (esd->GetEMCALCells()) { // protection against missing ESD information
- AliESDCaloCells &esdEMcells = *(esd->GetEMCALCells());
- Int_t nEMcell = esdEMcells.GetNumberOfCells() ;
-
- AliAODCaloCells &aodEMcells = *(aod->GetEMCALCells());
- aodEMcells.CreateContainer(nEMcell);
- aodEMcells.SetType(AliAODCaloCells::kEMCAL);
- for (Int_t iCell = 0; iCell < nEMcell; iCell++) {
- aodEMcells.SetCell(iCell,esdEMcells.GetCellNumber(iCell),esdEMcells.GetAmplitude(iCell));
- }
- aodEMcells.Sort();
- }
-
- // fill PHOS cell info
- if (esd->GetPHOSCells()) { // protection against missing ESD information
- AliESDCaloCells &esdPHcells = *(esd->GetPHOSCells());
- Int_t nPHcell = esdPHcells.GetNumberOfCells() ;
-
- AliAODCaloCells &aodPHcells = *(aod->GetPHOSCells());
- aodPHcells.CreateContainer(nPHcell);
- aodPHcells.SetType(AliAODCaloCells::kPHOS);
- for (Int_t iCell = 0; iCell < nPHcell; iCell++) {
- aodPHcells.SetCell(iCell,esdPHcells.GetCellNumber(iCell),esdPHcells.GetAmplitude(iCell));
- }
- aodPHcells.Sort();
- }
-
- // tracklets
- AliAODTracklets &SPDTracklets = *(aod->GetTracklets());
- const AliMultiplicity *mult = esd->GetMultiplicity();
- if (mult) {
- if (mult->GetNumberOfTracklets()>0) {
- SPDTracklets.CreateContainer(mult->GetNumberOfTracklets());
-
- for (Int_t n=0; n<mult->GetNumberOfTracklets(); n++) {
- SPDTracklets.SetTracklet(n, mult->GetTheta(n), mult->GetPhi(n), mult->GetDeltaPhi(n), mult->GetLabel(n));
- }
- }
- } else {
- Printf("ERROR: AliMultiplicity could not be retrieved from ESD");
- }
-
- delete [] usedTrack;
- delete [] usedV0;
- delete [] usedKink;
-
- // fill the tree for this event
- aodTree->Fill();
- } // end of event loop
-
- aodTree->GetUserInfo()->Add(aod);
-
- // write the tree to the specified file
- aodFile = aodTree->GetCurrentFile();
- aodFile->cd();
- aodTree->Write();
-
- return;
-}
-
-void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
-{
- // Write space-points which are then used in the alignment procedures
- // For the moment only ITS, TRD and TPC
-
- // 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);
- if (nsp) {
- AliTrackPointArray *sp = new AliTrackPointArray(nsp);
- track->SetTrackPointArray(sp);
- Int_t isptrack = 0;
- for (Int_t iDet = 3; iDet >= 0; iDet--) {
- AliTracker *tracker = fTracker[iDet];
- if (!tracker) continue;
- Int_t nspdet = track->GetNcls(iDet);
- if (nspdet <= 0) continue;
- track->GetClusters(iDet,idx);
- AliTrackPoint p;
- Int_t isp = 0;
- Int_t isp2 = 0;
- while (isp2 < nspdet) {
- Bool_t isvalid;
- TString dets = fgkDetectorName[iDet];
- if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
- fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
- fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
- fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
- isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
- } else {
- isvalid = tracker->GetTrackPoint(idx[isp2],p);
- }
- isp2++;
- const Int_t kNTPCmax = 159;
- if (iDet==1 && isp2>kNTPCmax) break; // to be fixed
- if (!isvalid) continue;
- sp->AddPoint(isptrack,&p); isptrack++; isp++;
- }
- }
- }
- }
- if (fTracker[3]){
- fTracker[3]->UnloadClusters();
- fLoader[3]->UnloadRecPoints();
- }
-}
-
-//_____________________________________________________________________________
-void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
-{
- // The method reads the raw-data error log
- // accumulated within the rawReader.
- // It extracts the raw-data errors related to
- // the current event and stores them into
- // a TClonesArray inside the esd object.
-
- if (!fRawReader) return;
-
- for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
-
- AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
- if (!log) continue;
- if (iEvent != log->GetEventNumber()) continue;
+ AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
+ if (!log) continue;
+ if (iEvent != log->GetEventNumber()) continue;
esd->AddRawDataErrorLog(log);
}
}
-TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
+TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
// Dump a file content into a char in TNamed
ifstream in;
in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
in.read (memblock, kBytes);
in.close();
TString fData(memblock,kBytes);
- fn = new TNamed(fName,fData);
+ fn = new TNamed(pName,fData);
printf("fData Size: %d \n",fData.Sizeof());
- printf("fName Size: %d \n",fName.Sizeof());
+ printf("pName Size: %d \n",pName.Sizeof());
printf("fn Size: %d \n",fn->Sizeof());
delete[] memblock;
}
return fn;
}
-void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
+void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
// This is not really needed in AliReconstruction at the moment
// but can serve as a template
TList *fList = fTree->GetUserInfo();
- TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
+ TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
printf("fn Size: %d \n",fn->Sizeof());
- TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
+ TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
const char* cdata = fn->GetTitle();
printf("fTmp Size %d\n",fTmp.Sizeof());
int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
printf("calculated size %d\n",size);
- ofstream out(fName.Data(),ios::out | ios::binary);
+ ofstream out(pName.Data(),ios::out | ios::binary);
out.write(cdata,size);
out.close();
}
-//_____________________________________________________________________________
-AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
-{
- // get the quality assurance data maker object and the loader for a detector
-
- if (fQADataMaker[iDet])
- return fQADataMaker[iDet];
-
- AliQADataMakerRec * qadm = NULL;
- if (iDet == fgkNDetectors) { //Global QA
- qadm = new AliGlobalQADataMaker();
- fQADataMaker[iDet] = qadm;
- return qadm;
- }
-
- // load the QA data maker object
- TPluginManager* pluginManager = gROOT->GetPluginManager();
- TString detName = fgkDetectorName[iDet];
- TString qadmName = "Ali" + detName + "QADataMakerRec";
- if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT"))
- return NULL;
-
- // first check if a plugin is defined for the quality assurance data maker
- TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
- // if not, add a plugin for it
- if (!pluginHandler) {
- AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
- TString libs = gSystem->GetLibraries();
- if (libs.Contains("lib" + detName + "base.so") ||
- (gSystem->Load("lib" + detName + "base.so") >= 0)) {
- pluginManager->AddHandler("AliQADataMakerRec", detName,
- qadmName, detName + "qadm", qadmName + "()");
- } else {
- pluginManager->AddHandler("AliQADataMakerRec", detName,
- qadmName, detName, qadmName + "()");
- }
- pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
- }
- if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
- qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
- }
-
- fQADataMaker[iDet] = qadm;
-
- return qadm;
-}
-
-//_____________________________________________________________________________
-Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
-{
- // run the Quality Assurance data producer
-
- AliCodeTimerAuto("")
- TString detStr = detectors;
- for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- if (!IsSelected(fgkDetectorName[iDet], detStr))
- continue;
- AliQADataMakerRec * qadm = GetQADataMaker(iDet);
- if (!qadm)
- continue;
- AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
-
- qadm->Exec(AliQA::kESDS, esd) ;
- qadm->Increment() ;
-
- AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
- }
- if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
- AliError(Form("the following detectors were not found: %s",
- detStr.Data()));
- if (fStopOnError)
- return kFALSE;
- }
-
- return kTRUE;
-
-}
-
//_____________________________________________________________________________
void AliReconstruction::CheckQA()
{
for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
TString detName(AliQA::GetDetName(iDet)) ;
- AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX(iDet)) ;
- if ( qa->IsSet(AliQA::DETECTORINDEX(iDet), AliQA::kSIM, AliQA::kFATAL)) {
+ 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)) ||
Bool_t AliReconstruction::FinishPlaneEff() {
//
// Here execute all the necessary operationis, at the end of the tracking phase,
- // in case that evaluation of PlaneEfficiencies was required for some detector.
- // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
+ // in case that evaluation of PlaneEfficiencies was required for some detector.
+ // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
//
// This Preliminary version works only FOR ITS !!!!!
// other detectors (TOF,TRD, etc. have to develop their specific codes)
//
// Input: none
- // Return: kTRUE if all operations have been done properly, kFALSE otherwise
+ // Return: kTRUE if all operations have been done properly, kFALSE otherwise
//
Bool_t ret=kFALSE;
//for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
- for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
+ for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
//if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
- if(fTracker[iDet]) ret=fTracker[iDet]->GetPlaneEff()->WriteIntoCDB();
+ if(fTracker[iDet]) {
+ 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 hname=planeeff->GetName();
+ hname+="Histo.root";
+ ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
+ }
+ }
}
return ret;
}
AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
return kTRUE;
}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::InitAliEVE()
+{
+ // This method should be called only in case
+ // AliReconstruction is run
+ // within the alieve environment.
+ // It will initialize AliEVE in a way
+ // so that it can visualize event processed
+ // by AliReconstruction.
+ // The return flag shows whenever the
+ // AliEVE initialization was successful or not.
+
+ TString macroStr;
+ macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
+ AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
+ if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
+
+ gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
+ gROOT->ProcessLine("alieve_online_init()");
+
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::RunAliEVE()
+{
+ // Runs AliEVE visualisation of
+ // the current event.
+ // Should be executed only after
+ // successful initialization of AliEVE.
+
+ AliInfo("Running AliEVE...");
+ gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
+ gSystem->Run();
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::SetRunQA(TString detAndAction)
+{
+ // Allows to run QA for a selected set of detectors
+ // and a selected set of tasks among RAWS, RECPOINTS and ESDS
+ // all selected detectors run the same selected tasks
+
+ if (!detAndAction.Contains(":")) {
+ AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
+ fRunQA = kFALSE ;
+ return kFALSE ;
+ }
+ Int_t colon = detAndAction.Index(":") ;
+ fQADetectors = detAndAction(0, colon) ;
+ if (fQADetectors.Contains("ALL") )
+ fQADetectors = fFillESD ;
+ fQATasks = detAndAction(colon+1, detAndAction.Sizeof() ) ;
+ if (fQATasks.Contains("ALL") ) {
+ fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
+ } else {
+ fQATasks.ToUpper() ;
+ TString tempo("") ;
+ if ( fQATasks.Contains("RAW") )
+ tempo = Form("%d ", AliQA::kRAWS) ;
+ if ( fQATasks.Contains("RECPOINT") )
+ tempo += Form("%d ", AliQA::kRECPOINTS) ;
+ if ( fQATasks.Contains("ESD") )
+ tempo += Form("%d ", AliQA::kESDS) ;
+ fQATasks = tempo ;
+ if (fQATasks.IsNull()) {
+ AliInfo("No QA requested\n") ;
+ fRunQA = kFALSE ;
+ return kTRUE ;
+ }
+ }
+ TString tempo(fQATasks) ;
+ tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS)) ;
+ tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
+ tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
+ AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
+ fRunQA = kTRUE ;
+ return kTRUE;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::InitRecoParams()
+{
+ // The method accesses OCDB and retrieves all
+ // the available reco-param objects from there.
+
+ Bool_t isOK = kTRUE;
+
+ TString detStr = fLoadCDB;
+ for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
+
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+
+ if (fRecoParam.GetDetRecoParamArray(iDet)) {
+ AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
+ continue;
+ }
+
+ AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
+
+ AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
+ AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
+ if(!entry){
+ AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
+ isOK = kFALSE;
+ }
+ else {
+ TObject *recoParamObj = entry->GetObject();
+ if (dynamic_cast<TObjArray*>(recoParamObj)) {
+ // The detector has a normal TobjArray of AliDetectorRecoParam objects
+ // Registering them in AliRecoParam
+ fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
+ }
+ else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
+ // The detector has only onse set of reco parameters
+ // Registering it in AliRecoParam
+ AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
+ dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
+ fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
+ }
+ else {
+ AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
+ isOK = kFALSE;
+ }
+ entry->SetOwner(0);
+ AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
+ }
+ }
+
+ if (AliDebugLevel() > 0) fRecoParam.Print();
+
+ return isOK;
+}
+
+//_____________________________________________________________________________
+Bool_t AliReconstruction::GetEventInfo()
+{
+ // Fill the event info object
+ // ...
+ AliCodeTimerAuto("")
+
+ AliCentralTrigger *aCTP = NULL;
+ if (fRawReader) {
+ fEventInfo.SetEventType(fRawReader->GetType());
+
+ ULong64_t mask = fRawReader->GetClassMask();
+ fEventInfo.SetTriggerMask(mask);
+ UInt_t clmask = fRawReader->GetDetectorPattern()[0];
+ fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
+
+ aCTP = new AliCentralTrigger();
+ TString configstr("");
+ if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
+ AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
+ delete aCTP;
+ return kFALSE;
+ }
+ aCTP->SetClassMask(mask);
+ aCTP->SetClusterMask(clmask);
+ }
+ else {
+ fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
+
+ if (fRunLoader && (!fRunLoader->LoadTrigger())) {
+ aCTP = fRunLoader->GetTrigger();
+ fEventInfo.SetTriggerMask(aCTP->GetClassMask());
+ fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
+ }
+ else {
+ AliWarning("No trigger can be loaded! The trigger information will not be used!");
+ return kFALSE;
+ }
+ }
+
+ AliTriggerConfiguration *config = aCTP->GetConfiguration();
+ if (!config) {
+ AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
+ if (fRawReader) delete aCTP;
+ return kFALSE;
+ }
+
+ UChar_t clustmask = 0;
+ TString trclasses;
+ ULong64_t trmask = fEventInfo.GetTriggerMask();
+ const TObjArray& classesArray = config->GetClasses();
+ Int_t nclasses = classesArray.GetEntriesFast();
+ for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
+ AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
+ if (trclass) {
+ Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
+ fesd->SetTriggerClass(trclass->GetName(),trindex);
+ if (trmask & (1 << trindex)) {
+ trclasses += " ";
+ trclasses += trclass->GetName();
+ trclasses += " ";
+ clustmask |= trclass->GetCluster()->GetClusterMask();
+ }
+ }
+ }
+ fEventInfo.SetTriggerClasses(trclasses);
+
+ // Set the information in ESD
+ fesd->SetTriggerMask(trmask);
+ fesd->SetTriggerCluster(clustmask);
+
+ if (!aCTP->CheckTriggeredDetectors()) {
+ if (fRawReader) delete aCTP;
+ return kFALSE;
+ }
+
+ if (fRawReader) delete aCTP;
+
+ // We have to fill also the HLT decision here!!
+ // ...
+
+ return kTRUE;
+}
+
+const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
+{
+ // Match the detector list found in the rec.C or the default 'ALL'
+ // to the list found in the GRP (stored there by the shuttle PP which
+ // gets the information from ECS)
+ static TString resultList;
+ TString detList = detectorList;
+
+ resultList = "";
+
+ for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
+ if ((detectorMask >> iDet) & 0x1) {
+ TString det = AliDAQ::OfflineModuleName(iDet);
+ if ((detList.CompareTo("ALL") == 0) ||
+ detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ") ||
+ (detList.CompareTo(det) == 0) ||
+ detList.BeginsWith(det) ||
+ detList.EndsWith(det) ||
+ detList.Contains( " "+det+" " )) {
+ if (!resultList.EndsWith(det + " ")) {
+ resultList += det;
+ resultList += " ";
+ }
+ }
+ }
+ }
+
+ // HLT
+ if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
+ TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
+ if ((detList.CompareTo("ALL") == 0) ||
+ detList.BeginsWith("ALL ") ||
+ detList.EndsWith(" ALL") ||
+ detList.Contains(" ALL ") ||
+ (detList.CompareTo(hltDet) == 0) ||
+ detList.BeginsWith(hltDet) ||
+ detList.EndsWith(hltDet) ||
+ detList.Contains( " "+hltDet+" " )) {
+ resultList += hltDet;
+ }
+ }
+
+ return resultList.Data();
+
+}
+
+//______________________________________________________________________________
+void AliReconstruction::Abort(const char *method, EAbort what)
+{
+ // Abort processing. If what = kAbortProcess, the Process() loop will be
+ // aborted. If what = kAbortFile, the current file in a chain will be
+ // aborted and the processing will continue with the next file, if there
+ // is no next file then Process() will be aborted. Abort() can also be
+ // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
+ // the SlaveTerminate() and Terminate() are always called. The abort flag
+ // can be checked in these methods using GetAbort().
+ //
+ // The method is overwritten in AliReconstruction for better handling of
+ // reco specific errors
+
+ if (!fStopOnError) return;
+
+ CleanUp();
+
+ TString whyMess = method;
+ whyMess += " failed! Aborting...";
+
+ AliError(whyMess.Data());
+
+ fAbort = what;
+ TString mess = "Abort";
+ if (fAbort == kAbortProcess)
+ mess = "AbortProcess";
+ else if (fAbort == kAbortFile)
+ mess = "AbortFile";
+
+ Info(mess, whyMess.Data());
+}
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff