AliMUONTrackerDataMaker.h

Go to the documentation of this file.

#ifndef ALIMUONTRACKERDATAMAKER_H
#define ALIMUONTRACKERDATAMAKER_H

/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
* See cxx source for full Copyright notice                               */

// $Id$

// Author Laurent Aphecetche, Subatech

#ifndef ALIMUONVTRACKERDATAMAKER_H
#  include "AliMUONVTrackerDataMaker.h"
#endif
#ifndef ROOT_TString
#  include "TString.h"
#endif

class AliMUONRecoParam;
class AliMUONCalibrationData;
class AliMUONDigitCalibrator;
class AliMUONVStore;
class AliMUONVTrackerData;
class AliRawReader;
class AliMUONLogger;

class AliMUONTrackerDataMaker : public AliMUONVTrackerDataMaker
{
public:
  AliMUONTrackerDataMaker(TRootIOCtor*);
  
  AliMUONTrackerDataMaker(const AliMUONRecoParam* recoParam,
                          Int_t runNumber,
                          AliRawReader* rawReader,
                          const char* cdbPath,
                          const char* calibMode,
                          Bool_t histogram=kFALSE,
                          Double_t xmin=0.0,
                          Double_t xmax=4095.0);
  
  AliMUONTrackerDataMaker(const AliMUONRecoParam* recoParam,
                          AliRawReader* rawReader,
                          const char* cdbPath,
                          const char* calibMode,
                          Bool_t histogram=kFALSE,
                          Double_t xmin=0.0,
                          Double_t xmax=4095.0);
  
  AliMUONTrackerDataMaker(AliRawReader* rawReader, Bool_t histogram=kFALSE);
  
  virtual ~AliMUONTrackerDataMaker();
  
  Bool_t Add(const AliMUONTrackerDataMaker& other);

  Bool_t IsValid() const { return fRawReader != 0x0; }
  
  AliMUONVTrackerData* Data() const { return fAccumulatedData; }
  
  void SetOwnerOfData(Bool_t flag) { fIsOwnerOfAccumulatedData = flag; }

  Bool_t IsEventByEvent() const { return fIsEventByEvent; }
  
  void SetEventByEvent(Bool_t flag) { fIsEventByEvent = flag; }
  
  Bool_t IsRunnable() const { return IsValid(); }
  
  Bool_t IsRunning() const { return fIsRunning; }
  
  void SetRunning(Bool_t flag) { fIsRunning = flag; }
  
  Bool_t ProcessEvent();
  
  Bool_t NextEvent();
  
  void Print(Option_t* opt="") const;
  
  void Rewind();
  
  TString Source() const { return fSource.Data(); }
  
  void SetSource(const char* source) { fSource = source; }
  
  Int_t NumberOfEvents() const { return fNumberOfEvents; }

  Int_t NumberOfPhysicsEvents() const { return fNumberOfPhysicsEvents; }

  Int_t NumberOfGoodPhysicsEvents() const { return fNumberOfGoodPhysicsEvents; }

  Long64_t Merge(TCollection* li);
  
  void SetRawReader(AliRawReader* rawReader);
  
  void EnableErrorLogger(AliMUONLogger* logger) { fLogger = logger; }
  
  Bool_t LastEventWasEmpty() const { return fLastEventWasEmpty; }
  
  void SetTryRecover(Bool_t flag) { fTryRecover = flag; }
  
  void SetEventRange(Int_t first, Int_t last) { fFirstEvent=first; fLastEvent=last; }

private:
  AliMUONTrackerDataMaker(const AliMUONTrackerDataMaker& rhs);
  AliMUONTrackerDataMaker& operator=(const AliMUONTrackerDataMaker& rhs);

  void Ctor(const AliMUONRecoParam* param,
            Int_t runNumber,
            const char* calibMode,
            Bool_t histogram,
            Double_t xmin=0.0, 
            Double_t xmax=4095.0);
  
private:
  AliRawReader* fRawReader; 
  AliMUONVTrackerData* fAccumulatedData; 
  Bool_t fIsOwnerOfAccumulatedData; 
  AliMUONVStore* fOneEventData; 
  AliMUONDigitCalibrator* fDigitCalibrator; 
  AliMUONCalibrationData* fCalibrationData; 
  TString fSource; 
  TString fOCDBPath; 
  Int_t fNumberOfEvents; 
  Int_t fRunNumber; 
  Bool_t fIsRunning; 
  Bool_t fIsOwnerOfRawReader; 
  Bool_t fIsEventByEvent; 
  static Int_t fgkCounter; 
  AliMUONLogger* fLogger; 
  Bool_t fLastEventWasEmpty; 
  Int_t fNumberOfPhysicsEvents; 
  Int_t fNumberOfGoodPhysicsEvents; 
  Bool_t fTryRecover; 
  Int_t fFirstEvent; 
  Int_t fLastEvent; 

  ClassDef(AliMUONTrackerDataMaker,5) // Producer of AliMUONVTrackerData from raw
};

#endif