JDetectorSimulator.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JDETECTORSIMULATOR__
#define __JDETECTOR__JDETECTORSIMULATOR__
 
#include "JLang/JSinglePointer.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JPMTRouter.hh"
#include "JDetector/JK40Simulator.hh"
#include "JDetector/JPMTSimulator.hh"
#include "JDetector/JCLBSimulator.hh"
#include "JLang/JException.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }
 
namespace JDETECTOR {
 
  using JLANG::JPointerException;
  
 
  /**
   * Detector simulation.
   *
   * This class implements the JK40Simulator, JPMTSimulator and JCLBSimulator interfaces.
   * The implementations of these interfaces should be provided via pointers to corresponding objects.
   *
   * N.B: This class owns the objects pointed to using class JLANG::JSinglePointer.
   */
  class JDetectorSimulator :
    public JPMTRouter,
    public JK40Simulator,
    public JPMTSimulator,
    public JCLBSimulator
  {
  private:
    /**
     * Make copy constructor inaccesible.
     */
    JDetectorSimulator(const JDetectorSimulator&);
 
 
    /**
     * Make assignment operator inaccesible
     */
    JDetectorSimulator& operator=(const JDetectorSimulator&);
    
 
  public:
    /**
     * Constructor.
     *
     * \param  detector         detector
     */
    JDetectorSimulator(const JDetector& detector) :
      JPMTRouter(detector)
    {}
 
 
    /**
     * Check availability of K40 simulator.
     *
     * \return                  true if simulator available; else false
     */
    bool hasK40Simulator() const
    {
      return k40Simulator.get() != NULL;
    }
 
 
 
    /**
     * Check availability of PMT simulator.
     *
     * \return                  true if simulator available; else false
     */
    bool hasPMTSimulator() const
    {
      return pmtSimulator.get() != NULL;
    }
 
 
    /**
     * Check availability of CLB simulator.
     *
     * \return                  true if simulator available; else false
     */
    bool hasCLBSimulator() const
    {
      return clbSimulator.get() != NULL;
    }
 
 
    /**
     * Get K40 simulator.
     *
     * \return                  K40 simulator
     */
    const JK40Simulator& getK40Simulator() const
    {
      if (hasK40Simulator())
        return *k40Simulator;
      else
        THROW(JPointerException, "JDetectorSimulator: K40 simulator not avaliable.");   
    }
 
 
    /**
     * Get PMT simulator.
     *
     * \return                  PMT simulator
     */
    const JPMTSimulator& getPMTSimulator() const
    {
      if (hasPMTSimulator())
        return *pmtSimulator;
      else
        THROW(JPointerException, "JDetectorSimulator: PMT simulator not avaliable.");   
    }
 
 
    /**
     * Get CLB simulator.
     *
     * \return                  CLB simulator
     */
    const JCLBSimulator& getCLBSimulator() const
    {
      if (hasCLBSimulator())
        return *clbSimulator;
      else
        THROW(JPointerException, "JDetectorSimulator: CLB simulator not avaliable.");   
    }
 
 
    /**
     * Reset K40 simulator.
     *
     * \param  k40Simulator     K40 simulator
     */
    void reset(JK40Simulator* k40Simulator)
    {
      this->k40Simulator.reset(k40Simulator);
    }
 
 
 
    /**
     * Reset PMT simulator.
     *
     * \param  pmtSimulator     PMT simulator
     */
    void reset(JPMTSimulator* pmtSimulator)
    {
      this->pmtSimulator.reset(pmtSimulator);
    }
 
 
    /**
     * Reset CLB simulator.
     *
     * \param  clbSimulator     CLB simulator
     */
    void reset(JCLBSimulator* clbSimulator)
    {
      this->clbSimulator.reset(clbSimulator);
    }
 
 
    /**
     * Generate hits.
     *
     * \param  module         module
     * \param  period         time window [ns]
     * \param  output         background data
     */
    virtual void generateHits(const JModule&    module,
                              const JTimeRange& period,
                              JModuleData&      output) const
    {
      getK40Simulator().generateHits(module, period, output);
    }
 
 
    /**
     * Process hits.
     *
     * \param  ID             PMT identifier
     * \param  calibration    PMT calibration
     * \param  input          PMT signals
     * \param  output         PMT hits
     */
    virtual void processHits(const JPMTIdentifier&       ID,
                             const JCalibration&         calibration,
                             const JPMTData<JPMTSignal>& input,
                             JPMTData<JPMTPulse>&        output) const
    {
      getPMTSimulator().processHits(ID, calibration, input, output);
    }
 
 
    /**
     * Process data.
     *
     * \param  input          PMT data
     * \param  output         CLB data
     */
    virtual void processData(const JCLBInput& input,
                             JDAQFrame&       output) const
    {
      getCLBSimulator().processData(input, output);
    }
 
 
    /**
     * Process module data in one step.
     *
     * \param  module         module
     * \param  input          PMT signals
     * \param  output         CLB data
     */
    virtual void operator()(const JModule& module,
                            JModuleData&   input,
                            JDAQFrame&     output) const
    {
      // PMT simulation
        
      JDETECTOR::reset(buffer, input.size());
  
      for (unsigned int pmt = 0; pmt != input.size(); ++pmt) {
            
        input[pmt].sort();
            
        processHits(JPMTIdentifier(module.getID(), pmt), module.getPMT(pmt), input[pmt], buffer[pmt]);
      }
          
      // CLB simulation
          
      processData(buffer, output);
    }
 
 
  protected:
    JLANG::JSinglePointer<JK40Simulator> k40Simulator;
    JLANG::JSinglePointer<JPMTSimulator> pmtSimulator;
    JLANG::JSinglePointer<JCLBSimulator> clbSimulator;
 
  private:
    mutable JCLBInput buffer;
  };
}
 
#endif