GETActarEventReader.hh

Go to the documentation of this file.

//======================================================================
/*! \file GETActarEventReader.hh
 *
 *  Header file for the GETActarEventReader class.
 */
//======================================================================

#ifndef GET_ACTAR_EVENT_READER_HH
#define GET_ACTAR_EVENT_READER_HH

#include "GEVSimulRun.hh"
#include "GETActarTpc.hh"
#include "GETActarTpcAnalyser.hh"

///! default initialization set-up file
#define GET_INIT_SETUP_DEFAULT_FILE   "get_init_setup.dat"

///! default name for events validation condition
#define GET_VALID_TRACK_FILTER_NAME   "F_ValidTrack"

///! default name for page displaying selected pads signal
#define GET_PAD_SIGNAL_PAGE   "TestPadSignal"

#define GET_BAD_DATA_BASELINE   1     ///< Bad event data identifier
#define GET_BAD_DATA_DELTA      2     ///< Bad event data identifier
#define GET_BAD_DATA_READ       4     ///< Bad event data identifier

//======================================================================
/*! \page get_page_actar_reader GETActarEventReader analysis
 *
 *  The GETActarEventReader class defines an effective run analysis class for
 *  the experimental data from ACTAR TPC.
 *
 *  It is based on various classes:
 *  - the GEVRunBase class from the \b Event \b Analysis library, for the
 *    general run analysis scheme;
 *  - the GETActarTpc class from the \b GET library for the ACTAR / GET
 *    data processing.
 *
 *  The class may be derived in a user class in order to include some
 *  specific analysis, otherwise a ready-to-use program is compiled
 *  for a direct use of the GETActarEventReader class: \b GETActarReader.
 *
 *
 *  \section get_actar_reader_class Analysis class
 *
 *  The GETActarEventReader is based on:
 *  - the GEVRunBase class (from the <B>Event Analysis</B> library)
 *    that provides the basic scheme for events reading and
 *    processing, including a graphical user interface for interactive
 *    running and spectra analysis;
 *  - the GETActarTpc class (from GET library) that defines an object
 *    handling the data from the GET electronic;
 *
 *  \section get_actar_reader_configuration Configuration of the analysis
 *
 *
 *
 *  \section get_actar_reader_user_hook User hook functions for derived classes
 *
 *  \par User functions from GEVRunBase class
 *
 *  \par User functions from GETActarTpc class
 *
 */

//======================================================================
/*! \class GETActarEventReader
 *
 *  See \ref get_page_actar_reader.
 *
 */
class GETActarEventReader : public GEVRunBase, public GETActarTpc
{
  //------------------------------------------------------------
  /*! \object_doc */
  GObject(GETActarEventReader);
  //------------------------------------------------------------

  protected:
  //============================================================
  /** @name Variables related to GET system */
  //@{
    bool        get_init;       ///< GET initialization flag
    u_int       get_dim;        ///< GET system channels size
    double      get_dt;         ///< GET system time step
    u_int       get_nx;         ///< ACTAR TPC pads number along X
    u_int       get_ny;         ///< ACTAR TPC pads number along X

    GETActarTpcAnalyser * get_analyser;   ///< Pointer to the analyser object associated to GET system

    string      get_init_default;   ///< Default file for GET system initialization
    string      get_init_cfg;       ///< File for GET system initialization
    string      get_run_cfg;        ///< File for GET system run parameters
    string      get_lookup_table;   ///< File for GET system look-up table
    bool        get_lt_rpad;        ///< Whether the look-up table file contains the pad number
    bool        get_lt_invxy;       ///< Whether the look-up table file has inverted X-Y pads
  //@}

  //------------------------------------------------------------
  /** @name Variables related to histograms created from GET data */
  //@{
    TH2       * h_full_raw;       ///< Full raw data summary histogram
    TH2       * h_full_out;       ///< Full output corrected data summary histogram
    TH1       * h_max_raw;        ///< Raw data max amplitude summary histogram
    TH1       * h_max_cor;        ///< Corrected data max amplitude summary histogram

    TH3       * h_exyt;           ///< X-Y and T pads signal amplitude histogram

    TH2       * h_hxy;            ///< X-Y pads hits histogram
    TH2       * h_txy;            ///< X-Y pads signal time histogram
    TH2       * h_exy;            ///< X-Y pads signal amplitude histogram
    TH2       * h_ext;            ///< X-T pads signal amplitude histogram
    TH2       * h_eyt;            ///< X-T pads signal amplitude histogram

    TH1       * h_ex;             ///< X signal projection histogram
    TH1       * h_ey;             ///< X signal projection histogram
    TH1       * h_et;             ///< X signal projection histogram

    int         tdim_nt;          ///< Number of bins of the time axis for the XY-T 3D histogram
    double      tdim_t0;          ///< Lower value of the time axis for the XY-T 3D histogram
    double      tdim_t1;          ///< Upper value of the time axis for the XY-T 3D histogram

    bool        hok_full_raw;     ///< Test for full raw event histogram creation
    bool        hok_full_out;     ///< Test for full corrected event histogram creation
    bool        hok_pads_xyt_e;   ///< Test for XY+T pads amplitude histograms creation
    bool        hok_pads_xy_h;    ///< Test for XY pads hits histograms creation
    bool        hok_pads_xy_t;    ///< Test for XY pads time histograms creation
    bool        hok_pads_xy_e;    ///< Test for XY pads amplitude histograms creation
    bool        hok_pads_xt_e;    ///< Test for XT pads amplitude histograms creation
    bool        hok_pads_yt_e;    ///< Test for YT pads amplitude histograms creation
    bool        hok_pads_x_e;     ///< Test for X projection histograms creation
    bool        hok_pads_y_e;     ///< Test for Y projection histograms creation
    bool        hok_pads_t_e;     ///< Test for T projection histograms creation
    bool        hok_channels;     ///< Indicates that some single channel histograms are defined
    bool      * hok_chan;         ///< Create histograms associated to channels array parameters
    bool        hok_pads;         ///< Indicates that some single pad histograms are defined
    bool      * hok_pad;          ///< Create pad histograms associated to channels array parameters
  //@}

  /** @name Variables related to parameters created from GET data */
  //@{
    bool        pok_data_read;        ///< Test for data read per channel array parameter creation
    bool        pok_max_raw;          ///< Test for channel raw maximum summary array parameter creation
    bool        pok_max_cor;          ///< Test for channel corrected maximum summary array parameter creation
    bool        pok_channels;         ///< Indicates that some single channel parameters are defined
    bool      * pok_chan;             ///< Test for single channels array parameters creation

    int         ip_evtnum;            ///< Parameter index for event number
    int         ip_max_raw;           ///< Parameter index for array of maximum values for raw signals
    int         ip_max_cor;           ///< Parameter index for array of maximum values for corrected signals
    int         ip_sum_all;           ///< Parameter index for GET signal sum (all channels)
    int         ip_sum_thr;           ///< Parameter index for GET signal sum (channels above threshold)

    int         ip_max_signal;        ///< Parameter index for maximum signal value
    int         ip_max_channel;       ///< Parameter index for channel number maximum signal

    int         ip_read_mult;         ///< Readout channels multiplicity parameter
    int         ip_pads_mult;         ///< Multiplicity of pads above (soft) threshold
    int         ip_saturation_count;  ///< parameter for number of saturated channels
    int         ip_noise;             ///< Parameter for array of channels noise
    int         ip_data_read;         ///< Readout data number per channel parameter
    int         ip_data_chk;          ///< Parameter for data checks
    int         ip_base_chk;          ///< Parameter for baseline fluctuation check
    int         ip_resol_amp;         ///< Parameter for amplitude resolution analysis

    int         ip_xmin;              ///< Parameter index for pads signal boundaries
    int         ip_xmax;              ///< Parameter index for pads signal boundaries
    int         ip_xlen;              ///< Parameter index for pads signal boundaries
    int         ip_ymin;              ///< Parameter index for pads signal boundaries
    int         ip_ymax;              ///< Parameter index for pads signal boundaries
    int         ip_ylen;              ///< Parameter index for pads signal boundaries
    int         ip_tmin;              ///< Parameter index for pads signal boundaries
    int         ip_tmax;              ///< Parameter index for pads signal boundaries
    int         ip_tlen;              ///< Parameter index for pads signal boundaries
    int       * ip_chan;              ///< Parameter index for single channels

    // analysis parameters
    int         read_mult;            ///< Readout channels multiplicity (with FPN)
    int         pads_mult;            ///< Pads multiplicity

    int         bad_events;           ///< Number of bad events in the run

    double      sum_all_a0;           ///< Calibration parameter for GET sum
    double      sum_all_a1;           ///< Calibration parameter for GET sum
    double      sum_thr_a0;           ///< Calibration parameter for GET sum
    double      sum_thr_a1;           ///< Calibration parameter for GET sum
  //@}

  //------------------------------------------------------------
  /** @name Variables related to preselected analysis */
  //@{
    string            pad_signal_page;          ///< Page name for automatic display of pads signal

    GStringList       default_analysis;         ///< Analysis loaded at initialization
  //@}

  public:

  //============================================================
  /** @name Constructor and destructor */
  //@{
    GETActarEventReader ( );
    virtual ~GETActarEventReader ( );
  //@}

  //------------------------------------------------------------
  /** @name Read of event files functions */
  //@{
    virtual int   Open   ( );
    virtual bool        IsOpen ( );
    virtual int         Close  ( );
    virtual int         RunInit   ( );

    virtual int   FileOpen  ( );
    virtual void  FileClose ( );

    virtual void  Reset     ( );

    virtual int   CreateEvent ( );
    virtual int   ReadEvent   ( );
  //@}

  //------------------------------------------------------------
  /** @name Graphical user interface modifications */
  //@{
    // Click in a page
    virtual int  HistoEventSlot ( Int_t event,
                                  const GEVPage * page_ptr,
                                  const GEVPad  * pad_ptr,
                                  const TH1     * histo_ptr,
                                  const Double_t x, const Double_t y );

    virtual int  HistoClickedSlot ( const GEVPage * page_ptr,
                                    const GEVPad  * pad_ptr,
                                    const TH1     * histo_ptr,
                                    const Double_t x, const Double_t y );

    virtual void  PadPlaneButton1Click       ( const TH2 * hpad, int ix, int iy );
    virtual void  PadPlaneButton1DoubleClick ( const TH2 * hpad, int ix, int iy );
    virtual void  PadPlaneButton2Click       ( const TH2 * hpad, int ix, int iy );
    virtual void  PadPlaneButton2DoubleClick ( const TH2 * hpad, int ix, int iy );

  //@}

  //------------------------------------------------------------
  /** @name Analysis configuration function */
  //@{
    virtual int   ProcessCmdLine ( int & argc, char ** argv, bool supp = true );
    virtual void  ProcessLineHelp ( ) const;

    virtual void  SetDefaultAnalysis ( const string & ana );
    virtual void  SetLookupTable ( const string & ltfile );

    virtual void  ReadInitConfig ( );
    virtual void  ReadRunConfig  ( );
    virtual int   ReadConfigFile ( const string & cfg );
    virtual int   ReadConfigFile ( FILE * fp );
    virtual bool  ConfigCommand     ( const GString & code, const GString & args = "", FILE * fptr = NULL );
    virtual bool  ConfigCommandLine ( const string & cmd, FILE * fptr = NULL );

    virtual void  GETInit ( );

    virtual void  SetGETInitConfigFile ( const string & cfg );
    virtual void  SetGETRunConfigFile  ( const string & cfg );
  //@}

  //------------------------------------------------------------
  /** @name Analysis definition */
  //@{
    string  GetCoBoId    ( int i ) const;           // inline
    string  GetAsAdId    ( int i ) const;           // inline
    string  GetAGetId    ( int i ) const;           // inline
    string  GetChannelId ( int i ) const;           // inline
    string  GetIndexId   ( int i ) const;           // inline
    string  GetPadId     ( int ix, int iy ) const;  // inline

    // preselected channels parameters & histograms
    virtual void  DefineChannelParam  ( const string & def, bool hdef = false );
    virtual void  DefineChannelParam  ( int cobo, int asad,
                                        int aget, int chan,
                                        bool hdef = false );
    virtual void  DefinePadParam      ( const string & def, bool hdef = false );
    virtual void  DefinePadParam      ( int ix0, int ix1, int iy0, int iy1, bool hdef = false );

    virtual int   DefinePadSpectrum   ( int ix, int iy, bool fill = false );

    // function defining the preselected spectra and analysis
    virtual void  PresetAnalysis ( );

    // specific analysis start / stop reimplemented from RunBase
    virtual void  AnalysisStart ( );
    virtual void  AnalysisStop  ( );

    virtual void  AnalysisEvent ( );
  //@}

  //------------------------------------------------------------
  /** @name Standard user hooks function */
  //@{

    // Initialization function (user parameters definition,...)
    virtual int UserEventDefine ( );

    // Start of run processing initialization
    virtual int UserRunStart ( );

    // Event processing
    virtual int UserEvent ( );

    // Function called after spectra update
    virtual int UserUpdate ( );

    // Fonction appelée après mise à jour automatique de l'affichage (spécifique GUI)
    virtual int UserRefresh ( );

    // End of run processing
    virtual int UserRunStop ( );

    // Function called at analysis reset (specific GUI)
    virtual int UserReset ( );

    // Function called when quitting interface (specific GUI)
    virtual int UserQuit ( );

    // Function called when a fit is accepted (specific GUI)
    virtual int UserFit ( );

  //@}

  //------------------------------------------------------------
  /** @name ROOT related function */
  //@{
    //  For ROOT encapsulation
    ClassDef(GETActarEventReader,0);
  //@}
};

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

#ifdef __MAKECINT__
#pragma link C++ class GETActarEventReader;
#endif

//======================================================================
//  Inline function

/*! Function defining a standardized short identifier for a CoBo module.
 *  \param  i     CoBo index
 */
inline string GETActarEventReader::GetCoBoId    ( int i ) const
  { char str[16]; sprintf ( str, "C%02d", i ); return ( string(str) ); }

/*! Function defining a standardized short identifier for an AsAd board.
 *  \param  i     Asad index (0-3)
 */
inline string GETActarEventReader::GetAsAdId    ( int i ) const
  { char str[16]; sprintf ( str, "A%01d", i ); return ( string(str) ); }

/*! Function defining a standardized short identifier for an AGet chip.
 *  \param  i     AGet index (0-3)
 */
inline string GETActarEventReader::GetAGetId    ( int i ) const
  { char str[16]; sprintf ( str, "G%01d", i ); return ( string(str) ); }

/*! Function defining a standardized short identifier for an AGet channel.
 *  \param  i     channel index (0-67)
 */
inline string GETActarEventReader::GetChannelId ( int i ) const
  { char str[16]; sprintf ( str, "Ch%02d", i ); return ( string(str) ); }

/*! Function defining a standardized short identifier for a channel of the
 *  whole GET system.
 *  \param  i     channel index
 */
inline string GETActarEventReader::GetIndexId   ( int i ) const
  { char str[16]; sprintf ( str, "%05d", i ); return ( string(str) ); }

/*! Function defining a standardized short identifier for a pad.
 *  \param  ix    pad index along X (0-...)
 *  \param  iy    pad index along Y (0-...)
 */
inline string GETActarEventReader::GetPadId   ( int ix, int iy ) const
  { char str[16]; sprintf ( str, "x%03d_y%03d", ix, iy ); return ( string(str) ); }


//======================================================================

#endif