JProductRouter.hh

Go to the documentation of this file.

#ifndef __JDB__JPRODUCTROUTER__
#define __JDB__JPRODUCTROUTER__

#include <ostream>
#include <map>

#include "JDB/JDetectorIntegration_t.hh"
#include "JDB/JPBS.hh"
#include "JDB/JUPI.hh"
#include "JLang/JEquals.hh"
#include "JLang/JComparable.hh"
#include "JLang/JVectorize.hh"
#include "JLang/JLangToolkit.hh"
#include "Jeep/JPrint.hh"


/**
 * \author mdejong
 */
namespace JDATABASE {}
namespace JPP { using namespace JDATABASE; }

namespace JDATABASE {

  /**
   * Auxiliary data structure for location of product in detector.
   */
  struct JLocation_t :
    public JLANG::JComparable<JLocation_t>
  {
    /**
     * Default constructor.\n
     * The default corresponds to an invalid location.
     */
    JLocation_t() :
      string  (-1),
      floor   (-1),
      position(-1)
    {}


    /**
     * Constructor.
     *
     * \param  string        string
     * \param  floor         floor
     * \param  position      position
     */
    JLocation_t(const int string,
                const int floor,
                const int position) :
      string  (string),
      floor   (floor),
      position(position)
    {}
    

    /**
     * Less-than method.
     *
     * \param  location      location
     * \return               true if this location less than given location; else false
     */
    bool less(const JLocation_t& location) const
    {
      if (this->string == location.string) {

        if (this->floor == location.floor)
          return this->position < location.position;
        else
          return this->floor    < location.floor;

      } else {

        return this->string < location.string;
      }
    }


    /**
     * Write location to output stream.
     *
     * \param  out        output stream
     * \param  object     location
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JLocation_t& object)
    {
      using namespace std;
      using namespace JPP;

      return out << FILL(3,'0') << object.string   << '.' 
                 << FILL(2,'0') << object.floor    << '.' 
                 << FILL(2,'0') << object.position << FILL();
    }


    int string;           //!< position in detector
    int floor;            //!< position in string
    int position;         //!< position in floor
  };


  /**
   * Auxiliary class to map %UPI to location in detector.
   */
  class JProductRouter 
  {

  public:

    /**
     * Constructor.
     *
     * \param  detector      detector integration
     */
    JProductRouter(const JDetectorIntegration_t& detector) 
    {
      using namespace std;
      using namespace JPP;

      for (JDetectorIntegration_t::const_iterator i = detector.begin(); i != detector.end(); ++i) {

        if (i->has()) {

          if (insert(detector, *i, vector<JPBS>{ PBS::DOM,            PBS::DETECTION_UNIT, PBS::DETECTOR })) { continue; }
          if (insert(detector, *i, vector<JPBS>{ PBS::BASE,           PBS::DETECTION_UNIT, PBS::DETECTOR })) { continue; }
          if (insert(detector, *i, vector<JPBS>{ PBS::BASE_CONTAINER, PBS::DETECTION_UNIT, PBS::DETECTOR })) { continue; }

          if (insert(detector, *i, vector<JPBS>{ PBS::CLB, PBS::DOM,            PBS::DETECTION_UNIT, PBS::DETECTOR })) { continue; }
          if (insert(detector, *i, vector<JPBS>{ PBS::CLB, PBS::BASE,           PBS::DETECTION_UNIT, PBS::DETECTOR })) { continue; }
          if (insert(detector, *i, vector<JPBS>{ PBS::CLB, PBS::BASE_CONTAINER, PBS::DETECTION_UNIT, PBS::DETECTOR })) { continue; }
        }
      }
    }


    /**
     * Get location of product with given %UPI.
     *
     * Note that only for products inside a string, a valid location is returned,
     * otherwise, the default location is returned.
     *
     * \param  upi           %UPI
     * \return               location
     */
    JLocation_t getLocation(const JUPI& upi) const
    {
      std::map<JUPI, JLocation_t>::const_iterator p = map.find(upi);

      if (p != map.end())
        return p->second;
      else
        return JLocation_t();
    }


    /**
     * Get %UPI of product with given location.
     *
     * Note that only for products inside a string, a valid location is returned,
     * otherwise, the default location is returned.
     *
     * \param  location      location
     * \return               %UPI
     */
    JUPI getUPI(const JLocation_t& location) const
    {
      std::map<JLocation_t, JUPI>::const_iterator p = inverse_map.find(location);

      if (p != inverse_map.end())
        return p->second;
      else
        return JUPI();
    }


  private:
    /**
     * Insert product.
     *
     * Note that given PBS hierarchy should contain at least three levels and
     * normally terminate with detection unit and detector.
     *
     * \param  detector      detector integration
     * \param  product       product
     * \param  pbs           %PBS hierarchy
     * \return               true if inserted; else false
     */
    bool insert(const JDetectorIntegration_t& detector,
                const JProductIntegration_t&  product,
                const std::vector<JPBS>&      pbs)
    {
      if (pbs.size() >= 3) {

        const JProductTrace trace(detector, product.content.getUPI(), pbs);

        if (trace.size() == pbs.size()) {

          const JUPI        upi = product.content.getUPI();
          const JLocation_t loc = JLocation_t(trace[2].position, trace[1].position, trace[0].position);

          map.insert        (make_pair(upi, loc));
          inverse_map.insert(make_pair(loc, upi));

          return true;
        }
      }

      return false;
    }

    std::map<JUPI, JLocation_t> map;
    std::map<JLocation_t, JUPI> inverse_map;
  };
}

#endif