GETChannel.hh

Go to the documentation of this file.

//======================================================================
/*! \file GETChannel.hh
 *
 *  Include file for the GETChannel class.
 */
//======================================================================

#ifndef GET_CHANNEL_HH
#define GET_CHANNEL_HH

//----------------------------------------------------------------------

#include "GETCommon.hh"
#include "GETObject.hh"
#include "GETCfgTools.hh"
#include "GETCfgChannel.hh"
class GETAGet;

//======================================================================
/*! \class GETChannel
 *
 *  This class defines the mechanism for a single channel processing.
 *  It can be used in 2 ways:
 *  - to analyse some "real" data: the data coming from the electronics
 *    is set in the output sample, and processed to estimate the input
 *    signal (deconvolution of the response function);
 *    in this case, an additionnal output noise can be defined
 *    (the input noise has to be set directly in the input test
 *    sample).
 *  - to simulate some data, setting an input signal that is transformed
 *    using the response function before being processed.
 *
 *  The GETChannel defines 3 signal samples objects:
 *  - the \b test sample: \b input signal (from simulations);
 *  - the \b output sample: the result from simulation input processing
 *    (with optional output noise) or the result from  a real measurement;
 *  - the \b reconstructed sample, from inverse processing of the
 *    output, with optional signal filtering.
 *
 */
class GETChannel : public GETObject
{
  //------------------------------------------------------------
  /*! \object_doc */
  GObject(GETChannel);
  //------------------------------------------------------------

  friend class GETSystem;
  friend class GETAGet;
  friend class GETCfgChannel;

  protected:

    // GET configuration
    GETCfgChannel * config;         ///< Configuration data

    // Channel data
    int             sig_id;         ///< Signal channel identifier (0-63 for signal, 64-67 for FPN)
    u_short         data_mode;      ///< Whether data comes from an experimental file or from simulation

    // input/output signals
    GETSample       signal_tst;     ///< Test (input) signal (for simulation)
    GETSample       signal_out;     ///< Output signal from AGET
    GETSample       signal_rec;     ///< Reconstructed signal (filtering and deconvolution)

    bool            read_ok[GET_MAX_DEPTH];   ///< Flag for read data
    u_int           read_count;     ///< Number of data read for the channel (from exp. raw data)
    u_int           satur_count;    ///< Number of data over saturation threshold
    int             satur_low;      ///< Lower saturated time bucket
    int             satur_high;     ///< Higher saturated time bucket

  public:
  //----------------------------------------------------------
  /** @name Constructors, affectation, destructor */
  //@{
    GETChannel ( u_int n = 0, double dt = 0.01L );
    virtual ~GETChannel ( );
  //@}

  //----------------------------------------------------------
  /** @name GET configuration */
  //@{
    virtual int           ResetConfig ( );

    const GETCfgChannel * GetConfig ( ) const;    // inline
          GETCfgChannel * GetConfig ( );          // inline

    bool  IsFPNChannel    ( ) const;
    bool  IsSignalChannel ( ) const;      // inline
  //@}

  //----------------------------------------------------------
  /** @name Initialization functions */
  //@{
    virtual void  Reset ( );
    virtual void  Init ( u_int n, double dt );
    virtual void  SetTimeStep  ( double dt );
    virtual void  ResetReadCount ( );       // inline
    virtual void  ClearEvent     ( );

    virtual void  ValidDataSet  ( );
    virtual void  ValidSimulSet ( );
    bool          IsModeData    ( ) const;  // inline
    bool          IsModeSimul   ( ) const;  // inline
  //@}

  //----------------------------------------------------------
  /** @name GET system core objects functions */
  //@{
    int             GetSignalId     ( ) const;              // inline
    virtual string  GetObjectId     ( ) const;              // inline
    virtual u_int   GetChannelCount ( ) const;              // inline

    virtual u_int   GetChildrenNumber ( ) const;            // inline
    virtual const   GETObject * GetChild ( u_int i ) const; // inline
    virtual         GETObject * GetChild ( u_int i );       // inline

    u_short         GetLastCell ( ) const;

    virtual void    IncrSaturationCount ( u_int incr = 1 ); // inline
    virtual void    SetSaturation       ( u_int buckid );
    u_int           GetSaturationCount  ( ) const;          // inline
    int             GetSaturationLow    ( ) const;          // inline
    int             GetSaturationHigh   ( ) const;          // inline
    virtual void    UpdateSaturations   ( u_int sat );

    virtual u_int   GetReadoutMultiplicity ( bool fpn = true ) const;
    virtual double  GetSignalSum ( u_short info = GET::signalOut );
  //@}

  //----------------------------------------------------------
  /** @name Channel samples (Test, Output, Reconstructed) function */
  //@{
    virtual void  IncrReadoutCount ( u_int incr = 1); // inline
    u_int         GetReadoutCount  ( ) const;         // inline

    bool          IsReadOk  ( u_short i ) const;          // inline
    void          SetReadOk ( u_short i, bool b = true ); // inline

    GETSample   & TstSample ( );      // inline
    GETSample   & OutSample ( );      // inline
    GETSample   & RecSample ( );      // inline

    virtual int   ProcessData       ( bool in_noise = true );
    virtual int   ProcessOutFromTst ( bool in_noise = true, bool out_noise = true );
    virtual int   ProcessRecFromOut ( bool out_corr = true );

    virtual int   ProcessOutputCorrection ( );

    virtual int   ApplyOutputNoise      ( GETSample & out_sample );
    virtual int   ApplyOutputCorrection ( GETSample & cor_sample );
  //@}


  //------------------------------------------------------------
  /** @name Read / write of custom objects scheme */
  //@{

  //@}


  //----------------------------------------------------------
  /** @name ROOT related functions */
  //@{
  public:

    /*! for use within ROOT.*/
    ClassDef(GETChannel,0);
  //@}
};


//----------------------------------------------------------------------
//  Inline functions
#include "icc/GETChannel.icc"


//======================================================================
#endif