EIC code displayed by LXR master/​include/​eicsmear/​erhic/​File.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-21 09:07:43

 /**
  \file
  Declarations of file information and log-reading classes.
 
  \author    Thomas Burton
  \date      2011-07-29
  \copyright 2011 Brookhaven National Lab
  */
 
 #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 {
 
 /**
  Base class for log file processors.
 
  Reads a log file from a Monte Carlo generator and extracts information.
  Inherited classes for each generator type implement the Extract()
  method to gather the required information for that generator and the
  Save() method to store it to file.
  */
 class LogReader : public TObject {
  public:
   /**
    Constructor.
    */
   LogReader() { }
 
   /**
    Destructor.
    */
   virtual ~LogReader() { }
 
   /**
    Return a new LogReader instance.
    */
   virtual LogReader* Create() const = 0;
 
   /**
    Extract data from the named log file.
    */
   virtual bool Extract(const std::string& file) = 0;
 
   /**
    Saves the extracted data to the current file, if one is open and is
    writeable.
    Returns -1 if the data cannot be saved.
    To write the LogReader itself, use LogReader::Write().
    */
   virtual Int_t Save() const = 0;
 
   ClassDef(erhic::LogReader, 1)
 };
 
 /**
  Processes PYTHIA log files.
 
  Reads a log file and finds the total cross section and the number
  of generated events when Extract() is called.
  Writes those values as TObjStrings to the current directory when
  Save() is called, assuming that directory is writeable.
  */
 class LogReaderPythia : public LogReader {
  public:
   /**
    Constructor.
    */
   LogReaderPythia();
 
   /**
    Destructor.
    */
   virtual ~LogReaderPythia();
 
   /**
    Return a new LogReaderPythia instance.
    */
   LogReaderPythia* Create() const;
 
   /**
    Extract data from the named log file.
    */
   bool Extract(const std::string& file);
 
   /**
    Write the extracted information to the current file, if it is
    writeable. If you want to write the LogReaderPythia itself, use
    LogReaderPythia::Write().
    */
   Int_t Save() const;
 
  protected:
   TObjString crossSection_;  ///> Total cross section in microbarns
   TObjString nEvents_;  ///> Total number of events generated and kept
   TObjString nTrials_;  ///> Total number of events generated
 
   ClassDef(erhic::LogReaderPythia, 2)
 };
 
 inline LogReaderPythia* LogReaderPythia::Create() const {
   return new LogReaderPythia;
 }
 
 /**
  Processes PEPSI log files.
 
  Reads a log file and finds the total cross section and the number
  of generated events when Extract() is called.
  Writes those values as TObjStrings to the current directory when
  Save() is called, assuming that directory is writeable.
  */
 class LogReaderPepsi : public LogReader {
  public:
   /**
    Constructor.
    */
   LogReaderPepsi();
 
   /**
    Destructor.
    */
   virtual ~LogReaderPepsi();
 
   /**
    Return a new LogReaderPepsi instance.
    */
   LogReaderPepsi* Create() const;
 
   /**
    Extract data from the named log file.
    */
   bool Extract(const std::string& file);
 
   /**
    Write the extracted information to the current file, if it is
    writeable. If you want to write the LogReaderPepsi itself, use
    LogReaderPepsi::Write().
    */
   Int_t Save() const;
 
  protected:
   TObjString crossSection_;  ///> Total cross section in microbarns
   TObjString nEvents_;  ///> Total number of events generated and kept
   TObjString nTrials_;  ///> Total number of events generated
 
   ClassDef(erhic::LogReaderPepsi, 2)
 };
 
 inline LogReaderPepsi* LogReaderPepsi::Create() const {
   return new LogReaderPepsi;
 }
 
 /**
  Processes DJANGOH log files.
 
  Reads a log file and finds the total cross section and the number
  of generated events when Extract() is called.
  Writes those values as TObjStrings to the current directory when
  Save() is called, assuming that directory is writeable.
  */
 class LogReaderDjangoh : public LogReader {
  public:
   /**
    Constructor.
    */
   LogReaderDjangoh();
 
   /**
    Destructor.
    */
   virtual ~LogReaderDjangoh();
 
   /**
    Return a new LogReaderDjangoh instance.
    */
   LogReaderDjangoh* Create() const;
 
   /**
    Extract data from the named log file.
    */
   bool Extract(const std::string& file);
 
   /**
    Write the extracted information to the current file, if it is
    writeable. If you want to write the LogReaderDjangoh itself, use
    LogReaderDjangoh::Write().
    */
   Int_t Save() const;
 
  protected:
   TObjString crossSection_;  ///> Total cross section in microbarns
   TObjString nEvents_;  ///> Total number of events generated and kept
   TObjString nTrials_;  ///> Total number of events generated
 
   ClassDef(erhic::LogReaderDjangoh, 2)
 };
 
 inline LogReaderDjangoh* LogReaderDjangoh::Create() const {
   return new LogReaderDjangoh;
 }
 
 /**
  Processes PYTHIA log files.
 
  Reads a log file and finds the total cross section and the number
  of generated events when Extract() is called.
  Writes those values as TObjStrings to the current directory when
  Save() is called, assuming that directory is writeable.
  */
 class LogReaderMilou : public LogReader {
  public:
   /**
    Constructor.
    */
   LogReaderMilou() { }
 
   /**
    Destructor.
    */
   virtual ~LogReaderMilou() { }
 
   /**
    Return a new LogReaderMilou instance.
    */
   LogReaderMilou* Create() const;
 
   /**
    Extract data from the named log file.
    */
   bool Extract(const std::string& file);
 
   /**
    Write the extracted information to the current file, if it is
    writeable. If you want to write the LogReaderMilou itself, use
    LogReaderMilou::Write().
    */
   Int_t Save() const;
 
   /**
    Returns the number of events reported by the log file.
    Extract() should be called first.
    */
   Int_t GetNEvents() const;
 
   /**
    Returns the total cross section reported by the log file.
    Extract() should be called first.
    */
   Double_t GetCrossSection() const;
 
   /**
    Returns the error on total cross section reported by the log file.
    Extract() should be called first.
    */
   Double_t GetCrossSectionError() const;
 
  protected:
   TObjString crossSection_;  ///> Total cross section in nb
   TObjString crossSectionError_;  ///> Cross section error in nb
   TObjString nEvents_;  ///> Total number of events generated
 
   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();
 }
 
 /**
  Returns the error on total cross section reported by the log file.
  Extract() should be called first.
  */
 inline Double_t LogReaderMilou::GetCrossSectionError() const {
   return crossSectionError_.GetString().Atof();
 }
 
 /**
  Processes gmc_trans log files.
 
  Reads a log file and finds the total cross section and the number
  of generated events.
  */
 class LogReaderGmcTrans : public LogReader {
  public:
   /**
    Constructor.
    */
   LogReaderGmcTrans();
 
   /**
    Destructor.
    */
   virtual ~LogReaderGmcTrans();
 
   /**
    Return a new LogReaderGmcTrans instance.
    */
   LogReaderGmcTrans* Create() const;
 
   /**
    Search the named file.
    Store the total cross section and number of generated events
    if they can be found.
    */
   bool Extract(const std::string& filename);
 
   /**
    Write the stored cross section and number of events to
    the active ROOT directory.
    Returns the total number of bytes written, or a value <= 0
    in the case of an error.
    */
   Int_t Save() const;
 
   /**
    Returns the number of events reported by the log file.
    Extract() should be called first.
    */
   Int_t GetNEvents() const;
 
   /**
    Returns the total cross section reported by the log file.
    Extract() should be called first.
    */
   Double_t GetCrossSection() const;
 
  protected:
   TObjString mNEvents;  ///< Number of generated events.
   TObjString mCrossSection;  ///< Total cross section in microbarns.
 
   ClassDef(erhic::LogReaderGmcTrans, 1)
 };
 
 /**
  Factory class for LogReaders.
 
  Singleton class.
  Creates a LogReader instance corresponding to a Monte Carlo
  generator type.
  */
 class LogReaderFactory {
  public:
   /**
    Returns the single instance of LogReaderFactory.
    */
   static LogReaderFactory& GetInstance();
 
   /**
    Returns a LogReader instance of the type for reading log files
    from the Monte Carlo generator event type 'event'.
    Returns NULL in the case of an unsupported generator.
    The LogReader must be deleted by the user.
    */
   LogReader* CreateReader(const EventBase& event) const;
 
   /**
    Returns a LogReader instance of the type for reading log files
    from the Monte Carlo generator named 'name'.
    Returns NULL in the case of an unsupported generator.
    The LogReader must be deleted by the user.
    */
   LogReader* CreateReader(const std::string& name) const;
 
   /**
    Returns a LogReader instance of the type for reading log files
    from the Monte Carlo generator which produced the content in an
    istream, by reading the first line of that stream.
    Returns NULL in the case of an unsupported generator.
    The LogReader must be deleted by the user.
    */
   LogReader* CreateReader(std::istream&) const;
 
   /**
    Attempts to locate a log file corresponding to the named Monte
    Carlo file.
    Searches for a file with the same base name and extension '.log'.
    Looks in
    the current directory and, if mcFile gives a path containing
    'TXTFILES', in the corresonding directory substituting 'LOGFILES'.
    */
   std::string Locate(const std::string& mcFile) const;
 
  protected:
   /**
    Constructor.
    */
   LogReaderFactory();
 
   /**
    Destructor.
    */
   ~LogReaderFactory();
 
   typedef std::map<std::string, LogReader*> Map;
   Map prototypes_;
 
   ClassDef(erhic::LogReaderFactory, 1)
 };
 
 /**
  Abstract base class for Monte Carlo file types.
  Describes a Monte Carlo file type and returns objects required for
  processing or analysis of that file type.
  */
 class FileType : public TObject {
  public:
   /**
    Destructor.
    */
   virtual ~FileType() { }
 
   /**
    Returns a new FileType instance.
    */
   virtual FileType* Create() const = 0;
 
   /**
    Returns a new event object for the generator making this type of file.
    */
   virtual EventBase* AllocateEvent() const = 0;
 
   /**
    Returns the name of the generator.
       Should be entirely in lower case.
    */
   virtual std::string GetGeneratorName() const;
 
   /**
    Sets the name of the generator.
    Should be entirely in lower case.
    */
   virtual void SetGeneratorName(const std::string newname="");
   
   /**
    Returns a reader to process the log file corresponding to this type of file.
    */
   virtual LogReader* CreateLogReader() const = 0;
 
   /**
    Returns a new event object for the generator making this type of file.
    */
   virtual VirtualEventFactory* CreateEventFactory(std::istream&) const = 0;
 
   std::map<std::string, std::string> mAdditionalInformation;
 
  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:
   /**
    Constructor.
 
    If the string argument is not empty, the File attempts to open
    a file with that name. If the file is opened it tries to extract
    */
   File();
 
   /**
    Destructor.
    */
   virtual ~File();
 
   /**
    Returns a new File object.
    */
   virtual File<T>* Create() const;
 
   /**
    Allocates an event of the type for this file.
    */
   virtual T* AllocateEvent() const;
   
   /**
    Create a LogReader for this type of Monte Carlo file.
    Returns NULL if the file type is unsupported or has no LogReader
    class implemented.
    The LogReader must be deleted by the user.
    */
   virtual LogReader* CreateLogReader() const;
 
   /**
    Returns a new event factory instance.
    */
   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:
 
   /**
    Constructor.
 
    If the string argument is not empty, the File attempts to open
    a file with that name. If the file is opened it tries to extract
    */
   File(){}
 
   /**
    Destructor.
    */
   virtual ~File(){}
 
   /**
    Returns a new File object.
    */
   virtual File<erhic::EventHepMC>* Create() const {
     return new File<erhic::EventHepMC>();
   }
   
   /**
      Allocates an event of the type for this file.
    */
   virtual erhic::EventHepMC* AllocateEvent() const {
     return new erhic::EventHepMC();
   }
 
   /**
    Create a LogReader for this type of Monte Carlo file.
    Returns NULL if the file type is unsupported or has no LogReader
    class implemented.
    The LogReader must be deleted by the user.
    */
   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>();
 }
 
 
 /**
  Factory class for Files.
  Singleton class.
  */
 class FileFactory {
  public:
   /**
    Returns the single instance of FileFactory.
    */
   static FileFactory& GetInstance();
 
   /**
    Returns a FileType object for the named generator.
    */
   const FileType* GetFile(const std::string& generatorName) const;
 
   /**
    Returns a FileType object, determining the generator type from a stream.
    The isp may need to be updated for hepmc, that's why it's passed by reference.
    */
   const FileType* GetFile(std::shared_ptr<std::istream>& isp, const std::string fileName="") const;
 
  protected:
   /**
    Constructor.
    */
   FileFactory();
 
   /**
    Destructor.
    */
   virtual ~FileFactory();
 
   typedef std::map<std::string, FileType*> Map;
   Map prototypes_;
 };
 
 }  // namespace erhic
 
 #endif  // INCLUDE_EICSMEAR_ERHIC_FILE_H_

This page was automatically generated by the 2.3.7 LXR engine. The LXR team