RGFitBase2D.hh

Go to the documentation of this file.

//======================================================================
/*! \file RGFitBase2D.hh
 *
 *  Include file for class RGFitBase2D
 */
//======================================================================

#ifndef RG_FIT_BASE_2D_HH
#define RG_FIT_BASE_2D_HH

#include "RFitBase2D.hh"
#include "RGFitDisplayer2D.hh"
#include "RGHistoWindow.hh"

#include <TLine.h>
#include <TMarker.h>

#include <TSystem.h>
#include <TPad.h>
#include <TCanvas.h>
#include <TPolyLine.h>
#include <TGFrame.h>
#include <TGCanvas.h>
#include <TGButton.h>
#include <TGLabel.h>
#include <TGNumberEntry.h>
#include <TGComboBox.h>
#include <TRootEmbeddedCanvas.h>
#include <TGDoubleSlider.h>
#include <TGSplitter.h>

#include <TColor.h>
#include <TGFileDialog.h>
#include <TFile.h>

// include pour les types de points de saisie.
#include "RGFitBase1D.hh"

//======================================================================
/*! \class RGFitBase2D
 *
 *  Base graphical user interface class for 2D histogram fits.
 *
 *  The interface is started with the Request() function.
 *  This is not done automatically, in order to preset parameters
 *  and options for the fit.
 *
 *  In the same manner, when the interface is closed, the instance is
 *  not destroyed, so that fit results can still be accessible.
 *  If it is allocated dynamically (with new), it must be deleted by
 *  the calling program.
 *
 *  When the interface is closed, a returned value can be accessed with
 *  the GetReturnValue() function.
 *  This value is:
 *  - -1 if interface was not started;
 *  - 0 if it was closed with button to accept result (done);
 *  - 1 if it was closed with button to reject result (cancel).
 */
class RGFitBase2D : virtual public RFitBase2D,
                    public RGHistoWindow
{
  //------------------------------------------------------------
  /*! \object_doc{RGFitBase2D} */
  GObjectV(RGFitBase2D);
  //------------------------------------------------------------

  friend class RGFitDisplayer2D;

  public:

    static  TAttLine    limit_line_att;     ///< Fit limits display attributes de fit
    static  TAttLine    select_line_att;    ///< Selected line attributes
    static  TAttMarker  limit_marker_att;   ///< Fit limits markers attributes
    static  TAttMarker  select_marker_att;  ///< Selected marker attributes

    static  UInt_t      canvas_width;       ///< Embedded canvas default width
    static  UInt_t      canvas_height;      ///< Embedded canvas default height

  protected:

    static  string      file_dir;           ///< Output directory name
    static  string      file_root_file;     ///< Output ROOT file
    static  string      file_param_file;    ///< Output parameter file
    static  string      file_output_file;   ///< Output result file

    // variables pour l'interface
    bool              exit_flag;            ///< End of request check
    bool              constructed;          ///< Check if interface is constructed
    Int_t             return_value;         ///< Interface return value

    const TGWindow  * main_window;          ///< Parent application main window

    Double_t          init_x1;              ///< Initial display lower limit
    Double_t          init_x2;              ///< Initial display upper limit
    Double_t          init_y1;              ///< Initial display lower limit
    Double_t          init_y2;              ///< Initial display upper limit

    // variable pour sélection des points
    Double_t          select_distance;      ///< Point selection distance (in pixel)
    Int_t             select_point;         ///< Point at selection distance (-1 if no point)
    bool              move_lock;            ///< Used to check if point is moving

    // variable pour saisie des points
    Int_t             np_max;               ///< Maximum number of preset points
  #ifndef __MAKECINT__
    bool            * pt_set;               ///< Array of points defined
    bool            * pt_pre;               ///< Array of preset points
    double          * pt_x;                 ///< Array of points X positions
    double          * pt_y;                 ///< Array of points Y positions
  #endif
    TList             obj_list;             ///< List of objects to drawList of objects to draw

    TH2             * h_fct;                ///<Fit function histogram pointer
    TH2             * h_diff;               ///<Difference histogram pointer
    TH2             * h_err_pos;            ///<Function positive error (square root) histogram
    TH2             * h_err_neg;            ///<Function negative error (square root) histogram

  // Widgets spécifiques

    /*! Variable used to avoid recursive loops in the widgets slots for
     *  parameters values (in ROOT version 5.12, it is not possible to
     *  set values without emission of the signal for TGNumberEntryList).*/
    bool                  inhibit_value_slot;

    TGGroupFrame        * w_fit_limits_frame;     ///<  Fit zone frame
    TGHorizontalFrame   *  w_fit_limit;           ///<   Fit limits line
    TGNumberEntry       *   w_fit_xinf_value;     ///<     Lower limit value
    TGNumberEntry       *   w_fit_yinf_value;     ///<     Lower limit value
    TGNumberEntry       *   w_fit_xsup_value;     ///<     Upper limit value
    TGNumberEntry       *   w_fit_ysup_value;     ///<     Upper limit value
    TGTextButton        *   w_fit_limit_set;      ///<     Limits validation button
    TGTextButton        *   w_fit_limit_disp;     ///<     Button to set fit limits to display

    TGHorizontalFrame   *  w_buttons_frame;       ///<  Buttons frame
    TGGroupFrame        *   w_fit_but_group;      ///<   Group for fit buttons
    TGComboBox          *    w_fit_mode_select;   ///<    Fit mode selection
    TGTextButton        *    w_preset_button;     ///<    Full precalculation button
    TGTextButton        *    w_fit_button;        ///<    Fit button
    TGTextButton        *    w_set_fit_button;    ///<    Precalculation and fit button
    TGGroupFrame        *   w_param_but_group;    ///<   Group for parameters buttons
    TGTextButton        *    w_view_button;       ///<    Result display button
    TGTextButton        *    w_save_button;       ///<    Fit data save button
    TGTextButton        *    w_param_button;      ///<    Parameters save button
    TGTextButton        *    w_update_button;     ///<    Interface update button
    TGGroupFrame        *   w_funct_but_group;    ///<   Group for functions buttons
    TGTextButton        *    w_clear_button;      ///<    Clear fit histograms button
    TGTextButton        *    w_funct_button;      ///<    Save functions button
    TGTextButton        *    w_draw_button;       ///<    Plot fit histograms button
    TGTextButton        *    w_display_button;    ///<    Separated display button
    TGVerticalFrame     *   w_global_but_frame;   ///<   Frame for general buttons
    TGTextButton        *    w_reset_button;      ///<    Reset interface button
    TGTextButton        *    w_load_button;       ///<    Fit data read button
    TGTextButton        *    w_cancel_button;     ///<    Cancel button (close interface)
    TGTextButton        *    w_done_button;       ///<    Done button (close interface)

  //----------------------------------------------------------
  public:
    // Constructeurs
    RGFitBase2D ( const TGWindow * parent, TH2 *hptr, TH2 * herr = NULL );
    RGFitBase2D ( const TGWindow * parent, TH2 *hptr, const Double_t x1, const Double_t x2,
                                                      const Double_t y1, const Double_t y2 );
    RGFitBase2D ( const TGWindow * parent, TH2 *hptr, TH2 * herr, const Double_t x1, const Double_t x2,
                                                                  const Double_t y1, const Double_t y2 );

  protected:
    RGFitBase2D ( const RGFitBase2D & original );

  public:
    // Destructeur
    virtual ~RGFitBase2D ( );

  protected:
    void    ClassInit ( );

  public:
    //----------------------------------------------------------
    // gestion de l'interface
    virtual void    Init             ( );
    virtual void    Construct        ( );
    virtual void    ConstructLimits  ( );
    virtual void    ConstructFitData ( );
    virtual void    ConstructActions ( );

    /*! Fonction qui démarre l'interface graphique (voir classe dérivée).*/
    virtual void    Request   ( ) = 0;
    virtual void    Quit      ( );

    virtual Int_t   GetReturnValue ( );
    virtual TH1   * GetHistoPtr    ( ) const;

    virtual void    Redraw       ( );
    virtual void    DrawPadHisto ( const char *opts = "COL", const Double_t zinf = 0., const Double_t zsup = 0.);

  //----------------------------------------------------------
  //  Surchage des fonctions de la classe RFitBase2D
  //  (pour associer la mise à jour de l'interface graphique)
    virtual void  SetPlotLimits ( const Double_t x1, const Double_t x2, const Double_t y1, const Double_t y );
    virtual void  SetFitLimits  ( const Double_t x1, const Double_t x2, const Double_t y1, const Double_t y2 );
    virtual void  SetFitMode    ( const Int_t mode );

    /*! Creation d'une structure de données relatives au fit (voir classes dérivées).*/
    virtual RFitData2D  * CreateFitData ( ) = 0;
    virtual RFitData2D  * GetFitData    ( );
    virtual void          SetFitData    ( const RFitData2D * fit_data );

    virtual void  GetDisplayMinMax ( Double_t & min, Double_t & max ) const;
    virtual void  AutoScale        ( ) const;

    virtual void  ResetFunctions ( );
    virtual void  CalcFunctions  ( const bool bg = false );
    virtual bool  SaveFunctions  ( const string &fname = "" ) const;

  //----------------------------------------------------------
  //  Fonctions liées à la saisie des points

  protected:
    virtual void  AnyEvent  ( const Double_t x, const Double_t y );

    // Renvoit le point le plus proche (distance en pixels)
    virtual Int_t SelectedPoint ( const Double_t x, const Double_t y );
    virtual Int_t GetPointType  ( const Int_t p );

    // Retrace les points saisis
    virtual void  RedrawPoints ( );

    // bouton 1 pour créer ou déplacer un point
    virtual void  MouseButton1Down  ( const Double_t x, const Double_t y );
    virtual void  MouseButton1Up    ( const Double_t x, const Double_t y );

    // bouton 2 pour supprimer un point
    virtual void  MouseButton2Down  ( const Double_t x, const Double_t y );
    virtual void  MouseButton2Up    ( const Double_t x, const Double_t y );

    virtual void  AddPoint    ( const Double_t x, const Double_t y, const bool select = true );
    virtual void  MovePoint   ( const Int_t p, const Double_t x, const Double_t y );
    virtual void  DeletePoint ( const Int_t p );

    virtual void  PointMoved      ( const Int_t p );
    virtual void  PointSelected   ( const Int_t p );
    virtual void  PointUnselected ( const Int_t p );

  //----------------------------------------------------------
  //  Fonctions de mise à jour de l'interface
  //  en principe, elles devraient être surchargées par les classes dérivées

    // remise à jour de l'interface lorsque les paramètres de fit ont
    // été perdus (appel à InitMode())
    virtual void  ParamUpdateAll ( );


    // points de saisie -> paramètres de fit (classe de base)
    virtual void  PointsToParam       ( );
    virtual void  PointsToParamLimits ( );

    // points de saisie -> valeurs widgets
    virtual void  PointsToWidget       ( );
    virtual void  PointsToWidgetLimits ( );


    // valeurs widgets -> paramètres de fit (classe de base)
    virtual void  WidgetsToParam        ( );
    virtual void  WidgetsToParamLimits  ( );
    virtual void  WidgetsToParamFitMode ( );

    // valeurs widgets -> points de saisie
    virtual void  WidgetsToPoint       ( );
    virtual void  WidgetsToPointLimits ( );


    // paramètres de fit (classe de base) -> valeurs des widgets
    virtual void  ParamToWidget        ( );
    virtual void  ParamToWidgetLimits  ( );
    virtual void  ParamToWidgetFitMode ( );

    // paramètres de fit (classe de base) -> points de saisie
    virtual void  ParamToPoint       ( );
    virtual void  ParamToPointLimits ( );


  //----------------------------------------------------------
  // affichage des widgets
    virtual void  GuiUpdateOptions ( );
    virtual void  GuiUpdateDisplay  ( );

  //----------------------------------------------------------
  //  Fonctions globales de fit
    virtual void  GuiPreset ( );
    virtual void  GuiFit    ( );

    virtual void  GuiTextView     ( );
    virtual void  GuiSaveFitData  ( );
    virtual void  GuiUpdate       ( );
    virtual void  GuiWriteParam   ( );

    virtual void  GuiWriteFct     ( );
    virtual void  GuiDrawFct      ( );
    virtual void  GuiDisplayFct   ( );

    virtual void  GuiReset        ( );
    virtual void  GuiLoadFitData  ( );

  //----------------------------------------------------------
  //  SLOTS

  public:
    virtual void  FitModeSelected ( Int_t m );

    virtual void  PresetButton    ( );
    virtual void  FitButton       ( );
    virtual void  PresetFitButton ( );

    virtual void  ViewButton    ( );
    virtual void  SaveButton    ( );
    virtual void  ParamButton   ( );
    virtual void  UpdateButton  ( );

    virtual void  FunctButton   ( );
    virtual void  DrawButton    ( );
    virtual void  DisplayButton ( );
    virtual void  ClearButton   ( );

    virtual void  ResetButton   ( );
    virtual void  LoadButton    ( );
    virtual void  CancelButton  ( );
    virtual void  DoneButton    ( );

    virtual void  FitXInfLimitChanged     ( Long_t n );
    virtual void  FitXInfLimitTextChanged ( const char * str );
    virtual void  FitYInfLimitChanged     ( Long_t n );
    virtual void  FitYInfLimitTextChanged ( const char * str );
    virtual void  FitXSupLimitChanged     ( Long_t n );
    virtual void  FitXSupLimitTextChanged ( const char * str );
    virtual void  FitYSupLimitChanged     ( Long_t n );
    virtual void  FitYSupLimitTextChanged ( const char * str );
    virtual void  FitLimitsSet            ( );
    virtual void  FitLimitsToDisplay      ( );

  //------------------------------------------------------------
  /*! For ROOT dictionary.*/
  public:
    ClassDef(RGFitBase2D,0);
};

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

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