GETProcess.hh

Go to the documentation of this file.

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

#ifndef GET_PROCESS_HH
#define GET_PROCESS_HH

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

#include "GETCommon.hh"
class GETChannel;
class GETObject;

//======================================================================
/*! \class GETProcess
 *
 *  This is a base class for samples processing objects: response functions,
 *  filters, noise generators...
 *
 *  The objects deriving from this base class are processes that acts
 *  on the data from a single channel.
 *
 *  Because each process defines (at least) one internal data sample
 *  with the dimension of the channels signal to process, the base
 *  constructors require the dimension and sampling period of the
 *  GET channels.
 *
 */
class GETProcess
{
  //------------------------------------------------------------
  /*! \object_doc */
  GObjectV(GETProcess);
  //------------------------------------------------------------

  protected:
    GETSample     result_sample;    ///< Internal processing result sample (processing result)

    u_int         options;          ///< Option flags

  public:
  //----------------------------------------------------------
  /** @name Constructors, affectation, destructor */
  //@{
    GETProcess ( GETObject & obj );
    GETProcess ( u_int n = 0, double dt = 0.01 );
    GETProcess ( const GETProcess & proc );
    virtual ~GETProcess ( );
  //@}

  //----------------------------------------------------------
  /** @name Initialization functions */
  //@{
    virtual void  SetOptions ( u_int opts );                  // inline
    virtual void  SetOption  ( u_int flags, bool b = true );  // inline
    virtual u_int GetOptions ( );                             // inline
    virtual bool  GetOption  ( u_int flags );                 // inline

    virtual void  Init ( u_int n, double dt );  // inline
  //@}

  //----------------------------------------------------------
  /** @name Access to class data */
  //@{
    u_int   GetDimension    ( ) const;    // inline
    double  GetSamplingTime ( ) const;    // inline

          GETSample * GetResultSamplePtr ( );        // inline
    const GETSample * GetResultSamplePtr ( ) const;  // inline
          GETSample & GetResultSample    ( );        // inline
    const GETSample & GetResultSample    ( ) const;  // inline
  //@}


  //----------------------------------------------------------
  /** @name Processing */
  //@{

    /*! This function process the argument channel and stores the result
     *  in the internal sample.
     *  The channel sample that is processed depends on the type of
     *  processing, and of the \b info argument if required.
     *  The function returns the internal result sample pointer.
     *  In case of error, the result is a NULL pointer.
     *
     *  \note
     *  The channel samples are not modified, the result is stored in the
     *  process internal sample.
     *
     *  \param  channel   GET system channel to be processed
     *  \param  info      additional optional information (sample signal identifier)
     */
    virtual GETSample * ProcessSample ( GETChannel & channel,
                                        u_short      info ) = 0;

    /*! This function process the input \b sample channel and stores the result
     *  in the \b result sample.
     *  The channel argument is provided if processing (from derived classes)
     *  may be affected by GET core objects properties.
     *  The function returns the (argument) result sample pointer.
     *  In case of error, the result is a NULL pointer.
     *
     *  Note that the \b sample to be processed and the \b result sample
     *  can be the same object, in which case the initial sample is replaced
     *  by the processing result.
     *
     *  \note
     *  - The \b sample to be processed and the \b result sample
     *    can be the same object, in which case the initial sample is replaced
     *    by the processing result.
     *
     *  \param  sample    input sample to be processed
     *  \param  result    sample where result should be stored
     *  \param  channel   GET system channel (the samples should correspond to this channel)
     */
    virtual GETSample * ProcessSample ( GETSample  & sample,
                                        GETSample  & result,
                                        GETChannel & channel ) = 0;
  //@}


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

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


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


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