JDetectorIntegration.hh

Go to the documentation of this file.

#ifndef __JDB__JDETECTORINTEGRATION__
#define __JDB__JDETECTORINTEGRATION__
 
#include <istream>
#include <ostream>
#include <sstream>
#include <limits>
#include <vector>
#include <map>
 
#include "JTools/JRange.hh"
#include "JDB/JDB.hh"
#include "JDB/JProductIntegration.hh"
#include "JDB/JPBS.hh"
#include "JDB/JUPI.hh"
#include "JLang/JEquals.hh"
#include "JLang/JComparable.hh"
#include "JLang/JException.hh"
 
#include "KM3NeTDBClient.h"
 
 
/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }
 
namespace JDATABASE {
 
  using JLANG::JDatabaseException;
  using JLANG::JException;
 
 
  /**
   * Auxiliary class for integration date.
   *
   * The corresponding ASCII format is "yyyy/mm/dd".
   */
  struct JDate_t :
    public JLANG::JComparable<JDate_t>
  {
    /**
     * Separation character.
     */
    static const char SEPARATOR = '/';
 
 
    /**
     * Default constructor.
     */
    JDate_t() :
      year (0),
      month(0),
      day  (0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  year       year
     * \param  month      month
     * \param  day        day
     */
    JDate_t(const int year,
            const int month,
            const int day) :
      year (year),
      month(month),
      day  (day)
    {}
 
 
    static JDate_t min() { return JDate_t(-std::numeric_limits<int>::max(),  1,  1); }  //!< Minimal date
    static JDate_t max() { return JDate_t(+std::numeric_limits<int>::max(), 12, 31); }  //!< Maximal date
 
 
    /**
     * Less-than method.
     *
     * \param  date          date
     * \return               true if this date earlier than given date; else false
     */
    bool less(const JDate_t& date) const
    {
      if (this->year == date.year) {
 
        if (this->month == date.month)
          return this->day   < date.day;
        else
          return this->month < date.month;
 
      } else {
 
        return this->year < date.year;
      }
    }
 
 
    /**
     * Read date from input stream.
     *
     * \param  in         input stream
     * \param  object     date
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JDate_t& object)
    {
      using namespace std;
 
      object = JDate_t();
 
      string buffer;
 
      if (in >> buffer) {
 
        for (string::iterator i = buffer.begin(); i != buffer.end(); ++i) {
          if (*i == JDate_t::SEPARATOR) {
            *i = ' ';
          }
        }
 
        istringstream is(buffer);
 
        is >> object.year >> object.month >> object.day;
 
        in.setstate(is.rdstate());
      }
 
      return in;
    }
 
 
    /**
     * Write date to output stream.
     *
     * \param  out        output stream
     * \param  object     date
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDate_t& object)
    {
      return out << object.year  << JDate_t::SEPARATOR
                 << object.month << JDate_t::SEPARATOR
                 << object.day;
    }
 
 
    int year;              //!< year
    int month;             //!< month
    int day;               //!< year
  };
 
 
  /**
   * Type definition of period.
   */
  typedef JTOOLS::JRange<JDate_t>  JPeriod_t;
 
 
  /**
   * Write period to output stream.
   *
   * \param  out        output stream
   * \param  object     period
   * \return            output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JPeriod_t& object)
  {
    return out << "(" << object.getLowerLimit() << "," << object.getUpperLimit() << ")";
  }
  
 
  /**
   * Auxiliary class for product integration data.
   *
   * This class is primarily used to 
   * - convert the string data from JDATABASE::JProductIntegration to corresponding data structures;
   * - implement efficient (in)equality operations;
   */
  struct JProductIntegration_t {
    /**
     * Default constructor.
     */
    JProductIntegration_t() :
      status(false)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  input        product integration data
     */
    JProductIntegration_t(const JProductIntegration& input) :
      status(false)
    {
      using namespace std;
 
      this->operation = input.OPERATIONID;
      this->position  = input.POSITION;
 
      istringstream(input.CONTAINER_UPI) >> this->container;
      istringstream(input.CONTENT_UPI)   >> this->content;
      istringstream(input.STARTD)        >> this->start_date;
      istringstream(input.ENDD)          >> this->end_date;
    }
 
 
    /**
     * Has status.
     */
    bool has() const
    {
      return status;
    }
 
 
    /**
     * Set status.
     */
    void set()
    {
      status = true;
    }
 
 
    /**
     * Unset status.
     */
    void unset()
    {
      status = false;
    }
 
 
    /**
     * Check whether there is an overlap between products.
     *
     * The overlap is evaluated based on container UPI and position.
     *
     * \param  product       product
     * \return               true if this product overlaps with given product; else false
     */
    bool overlap(const JProductIntegration_t& product) const
    {
      return (this->container == product.container   &&
              this->position  == product.position);
    }
 
 
    /**
     * Write product integration to output stream.
     *
     * \param  out          output stream
     * \param  object       product integration
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JProductIntegration_t& object)
    {
      using namespace std;
 
      out << object.operation          << ' '
          << object.container.getUPI() << ' '
          << object.content  .getUPI() << ' '
          << object.position           << ' '
          << object.start_date         << ' '
          << object.end_date;
 
      return out;
    }
 
 
    std::string  operation;
    int          position;
    JUPI         container;
    JUPI         content;
    JDate_t      start_date;
    JDate_t      end_date;
    bool         status;
  };
 
 
  /**
   * Detector integration.
   *
   * This class is used
   * - to read product integration data from the data base;  
   * - to organise detector specific integration data in memory;
   * - to efficiently %trace a product;
   * - to efficiently %find product(s);
   */
  struct JDetectorIntegration
  {
    static const char* const getName() { return JProductIntegration::getName(); } //!< Table name
 
 
    typedef  std::multimap<JUPI, int>                               map_type;
    typedef  std::pair<map_type::const_iterator,
                       map_type::const_iterator>                    range_type;
    typedef  map_type::const_iterator                               range_const_iterator;
    typedef  map_type::const_iterator                               range_iterator;
 
    typedef  std::vector<JProductIntegration_t>                     data_type;
    typedef  data_type::const_iterator                              const_iterator;
    typedef  data_type::iterator                                    iterator;
    typedef  data_type::const_reverse_iterator                      const_reverse_iterator;
    typedef  data_type::reverse_iterator                            reverse_iterator;
 
 
    /**
     * Default constructor.
     */
    JDetectorIntegration()
    {}
 
 
    const_iterator         begin()  const { return data.begin(); }     //!< begin of integration data
    const_iterator         end()    const { return data.end(); }       //!< end   of integration data
    const_reverse_iterator rbegin() const { return data.rbegin(); }    //!< reverse begin of integration data
    const_reverse_iterator rend()   const { return data.rend(); }      //!< reverse end   of integration data
 
    bool   empty() const { return data.empty(); }                      //!< check emptyness of integration data
    size_t size()  const { return data.size(); }                       //!< size of integration data
 
 
    /**
     * Get product at given index.
     *
     * \param  index         index
     * \return               product
     */
    const JProductIntegration_t& operator[](const int index) const
    {
      return data[index];
    }
 
 
    /**
     * Configure detector integration for given detector identifier.
     *
     * The components of the given detector are selected based on the following rules:
     *   -# the component should have a start date before that of the given detector;
     *   -# if multiple components appear at the same place in the same container, 
     *      the one with the latest start date is taken.
     *
     * \param  detid         detector identifier
     */
    void configure(const std::string& detid)
    {
      using namespace std;
 
      up  .clear();
      down.clear();
 
      for (size_t index = 0; index != data.size(); ++index) {
 
        JProductIntegration_t& product = data[index];
 
        product.unset();
 
        up  .insert(make_pair(product.content  .getUPI(), index));
        down.insert(make_pair(product.container.getUPI(), index));
      }
 
 
      for (data_type::iterator product = data.begin(); product != data.end(); ++product) {
        if (product->operation == detid) {
          configure(*product, JPeriod_t(product->start_date, product->end_date));
        }
      }
 
 
      up  .clear();
      down.clear();
 
      for (size_t index = 0; index != data.size(); ++index) {
 
        const JProductIntegration_t& product = data[index];
 
        if (product.has()) {
          up  .insert(make_pair(product.content  .getUPI(), index));
          down.insert(make_pair(product.container.getUPI(), index));
        }
      }
    }
 
 
    /**
     * Trace product up to given integration level.
     *
     * \param  upi           %UPI
     * \param  pbs           %PBS
     * \return               product
     */
    const JProductIntegration_t& trace(const JUPI& upi,
                                       const JPBS& pbs = PBS::DETECTOR) const
    {
      if (upi.getPBS() >= pbs) {
 
        const int index = find(upi);
 
        if (index != -1) {
 
          const JProductIntegration_t& product = data[index];
 
          if (product.container.getPBS() == pbs) 
            return product;
          else
            return trace(product.container.getUPI(), pbs);
 
        } else {
 
          THROW(JDatabaseException, "Invalid UPI " << upi);
        }
 
      } else {
 
        THROW(JDatabaseException, "Invalid PBS " << upi.getPBS() << " < " << pbs);
      }
    }
 
 
    /**
     * Print product trace.
     *
     * \param  out           output stream
     * \param  upi           %UPI
     */
    void print(std::ostream& out, const JUPI& upi) const
    {
      using namespace std;
 
      const int index = find(upi);
 
      if (index != -1) {
 
        out << upi << " -> ";
 
        print(out, data[index]);
      }
 
      const range_type range  = down.equal_range(upi);
 
      for (range_iterator i = range.first; i != range.second; ++i) {
        out << "<- " << data[i->second] << endl; 
      }
    }
 
 
    /**
     * Print product trace.
     *
     * \param  out           output stream
     * \param  product       product
     */
    void print(std::ostream& out, const JProductIntegration_t& product) const
    {
      out << product.container.getUPI()                      << ' '
          << JPeriod_t(product.start_date, product.end_date) << ' '
          << " -> ";
 
      const int index = find(product.container.getUPI());
 
      if (index != -1)
        print(out, data[index]);
      else
        out << product.operation << std::endl;
    }
 
 
    /**
     * Read detector integration from result set.
     *
     * \param  rs            result set
     * \param  detector      detector
     * \return               true if read; else false
     */
    friend inline bool operator>>(ResultSet& rs, JDetectorIntegration& detector)
    {
      for (JProductIntegration parameters; rs >> parameters; ) {
 
        const JProductIntegration_t product(parameters);
 
        detector.up  .insert(make_pair(product.content  .getUPI(), detector.data.size()));
        detector.down.insert(make_pair(product.container.getUPI(), detector.data.size()));
 
        detector.data.push_back(product);
      }
 
      rs.Close();
 
      return true;
    }
 
 
    /**
     * Write detector integration to output stream.
     *
     * \param  out          output stream
     * \param  object       detector integration
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JDetectorIntegration& object)
    {
      for (const_iterator i = object.data.begin(); i != object.data.end(); ++i) {
        out << *i << std::endl;
      }
 
      return out;
    }
 
 
    /**
     * Find index of unique product with given %UPI.\n
     * This method can only be used after method JDetectorIntegration::configure.
     *
     * \param  upi           %UPI
     * \return               index
     */
    int find(const JUPI& upi) const
    {
      const range_type range = up.equal_range(upi);
 
      switch (std::distance(range.first, range.second)) {
 
      case 0:
        return -1;
 
      case 1:
        return range.first->second;
 
      default:
        THROW(JDatabaseException, "Ambiguous integration of UPI (call first method JDetectorIntegration::configure) " << upi);
      }
    }
 
 
    /**
     * Find range of products with given %PBS.\n
     * The returned range correspond to the usual begin and end iterators,
     * each pointing to an STL pair consisting of a %UPI and index.
     *
     * \param  pbs           %PBS
     * \return               range
     */
    range_type find(const JPBS& pbs) const
    {
      range_const_iterator p = up.lower_bound(JUPI(pbs));
      range_const_iterator q = p;
 
      while (q != up.end() && data[q->second].content.getPBS() <= pbs) {
        ++q;
      }
 
      return range_type(p,q);
    }
 
  protected:
    /**
     * Configure detector integration for given detector identifier.\n
     * This method sets the status all related products.
     *
     * \param  product       product
     * \param  period        validity period
     */
    void configure(JProductIntegration_t& product, const JPeriod_t& period)
    {
      using namespace std;
 
      product.set();
 
      vector<int> buffer;
      
      range_type range = down.equal_range(product.content);
 
      for (range_iterator i = range.first; i != range.second; ++i) {
 
        if (data[i->second].start_date <= period.getLowerLimit()) {
 
          int ns = 0;
 
          for (vector<int>::iterator p = buffer.begin(); p != buffer.end(); ++p) {
 
            if (data[*p].overlap(data[i->second])) {
 
              ++ns;
 
              if (data[i->second].start_date > data[*p].start_date) {
                *p = i->second;
              }
            }
          }
 
          if (ns == 0) {
            buffer.push_back(i->second);
          }
        }
      }
 
      for (vector<int>::const_iterator i = buffer.begin(); i != buffer.end(); ++i) {
        configure(data[*i], period);
      }
    }
 
 
    data_type  data;   //!< integration data
    map_type   up;     //!< up   link %UPI to integration data
    map_type   down;   //!< down link %UPI to integration data
  };
 
 
  /**
   * Auxiliary class to trace product.
   */
  struct JProductTrace :
    std::vector<JProductIntegration_t>
  {
    /**
     * Constructor.
     *
     * \param  detector      detector
     * \param  upi           %UPI
     * \param  pbs           %PBS
     */
    JProductTrace(const JDetectorIntegration& detector,
                  const JUPI&                 upi,
                  const std::vector<JPBS>&    pbs)
    {
      JUPI __upi__ = upi;
 
      for (std::vector<JPBS>::const_iterator i = pbs.begin(); i != pbs.end(); ++i) {
 
        try {
 
          const JProductIntegration_t& product = detector.trace(__upi__, *i);
 
          push_back(product);
 
          __upi__ = product.container.getUPI();
        }
        catch(std::exception& error) {
          break;
        }
      }
    }
  };
}
 
#endif