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 "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;
}


/**
 * \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;
}


/**
 * 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;
}


/**
 * 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) {

      const int motherType = (trk.mother_id >= 0 && trk.mother_id < (int) evt.mc_trks.size() ?
                              evt.mc_trks[trk.mother_id].type : 0);

      out << mc_keys::track_in_t     << ' '
          << trk.id                  << ' '
          << trk.type                << ' '
          << trk.mother_id           << ' '
          << motherType              << ' '
          << 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;
}


/**
 * 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;
}


/**
 * 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;
}


namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }

namespace JSUPPORT {

  using JAANET::JHead;
  using JAANET::JMultiHead;
  
  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)
    {}


    /**
     * Open file.
     *
     * \param  file_name       file name
     */
    virtual void open(const char* file_name) override 
    {
      JFileReader_t<Head>::open(file_name);

      do_next = true;
    }


    /**
     * 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;
      }
    }

  private:
    bool do_next;
  };


  /**
   * 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;
      }
    }
  };


  /**
   * Template implementation of Monte Carlo object reader for ASCII formatted file (i.e.\ '.evt')
   */
  template<>
  class JMonteCarloASCIIFileReader<Head> :
    public JMonteCarloFileReader<Head, JASCIIFileReader>
  {};


  /**
   * Template implementation of Monte Carlo object reader for ASCII formatted file (i.e.\ '.evt')
   */
  template<>
  class JMonteCarloASCIIFileReader<Evt> :
    public JMonteCarloFileReader<Evt, JASCIIFileReader>
  {};


  /**
   * Template implementation of Monte Carlo object reader for gzipped ASCII formatted file (i.e.\ '.gz')
   */
  template<>
  class JMonteCarloGZFileReader<Head> :
    public JMonteCarloFileReader<Head, JGZFileReader>
  {};


  /**
   * Template implementation of Monte Carlo object reader for gzipped ASCII formatted file (i.e.\ '.gz')
   */
  template<>
  class JMonteCarloGZFileReader<Evt> :
    public JMonteCarloFileReader<Evt, JGZFileReader>
  {};


  /**
   * 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, "")
    {}
  };


  /**
   * 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, "")
    {}
  };


  /**
   * 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)
    {}


    /**
     * 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;
    }


    /**
     * Rewind.
     */
    virtual void rewind() override 
    {
      do_next = true;
    }


    /**
     * 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;
      }
    }


    /**
     * 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;
    }

    static bool merge;    //!< Allow merging of files w/o header.

  private:
    bool do_next;
  };


  /**
   * 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();
  }


  /**
   * 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;
  }


  /**
   * 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;
  }
  


  /**
   * 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;
  }
}

#endif