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(10) << frame->getModuleID();
        out << ' ' << setw(6)  << frame->getLength();
        out << ' ' << setw(6)  << frame->getDataType();
        out << ' ' << setw(6)  << frame->getTimesliceStart();
        out << ' ' << setw(8)  << setfill('0') << hex << frame->getStatus()     << dec << setfill(' ');
        out << '|' << setw(8)  << setfill('0') << hex << frame->getFIFOStatus() << dec << setfill(' ');
        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