JROOT/JRandom.hh

Go to the documentation of this file.

#ifndef __JROOT__JRANDOM__
#define __JROOT__JRANDOM__
 
#include <string>
#include <istream>
#include <ostream>
#include <fstream>
#include <sstream>
 
#include <TString.h>
#include <TRandom.h>
#include <TBufferJSON.h>
 
#include "JROOT/JRootFileReader.hh"
#include "JROOT/JRootFileWriter.hh"
 
/**
 * \author mdejong
 */
 
namespace JROOT {}
namespace JPP { using namespace JROOT; }
 
namespace JROOT {
 
  /**
   * Auxiliary data structure to configure random number generator.
   *
   * The internal <tt>TString</tt> can hold any of the following data.
   *  - decimal value corresponding to seed;
   *  - name of ROOT formatted binary file; or
   *  - name of JSON formatted ASCII file.
   */
  struct JRandom :
    public TString
  {
    /**
     * Default constructor.
     */
    JRandom()
    {}
    
 
    /**
     * Constructor.
     *
     * \param  buffer       buffer
     */
    JRandom(const TString& buffer)
    {
      static_cast<TString&>(*this)  = buffer;
    }
    
 
    /**
     * Constructor.
     *
     * \param  seed         seed
     */
    JRandom(const ULong_t seed)
    {
      static_cast<TString&>(*this) += seed;
    }
 
 
    /**
     * Read random from input.
     *
     * \param  in           input stream
     * \param  object       random
     * \return              input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JRandom& object)
    {
      return in >> static_cast<TString&>(object);
    }
 
 
    /**
     * Write random to output.
     *
     * \param  out          output stream
     * \param  object       random
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JRandom& object)
    {
      return out << object.Data();
    }
 
 
    /**
     * Configure random number generator.
     *
     * \param  pr           reference pointer to random number generator
     * \return              true if successful; else false
     */
    bool set(TRandom*& pr) const
    {
      using namespace std;
      using namespace JPP;
 
      if (pr != NULL) {
 
        if (this->IsDec()) {
 
          pr->SetSeed(this->Atoll());
 
          return true;
 
        } else {
 
          return JRandom::read(static_cast<const TString&>(*this), pr);
        }
      }
 
      return false;
    }
 
 
    /**
     * Read random number generator from file.
     *
     * \param  file_name    file name
     * \param  pr           reference pointer to random number generator
     * \return              true if successful; else false
     */
    static bool read(const TString& file_name, TRandom*& pr)
    {
      using namespace std;
      using namespace JPP;
 
      if (pr != NULL) {
 
        if        (file_name.EndsWith(".root")) {
 
          JRootFileReader<TRandom> in(file_name.Data(), pr->GetName());
 
          if (in.hasNext()) {
 
            TRandom* p = in.next();
 
            pr = (TRandom*) p->Clone();
 
            return true;
          }
          
        } else if (file_name.EndsWith(".txt")) {
 
          fstream in(file_name.Data());
 
          stringstream io;
 
          if (io << in.rdbuf()) {
 
            pr = (TRandom*) TBufferJSON::ConvertFromJSON(io.str().c_str());
 
            return true;
          }
        }
      }
 
      return false;
    }
 
 
    /**
     * Write random number generator to file.
     *
     * \param  file_name    file name
     * \param  pr           pointer to random number generator
     * \return              true if successful; else false
     */
    static bool write(const TString& file_name, TRandom* pr)
    {
      using namespace std;
      using namespace JPP;
 
      if (pr != NULL) {
 
        if        (file_name.EndsWith(".root")) {
 
          JRootFileWriter<TRandom> out(file_name.Data());
 
          out.put(*gRandom);
 
          out.close();
 
          return true;
 
        } else if (file_name.EndsWith(".txt")) {
 
          ofstream out(file_name.Data());
 
          out << TBufferJSON::ConvertToJSON(gRandom).Data();
 
          out.close();
 
          return true;
        }
      }
      
      return false;
    }
  };
}
 
#endif