JDAQTimeslice.hh

Go to the documentation of this file.

#ifndef __JDAQTIMESLICE__
#define __JDAQTIMESLICE__

#include <ostream>
#include <iomanip>
#include <vector>
#include <map>

#include "JDAQ/JDAQRoot.hh"
#include "JDAQ/JDAQPreamble.hh"
#include "JDAQ/JDAQTimesliceHeader.hh"
#include "JDAQ/JDAQSuperFrame.hh"
#include "JDAQ/JDAQException.hh"
#include "JDAQ/JDAQPrint.hh"
#include "JIO/JSerialisable.hh"
#include "JIO/JSTDIO.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  using JIO::JReader;
  using JIO::JWriter;


  class JDAQEvent;
  class JDAQSummaryslice;
  

  /**
   * Data time slice.
   */
  class JDAQTimeslice :
    public JDAQPreamble,
    public JDAQTimesliceHeader,
    public std::vector<JDAQSuperFrame>
  {
  public:
    /**
     * Default constructor.
     */
    JDAQTimeslice() :
      JDAQPreamble(JDAQType<JDAQTimeslice>()),
      JDAQTimesliceHeader(),
      std::vector<JDAQSuperFrame>()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     */
    JDAQTimeslice(const JDAQChronometer& chronometer) :
      JDAQPreamble(JDAQType<JDAQTimeslice>()),
      JDAQTimesliceHeader(chronometer),
      std::vector<JDAQSuperFrame>()
    {}
    

    /**
     * Constructor.
     *
     * \param  event          DAQ event
     * \param  snapshot       use shapshot hits (else use triggered hits)
     */
    JDAQTimeslice(const JDAQEvent& event,
                  const bool       snapshot = true);


    /**
     * Constructor.
     *
     * \param  event          DAQ event
     * \param  summary        summary
     * \param  snapshot       use shapshot hits (else use triggered hits)
     */
    JDAQTimeslice(const JDAQEvent&        event,
                  const JDAQSummaryslice& summary,
                  const bool              snapshot = true);

    
    /**
     * Virtual destructor.
     */
    virtual ~JDAQTimeslice()
    {
      clear();
    }


    /**
     * Clear data.
     */
    void clear()
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->clear();
      }

      std::vector<JDAQSuperFrame>::clear();
    }


    /**
     * Assignment operator.
     *
     * \param  timeslice      timeslice
     * \return                this timeslice
     */
    JDAQTimeslice& operator=(const JDAQTimeslice& timeslice)
    {
      clear();

      setDAQChronometer(timeslice.getDAQChronometer());

      for (const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {
        push_back(*i);
      }

      return *this;
    }


    /**
     * Add another timeslice.
     *
     * \param  timeslice      timeslice
     * \return                this timeslice
     */
    JDAQTimeslice& add(const JDAQTimeslice& timeslice) 
    {
      using namespace std;

      map<JDAQModuleIdentifier, int> buffer;

      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        buffer[i->getModuleIdentifier()] = distance(static_cast<const JDAQTimeslice&>(*this).begin(),i);
      }

      for (JDAQTimeslice::const_iterator i = timeslice.begin(); i != timeslice.end(); ++i) {

        map<JDAQModuleIdentifier, int>::const_iterator p = buffer.find(i->getModuleIdentifier());
        
        if (p != buffer.end()) {

          JDAQSuperFrame& frame = this->at(p->second);

          frame.add(*i);

          sort(frame.begin(), frame.end());

        } else {

          this->push_back(*i);
        }
      }
      
      return *this;
    }


    /**
     * Read DAQ timeslice from input.
     *
     * \param  in             JReader
     * \param  timeslice      JDAQTimeslice
     * \return                JReader
     */
    friend inline JReader& operator>>(JReader& in, JDAQTimeslice& timeslice)
    {
      timeslice.clear();

      in >> static_cast<JDAQPreamble&>               (timeslice);
      in >> static_cast<JDAQTimesliceHeader&>        (timeslice);
      in >> static_cast<std::vector<JDAQSuperFrame>&>(timeslice);

      return in;
    }


    /**
     * Write DAQ timeslice to output.
     *
     * \param  out           JWriter
     * \param  timeslice     JDAQTimeslice
     * \return               JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JDAQTimeslice& timeslice)
    {
      out << static_cast<const JDAQPreamble&>               (timeslice);
      out << static_cast<const JDAQTimesliceHeader&>        (timeslice);
      out << static_cast<const std::vector<JDAQSuperFrame>&>(timeslice);

      return out;
    }


    /**
     * Print DAQ Timeslice.
     *
     * \param  out           output stream
     * \param  lpr           long print
     * \return               output stream
     */
    std::ostream& print(std::ostream& out, const bool lpr = false) const
    {
      using namespace std;
      
      out << this->ClassName() << endl;
      out << dynamic_cast<const JDAQPreamble&>   (*this) << endl;
      out << dynamic_cast<const JDAQChronometer&>(*this) << endl;
      
      for (JDAQTimeslice::const_iterator frame = this->begin(); frame != this->end(); ++frame) {
        
        out << ' ' << setw(5)  << frame->getModuleID();
        out << ' ' << setw(6)  << frame->getLength();
        out << ' ' << setw(6)  << frame->getDataType();
        out << ' ' << setw(6)  << frame->getTimesliceStart();
        out << ' ' << setw(8)  << hex << frame->getStatus()     << dec;
        out << '|' << setw(8)  << hex << frame->getFIFOStatus() << dec;
        out << ' ' << setw(6)  << frame->size();
        
        if (!lpr) {
          
          if (!frame->empty()) {
            
            out << ' ' << setw(10) << frame-> begin()->getT();
            out << " ... ";
            out << ' ' << setw(10) << frame->rbegin()->getT();
          }
          
          out << endl;
          
        } else {
          
          out << endl;
          
          int n = 1;
          
          for (JDAQFrame::const_iterator hit = frame->begin(); hit != frame->end(); ++hit, ++n) {
            out << setw(2) << (int) hit->getPMT() << ' ' << setw(8) << hit->getT() << (n%10 == 0 ? '\n' : ' ');
          }

          out << endl;
        }
      }

      return out;
    }

    /**
     * Get size of object.
     *
     * \return               number of bytes
     */
    virtual int getSize() const
    { 
      int len = 0;

      len += JDAQPreamble       ::sizeOf();
      len += JDAQTimesliceHeader::sizeOf();

      len += sizeof(int);

      for (const_iterator frame = begin(); frame != end(); ++frame) {
        len += frame->getSize();
      }

      return len;
    }


    ClassDef(JDAQTimeslice,4);
  };


  /**
   * Equal operator for DAQ time slices.
   *
   * \param  first     time slice
   * \param  second    time slice
   * \result           true if first time slice equal to second; else false
   */
  inline bool operator==(const JDAQTimeslice& first,
                         const JDAQTimeslice& second)
  {
    return (first.getDAQTimesliceHeader()                          == second.getDAQTimesliceHeader()                          &&
            static_cast<const std::vector<JDAQSuperFrame>&>(first) == static_cast<const std::vector<JDAQSuperFrame>&>(second));
  }


  /**
   * Not-equal operator for DAQ time slices.
   *
   * \param  first     time slice
   * \param  second    time slice
   * \result           true if first time slice not equal to second; else false
   */
  inline bool operator!=(const JDAQTimeslice& first,
                         const JDAQTimeslice& second)
  {
    return !(first == second);
  }
  

  /**
   * Timeslice data structure for L0 data.
   */
  struct JDAQTimesliceL0 : public JDAQTimeslice { ClassDef(JDAQTimesliceL0,1); };


  /**
   * Timeslice data structure for L1 data.
   */
  struct JDAQTimesliceL1 : public JDAQTimeslice { ClassDef(JDAQTimesliceL1,1); };


  /**
   * Timeslice data structure for L2 data.
   */
  struct JDAQTimesliceL2 : public JDAQTimeslice { ClassDef(JDAQTimesliceL2,1); };


  /**
   * Timeslice data structure for SN data.
   */
  struct JDAQTimesliceSN : public JDAQTimeslice { ClassDef(JDAQTimesliceSN,1); };
  

  /**
   * Print DAQ Timeslice.
   *
   * \param  out           output stream
   * \param  timeslice     timeslice
   * \return               output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JDAQTimeslice& timeslice)
  {
    return timeslice.print(out, getDAQLongprint());
  }
}

#endif