JDetectorSimulator.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JDETECTORSIMULATOR__
#define __JDETECTOR__JDETECTORSIMULATOR__
 
#include <memory>
 
#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 override
    {
      getK40Simulator().generateHits(module, period, output);
    }
 
 
    /**
     * Generate mixed-L1/L0 hits.
     *
     * \param  input          module pair
     * \param  period         time window [ns]
     * \param  output         background data
     */
    virtual void generateHits(const module_pair& input,
                              const JTimeRange&  period,
                              const module_data& output) const override
    {
      getK40Simulator().generateHits(input, period, output);
    }
 
 
    /**
     * Process hits.
     *
     * \param  ID             PMT identifier
     * \param  calibration    PMT calibration
     * \param  status         PMT status
     * \param  input          PMT signals
     * \param  output         PMT hits
     */
    virtual void processHits(const JPMTIdentifier&       ID,
                             const JCalibration&         calibration,
                             const JStatus&              status,
                             const JPMTData<JPMTSignal>& input,
                             JPMTData<JPMTPulse>&        output) const override
    {
      getPMTSimulator().processHits(ID, calibration, status, input, output);
    }
 
 
    /**
     * Process data.
     *
     * \param  id               module identifier
     * \param  input            PMT data
     * \param  output           CLB data
     */
    virtual void processData(const JModuleIdentifier& id, const JCLBInput& input, JDAQSuperFrame& output) const override 
    {
      getCLBSimulator().processData(id, 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,
                            JDAQSuperFrame& output) const
    {
      // PMT simulation
        
      JCLBInput buffer(input.size());
  
      for (unsigned int i = 0; i != input.size(); ++i) {
            
        input[i].sort();
            
        const JPMT& pmt = module.getPMT(i);
 
        processHits(JPMTIdentifier(module.getID(), i), 
                    pmt.getCalibration(), 
                    pmt.getStatus(), 
                    input [i], 
                    buffer[i]);
      }
          
      // CLB simulation
          
      processData(module, buffer, output);
    }
 
 
  protected:
    std::unique_ptr<JK40Simulator> k40Simulator;
    std::unique_ptr<JPMTSimulator> pmtSimulator;
    std::unique_ptr<JCLBSimulator> clbSimulator;
  };
}
 
#endif