JMonteCarloFileSupportkit.hh

Go to the documentation of this file.

#ifndef __JSUPPORT__JMONTECARLOFILESUPPORTKIT__
#define __JSUPPORT__JMONTECARLOFILESUPPORTKIT__
 
#include "km3net-dataformat/offline/Head.hh"
#include "km3net-dataformat/offline/MultiHead.hh"
#include "km3net-dataformat/offline/Evt.hh"
 
#include "km3net-dataformat/offline/io_ascii.hh"
 
#include "JLang/JASCIIFileReader.hh"
#include "JLang/JGZFileReader.hh"
#include "JLang/JStreamObjectOutput.hh"
#include "JLang/JAbstractObjectIterator.hh"
#include "JLang/JObjectOutput.hh"
#include "JLang/JException.hh"
#include "JLang/JManip.hh"
 
#include "JAAnet/JHead.hh"
#include "JAAnet/JMultiHead.hh"
#include "JAAnet/JHeadToolkit.hh"
#include "JAAnet/JAAnetToolkit.hh"
#include "JAAnet/JEvtCategoryToolkit.hh"
 
#include "JSupport/JMonteCarloFileReader.hh"
#include "JSupport/JMonteCarloFileWriter.hh"
#include "JSupport/JMultipleFileScanner.hh"
 
 
/**
 * \author mdejong
 */
 
/**
 * Read header from input.
 *
 * \param  in            input stream
 * \param  header        header
 * \return               input stream
 */
inline std::istream& operator>>(std::istream& in, Head& header)
{
  header.clear();
 
  read(header, in);
 
  return in;
}
inline std::istream& operator>>(std::istream& in, Head& header) {…}
 
 
/**
 * \cond NEVER
 * Write header to output.
 *
 * \param  out           output stream
 * \param  header        header
 * \return               output stream
 * \endcond
 */
/*
  inline std::ostream& operator<<(std::ostream& out, const Head& header)
  {
  write(header, out);
 
  return out;
  }
*/
 
 
/**
 * Write multi-header to output.
 *
 * \param  out           output stream
 * \param  header        header
 * \return               output stream
 */
inline std::ostream& operator<<(std::ostream& out, const MultiHead& header)
{
  for (MultiHead::const_iterator i = header.begin(); i != header.end(); ++i) {
    write(*i, out);
  }
 
  return out;
}
inline std::ostream& operator<<(std::ostream& out, const MultiHead& header) {…}
 
 
/**
 * Read event from input.
 *
 * \param  in            input stream
 * \param  evt           event
 * \return               input stream
 */
inline std::istream& operator>>(std::istream& in, Evt& evt)
{
  evt = Evt();
  
  read(evt, in, false);
  
  return in;
}
inline std::istream& operator>>(std::istream& in, Evt& evt) {…}
 
 
/**
 * Write event to output.
 *
 * \param  out           output stream
 * \param  evt           event
 * \return               output stream
 */
inline std::ostream& operator<<(std::ostream& out, const Evt& evt)
{
  using namespace std;
  using namespace JPP;
  
  const ios_base::fmtflags flags = out.flags();
 
  out << setw(15) << scientific << setprecision(5);
 
  if (getLongprint(out)) {
 
    out << mc_keys::start_event_t << ' ' << evt.mc_id << ' ' << 1 << endl;
 
    for (const auto& trk : evt.mc_trks) {
 
      out << mc_keys::track_in_t     << ' '
          << trk.id                  << ' '
          << trk.type                << ' '
          << trk.mother_id           << ' '
          << trk.pos                 << ' '
          << trk.dir                 << ' '
          << trk.len                 << ' '
          << trk.E                   << ' '
          << trk.t                   << ' '
          << trk.status              << ' '
          << is_initialstate(trk)
          << is_finalstate  (trk)
          << endl;
    }
 
    for (const auto& trk : evt.trks) {
 
      out << mc_keys::track_fit_t    << ' '
          << trk.id                  << ' '
          << trk.pos                 << ' '
          << trk.dir                 << ' '
          << trk.len                 << ' '
          << trk.E                   << ' '
          << trk.t                   << ' '
          << trk.status              << endl;
    }
 
    for (const auto& hit : evt.mc_hits) { write (hit, out, mc_keys::hit_t); }
    for (const auto& hit : evt.hits)    { write (hit, out, mc_keys::hit_raw_t); }
 
    out << mc_keys::weights_t; for (const auto&  w : evt.w)      { out << ' ' << w;} out << endl;
    out << mc_keys::w2list_t;  for (const auto&  w : evt.w2list) { out << ' ' << w;} out << endl;
    out << mc_keys::w3list_t;  for (const auto&  w : evt.w3list) { out << ' ' << w;} out << endl;
 
    out << mc_keys::eventtime_t                << ' '
        << evt.mc_event_time.GetSec()          << ' '
        << evt.mc_event_time.GetNanoSec() / 16 << endl;
 
    out << mc_keys::end_event_t << endl;
 
  } else {
    
    write(evt, out << fixed);
  }
 
  out.flags(flags);
  
  return out;
}
inline std::ostream& operator<<(std::ostream& out, const Evt& evt) {…}
 
 
/**
 * Read hit from input.
 *
 * \param  in            input stream
 * \param  hit           hit
 * \return               input stream
 */
inline std::istream& operator>>(std::istream& in, Hit& hit)
{
  hit = Hit();
  
  read(hit, in, false);
  
  return in;
}
inline std::istream& operator>>(std::istream& in, Hit& hit) {…}
 
 
/**
 * Write hit to output.
 *
 * \param  out           output stream
 * \param  hit           hit
 * \return               output stream
 */
inline std::ostream& operator<<(std::ostream& out, const Hit& hit)
{
  using namespace std;
 
  const ios_base::fmtflags flags = out.flags();
    
  write(hit, out << fixed);
 
  out.flags(flags);
  
  return out;
}
inline std::ostream& operator<<(std::ostream& out, const Hit& hit) {…}
 
 
namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }
 
namespace JSUPPORT {
 
  using JAANET::JHead;
  using JAANET::JMultiHead;
  using JAANET::JEvtCategoryHelper;
  
  using JLANG::JASCIIFileReader;
  using JLANG::JGZFileReader;
  using JLANG::JStreamObjectOutput;
  using JLANG::JRewindableAbstractObjectIterator;
  using JLANG::JNullPointerException;
  using JLANG::JException;
 
 
  /**
   * Template definition of Monte Carlo object reader.
   */
  template<class T, template<class> class JFileReader_t>
  class JMonteCarloFileReader;
 
 
  /**
   * Template specialisation of JMonteCarloFileReader for Head.
   *
   * This class re-implements the methods open of the JLANG::JAccessible and method hasNext
   * of the JLANG::JObjectIterator interface so that only one Head is read per file.
   */
  template<template<class> class JFileReader_t>
  class JMonteCarloFileReader<Head, JFileReader_t> :
    public JFileReader_t<Head>
  {
  public:
    /**
     * Default constructor.
     */
    JMonteCarloFileReader() :
      JFileReader_t<Head>(),
      do_next(false)
    {}
    JMonteCarloFileReader() : {…}
 
 
    /**
     * Open file.
     *
     * \param  file_name       file name
     */
    virtual void open(const char* file_name) override 
    {
      JFileReader_t<Head>::open(file_name);
 
      do_next = true;
    }
    virtual void open(const char* file_name) override  {…}
 
 
    /**
     * Check availability of next element.
     *
     * \return            true if the iteration has more elements; else false
     */
    virtual bool hasNext() override 
    {
      if (do_next) {
 
        do_next = false;
 
        return JFileReader_t<Head>::hasNext();
 
      } else {
 
        return false;
      }
    }
    virtual bool hasNext() override  {…}
 
  private:
    bool do_next;
  };
  class JMonteCarloFileReader<Head, JFileReader_t> : {…};
 
 
  /**
   * Template specialisation of JMonteCarloFileReader for Event.
   *
   * This class re-implements the method open of the JLANG::JAccessible interface
   * so that the Head is skipped for each file.
   */
  template<template<class> class JFileReader_t>
  class JMonteCarloFileReader<Evt, JFileReader_t> :
    public JFileReader_t<Evt>
  {
  public:
    /**
     * Open file.
     *
     * \param  file_name       file name
     */
    virtual void open(const char* file_name) override 
    {
      using namespace std;
 
      JFileReader_t<Evt>::open(file_name);
 
      if (this->is_open()) {
 
        Head buffer;
 
        static_cast<istream&>(*this) >> buffer;
      }
    }
    virtual void open(const char* file_name) override  {…}
  };
  class JMonteCarloFileReader<Evt, JFileReader_t> : {…};
 
 
  /**
   * Template implementation of Monte Carlo object reader for ASCII formatted file (i.e.\ '.evt')
   */
  template<>
  class JMonteCarloASCIIFileReader<Head> :
    public JMonteCarloFileReader<Head, JASCIIFileReader>
  {};
  class JMonteCarloASCIIFileReader<Head> : {…};
 
 
  /**
   * Template implementation of Monte Carlo object reader for ASCII formatted file (i.e.\ '.evt')
   */
  template<>
  class JMonteCarloASCIIFileReader<Evt> :
    public JMonteCarloFileReader<Evt, JASCIIFileReader>
  {};
  class JMonteCarloASCIIFileReader<Evt> : {…};
 
 
  /**
   * Template implementation of Monte Carlo object reader for gzipped ASCII formatted file (i.e.\ '.gz')
   */
  template<>
  class JMonteCarloGZFileReader<Head> :
    public JMonteCarloFileReader<Head, JGZFileReader>
  {};
  class JMonteCarloGZFileReader<Head> : {…};
 
 
  /**
   * Template implementation of Monte Carlo object reader for gzipped ASCII formatted file (i.e.\ '.gz')
   */
  template<>
  class JMonteCarloGZFileReader<Evt> :
    public JMonteCarloFileReader<Evt, JGZFileReader>
  {};
  class JMonteCarloGZFileReader<Evt> : {…};
 
 
  /**
   * Template specialisation of JMonteCarloStreamObjectOutput for Head.
   *
   * This class provides for a ASCII formatted stream output without separator.
   */
  template<>
  class JMonteCarloStreamObjectOutput<Head> :
    public JStreamObjectOutput<Head>
  {
  protected:
    /**
     * Constructor.
     *
     * \param  out        output stream
     */
    JMonteCarloStreamObjectOutput(std::ostream& out) :
      JStreamObjectOutput<Head>(out, "")
    {}
    JMonteCarloStreamObjectOutput(std::ostream& out) : {…}
  };
  class JMonteCarloStreamObjectOutput<Head> : {…};
 
 
  /**
   * Template specialisation of JMonteCarloStreamObjectOutput for Evt.
   *
   * This class provides for a ASCII formatted stream output without separator.
   */
  template<>
  class JMonteCarloStreamObjectOutput<Evt> :
    public JStreamObjectOutput<Evt>
  {
  protected:
    /**
     * Constructor.
     *
     * \param  out        output stream
     */
    JMonteCarloStreamObjectOutput(std::ostream& out) :
      JStreamObjectOutput<Evt>(out, "")
    {}
    JMonteCarloStreamObjectOutput(std::ostream& out) : {…}
  };
  class JMonteCarloStreamObjectOutput<Evt> : {…};
 
 
  /**
   * Template specialisation of JMultipleFileScanner for Monte Carlo header.
   *
   * This class re-implements the methods rewind and setObject of the JLANG::JRewindableAbstractObjectIterator interface
   * so that all header objects in the complete file list are read and added.
   * It provides for the method JSUPPORT::getHeader which returns the sum of all headers.
   */
  template<>
  class JMultipleFileScanner<Head> :
    public virtual JMultipleFileScanner<>,
    public JRewindableAbstractObjectIterator<Head>
  {
  public:
    /**
     * Default constructor.
     */
    JMultipleFileScanner() :
      JMultipleFileScanner<>(),
      JRewindableAbstractObjectIterator<Head>(),
      do_next(true)
    {}
    JMultipleFileScanner() : {…}
 
 
    /**
     * Copy constructor.
     * The file list is copied.
     *
     * \param  file_list  JMultipleFileScanner
     */
    JMultipleFileScanner(const JMultipleFileScanner_t& file_list) :
      JMultipleFileScanner<>(),
      JRewindableAbstractObjectIterator<Head>(),
      do_next(true)
    {
      static_cast<JMultipleFileScanner_t&>(*this) = file_list;
    }
    JMultipleFileScanner(const JMultipleFileScanner_t& file_list) : {…}
 
 
    /**
     * Rewind.
     */
    virtual void rewind() override 
    {
      do_next = true;
    }
    virtual void rewind() override  {…}
 
 
    /**
     * Set object.
     *
     * \param  object     reference to object to be set
     * \return            true if set; else false
     */
    virtual bool setObject(Head& object) override 
    {
      if (do_next) {
 
        using namespace JLANG;
 
        JHead header;
 
        do_next = false;
 
        unsigned int count = 0;
 
        JFileScanner<Head> scanner;
 
        for (const_iterator i = this->begin(); i != this->end(); ++i) {
          
          scanner.open(i->c_str());
 
          if (scanner.hasNext()) {
 
            const JHead buffer = *scanner.next();
 
            if      (count == 0)
              header  =  buffer;
            else if (header.match(buffer))
              header.add(buffer);
            else
              THROW(JException, "JMultipleFileScanner<Head>::setObject(): inconsistent headers.");
 
            ++count;
          }
          
          scanner.close();
        }
 
        copy(header, object);
 
        if (count != 0 && count != this->size()) {
          if (!merge) {
            THROW(JException, "JMultipleFileScanner<Head>::setObject(): missing header(s): " << count << " != " << this->size());
          }
        }
 
        return count != 0;
 
      } else {
 
        return false;
      }
    }
    virtual bool setObject(Head& object) override  {…}
 
 
    /**
     * Get Monte Carlo Header.
     *
     * \return            header
     */
    const Head& getHeader()
    {
      const Head* p = NULL;
 
      if (!this->hasNext() || (p = this->next()) == NULL) {
        THROW(JNullPointerException, "JMultipleFileScanner<Head>::getHeader(): Missing Header.");
      }
 
      rewind();
 
      return *p;
    }
    const Head& getHeader() {…}
 
    static bool merge;    //!< Allow merging of files w/o header.
 
  private:
    bool do_next;
  };
  class JMultipleFileScanner<Head> : {…};
 
 
  /**
   * Initialisation of merge option.
   */
  bool JMultipleFileScanner<Head>::merge = false;
 
 
  /**
   * Get Monte Carlo header.
   *
   * \param  file_list  file list
   * \return            Monte Carlo header
   */
  inline Head getHeader(const JMultipleFileScanner_t& file_list)
  {
    return JMultipleFileScanner<Head>(file_list).getHeader();
  }
  inline Head getHeader(const JMultipleFileScanner_t& file_list) {…}
 
 
  /**
   * Get common Monte Carlo header.
   *
   * \param  file_list  file list
   * \return            Monte Carlo header
   */
  inline Head getCommonHeader(const JMultipleFileScanner_t& file_list)
  {
    Head head;
    
    if (!file_list.empty()) {
 
      JHead buffer = getHeader(file_list[0]);
 
      buffer.createUUID();
      
      for (size_t i = 1; i != file_list.size(); ++i) {
        buffer = buffer.getMatch(getHeader(file_list[i]));
      }
 
      copy(buffer, head);
    }
 
    return head;
  }
  inline Head getCommonHeader(const JMultipleFileScanner_t& file_list) {…}
 
 
  /**
   * Get multi-header corresponding to a given file list.
   *
   * \param  file_list  file list
   * \return            Monte Carlo multi header
   */
  inline JMultiHead getMultiHeader(const JMultipleFileScanner_t& file_list)
  {
    using namespace JPP;
 
    JMultiHead multiHeader;
      
    for (JMultipleFileScanner<MultiHead> in(file_list); in.hasNext(); ) {
 
      const MultiHead* p = in.next();
 
      for (MultiHead::const_iterator i = p->cbegin(); i != p->cend(); ++i) {
 
        JHead header = *i;
 
        multiHeader.insert(header);
      }
    }
      
    multiHeader.merge();
 
    return multiHeader;
  }
  inline JMultiHead getMultiHeader(const JMultipleFileScanner_t& file_list) {…}
  
 
 
  /**
   * Get list of files compatible with geven header.
   *
   * Note that the option corresponds to that of method JHead::match.
   *
   * \param  input         file list
   * \param  test          test function
   * \return               file list
   */
  template<class JFunction_t>
  JMultipleFileScanner_t getAAnetFiles(const JMultipleFileScanner_t& input, JFunction_t test)
  {
    using namespace JPP;
    
    JMultipleFileScanner_t result;
 
    for (JMultipleFileScanner_t::const_iterator i = input.begin(); i != input.end(); ++i) {
      if (test(getHeader(*i))) {
        result.push_back(*i);
      }
    }
 
    return result;
  }
  JMultipleFileScanner_t getAAnetFiles(const JMultipleFileScanner_t& input, JFunction_t test) {…}
 
 
  /**
   * Get the unique event categories corresponding to a given list of MC files.
   *
   * \param  file_list         list of MC files
   * \return                   unique event categories
   */
  inline JAANET::JEvtCategorySet getCategories(const JMultipleFileScanner_t& file_list)
  {
    using namespace std;
    using namespace JPP;
 
    JEvtCategorySet categories;
    
    for (JMultipleFileScanner_t::const_iterator i = file_list.cbegin(); i != file_list.cend(); ++i) {
      const JHead& header = getHeader(*i);
 
      JEvtCategorySet cats = getCategories(header);
 
      categories.insert(cats.begin(), cats.end());
    }
 
    return categories;
  }
  inline JAANET::JEvtCategorySet getCategories(const JMultipleFileScanner_t& file_list) {…}
}
 
#endif