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

///! Maximum number of selected events output files
#define GET_SELECT_MAX          16

///! Maximum number of filters to pause analysis
#define GET_FILTER_PAUSE        16

///! Maximum number of histogram families to reset/save at run start/stop
#define GET_RUN_FAMILY_MAX      16

//======================================================================
/*! \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_features Features of the analysis class
 *
 *  <B>Definition of ACTAR TPC analysis structures</B>
 *
 *
 *  <B>Creation of selected events files</B>
 *
 *
 *  <B>Automatic save/reset of histogram family at end/start of run</B>
 *
 *
 *  <B>Channel signal verification</B>
 *
 *
 *  <B>User hook functions for derived classes</B>
 *
 *  - user functions from GEVRunBase
 *  \code

    int UserEventDefine ( );
    int UserRunStart ( );
    int UserEvent ( );
    int UserUpdate ( );
    int UserRefresh ( );
    int UserRunStop ( );
    int UserReset ( );
    int UserQuit ( );
    int UserFit ( );

    \endcode
 *
 *  - user functions from GETSystem
 *  \code

    int   UserRawEvent ( );
    int   UserCorEvent ( );

    int   UserAnyFrame     ( MFMCommonFrame  & frame );
    int   UserMergeFrame   ( MFMMergeFrame   & frame );
    int   UserCoBoFrame    ( MFMCoboFrame    & frame );
    int   UserEbyedatFrame ( MFMEbyedatFrame & frame );

    \endcode
 *
 *
 *  \section get_actar_reader_configuration Configuration of the analysis
 *
 *  The reader/analysis class can be configured with a configuration
 *  file, that can combine configuration directives of the
 *  GETActarTpcAnalyser class and specific directives of the reader.
 *
 *  The commands for the configuration file are detailed in the
 *  GETActarEventReader::ConfigCommand function.
 *
 *  Some commands require that the GETSystem is defined (number of channels,
 *  sampling time and dimension).
 *
 *  The configuration commands at defined and interpreted at different levels,
 *  in the following order:
 *  - in the current object (GETActarEventReader::ConfigCommand)
 *  - in the associated analyser (GETActarTpc::ConfigCommand)
 *  - in the analyser base class (GETSystem::ConfigCommand)
 *  
 *
 */

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

  protected:
  //============================================================
  /** @name Additions to the GUI */
  //@{
    TGNumberEntryField  * w_anal_stat_mfm;  ///<  MFM event number
  //@}

  /** @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

    double      time_ref;       ///< Run reference time (1st event) in sec.
    double      vdrift;         ///< Signal drift velocity: if defined, use Z distance instead of time

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

    int         current_run_num;    ///< Run number of current file
    int         prev_run_num;       ///< Run number of previous file
    bool        run_changed;        ///< Indicate whether a new run has started (from run number)

    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
    TH1       * h_time_raw;       ///< Raw data time summary histogram
    TH1       * h_time_cor;       ///< Corrected data time summary histogram

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

    TH2       * h_dxy;            ///< X-Y histogram for pads with data
    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_d;    ///< Test for XY histograms for pads data 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_out;     ///< Create histograms associated to channels array parameters
    bool        hok_pads;         ///< Indicates that some single pad histograms are defined
    bool      * hok_pad_out;      ///< Create pad histograms associated to channels array parameters
    bool        hok_elec;         ///< Indicates that some single electronics channels histograms are defined
    bool      * hok_elec_out;     ///< Create electronics channels histograms associated to channels array parameters

    bool      * aget_page;        ///< AGet signal pages creation flags
  //@}

  /** @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_time_raw;          ///< Test for channel raw time summary array parameter creation
    bool        pok_time_cor;          ///< Test for channel corrected time summary array parameter creation
    bool        pok_channels;         ///< Indicates that some single channel parameters are defined
    bool      * pok_chan_out;         ///< Test for single channels array parameters creation (output signal)
    //bool      * pok_chan_rec;         ///< Test for single channels array parameters creation (reconstructed signal)

    int         ip_evtnum;            ///< Parameter index for event number
    int         ip_evtacq;            ///< Parameter index for event number in GET acquisition
    int         ip_evttime;           ///< Parameter index for event time (sec.) in GET acquisition
    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_time_raw;          ///< Parameter index for array of time values for raw signals
    int         ip_time_cor;          ///< Parameter index for array of time values for corrected signals

    int         ip_eamp_all;          ///< Parameter index for GET signal sum of channels maximum (all channels)
    int         ip_eamp_thr;          ///< Parameter index for GET signal sum of channels maximum (channels above threshold)
    int         ip_eint_all;          ///< Parameter index for GET signal sum of channels integral (all channels)
    int         ip_eint_thr;          ///< Parameter index for GET signal sum of channels integral (channels above threshold)
    int         ip_mmax_sum;          ///< Parameter index for GET signal sum from multiple maxima analysis

    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_out;          ///< Parameter index for single channels output signal
    int       * ip_chan_rec;          ///< Parameter index for single channels reconstructed signal
    int       * ip_chan_fit;          ///< Parameter index for single channels fitted signal

    // 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      ampl_all_c0;          ///< Calibration parameter for sum of channels maximum
    double      ampl_all_c1;          ///< Calibration parameter for sum of channels maximum
    double      ampl_thr_c0;          ///< Calibration parameter for sum of channels (above threshold) maximum
    double      ampl_thr_c1;          ///< Calibration parameter for sum of channels (above threshold) maximum

    double      eint_all_c0;              ///< Calibration parameter for sum of channels integral
    double      eint_all_c1;              ///< Calibration parameter for sum of channels integral
    double      eint_thr_c0;          ///< Calibration parameter for sum of channels (above threshold) integral
    double      eint_thr_c1;          ///< Calibration parameter for sum of channels (above threshold) integral
  //@}

  //------------------------------------------------------------
  /** @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

  //@}

  //------------------------------------------------------------
  /** @name Selected events output file */
  //@{

    string      selTxtColor;    ///< Highlight for selected events messages
    string      selTxtNorm;     ///< End of highlight for selected events messages

    // the event selection is performed at "update" phase of the analysis
    u_int       selEventNum;                      ///< Number of selected events outputs
    u_int       selEventCount  [GET_SELECT_MAX];  ///< Counts of selected events
    string      selEventDir    [GET_SELECT_MAX];  ///< Names of the directories for selected events output
    string      selEventFname;                    ///< Base file name (set at start of new run)
    FILE      * selEventFilePtr[GET_SELECT_MAX];  ///< File pointers for selected events
    int         selEventFileLun[GET_SELECT_MAX];  ///< Logical units of file for selected events
    u_int       selEventFileSub[GET_SELECT_MAX];  ///< Selected events sub-file number
    u_int       selEventFileCnt[GET_SELECT_MAX];  ///< Number of events in the sub-file
    u_int       selEventFileMax[GET_SELECT_MAX];  ///< Max. number of events in the sub-file
    string      selFilterName  [GET_SELECT_MAX];  ///< Names of the filters for event selection
    Filter    * selFilterPtr   [GET_SELECT_MAX];  ///< Pointer to the filters for event selection

    //string      lastRunFileName;      ///< To check if a new file was open for the same run

    u_int       pauseFilterNum;                     ///< Number of filters that cause the analysis pause
    string      pauseFilterName [GET_FILTER_PAUSE]; ///< Names of the filters
    Filter    * pauseFilterPtr  [GET_FILTER_PAUSE]; ///< Pointer to the filters
    u_int       pauseFilterCount[GET_FILTER_PAUSE]; ///< Names of the filters
    bool        pauseFilterStop [GET_FILTER_PAUSE]; ///< The filter stops event reading (else, only update)

  //------------------------------------------------------------
  /** @name Automatic reset/save histogram families at run start/stop */
  //@{
    u_int       runFamilyNum;                       ///< Number of run families
    string      runFamilyName[GET_RUN_FAMILY_MAX];  ///< Names of run families
    GString     runFamilyFile[GET_RUN_FAMILY_MAX];  ///< File names of run families (empty for no save)
  //@}

  public:

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

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

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

    // overloaded to adapt RunStop call
    virtual void  ResetFileList ( );

    virtual void  Reset     ( );
    virtual void  Quit      ( );

    virtual bool  RunChanged ( ) const;   // inline

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

  //------------------------------------------------------------
  /** @name Graphical user interface modifications */
  //@{
    // function redefined from GEVRunBase    
    virtual void  Construct     ( );
    virtual void  SetColorMode  ( );
    virtual void  UpdateDisplay ( );

    // 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 GETActarTpcAnalyser * DefineAnalyser ( );

    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
    string  GetElecId    ( int i ) const;           // inline
    string  GetElecId    ( int co, int as, int ag, int ch ) const;  // inline

    // preselected channels parameters & histograms
    virtual void  PresetChannelParam  ( const string & def, bool hdef = false );
    virtual void  PresetChannelParam  ( int cobo, int asad,
                                        int aget, int chan,
                                        bool hdef = false );
    virtual void  PresetChannelParam  ( int ich0 = 0, int ich1 = -1,
                                        bool hdef = false );
    virtual void  PresetPadParam      ( const string & def, bool hdef = false );
    virtual void  PresetPadParam      ( int ix0, int ix1, int iy0, int iy1, bool hdef = false );

    virtual int   DefinePadSpectrum     ( int ix, int iy, bool fill = false );
    virtual int   DefineElecSpectrum    ( u_int cobo, u_int asad, u_int aget, u_int chan, bool fill = false );
    virtual int   DefineChannelSpectrum ( int ich, bool fill = false );
    virtual int   DefineChannelSpectrum ( int ich, const string & name, bool fill = false );

    virtual void  PresetAgetPage  ( const string & def );
    virtual void  PresetAgetPage  ( int cobo, int asad, int aget );

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

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

    virtual void  AnalysisEvent ( );

    // incrementation function, reimplemented from GEVRunBase for
    // writting of selected events after user event analysis
    virtual void  IncrementSpectra  ( ) const;
  //@}

  //------------------------------------------------------------
  /** @name Selected events output files */
  //@{
    virtual bool  SetSelectedEventsFilter  ( const string & filter, const string & dir, u_int nmax = 0 );
    virtual int   OpenSelectedEventsFile   ( u_int nf );
    virtual int   CloseSelectedEventsFile  ( u_int nf );
    virtual int   CloseSelectedEventsFiles ( );
    virtual int   WriteSelectedEvent       ( );
  //@}

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

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

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

    // New file open, with or without no run change
    virtual int UserNewFile ( );

    // 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 User hooks function from GETActarTpc class */
  //@{

    // Function called after the raw data analysis of the GET system
    virtual int UserRawEvent ( );

    // Function called after the corrected / reconstructed data analysis of the GET system
    virtual int UserCorEvent ( );

  //@}

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

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

///! Defined to avoid recursive declaration for ROOT dictionary
#ifndef GET_ACTAR_EVENT_READER_LINKDEF_H
  #define GET_ACTAR_EVENT_READER_LINKDEF_H
  #if defined (__MAKECINT__) || defined (__ROOTCLING__)
  #pragma link C++ class GETActarEventReader;
  #endif
#endif

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

/*! This function returns true, at run start, if the run number has changed.
 *  When a new file is open from the same run, it remains to false.
 */
inline bool GETActarEventReader::RunChanged ( ) const
{ return ( run_changed ); }

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

/*! 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) ); }


/*! Function defining a standardized short identifier for an electronics channel.
 *  \param  i     global channel index
 */
inline string GETActarEventReader::GetElecId ( int i ) const
  { int   cobo = LookupTable().GetCoBo(i);
    int   asad = LookupTable().GetAsAd(i);
    int   aget = LookupTable().GetAGet(i);
    int   chan = LookupTable().GetChannel(i);
    return ( GetElecId(cobo,asad,aget,chan) ); }

/*! Function defining a standardized short identifier for an electronics channel.
 *  \param  co    CoBo index
 *  \param  as    AsAd index in CoBo (0-3)
 *  \param  ag    AGET index in AsAd (0-3)
 *  \param  ch    Channel index in AGET (0-67)
 */
inline string GETActarEventReader::GetElecId ( int co, int as, int ag, int ch ) const
  { return ( GetCoBoId(co) 
     + "_" + GetAsAdId(as) 
     + "_" + GetAGetId(ag) 
     + "_" + GetChannelId(ch) ); }

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


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

#endif