File.h

Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file File.h

#ifndef INCLUDE_EICSMEAR_ERHIC_FILE_H_
#define INCLUDE_EICSMEAR_ERHIC_FILE_H_

#include <iostream>
#include <map>
#include <string>

#include <TObject.h>
#include <TObjString.h>
#include <TString.h>

#include "eicsmear/erhic/EventBase.h"
#include "eicsmear/erhic/EventHepMC.h"
#include "eicsmear/erhic/EventMilou.h"
#include "eicsmear/erhic/EventPythia.h"
#include "eicsmear/erhic/EventFactory.h"

namespace erhic {

class LogReader : public TObject {
 public:
  LogReader() { }

  virtual ~LogReader() { }

  virtual LogReader* Create() const = 0;

  virtual bool Extract(const std::string& file) = 0;

  virtual Int_t Save() const = 0;

  ClassDef(erhic::LogReader, 1)
};

class LogReaderPythia : public LogReader {
 public:
  LogReaderPythia();

  virtual ~LogReaderPythia();

  LogReaderPythia* Create() const;

  bool Extract(const std::string& file);

  Int_t Save() const;

 protected:
  TObjString crossSection_;  
  TObjString nEvents_;  
  TObjString nTrials_;  

  ClassDef(erhic::LogReaderPythia, 2)
};

inline LogReaderPythia* LogReaderPythia::Create() const {
  return new LogReaderPythia;
}

class LogReaderPepsi : public LogReader {
 public:
  LogReaderPepsi();

  virtual ~LogReaderPepsi();

  LogReaderPepsi* Create() const;

  bool Extract(const std::string& file);

  Int_t Save() const;

 protected:
  TObjString crossSection_;  
  TObjString nEvents_;  
  TObjString nTrials_;  

  ClassDef(erhic::LogReaderPepsi, 2)
};

inline LogReaderPepsi* LogReaderPepsi::Create() const {
  return new LogReaderPepsi;
}

class LogReaderDjangoh : public LogReader {
 public:
  LogReaderDjangoh();

  virtual ~LogReaderDjangoh();

  LogReaderDjangoh* Create() const;

  bool Extract(const std::string& file);

  Int_t Save() const;

 protected:
  TObjString crossSection_;  
  TObjString nEvents_;  
  TObjString nTrials_;  

  ClassDef(erhic::LogReaderDjangoh, 2)
};

inline LogReaderDjangoh* LogReaderDjangoh::Create() const {
  return new LogReaderDjangoh;
}

class LogReaderMilou : public LogReader {
 public:
  LogReaderMilou() { }

  virtual ~LogReaderMilou() { }

  LogReaderMilou* Create() const;

  bool Extract(const std::string& file);

  Int_t Save() const;

  Int_t GetNEvents() const;

  Double_t GetCrossSection() const;

  Double_t GetCrossSectionError() const;

 protected:
  TObjString crossSection_;  
  TObjString crossSectionError_;  
  TObjString nEvents_;  

  ClassDef(erhic::LogReaderMilou, 1)
};

inline LogReaderMilou* LogReaderMilou::Create() const {
  return new LogReaderMilou;
}

inline Int_t LogReaderMilou::GetNEvents() const {
  return nEvents_.GetString().Atoi();
}

inline Double_t LogReaderMilou::GetCrossSection() const {
  return crossSection_.GetString().Atof();
}

inline Double_t LogReaderMilou::GetCrossSectionError() const {
  return crossSectionError_.GetString().Atof();
}

class LogReaderGmcTrans : public LogReader {
 public:
  LogReaderGmcTrans();

  virtual ~LogReaderGmcTrans();

  LogReaderGmcTrans* Create() const;

  bool Extract(const std::string& filename);

  Int_t Save() const;

  Int_t GetNEvents() const;

  Double_t GetCrossSection() const;

 protected:
  TObjString mNEvents;  
  TObjString mCrossSection;  

  ClassDef(erhic::LogReaderGmcTrans, 1)
};

class LogReaderFactory {
 public:
  static LogReaderFactory& GetInstance();

  LogReader* CreateReader(const EventBase& event) const;

  LogReader* CreateReader(const std::string& name) const;

  LogReader* CreateReader(std::istream&) const;

  std::string Locate(const std::string& mcFile) const;

 protected:
  LogReaderFactory();

  ~LogReaderFactory();

  typedef std::map<std::string, LogReader*> Map;
  Map prototypes_;

  ClassDef(erhic::LogReaderFactory, 1)
};

class FileType : public TObject {
 public:
  virtual ~FileType() { }

  virtual FileType* Create() const = 0;

  virtual EventBase* AllocateEvent() const = 0;

  virtual std::string GetGeneratorName() const;

  virtual void SetGeneratorName(const std::string newname="");
  
  virtual LogReader* CreateLogReader() const = 0;

  virtual VirtualEventFactory* CreateEventFactory(std::istream&) const = 0;

 protected:
    std::string generatorname;
  
  ClassDef(erhic::FileType, 2)
};

/*
 Templated file descriptor class, valid for Monte Carlo event classes.
 e.g. File<EventPythia> describes a Pythia event file.
 */
template<typename T>
class File : public FileType {
 public:
  File();

  virtual ~File();

  virtual File<T>* Create() const;

  virtual T* AllocateEvent() const;
  
  virtual LogReader* CreateLogReader() const;

  virtual EventFromAsciiFactory<T>*
    CreateEventFactory(std::istream& is) const {
     return new EventFromAsciiFactory<T>(is);
  }

 protected:
  T* t_;

  // Warning: explicitly putting the erhic:: namespace before the class
  // name doesn't seen to work for template classes.
  ClassDef(File, 2)
};

template<>
class File<erhic::EventHepMC> : public FileType {
 public:

  File(){}

  virtual ~File(){}

  virtual File<erhic::EventHepMC>* Create() const {
    return new File<erhic::EventHepMC>();
  }
  
  virtual erhic::EventHepMC* AllocateEvent() const {
    return new erhic::EventHepMC();
  }

  virtual LogReader* CreateLogReader() const {return nullptr;}

  EventFromAsciiFactory<erhic::EventHepMC>* CreateEventFactory(std::istream& is) const {
    return new EventFromAsciiFactory<erhic::EventHepMC>(is);}
 protected:
  erhic::EventHepMC* t_;

  ClassDef(File<erhic::EventHepMC>, 1)
};

template<typename T>
inline T* File<T>::AllocateEvent() const {
  return new T;
}

template<typename T>
inline File<T>* File<T>::Create() const {
  return new File<T>();
}


class FileFactory {
 public:
  static FileFactory& GetInstance();

  const FileType* GetFile(const std::string& generatorName) const;

  const FileType* GetFile(std::shared_ptr<std::istream>& isp, const std::string fileName="") const;

 protected:
  FileFactory();

  virtual ~FileFactory();

  typedef std::map<std::string, FileType*> Map;
  Map prototypes_;
};

}  // namespace erhic

#endif  // INCLUDE_EICSMEAR_ERHIC_FILE_H_