Forester.h

Go to the documentation of this file.

#ifndef INCLUDE_EICSMEAR_ERHIC_FORESTER_H_
#define INCLUDE_EICSMEAR_ERHIC_FORESTER_H_

// C(++) headers
#include <cmath>
#include <ctime>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <string>

// ROOT headers
#include <Rtypes.h>
#include <TFile.h>
#include <TStopwatch.h>
#include <TTree.h>

// Other headers
#include "eicsmear/erhic/EventMC.h"

namespace erhic {

class FileType;
class VirtualEventFactory;

class Forester : public TObject {
 public:
  Forester();

  virtual ~Forester();

  Long64_t Plant();

  void SetInputFileName(const std::string&);

  void SetOutputFileName(const std::string&);

  void SetTreeName(const std::string& = "EICTree");

  void SetBranchName(const std::string& = "event");

  std::string GetInputFileName() const;

  std::string GetOutputFileName() const;

  std::string GetTreeName() const;

  std::string GetBranchName() const;

  void SetMaxNEvents(Long64_t = 0);

  Long64_t GetMaxNEvents() const;

  void SetMessageInterval(Long64_t = 10000);

  void Print(std::ostream& stream) const;

  void Print(Option_t* = "not used") const;

  void SetBeVerbose(bool = false);

  bool BeVerbose() const;

  const erhic::FileType* GetFileType() const;

 protected:
  class Status {
   public:
    Status()
    : mNEvents(0)
    , mNParticles(0) {
      // Initialise the start and end time to the creation time and reset
      // the timer to ensure it is at zero.
      std::time(&mStartTime);
      mEndTime = mStartTime;
      mTimer.Reset();
    }

    virtual ~Status() { }

    virtual std::ostream& Print(std::ostream& os = std::cout) const {
      // Put start and end times in different os <<... otherwise I get
      // the same time for each...
      os << "Began on " << std::ctime(&mStartTime);
      os << "Ended on " << std::ctime(&mEndTime);
      os << "Processed " << mNEvents << " events containing "
      << mNParticles << " particles in "
      << mTimer.RealTime() << " seconds "
      << '(' << mTimer.RealTime()/mNEvents <<" sec/event)" << std::endl;
      return os;
    }

  protected:
    virtual void StartTimer() {
      std::time(&mStartTime);
      mTimer.Start();
    }

    virtual void StopTimer() {
      std::time(&mEndTime);
      mTimer.Stop();
    }

    virtual void ModifyEventCount(Long64_t count) {
      mNEvents += count;
    }

    virtual void ModifyParticleCount(Long64_t count) {
      mNParticles += count;
    }

    time_t mStartTime;
    time_t mEndTime;
    Long64_t mNEvents;
    Long64_t mNParticles;

    // The TStopwatch is mutable as "GetRealTime()" is non-const.
    mutable TStopwatch mTimer;

    friend class Forester;

    ClassDef(Status, 1)
  };

  // End of class Status

  const Status& GetGetStatus() const {
    return mStatus;
  }

  bool OpenInput();

  bool SetupOutput();

  void Finish();

  bool AllocateEvent();

  bool FindFirstEvent();

  void PrintStatus() const;

  bool MustQuit() const;

  void SetMustQuit(bool quit);

  // Member variables.
  // Those with comment //!< will be treated as transient members by ROOT
  // and won't be written to a file.

  Bool_t mQuit;  
  Bool_t mVerbose;  
  TTree* mTree;  
  VirtualEvent* mEvent;  
  const erhic::FileType* mFile;  
  TFile* mRootFile;  
  Long64_t mMaxNEvents;  
  Long64_t mInterval;  
  std::ifstream* mTextFile;  
  std::string mInputName;  
  std::string mOutputName;  
  std::string mTreeName;  
  std::string mBranchName;  
  std::string mLine;  
  Status mStatus;  
  VirtualEventFactory* mFactory;  

  ClassDef(Forester, 1)
};

inline void Forester::SetInputFileName(const std::string& name) {
  mInputName = name;
}

inline void Forester::SetOutputFileName(const std::string& name) {
  mOutputName = name;
}

inline void Forester::SetTreeName(const std::string& name) {
  mTreeName = name;
}

inline void Forester::SetBranchName(const std::string& name) {
  mBranchName = name;
}

inline std::string Forester::GetInputFileName() const {
  return mInputName;
}

inline std::string Forester::GetOutputFileName() const {
  return mOutputName;
}

inline std::string Forester::GetTreeName() const {
  return mTreeName;
}

inline std::string Forester::GetBranchName() const {
  return mBranchName;
}

inline void Forester::SetMaxNEvents(Long64_t number) {
  mMaxNEvents = number;
}

inline Long64_t Forester::GetMaxNEvents() const {
  return mMaxNEvents;
}

inline void Forester::SetMessageInterval(Long64_t number) {
  mInterval = number;
}

inline bool Forester::MustQuit() const {
  return mQuit;
}

inline void Forester::SetMustQuit(bool flag) {
  mQuit = flag;
}

inline void Forester::SetBeVerbose(bool flag) {
  mVerbose = flag;
}

inline bool Forester::BeVerbose() const {
  return mVerbose;
}

inline const FileType* Forester::GetFileType() const {
  return mFile;
}

}  // namespace erhic

#endif  // INCLUDE_EICSMEAR_ERHIC_FORESTER_H_