GETDocProcess.hh

Go to the documentation of this file.

//======================================================================
/*! \file GETDocProcess.hh
 *
 *  Documentation page related to the processes to be applied of
 *  signal.
 */
//======================================================================

//======================================================================
/*! \page get_page_process Signal processing classes
 *
 *  For each channel, the \b input, \b output and \b reconstructed samples
 *  are related by transformation processes:
 *
 *  - the \b correction processes (GETSignalModifier class) that are
 *    essentially for use with experimental data;
 *
 *  - the channel \b response function (GETResponse class) that is used
 *    for the transformation of simulation inputs into GET system
 *    outputs (convolution), of for the reconstruction of the effective
 *    charge deposit from the output data of the channels;
 *
 *  - the reconstruction \b filter (GETFilter class), needed for the
 *    reconstruction of charge deposit, because of the noise that
 *    creates large oscillation at deconvolution stage;
 *
 *  - the simulation input/output \b noise (GETNoise class).
 *
 *  An example can be found in the ROOT macro example for a single channel
 *  with simulated signals.
 *
 *  The signal processing is performed at the channel level (GETChannel
 *  class).
 *  The channel data samples (input, output and reconstructed signals) and
 *  the processes between channels are illustrated in the figure below,
 *  for experimental or simulation data analysis.
 *
 *  \image html GETChannelAnalysis.png
 *
 *
 *  \section get_process_setting Setting processes
 *
 *  The base functions to associate processes to GET objects (at channel level
 *  or for sets of channels from other GET objects) are mainly defined in
 *  the base class GETObject.
 *
 *  The processes can be defined either locally (the process belongs only
 *  to the object and is destroyed with the object), either externally
 *  (the process is created independently of the object, and it is not
 *  deleted when the object is destroyed).
 *
 *  When a process is set to a GET object, it can be recursively set to
 *  the children of the object: from GETSystem to GETCoBo, to GETAsAd,
 *  to GETAGet and to GETChannel.
 *  In such case, the process is created locally or externally for the parent
 *  object, and externally for all children (see also \ref get_process_sharing).
 *
 *
 *  \subsection get_process_sharing Sharing processes for several GET objects
 *
 *  Basically, the processes may only apply to the signal samples defined in
 *  the GETChannel class.
 *  Nevertheless, it may often happen that exactly the same process should
 *  be applied on several or all channels.
 *  It may be the case mostly for filters, but it may also be the case for
 *  the response function and the input/output noise in the case of
 *  simulations.
 *
 *  Then the processes can be associated to any of the GET core objects,
 *  and not only the GETChannel: a process associated to a parent object
 *  can be shared by all the children objects.
 *
 *  This is achieved by the intermediate classes GETProcessLink.
 *  Each GET object contains such an object for each the processes types.
 *  The GETProcessLink class defines a pointer to the process itself, and
 *  it contains the information whether the process is defined
 *  \b locally (the process will be deleted with the object) or
 *  \b externally (the process is managed somewhere else, for example
 *  by a parent object).
 *
 *
 *  \subsection get_process_setting_response Setting response function, filters and noise
 *
 *  For the <B>response function</B>, the \b filter and the \b noises
 *  processes, the GETObject functions to set the processes use:
 *  - a \b pointer argument to set the process as local (if the pointer is
 *    NULL, if a process was previously defined, it is removed);
 *  - a \b reference argument set the process as external.
 *
 * \code
  GETSystem * syst = new GETSystem(...);
  //[...set properties for the system...]

  GETResponse * resp = new GETResponse(...);
  //[...set properties for response function process...]

  // set the response function locally for cobo module #0
  (*syst)[0].SetResponse ( resp );

  // set the response function externally for cobo module #1
  (*syst)[0].SetResponse ( &resp );

  \endcode
 *
 *  The functions are: GETObject::SetResponse, GETObject::SetFilter,
 *  GETObject::SetNoiseIn and GETObject::SetNoiseOut.
 *  The input and output noise processes allow to add perturbations in the
 *  signals resulting from simulations.
 *  In principle, they may not be used for real signal analysis.
 *
 *
 *  \subsection get_process_setting_correction Setting output signal corrections
 *
 *  The correction processes may be slightly more complicated since they
 *  may be combined into many possible ways, especially when dealing with
 *  real experimental data.
 *  For example, baseline corrections, calibrations, or other processes
 *  may be used together, in various order.
 *
 *  Then, in addition to the GETObject::SetOutputCorrection functions
 *  that set a single output correction process, a special process
 *  is defined as a list of processes: the GETProcessSerie.
 *  Such a process can also be used for other types of processes (response
 *  function, filter or noise), but the GETObject does not provide
 *  functions to manage it automatically, and the processes from the
 *  serie have to be set manually for children objects (down to channels
 *  level).
 *
 *  In order to manage the series of output processes, the following functions
 *  are defined:
 *  - GETObject::SetOutputCorrectionList to define the output correstions
 *    as a serie;
 *  - GETObject::AddOutputCorrection to set a new output correction in the
 *    serie.
 *
 *  
 *  \section get_process_processes Processes types
 *
 *
 *  \subsection get_process_response Response function processes: the GETResponse class
 *
 *
 *  \subsection get_process_filter Filter processes: the GETFilter class
 *
 *
 *  \subsection get_process_correction Signal correction processes
 *
 *
 *
 */
//======================================================================