JTimesliceClone.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JTIMESLICECLONE__
#define __JTRIGGER__JTIMESLICECLONE__
 
#include <vector>
 
#include "JTrigger/JSuperFrameClone1D.hh"
#include "JTrigger/JTimeslice.hh"
#include "JTrigger/JHitToolkit.hh"
#include "JLang/JClass.hh"
#include "JGeometry3D/JMatrix3D.hh"
#include "JGeometry3D/JRotation3D.hh"
#include "JDetector/JModuleRouter.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
namespace JTRIGGER {
 
  using JGEOMETRY3D::JMatrix3D;
  using JGEOMETRY3D::JRotation3D;
  using JDETECTOR::JModuleRouter;
 
 
  /**
   * Clone of JTimeslice.
   */
  template<class JElement_t>
  class JTimesliceClone :
    public std::vector< JSuperFrameClone1D<JElement_t> >,
    public JHitToolkit<JElement_t>
  {
  public:
 
    typedef typename JLANG::JClass<JElement_t>::argument_type            argument_type;
    typedef JSuperFrameClone1D<JElement_t>                               value_type;
    typedef typename std::vector<value_type>::iterator                   iterator;
    typedef typename std::vector<value_type>::const_iterator             const_iterator;
    typedef typename std::vector<value_type>::reverse_iterator           reverse_iterator;
    typedef typename std::vector<value_type>::const_reverse_iterator     const_reverse_iterator;
 
 
    /**
     * Default constructor.
     */
    JTimesliceClone()
    {}
    
 
    /**
     * Constructor.
     *
     * The cloned data are organised according the input time slice.
     *
     * \param  input    super frame
     */
    JTimesliceClone(const JTimeslice<JElement_t>& input)
    {
      for (typename JTimeslice<JElement_t>::const_iterator i = input.begin(); i != input.end(); ++i) {
        this->push_back(JSuperFrameClone1D<JElement_t>(*i));
      }
    }
    
 
    /**
     * Constructor.
     *
     * The cloned data are organised according the module router.
     *
     * \param  input    super frame
     * \param  router   module router
     */
    JTimesliceClone(const JTimeslice<JElement_t>& input,
                    const JModuleRouter&          router)
    {
      this->resize(router.getReference().size());
 
      for (typename JTimeslice<JElement_t>::const_iterator i = input.begin(); i != input.end(); ++i) {
        (*this)[router.getAddress(i->getModuleID()).first] = JSuperFrameClone1D<JElement_t>(*i);
      }
 
      // add end marker to empty frames
 
      if (buffer.empty()) {
        buffer.push_back(this->getEndMarker());
      }
 
      for (iterator i = this->begin(); i != this->end(); ++i) {
        if (i->empty()) {
          *i = JSuperFrameClone1D<JElement_t>(buffer);
        }
      }
    }
 
 
    /**
     * Transform.
     *
     * \param  R        matrix
     */
    JTimesliceClone<JElement_t>& transform(const JMatrix3D& R)
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->transform(R);
      }
 
      return *this;
    }
 
 
    /**
     * Rotate.
     *
     * \param  R        rotation matrix
     */
    JTimesliceClone<JElement_t>& rotate(const JRotation3D& R)
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->rotate(R);
      }
 
      return *this;
    }
 
 
    /**
     * Rotate back.
     *
     * \param  R        rotation matrix
     */
    JTimesliceClone<JElement_t>& rotate_back(const JRotation3D& R)
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->rotate_back(R);
      }
 
      return *this;
    }
 
 
    /**
     * Rewind internal iterators.
     */
    inline void rewind() const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        i->rewind();
      }
    }
 
 
    /**
     * Set the internal iterators to the lower bounds corresponding to the time of the given hit.
     *
     * \param  hit            hit
     */
    void lower_bound(argument_type hit) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        i->lower_bound(hit);
      }
    }
 
 
    /**
     * Increment the internal iterators until the lower bounds corresponding to the time of the given hit.
     *
     * \param  hit            hit
     */
    void fast_forward(argument_type hit) const
    {
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        i->fast_forward(hit);
      }
    }
 
  private:
    static JSuperFrame1D<JElement_t> buffer;
  };
 
 
  /**
   */
  template<class JElement_t>
  JSuperFrame1D<JElement_t> JTimesliceClone<JElement_t>::buffer;
}
 
#endif