JTDC_t.hh

Go to the documentation of this file.

#ifndef __JCALIBRATE_JTDC_t__
#define __JCALIBRATE_JTDC_t__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <map>
 
#include "km3net-dataformat/online/JDAQ.hh"
 
#include "JSystem/JStat.hh"
#include "JLang/JStringStream.hh"
#include "JLang/JException.hh"
#include "Jeep/JComment.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JCALIBRATE {}
namespace JPP { using namespace JCALIBRATE; }
 
/**
 * Auxiliary classes and methods for PMT calibration.
 */
namespace JCALIBRATE {
 
  using JLANG::JValueOutOfRange;
  using KM3NETDAQ::NUMBER_OF_PMTS;
  using JEEP::JComment;
 
 
  /**
   * Auxiliary class for TDC constraints.
   */
  struct JTDC_t :
    public std::multimap<int, int> // module identifier -> TDC
  {
    typedef std::multimap<int, int>                    multimap_type;
 
    /**
     * Type definition for range of TDC constraints of a given module identfier.
     */
    typedef std::pair<const_iterator, const_iterator>  range_type;
 
 
    /**
     * Wild card for module identifier and TDC.
     */
    enum { WILDCARD = -1 };
 
 
    /**
     * Insert constraint.
     *
     * Note that if TDC equals JTDC_t::WILDCARD,
     * all possible TDCs in the given module are inserted.
     *
     * \param  value        module identifier and TDC
     */
    void insert(const value_type& value)
    {
      if (value.second == WILDCARD) {
 
        for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
          multimap_type::insert(value_type(value.first, pmt));
        }
 
      } else {
 
        multimap_type::insert(value);
      }
    }
 
 
    /**
     * Insert constraint.
     *
     * Note that if TDC equals JTDC_t::WILDCARD,
     * all possible TDCs in the given module are inserted.
     *
     * \param  id           module identifier
     * \param  tdc          TDC
     */
    void insert(const int id, const int tdc)
    {
      this->insert(value_type(id, tdc));
    }
 
 
    /**
     * Get range of constraints for given module.
     *
     * Note that if no data are available for given module identifier, 
     * the data corresponding to JTDC_t::WILDCARD are returned.
     *
     * \param  id           module identifier
     * \return              range of constraints
     */
    range_type equal_range(const int id)
    {
      range_type range = multimap_type::equal_range(id);
 
      if (range.first == range.second) {
        range = multimap_type::equal_range(WILDCARD);
      }
 
      return range;
    }
 
 
    /**
     * Check if TDC is constraint.
     *
     * \param  id           module identifier
     * \param  tdc          TDC channel
     * \return              true if given TDC is constraint; else false
     */
    bool has(const int id, const int tdc)
    {
      const range_type range = equal_range(id);
 
      for (JTDC_t::const_iterator i = range.first; i != range.second; ++i) {
        if (tdc == i->second) {
          return true;
        }
      }
 
      return false;
    }
 
 
    /**
     * Reverse constraints.
     */
    void reverse()
    {
      JTDC_t buffer;
 
      for (JTDC_t::const_iterator p = this->begin(); p != this->end(); ) {
      
        JTDC_t::const_iterator q = p;
      
        for ( ; q != this->end() && q->first == p->first; ++q) {}
      
        for (int pmt = 0; pmt != NUMBER_OF_PMTS; ++pmt) {
        
          JTDC_t::const_iterator i = p;
        
          for ( ; i != q && i->second != pmt; ++i) {}
 
          if (i == q) {
            buffer.insert(value_type(p->first, pmt));
          }
        }
      
        p = q;
      }
    
      this->swap(buffer);
    }
 
 
    /**
     * Check validity of TDC constrants.
     *
     * \param  option     option (if true, throw exception if not valid)
     * \return            true if valid; else false
     */
    bool is_valid(const bool option = false) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
 
        if (i->first < WILDCARD) {
 
          if (option) {
            THROW(JValueOutOfRange, "Invalid module identifier: " << i->first << " < " << WILDCARD);
          }
 
          return false;
        }
 
        if (i->second < 0 || i->second >= NUMBER_OF_PMTS) {
 
          if (option) {
            THROW(JValueOutOfRange, "Invalid TDC: " << i->second << " {0, .., " << NUMBER_OF_PMTS - 1 << "}");
          }
 
          return false;
        }
      }
 
      return true;
    }
 
 
    /**
     * Read TDC constraints from input.
     *
     * \param  in         input stream
     * \param  tdc        TDC constraints
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTDC_t& tdc)
    {
      using namespace std;
      using namespace JPP;
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
 
      is >> tdc.comment;
 
      for (int id, pmt; is >> id >> pmt; ) {
        tdc.insert(JTDC_t::value_type(id, pmt));
      }
 
      return in;
    }
 
 
    /**
     * Write TDC constraints to output.
     *
     * \param  out        output stream
     * \param  tdc        TDC constraints
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTDC_t& tdc)
    {
      using namespace std;
 
      out << tdc.comment;
 
      for (JTDC_t::const_iterator i = tdc.begin(); i != tdc.end(); ++i) {
        out << setw(10) << i->first << ' ' << setw(2) << i->second << endl;
      }
 
      return out;
    }
 
    JComment comment;
  };
}
 
#endif