File.h

Go to the documentation of this file.

 
#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/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_;  
 
  ClassDef(erhic::LogReaderPythia, 1)
};
 
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_;  
 
  ClassDef(erhic::LogReaderPepsi, 1)
};
 
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_;  
 
  ClassDef(erhic::LogReaderDjangoh, 1)
};
 
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 = 0;
 
  virtual LogReader* CreateLogReader() const = 0;
 
  virtual VirtualEventFactory* CreateEventFactory(std::istream&) const = 0;
 
  ClassDef(erhic::FileType, 1)
};
 
/*
 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 std::string GetGeneratorName() 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, 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::istream&) const;
 
 protected:
  FileFactory();
 
  virtual ~FileFactory();
 
  typedef std::map<std::string, FileType*> Map;
  Map prototypes_;
};
 
}  // namespace erhic
 
#endif  // INCLUDE_EICSMEAR_ERHIC_FILE_H_