JModuleAddressMap.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JMODULEADDRESSMAP__
#define __JDETECTOR__JMODULEADDRESSMAP__
 
#include <string>
#include <vector>
#include <algorithm>
 
#include "JLang/JMultiComparable.hh"
#include "JLang/JString.hh"
#include "JLang/JException.hh"
#include "JDetector/JPMTReadoutAddress.hh"
#include "JDetector/JPMTPhysicalAddress.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }
 
namespace JDETECTOR {
 
  using JLANG::JMultiComparable;
  using JLANG::JTYPELIST;
  using JLANG::JIndexOutOfRange;
 
  /**
   * Data structure to translate PMT physical to readout address.
   */
  struct JPMTAddressTranslator :
    public JPMTReadoutAddress,
    public JPMTPhysicalAddress,
    public JMultiComparable<JPMTAddressTranslator, JTYPELIST<JPMTReadoutAddress, JPMTPhysicalAddress>::typelist>
  {
    /**
     * Constructor.
     *
     * \param  readout     readout  address
     * \param  address     physical address
     */
    JPMTAddressTranslator(const JPMTReadoutAddress&  readout,
                          const JPMTPhysicalAddress& address) :
      JPMTReadoutAddress (readout),
      JPMTPhysicalAddress(address)
    {}
 
 
    /**
     * Convert PMT address translator to string.
     *
     * \return            string
     */
    std::string toString() const
    {
      return toString("% % %");
    }
 
 
    /**
     * Convert PMT address translator to string.
     *
     * The targets <tt>target</tt> in the format string <tt>fmt</tt> are
     * consecutively replaced by <tt>tdc</tt>, <tt>ring</tt> and <tt>position</tt>.
     *
     * \param  fmt        format
     * \param  target     target
     * \return            string
     */
    std::string toString(const std::string& fmt, const std::string target = "%") const
    {
      JLANG::JString buffer(fmt);
 
      buffer.replace(target, tdc,      1);
      buffer.replace(target, ring,     1);
      buffer.replace(target, position, 1);
 
      return buffer;
    }
  };
 
  
  /**
   * Lookup table for PMT addresses in optical module.
   */
  class JModuleAddressMap :
    public std::vector<JPMTAddressTranslator>
  {
  public:
    /**
     * Default constructor.
     *
     * The list of valid PMT address translations should be build according to the detector type.
     * The internal router is used to convert a readout channel (TDC) to a PMT readout address.
     */
    JModuleAddressMap() :
      std::vector<JPMTAddressTranslator>()
    {}
 
 
    /**
     * Test whether index is available.
     *
     * \param  index       index
     * \return             true if index is available; else false
     */
    bool has(const int index) const
    {
      return (index >= 0 && index < (int) this->size());
    }
 
 
    /**
     * Test whether TDC is available.
     *
     * \param  tdc         TDC
     * \return             true if TDC is available; else false
     */
    bool hasTDC(const int tdc) const
    {
      return (tdc >= 0 && tdc < (int) router.size() && router[tdc] != -1);
    }
 
 
    /**
     * Test whether PMT is available.
     *
     * \param  address     PMT address
     * \return             true if PMT is available; else false
     */
    bool hasPMT(const JPMTPhysicalAddress& address) const
    {
      using namespace std;
 
      const_iterator p = lower_bound(this->begin(), this->end(), address, less<JPMTPhysicalAddress>());
      
      return (p != this->end() && *p == address);
    }
 
 
    /**
     * Configure internal router.
     */
    void configure()
    {
      using namespace std;
      
      sort(this->begin(), this->end(), less<JPMTPhysicalAddress>());
 
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
 
        if (i->tdc >= (int) router.size()) {
          router.resize(i->tdc + 1, -1);
        }
 
        router[i->tdc] = std::distance(const_iterator(this->begin()),i);
      }
    }
 
 
    /**
     * Swap readout addresses corresponding to indices.
     *
     * \param  i1          first  index
     * \param  i2          second index
     */
    void swap(const int i1, const int i2)
    {
      std::swap(router[at(i1).tdc], 
                router[at(i2).tdc]);
 
      std::swap(static_cast<JPMTReadoutAddress&>(at(i1)), 
                static_cast<JPMTReadoutAddress&>(at(i2)));
    }
 
 
    /**
     * Swap physical addresses corresponding to TDCs.
     *
     * \param  tdc1        first  TDC
     * \param  tdc2        second TDC
     */
    void swapTDC(const int tdc1, const int tdc2)
    {
      std::swap(static_cast<JPMTReadoutAddress&>(at(router[tdc1])), 
                static_cast<JPMTReadoutAddress&>(at(router[tdc2])));
 
      std::swap(router[tdc1], 
                router[tdc2]);
    }
 
 
    /**
     * Swap readout addresses corresponding to PMTs.
     *
     * \param  pmt1        first  PMT
     * \param  pmt2        second PMT
     */
    void swapPMT(const JPMTPhysicalAddress& pmt1,const JPMTPhysicalAddress& pmt2)
    {
      swapTDC(getPMTReadoutAddress(pmt1).tdc, getPMTReadoutAddress(pmt2).tdc);
    }
 
 
    /**
     * Swap readout addresses by right rotation of physical addresses of PMTs in a given ring.
     *
     * \param  ring        ring
     */
    void rotateR(const char ring)
    {
      if (ring != 'A') {
        swapPMT(JPMTPhysicalAddress(ring,5), JPMTPhysicalAddress(ring,6));
        swapPMT(JPMTPhysicalAddress(ring,4), JPMTPhysicalAddress(ring,5));
        swapPMT(JPMTPhysicalAddress(ring,3), JPMTPhysicalAddress(ring,4));
        swapPMT(JPMTPhysicalAddress(ring,2), JPMTPhysicalAddress(ring,3));
        swapPMT(JPMTPhysicalAddress(ring,1), JPMTPhysicalAddress(ring,2));
      }
    }
 
 
    /**
     * Swap readout addresses by left rotation of physical addresses of PMTs in a given ring.
     *
     * \param  ring        ring
     */
    void rotateL(const char ring)
    {
      if (ring != 'A') {
        swapPMT(JPMTPhysicalAddress(ring,1), JPMTPhysicalAddress(ring,2));
        swapPMT(JPMTPhysicalAddress(ring,2), JPMTPhysicalAddress(ring,3));
        swapPMT(JPMTPhysicalAddress(ring,3), JPMTPhysicalAddress(ring,4));
        swapPMT(JPMTPhysicalAddress(ring,4), JPMTPhysicalAddress(ring,5));
        swapPMT(JPMTPhysicalAddress(ring,5), JPMTPhysicalAddress(ring,6));
      }
    }
    
 
    /**
     * Get PMT logical index for given TDC channel.
     *
     * \param  tdc         TDC
     * \return             PMT logical index
     */
    int getIndex(const int tdc) const
    {
      return router.at(tdc);
    }
 
 
    /**
     * Get PMT address translator.
     *
     * \param  tdc         TDC
     * \return             PMT address translator
     */
    const JPMTAddressTranslator& getAddressTranslator(const int tdc) const
    {
      return at(getIndex(tdc));
    }
 
 
    /**
     * Get PMT physical address.
     *
     * \param  tdc         TDC
     * \return             PMT physical address
     */
    const JPMTPhysicalAddress& getPMTPhysicalAddress(const int tdc) const
    {
      return getAddressTranslator(tdc);
    }
 
 
    /**
     * Get PMT address translator.
     *
     * \param  address     PMT physical address
     * \return             PMT address translator
     */
    const JPMTAddressTranslator& getAddressTranslator(const JPMTPhysicalAddress& address) const
    {
      using namespace std;
 
      const_iterator p = lower_bound(this->begin(), this->end(), address, less<JPMTPhysicalAddress>());
      
      if (p != this->end() && *p == address)
        return *p;
      else
        THROW(JIndexOutOfRange, "Invalid PMT address " << address);
    }
 
 
    /**
     * Get PMT readout address.
     *
     * \param  address     PMT physical address
     * \return             PMT readout address
     */
    const JPMTReadoutAddress& getPMTReadoutAddress(const JPMTPhysicalAddress& address) const
    {
      return getAddressTranslator(address);
    }
 
 
  protected:
    std::vector<int> router;
  };
}
 
#endif