JCLBDefaultSimulatorInterface.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JCLBDEFAULTSIMULATORINTERFACE__
#define __JDETECTOR__JCLBDEFAULTSIMULATORINTERFACE__

#include <vector>
#include <algorithm>

#include "JLang/JSinglePointer.hh"
#include "JDetector/JCLBSimulator.hh"
#include "JDAQ/JDAQClock.hh"


/**
 * \author mdejong
 */

namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }

namespace JDETECTOR {

  using KM3NETDAQ::JDAQHit;
  using KM3NETDAQ::JDAQFrame;
  using KM3NETDAQ::getRTS;


  /**
   * Default CLB simulation.
   *
   * This class provides for a default implementation of the JCLBSimulator interface
   * which is based on a simulation of the TDC and the state machine inside the CLB.
   * In this, the number of hits may actually change due to the dynamic range of 
   * the TDC (loss of hits) and the dynamic range of the time-over-threshold (gain 
   * of hits).
   * The nested class JStateMachine constitutes a user interface for the simulation 
   * of the state machine through method JStateMachine::maybeSwapped().
   * With the default implementation, the overall time ordering if hits is maintained.
   * For a realistic simulation of the CLB, a pointer to an implementation of this
   * interface should be provided.
   */
  class JCLBDefaultSimulatorInterface :
    public JCLBSimulator
  {
  protected:

    typedef JDAQHit::JPMT_t           JPMT_t;
    typedef JDAQHit::JTDC_t           JTDC_t;
    typedef JDAQHit::JTOT_t           JTOT_t;


  public:
    /**
     * Interface for TDC.
     */
    class JTDC {
    public:
      /**
       * Virtual destructor.
       */
      virtual ~JTDC()
      {}
      

      /**
       * Make DAQ hit.
       *
       * \param  pmt            PMT channel
       * \param  t_ns           time of hit         [ns]
       * \param  tot_ns         time over threshold [ns]
       * \return                DAQ hit       
       */
      virtual JDAQHit makeHit(const JPMT_t pmt, 
                              const double t_ns,
                              const JTOT_t tot_ns) const 
      {
        return JDAQHit(pmt, (JTDC_t) t_ns, tot_ns);
      }
    };
  

    /**
     * Interface to mimic hit ordering effects due to state machine inside CLB.
     */
    class JStateMachine {
    public:
      /**
       * Virtual destructor.
       */
      virtual ~JStateMachine()
      {}


      /**
       * Test whether two consecutive hits may be swapped.
       *
       * \param  first          first  DAQ hit
       * \param  second         second DAQ hit
       * \return                true if first and second hit may be swapped; else false
       */
      virtual bool maybeSwapped(const JDAQHit& first, const JDAQHit& second) const 
      {
        return false;
      }
    };


    /**
     * Constructor.
     * N.B: This class owns the object pointed to using JSinglePointer<>.
     *
     * \param __TDC             pointer TDC simulator
     * \param __state_machine   pointer state machine
     */
    JCLBDefaultSimulatorInterface(JTDC* __TDC, JStateMachine* __state_machine) :
      JCLBSimulator(),
      TDC          (__TDC),
      state_machine(__state_machine)
    {}


    /**
     * Process data.
     *
     * \param  input            PMT data
     * \param  output           CLB data
     */
    virtual void processData(const JCLBInput& input,
                             JDAQFrame&       output) const
    {      
      using namespace std;


      const JTDC_t TMIN = 0;                   // [ns]
      const JTDC_t TMAX = (JTDC_t) getRTS();   // [ns]

      buffer.clear();


      for (JPMT_t pmt = 0; pmt != (JPMT_t) input.size(); ++pmt) {


        const JPMTData<JPMTPulse>& in = input[pmt];


        // TDC

        JPMTData<JPMTPulse>::const_iterator hit = in.begin(); 

        for ( ; hit != in.end() && hit->t_ns < TMIN; ++hit) {}

        for ( ; hit != in.end() && hit->t_ns < TMAX; ++hit) {

          double t1  = hit->t_ns;
          double tot = hit->tot_ns;

          // generate multiple hits if time-over-threshold exceeds dynamic range
          
          while (tot > JDAQHit::getMaximalToT()) {
            
            buffer.push_back(TDC->makeHit(pmt, t1, JDAQHit::getMaximalToT()));
            
            t1  += JDAQHit::getMaximalToT();
            tot -= JDAQHit::getMaximalToT();
          }
          
          if (tot > getMinimalToT()) {
            buffer.push_back(TDC->makeHit(pmt, t1, (JTOT_t) (tot + 0.5)));
          }
        }
      }


      if (buffer.size() > 1) {

        // process data through state machine

        sort(buffer.begin(), buffer.end());

        for (std::vector<JDAQHit>::iterator q = buffer.begin(), p = q++; q != buffer.end(); ++p, ++q) {

          if (state_machine->maybeSwapped(*p,*q)) {
            iter_swap(p,q);
          }
        }
      }


      output.add(buffer.size(), buffer.data());
    }


    /**
     * Get maximal pulse length of time-over-threshold measurement.
     *
     * \return                  TDC value [ns]
     */
    static JTOT_t getMaximalToT()
    {
      return 0xFE;
    }
      

    /**
     * Get minimal pulse length of time-over-threshold measurement.
     *
     * \return                  TDC value [ns]
     */
    static double getMinimalToT()
    {
      return 0.5;
    }

  private:
    JLANG::JSinglePointer<JTDC>          TDC;
    JLANG::JSinglePointer<JStateMachine> state_machine;
    mutable std::vector<JDAQHit>         buffer;
  };
}

#endif