#ifndef ALIRECONSTRUCTION_H
#define ALIRECONSTRUCTION_H
#include <TSelector.h>
#include <TString.h>
#include <TObjArray.h>
class AliReconstructor;
class AliRunLoader;
class AliRawReader;
class AliLoader;
class AliTracker;
class AliMagF;
class AliVertexer;
class AliTrackleter;
class AliESDVertex;
class AliESDEvent;
class AliESDfriend;
class AliESDpid;
class AliVertexerTracks;
class TFile;
class TTree;
class TList;
class AliQAManager;
class TMap;
class AliRecoParam;
class AliDetectorRecoParam;
class AliRunInfo;
class AliGRPObject;
class THashTable;
class AliTriggerRunScalers;
class AliCTPTimeParams;
class AliAnalysisManager;
class AliRecoInputHandler;
#include "AliQAv1.h"
#include "AliEventInfo.h"
#include "AliRecoParam.h"
using std::ofstream;
class AliReconstruction: public TSelector {
public:
AliReconstruction(const char* gAliceFilename = "galice.root");
virtual ~AliReconstruction();
void SetGAliceFile(const char* fileName);
void SetInput(const char* input);
void SetOutput(const char* output);
void SetEquipmentIdMap(const char *mapFile) {fEquipIdMap = mapFile;};
void SetEventRange(Int_t firstEvent = 0, Int_t lastEvent = -1)
{fFirstEvent = firstEvent; fLastEvent = lastEvent;};
void SetNumberOfEventsPerFile(UInt_t nEvents)
{fNumberOfEventsPerFile = nEvents;};
void SetFractionFriends(Double32_t frac = 0.04)
{fFractionFriends = frac;};
void SetOption(const char* detector, const char* option);
void SetRecoParam(const char* detector, AliDetectorRecoParam *par);
void SetRunLocalReconstruction(const char* detectors) {
fRunLocalReconstruction = detectors;};
void SetRunTracking(const char* detectors) {
fRunTracking = detectors;};
void SetFillESD(const char* detectors) {fFillESD = detectors;};
void SetRunReconstruction(const char* detectors) {
SetRunLocalReconstruction(detectors);
SetRunTracking(detectors);
SetFillESD(detectors);};
void SetDeleteRecPoints(const char* dets) {fDeleteRecPoints = dets;}
void SetDeleteDigits(const char* dets) {fDeleteDigits = dets;}
void SetUseTrackingErrorsForAlignment(const char* detectors)
{fUseTrackingErrorsForAlignment = detectors;};
void SetLoadAlignFromCDB(Bool_t load) {fLoadAlignFromCDB = load;};
void SetLoadAlignData(const char* detectors)
{fLoadAlignData = detectors;};
void SetTreeBuffSize(Long64_t sz=30000000) {fTreeBuffSize = sz;}
void SetRunMultFinder(Bool_t flag=kTRUE) {fRunMultFinder=flag;};
void SetRunVertexFinder(Bool_t flag=kTRUE) {fRunVertexFinder=flag;};
void SetRunVertexFinderTracks(Bool_t flag=kTRUE) {fRunVertexFinderTracks=flag;};
void SetRunV0Finder(Bool_t flag=kTRUE) {fRunV0Finder=flag;};
void SetRunCascadeFinder(Bool_t flag=kTRUE) {fRunCascadeFinder=flag;};
void SetStopOnError(Bool_t flag=kTRUE) {fStopOnError=flag;}
void SetStopOnMissingTriggerFile(Bool_t flag=kTRUE) {fStopOnMissingTriggerFile=flag;}
void SetWriteAlignmentData(Bool_t flag=kTRUE){fWriteAlignmentData=flag;}
void SetWriteESDfriend(Bool_t flag=kTRUE){fWriteESDfriend=flag;}
void SetFillTriggerESD(Bool_t flag=kTRUE){fFillTriggerESD=flag;}
void SetDiamondProfileSPD(AliESDVertex *dp) {fDiamondProfileSPD=dp;}
void SetDiamondProfile(AliESDVertex *dp) {fDiamondProfile=dp;}
void SetDiamondProfileTPC(AliESDVertex *dp) {fDiamondProfileTPC=dp;}
void SetCleanESD(Bool_t flag=kTRUE){fCleanESD=flag;}
void SetUseHLTData(const char* detectors){fUseHLTData=detectors;}
void SetV0DCAmax(Float_t d) {fV0DCAmax=d;}
void SetV0CsPmin(Float_t d) {fV0CsPmin=d;}
void SetDmax(Float_t d) {fDmax=d;}
void SetZmax(Float_t z) {fZmax=z;}
Float_t GetV0DCAmax() const {return fV0DCAmax;}
Float_t GetV0CsPmin() const {return fV0CsPmin;}
Float_t GetDmax() const {return fDmax;}
Float_t GetZmax() const {return fZmax;}
Bool_t HasNextEventAfter(Int_t eventId);
Bool_t IsRunMultFinder() const {return fRunMultFinder;}
void SetDefaultStorage(const char* uri);
void SetSpecificStorage(const char* calibType, const char* uri);
void SetCDBSnapshotMode(const char* snapshotFileName);
void AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment="");
void RemCheckRecoCDBvsSimuCDB(const char* cdbpath);
void ResetCheckRecoCDBvsSimuCDB() {fCheckRecoCDBvsSimuCDB.Delete();}
void RectifyCDBurl(TString& url);
const TObjArray* GetCheckRecoCDBvsSimuCDB() const {return &fCheckRecoCDBvsSimuCDB;}
void CheckRecoCDBvsSimuCDB();
Bool_t MisalignGeometry(const TString& detectors);
void SetAlignObjArray(TObjArray *array)
{fAlignObjArray = array;
fLoadAlignFromCDB = kFALSE;}
virtual Int_t Version() const {return 2;}
virtual void Begin(TTree*);
virtual void SlaveBegin(TTree*);
virtual void Init(TTree *tree);
virtual Bool_t Process(Long64_t entry);
virtual Bool_t ProcessEvent(Int_t iEvent);
virtual void SlaveTerminate();
virtual void Terminate();
virtual Bool_t Run(const char* input = NULL);
void Abort(const char *method, EAbort what);
virtual void SetOption(const char* option) {
TSelector::SetOption(option);
}
AliTracker* GetTracker(Int_t idx) const { return fTracker[idx]; }
Bool_t CreateTrackers(const TString& detectors);
void ImportRunLoader(AliRunLoader* rl) { fRunLoader = rl; }
void SetQACycles(AliQAv1::DETECTORINDEX_t det, Int_t cycles) { fQACycles[det] = cycles ; }
void SetQAWriteExpert(AliQAv1::DETECTORINDEX_t det) { fQAWriteExpert[det] = kTRUE ; }
Bool_t SetRunQA(TString detAndAction="ALL:ALL") ;
void SetRunGlobalQA(Bool_t flag=kTRUE){fRunGlobalQA = flag;}
void SetQARefDefaultStorage(const char* uri);
void InitQA();
void MergeQA(const char *fileName = NULL);
void SetWriteQAExpert() { fWriteQAExpertData = kTRUE ; }
Bool_t IsRunQA() const { return fRunQA ; }
Bool_t IsRunGlobalQA() const { return fRunGlobalQA ; }
Bool_t IsInTasks(AliQAv1::TASKINDEX_t tsk) { return fQATasks.Contains(Form("%d", tsk)) ; }
void SetRunPlaneEff(Bool_t flag=kFALSE) {fRunPlaneEff = flag;}
enum {
kNDetectors = 18
};
static Int_t GetDetIndex(const char * detector);
static const char** GetDetectorNames() { return fgkDetectorName; }
void SetUpgradeModule(const char* detectors) {fUpgradeModule = detectors; MatchUpgradeDetector() ; }
void MatchUpgradeDetector();
void SetAnalysisMacro(const char *macropath) {fAnalysisMacro = macropath;}
const char *GetAnalysisMacro() const {return fAnalysisMacro.Data();}
void SetAnalysisManager(AliAnalysisManager *mgr) {fAnalysis = mgr;}
AliAnalysisManager *GetAnalysisManager() const {return fAnalysis;}
void DeclareTriggerClasses(const char *trClasses) {fDeclTriggerClasses = trClasses;}
void CleanProcessedEvent();
AliESDEvent* GetESDEvent() const { return fesd; }
AliESDfriend* GetESDfriend() const { return fesdf; }
AliRunLoader* GetRunLoader() const { return fRunLoader;}
AliRawReader* GetRawReader() const { return fRawReader; }
Bool_t HasEnoughResources(int ev);
void SetStopOnResourcesExcess(int vRSS=3000,int vVMEM=4000);
virtual Bool_t ProcessEvent(void* event);
void InitRun(const char* input);
protected:
Bool_t IsHighPt() const;
Bool_t IsCosmicOrCalibSpecie() const;
void WriteESDfriend();
private:
AliReconstruction(const AliReconstruction& rec);
AliReconstruction& operator = (const AliReconstruction& rec);
void InitRawReader(const char* input);
void InitCDB();
Bool_t InitGRP();
void SetCDBLock();
Bool_t SetRunNumberFromData();
Bool_t LoadCDB();
Bool_t LoadTriggerScalersCDB();
Bool_t LoadCTPTimeParamsCDB();
Bool_t ReadIntensityInfoCDB();
Bool_t RunLocalEventReconstruction(const TString& detectors);
Bool_t RunVertexFinder(AliESDEvent*& esd);
Bool_t RunMuonTracking(AliESDEvent*& esd);
Bool_t RunMFTTrackingMU(AliESDEvent*& esd);
Bool_t RunSPDTrackleting(AliESDEvent*& esd);
Bool_t RunMultFinder(AliESDEvent*& esd);
Bool_t RunTracking(AliESDEvent*& esd, AliESDpid &PID);
Bool_t CleanESD(AliESDEvent *esd);
Bool_t FillESD(AliESDEvent*& esd, const TString& detectors);
Bool_t FillTriggerESD(AliESDEvent*& esd);
Bool_t FillTriggerScalers(AliESDEvent*& esd);
Bool_t FillRawEventHeaderESD(AliESDEvent*& esd);
void DeleteRecPoints(const TString& detectors);
void DeleteDigits(const TString& detectors);
Bool_t IsSelected(TString detName, TString& detectors) const;
Bool_t InitRunLoader();
AliReconstructor* GetReconstructor(Int_t iDet);
AliVertexer* CreateVertexer();
AliTrackleter* CreateMultFinder();
void CleanUp();
Bool_t ParseOutput();
void WriteAlignmentData(AliESDEvent* esd);
void FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd);
Bool_t FinishPlaneEff();
Bool_t InitPlaneEff();
Bool_t InitAliEVE();
void RunAliEVE();
Bool_t InitRecoParams();
Bool_t GetEventInfo();
const char *MatchDetectorList(const char *detectorList, UInt_t detectorMask);
Bool_t fRunVertexFinder;
Bool_t fRunVertexFinderTracks;
Bool_t fRunMuonTracking;
Bool_t fRunMFTTrackingMU;
Bool_t fRunV0Finder;
Bool_t fRunCascadeFinder;
Bool_t fRunMultFinder;
Bool_t fStopOnError;
Bool_t fStopOnMissingTriggerFile;
Bool_t fWriteAlignmentData;
Bool_t fWriteESDfriend;
Bool_t fFillTriggerESD;
Bool_t fCleanESD;
Float_t fV0DCAmax;
Float_t fV0CsPmin;
Float_t fDmax;
Float_t fZmax;
TString fRunLocalReconstruction;
TString fRunTracking;
TString fFillESD;
TString fDeleteRecPoints;
TString fDeleteDigits;
TString fLoadCDB;
TString fUseTrackingErrorsForAlignment;
TString fGAliceFileName;
TString fRawInput;
TString fESDOutput;
TString fProofOutputFileName;
TString fProofOutputLocation;
Bool_t fProofOutputDataset;
TString fProofOutputArchive;
TString fEquipIdMap;
Int_t fFirstEvent;
Int_t fLastEvent;
UInt_t fNumberOfEventsPerFile;
Double32_t fFractionFriends;
TObjArray fOptions;
Bool_t fLoadAlignFromCDB;
TString fLoadAlignData;
TString fUseHLTData;
AliRunInfo* fRunInfo;
AliEventInfo fEventInfo;
AliTriggerRunScalers* fRunScalers;
AliCTPTimeParams* fCTPTimeParams;
AliCTPTimeParams* fCTPTimeAlign;
AliRunLoader* fRunLoader;
AliRawReader* fRawReader;
AliRawReader* fParentRawReader;
static const char* fgkDetectorName[kNDetectors];
AliReconstructor* fReconstructor[kNDetectors];
AliRecoParam fRecoParam;
AliLoader* fLoader[kNDetectors];
AliTracker* fTracker[kNDetectors];
AliTracker* fSPDTrackleter;
AliESDVertex* fDiamondProfileSPD;
AliESDVertex* fDiamondProfile;
AliESDVertex* fDiamondProfileTPC;
THashTable* fListOfCosmicTriggers;
AliGRPObject* fGRPData;
TObjArray* fAlignObjArray;
TString fCDBUri;
TString fQARefUri;
TObjArray fSpecCDBUri;
TObjArray fCheckRecoCDBvsSimuCDB;
Bool_t fInitCDBCalled;
Bool_t fCDBSnapshotMode;
Bool_t fSetRunNumberFromDataCalled;
Int_t fQACycles[ AliQAv1::kNDET];
Bool_t fQAWriteExpert[AliQAv1::kNDET];
TString fQADetectors ;
TString fQATasks ;
Bool_t fRunQA ;
Bool_t fRunGlobalQA;
Bool_t fSameQACycle;
Bool_t fInitQACalled;
Bool_t fWriteQAExpertData ;
Bool_t fRunPlaneEff ;
AliESDpid* fESDpid;
AliESDEvent* fesd;
AliESDEvent* fhltesd;
AliESDfriend* fesdf;
TFile* ffile;
TFile* ffileF;
TTree* ftree;
TTree* ftreeF;
TTree* fhlttree;
AliVertexerTracks* ftVertexer;
Bool_t fIsNewRunLoader;
Bool_t fRunAliEVE;
Double_t fBeamInt[2][2];
TTree* fChain;
Int_t fNall;
Int_t fNspecie;
Int_t fSspecie;
Int_t fNhighPt;
Int_t fShighPt;
Long64_t fTreeBuffSize;
Long64_t fMemCountESD;
Long64_t fMemCountESDF;
Long64_t fMemCountESDHLT;
TString fUpgradeModule;
Bool_t fUpgradeMask[kNDetectors];
TString fAnalysisMacro;
AliAnalysisManager *fAnalysis;
AliRecoInputHandler *fRecoHandler;
TString fDeclTriggerClasses;
Bool_t fStopped;
Int_t fMaxRSS;
Int_t fMaxVMEM;
static const char* fgkStopEvFName;
ClassDef(AliReconstruction, 49)
};
#endif