Analysis8.0/html/GanilRun_8hh_source.html

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

 /*! \file GanilRun.hh

  *

  *  D�claration des m�thodes de la classe GanilRun qui g�re l'analyse

  *  des runs de l'acquisition GANIL.

  */

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


 #ifndef GANIL_RUN_HH

 #define GANIL_RUN_HH


 #include "GanilInfo.hh"

 #include "GanilBuffer.hh"

 #include "GanilScaler.hh"

 #include "GanilGlobal.hh"


 #include "RunBase.hh"


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

 /*! \class GanilRun

  *

  *  C'est la classe principale pour l'analyse des runs de l'acquisition

  *  GANIL.

  *  Elle d�rive des classes suivantes:

  *    - GanilInfo, qui fournit les informations des buffers d'ent�te

  *    - RunBase, classe de base des analyses

  *

  *  C'est une classe abstraite: elle doit �tre d�riv�e.

  *  Les fonctions utilisateur sont celles d�finies dans la classe de base

  *  RunBase.

  *

  *  Deux nouvelles fonctions utilisateurs sont d�finies.

  *  - la fonction UserBuffer, qui est appel�e � la lecture de chaque

  *    buffer de donn�es.

  *  - la fonction UserScaler, qui est appel�e lorsqu'un buffer d'�chelles

  *    a �t� lu.

  */


 class GanilRun : virtual public RunBase, public GanilInfo

 {

   friend  class GanilBuffer;


   /// Format des donn�es binaires

   enum GanilFormat

   {

     fmtMSB = 0,

     fmtLSB = 1

   };


   /// Bits d'�tat des runs GANIL

   enum GanilStatus

   {

     statusFileh         = 0x00010000, // Bit d'�tat indiquant la lecture de buffers FILEH

     statusEventh        = 0x00020000, // Bit d'�tat indiquant la lecture de buffers EVENTH

     statusComment       = 0x00040000, // Bit d'�tat indiquant la lecture de buffers COMMENT

     statusParam         = 0x00080000, // Bit d'�tat indiquant la lecture de buffers PARAM

     statusEndrun        = 0x00100000, // Bit d'�tat indiquant la lecture de buffers ENDRUN


     statusHeader        = 0x000F0000, // Masque sur les bits d'�tat des buffers d'ent�te


     statusEventCreated  = 0x00200000, // Bit d'�tat indiquant la structure d'�v�nement brut est cr��e

     statusEndOfFile     = 0x00400000  // Bit d'�tat indiquant la fin de fichier

   };


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

   /*! \object_doc */

   GObject(GanilRun);

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


   protected:

     u_int         status;       ///< bits d'�tat de l'analyse

     u_int         format;       ///< format binaire


     // options

     bool          opt_warn_empty_buffer;    ///< alerte en cas de buffer vide


 #ifndef __MAKECINT__

     FILE        * file_ptr;     ///< pointeur sur le fichier de runs

 #endif


     GanilBuffer   buffer_data;          ///< donn�es du buffer courant de fichier

     u_int         buffer_count;         ///< compteur des buffers

     u_int         total_buffer_count;   ///< compteur des buffers


     GanilScaler   scaler_data;          ///< information des buffers d'�chelles


   public:

     // constructeur par d�faut

     GanilRun ( );


     // destructeur

     virtual  ~GanilRun ( );


   protected:

     // constructeur de recopie

     GanilRun ( const GanilRun &original );


   public:


     // fonctions abstraites de la classe de base

     virtual int   Open      ( );

     virtual int   Open      ( const string &f_name );

     virtual int   Open      ( const u_int f_num );

     virtual bool  IsOpen    ( );

     virtual int   Close     ( );


     virtual int   RunInit   ( );

     virtual int   ReadEvent ( );


     // surcharge des autres fonctions

     virtual void  Reset       ( );

     virtual void  BufferReset ( );

     virtual int   ReadHeaders ( );

     virtual int   ReadBuffer  ( );


   protected:

     virtual int   FileOpen    ( );

     virtual void  FileClose   ( );


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

   public:


     void  SetOptionWarnEmptyBuffer ( const bool b = true );


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

     // dump de l'�v�nement (param�tres GANIL) sur la sortie standard.

     void  DumpGanilEvent ( const bool all = false ) const;


     // dump de l'�v�nements (param�tres GANIL) dans un fichier

     void  DumpGanilEvent ( const string &file_name, const bool all = false ) const;


     // dump de l'�v�nements (param�tres GANIL) dans un flux de sortie

     void  DumpGanilEvent ( ostream &os, const bool all = false ) const;


     // dump de l'�v�nement (param�tres GANIL) sur la sortie standard.

     void  DumpUserEvent ( const bool all = false ) const;


     // dump de l'�v�nements (param�tres GANIL) dans un fichier

     void  DumpUserEvent ( const string &file_name, const bool all = false ) const;


     // dump de l'�v�nements (param�tres GANIL) dans un flux de sortie

     void  DumpUserEvent ( ostream &os, const bool all = false ) const;


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

     virtual   void  EndrunInfo  ( ostream & );


     // sortie des statistiques du run

     virtual   void  StatInfo ( ) const;

     virtual   void  StatInfo ( ostream & ) const;


     u_int     GetScalerNumber    ( ) const;

     u_int     GetScalerAcqStatus ( ) const;

     u_int     GetScalerLabel     ( const u_int n ) const;

     u_int     GetScalerValue     ( const u_int n ) const;

     u_int     GetScalerFreq      ( const u_int n ) const;

     u_int     GetScalerTics      ( const u_int n ) const;

     int       GetScalerStatus    ( const u_int n ) const;


     // Retourne infos de run GANIL

     u_int   GetRunNumber   ( ) const;

     u_int   GetEventNumber ( ) const;   // nombre d'�v�nements total dans le run


     // Retourne le nombre de buffers lus.

     u_int   GetBufferCount      ( ) const;

     u_int   GetTotalBufferCount ( ) const;


     // Retourne le nombre de buffers d'un type donn�.    u_int   GetBufferStat ( const u_int t ) const;

    // Retourne le nombre de param�tres GANIL/user de l'�v�nement.
    u_int   GetGanilParamNumber ( ) const;
    u_int   GetUserParamNumber  ( ) const;

    bool    SetGanilParamMultihit ( const string &par_name );
    bool    SetGanilParamMultihit ( const u_int   par_num  );

    bool    SetGanilParamArray    ( const string &par_name, const int dim );
    bool    SetGanilParamArray    ( const u_int   par_num,  const int dim  );

    // teste la fin de run
    bool  EndOfRun ( ) const;

    // test du format binaire
    bool  IsLSB ( ) const;
    bool  IsMSB ( ) const;

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

    // ajout d'un param�tre utilisateur (surcharge de EventManager)
    int   AddParam ( const Param &par );

    // mise � valeur un param�tre (user) de l'�v�nement.
    template < class T > const Data  &  SetParam( const u_int num, const T &val );
    template < class T > const Data  &  SetParam( const string &par_name, const T &val );

    // mise � valeur un param�tre multiple (user) de l'�v�nement.
    template < class T > const Data  &  SetParam( const u_int num, const u_int index, const T &val );
    template < class T > const Data  &  SetParam( const string &par_name, const u_int index, const T &val );

//----------------------------------------------------------------------
//  M�thodes prot�g�es

  protected:

    // cr�ation de la structure d'�v�nement
    virtual int   CreateEvent ( );

//----------------------------------------------------------------------
//  Fonctions utilisateur suppl�mentaires
//----------------------------------------------------------------------

    /*  Fonction utilisateur appel�e chaque fois qu'un buffer.
     *  est lu.
     *  (elle est appel�e dans GanilDevice::ReadBuffer)
     */
    virtual int UserBuffer ( );

    /*  Fonction utilisateur de traitement des buffers d'�chelle.
     *  (elle est appel�e dans GanilDevice::ReadEvent)
     */
    virtual int UserScaler ( );


//----------------------------------------------------------------------
//  pour ROOT...
  public:
    /*! D�finition � usage de ROOT... */
    ClassDef(GanilRun,0);
};


//======================================================================
//  METHODES INLINE
//======================================================================

/*! D�finit l'option d'affichage des alertes en cas de buffers d'�v�nements
 *  vides.
 *  \param  b   �tat de l'otion
 */
inline void GanilRun::SetOptionWarnEmptyBuffer ( const bool b )
  { opt_warn_empty_buffer = b; }

/*! Surcharge de la fonction de la classe RunBase.
 *  La fonction ne fait qu'appeler celle de RunBase.
 *  \param  f_name   nom du fichier
 */
inline int GanilRun::Open ( const string &f_name )
  { return (RunBase::Open (f_name)); }

/*! Surcharge de la fonction de la classe RunBase.
 *  La fonction ne fait qu'appeler celle de RunBase.
 *  \param  f_num   num�ro du fichier
 */
inline int GanilRun::Open ( const u_int f_num )
  { return (RunBase::Open (f_num)); }

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

/*! Retourne le num�ro de run en cours.
 */
inline u_int GanilRun::GetRunNumber () const
  { return (GanilEventInfo::run_number); }

/*! Retourne le nombre d'�v�nement lus (en fin de run).
 */
inline u_int GanilRun::GetEventNumber () const
  { return (event_number); }

/*! Retourne le nombre de buffers lus dans le fichier en cours.
 */
inline u_int GanilRun::GetBufferCount () const
  { return (buffer_count); }

/*! Retourne le nombre total de buffers lus.
 */
inline u_int GanilRun::GetTotalBufferCount () const
  { return (total_buffer_count); }

/*! Retourne le nombre de buffers d'un type donn�.
 *  \param  t   type de buffers
 */
inline u_int GanilRun::GetBufferStat ( const u_int t ) const
  { return (buffer_data.GetBufferStat(t)); }


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

/*! Ecriture des informations concernant la statistique du run sur la
 *  sortie standard.
 */
inline void GanilRun::StatInfo() const
  { StatInfo (cout); }


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

/*! Retourne le nombre de voies d'�chelles.*/
inline u_int GanilRun::GetScalerNumber ( ) const
  { return (scaler_data.GetNumber()); }

/*! Retourne le label (num�ro) d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerLabel ( const u_int n ) const
  { return (scaler_data.GetLabel(n)); }

/*! Retourne la valeur d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerValue ( const u_int n ) const
  { return (scaler_data.GetValue(n)); }

/*! Retourne la fr�quence d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerFreq ( const u_int n ) const
  { return (scaler_data.GetFreq(n)); }

/*! Retourne le d�lai (x10ms) d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerTics ( const u_int n ) const
  { return (scaler_data.GetTics(n)); }

/*! Retourne l'�tat d'une �chelle: 1 = marche, 0 = arr�t, -1 = offline, -2 = non d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline int GanilRun::GetScalerStatus ( const u_int n ) const
  { return (scaler_data.GetStatus(n)); }


/*! Retourne l'�tat de l'acquisition: 1 = marche, 0 = arr�t.*/
inline u_int GanilRun::GetScalerAcqStatus ( ) const
  { return (scaler_data.GetAcqStatus()); }


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

/*! Retourne le nombre de param�tres GANIL (param�tres bruts) de
 *  la structure d'�v�nement.
 */
inline u_int GanilRun::GetGanilParamNumber () const
  { return (param_list.GetSize()); }

/*! Retourne le nombre de param�tres utilisateur de
 *  la structure d'�v�nement.
 */
inline u_int GanilRun::GetUserParamNumber () const
  { return (event.GetSize() - param_list.GetSize()); }

/*! Retourne vrai si le run est au format LSB.
 */
inline bool GanilRun::IsLSB () const
  { return ( format == fmtLSB ); }

/*! Retourne vrai si le run est au format MSB.
 */
inline bool GanilRun::IsMSB () const
  { return ( format == fmtMSB ); }

/*! Retourne vrai si la fin de run est atteinte.
 */
inline bool GanilRun::EndOfRun () const
  { return ( (status & statusEndrun) != 0 ); }


//----------------------------------------------------------------------
//  SORTIE DES EVENEMENTS

/*! Ecriture des param�tres GANIL de l'�v�nement courant sur la sortie
 *  standard: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( const bool all ) const
  { DumpEvent ( cout, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un
 *  fichier: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un flux de
 *  sortie: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant sur la sortie
 *  standard.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const bool all ) const
  { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un
 *  fichier.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

     u_int   GetBufferStat ( const u_int t ) const;


     // Retourne le nombre de param�tres GANIL/user de l'�v�nement.

     u_int   GetGanilParamNumber ( ) const;

     u_int   GetUserParamNumber  ( ) const;


     bool    SetGanilParamMultihit ( const string &par_name );

     bool    SetGanilParamMultihit ( const u_int   par_num  );


     bool    SetGanilParamArray    ( const string &par_name, const int dim );

     bool    SetGanilParamArray    ( const u_int   par_num,  const int dim  );


     // teste la fin de run

     bool  EndOfRun ( ) const;


     // test du format binaire

     bool  IsLSB ( ) const;

     bool  IsMSB ( ) const;


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


     // ajout d'un param�tre utilisateur (surcharge de EventManager)

     int   AddParam ( const Param &par );


     // mise � valeur un param�tre (user) de l'�v�nement.

     template < class T > const Data  &  SetParam( const u_int num, const T &val );

     template < class T > const Data  &  SetParam( const string &par_name, const T &val );


     // mise � valeur un param�tre multiple (user) de l'�v�nement.

     template < class T > const Data  &  SetParam( const u_int num, const u_int index, const T &val );

     template < class T > const Data  &  SetParam( const string &par_name, const u_int index, const T &val );


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

 //  M�thodes prot�g�es


   protected:


     // cr�ation de la structure d'�v�nement

     virtual int   CreateEvent ( );


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

 //  Fonctions utilisateur suppl�mentaires

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


     /*  Fonction utilisateur appel�e chaque fois qu'un buffer.

      *  est lu.

      *  (elle est appel�e dans GanilDevice::ReadBuffer)

      */

     virtual int UserBuffer ( );


     /*  Fonction utilisateur de traitement des buffers d'�chelle.

      *  (elle est appel�e dans GanilDevice::ReadEvent)

      */

     virtual int UserScaler ( );


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

 //  pour ROOT...

   public:

     /*! D�finition � usage de ROOT... */

     ClassDef(GanilRun,0);

 };


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

 //  METHODES INLINE

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


 /*! D�finit l'option d'affichage des alertes en cas de buffers d'�v�nements

  *  vides.

  *  \param  b   �tat de l'otion

  */

 inline void GanilRun::SetOptionWarnEmptyBuffer ( const bool b )

   { opt_warn_empty_buffer = b; }


 /*! Surcharge de la fonction de la classe RunBase.

  *  La fonction ne fait qu'appeler celle de RunBase.

  *  \param  f_name   nom du fichier

  */

 inline int GanilRun::Open ( const string &f_name )

   { return (RunBase::Open (f_name)); }


 /*! Surcharge de la fonction de la classe RunBase.

  *  La fonction ne fait qu'appeler celle de RunBase.

  *  \param  f_num   num�ro du fichier

  */

 inline int GanilRun::Open ( const u_int f_num )

   { return (RunBase::Open (f_num)); }


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


 /*! Retourne le num�ro de run en cours.

  */

 inline u_int GanilRun::GetRunNumber () const

   { return (GanilEventInfo::run_number); }


 /*! Retourne le nombre d'�v�nement lus (en fin de run).

  */

 inline u_int GanilRun::GetEventNumber () const

   { return (event_number); }


 /*! Retourne le nombre de buffers lus dans le fichier en cours.

  */

 inline u_int GanilRun::GetBufferCount () const

   { return (buffer_count); }


 /*! Retourne le nombre total de buffers lus.

  */

 inline u_int GanilRun::GetTotalBufferCount () const

   { return (total_buffer_count); }


 /*! Retourne le nombre de buffers d'un type donn�. *  \param  t   type de buffers
 */
inline u_int GanilRun::GetBufferStat ( const u_int t ) const
  { return (buffer_data.GetBufferStat(t)); }


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

/*! Ecriture des informations concernant la statistique du run sur la
 *  sortie standard.
 */
inline void GanilRun::StatInfo() const
  { StatInfo (cout); }


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

/*! Retourne le nombre de voies d'�chelles.*/
inline u_int GanilRun::GetScalerNumber ( ) const
  { return (scaler_data.GetNumber()); }

/*! Retourne le label (num�ro) d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerLabel ( const u_int n ) const
  { return (scaler_data.GetLabel(n)); }

/*! Retourne la valeur d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerValue ( const u_int n ) const
  { return (scaler_data.GetValue(n)); }

/*! Retourne la fr�quence d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerFreq ( const u_int n ) const
  { return (scaler_data.GetFreq(n)); }

/*! Retourne le d�lai (x10ms) d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline u_int GanilRun::GetScalerTics ( const u_int n ) const
  { return (scaler_data.GetTics(n)); }

/*! Retourne l'�tat d'une �chelle: 1 = marche, 0 = arr�t, -1 = offline, -2 = non d�finie.
 *  \param  n     num�ro de l'�chelle
 */
inline int GanilRun::GetScalerStatus ( const u_int n ) const
  { return (scaler_data.GetStatus(n)); }


/*! Retourne l'�tat de l'acquisition: 1 = marche, 0 = arr�t.*/
inline u_int GanilRun::GetScalerAcqStatus ( ) const
  { return (scaler_data.GetAcqStatus()); }


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

/*! Retourne le nombre de param�tres GANIL (param�tres bruts) de
 *  la structure d'�v�nement.
 */
inline u_int GanilRun::GetGanilParamNumber () const
  { return (param_list.GetSize()); }

/*! Retourne le nombre de param�tres utilisateur de
 *  la structure d'�v�nement.
 */
inline u_int GanilRun::GetUserParamNumber () const
  { return (event.GetSize() - param_list.GetSize()); }

/*! Retourne vrai si le run est au format LSB.
 */
inline bool GanilRun::IsLSB () const
  { return ( format == fmtLSB ); }

/*! Retourne vrai si le run est au format MSB.
 */
inline bool GanilRun::IsMSB () const
  { return ( format == fmtMSB ); }

/*! Retourne vrai si la fin de run est atteinte.
 */
inline bool GanilRun::EndOfRun () const
  { return ( (status & statusEndrun) != 0 ); }


//----------------------------------------------------------------------
//  SORTIE DES EVENEMENTS

/*! Ecriture des param�tres GANIL de l'�v�nement courant sur la sortie
 *  standard: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( const bool all ) const
  { DumpEvent ( cout, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un
 *  fichier: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un flux de
 *  sortie: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant sur la sortie
 *  standard.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const bool all ) const
  { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un
 *  fichier.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  \param  t   type de buffers

  */

 inline u_int GanilRun::GetBufferStat ( const u_int t ) const

   { return (buffer_data.GetBufferStat(t)); }


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


 /*! Ecriture des informations concernant la statistique du run sur la

  *  sortie standard.

  */

 inline void GanilRun::StatInfo() const

   { StatInfo (cout); }


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


 /*! Retourne le nombre de voies d'�chelles.*/

 inline u_int GanilRun::GetScalerNumber ( ) const

   { return (scaler_data.GetNumber()); }


 /*! Retourne le label (num�ro) d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.

  *  \param  n     num�ro de l'�chelle

  */

 inline u_int GanilRun::GetScalerLabel ( const u_int n ) const

   { return (scaler_data.GetLabel(n)); }


 /*! Retourne la valeur d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.

  *  \param  n     num�ro de l'�chelle

  */

 inline u_int GanilRun::GetScalerValue ( const u_int n ) const

   { return (scaler_data.GetValue(n)); }


 /*! Retourne la fr�quence d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.

  *  \param  n     num�ro de l'�chelle

  */

 inline u_int GanilRun::GetScalerFreq ( const u_int n ) const

   { return (scaler_data.GetFreq(n)); }


 /*! Retourne le d�lai (x10ms) d'une �chelle, et 0xFFFFFFFF si elle n'est pas d�finie.

  *  \param  n     num�ro de l'�chelle

  */

 inline u_int GanilRun::GetScalerTics ( const u_int n ) const

   { return (scaler_data.GetTics(n)); }


 /*! Retourne l'�tat d'une �chelle: 1 = marche, 0 = arr�t, -1 = offline, -2 = non d�finie.

  *  \param  n     num�ro de l'�chelle

  */

 inline int GanilRun::GetScalerStatus ( const u_int n ) const

   { return (scaler_data.GetStatus(n)); }


 /*! Retourne l'�tat de l'acquisition: 1 = marche, 0 = arr�t.*/

 inline u_int GanilRun::GetScalerAcqStatus ( ) const

   { return (scaler_data.GetAcqStatus()); }


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


 /*! Retourne le nombre de param�tres GANIL (param�tres bruts) de

  *  la structure d'�v�nement.

  */

 inline u_int GanilRun::GetGanilParamNumber () const

   { return (param_list.GetSize()); }


 /*! Retourne le nombre de param�tres utilisateur de

  *  la structure d'�v�nement.

  */

 inline u_int GanilRun::GetUserParamNumber () const

   { return (event.GetSize() - param_list.GetSize()); }


 /*! Retourne vrai si le run est au format LSB.

  */

 inline bool GanilRun::IsLSB () const

   { return ( format == fmtLSB ); }


 /*! Retourne vrai si le run est au format MSB.

  */

 inline bool GanilRun::IsMSB () const

   { return ( format == fmtMSB ); }


 /*! Retourne vrai si la fin de run est atteinte.

  */

 inline bool GanilRun::EndOfRun () const

   { return ( (status & statusEndrun) != 0 ); }


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

 //  SORTIE DES EVENEMENTS


 /*! Ecriture des param�tres GANIL de l'�v�nement courant sur la sortie

  *  standard: seuls les param�tres bruts de l'acquisition GANIL sont �cris.

  *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris

  *                les param�tres non affect�s */
inline void GanilRun::DumpGanilEvent ( const bool all ) const
  { DumpEvent ( cout, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un
 *  fichier: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un flux de
 *  sortie: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant sur la sortie
 *  standard.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const bool all ) const
  { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un
 *  fichier.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  */

 inline void GanilRun::DumpGanilEvent ( const bool all ) const

   { DumpEvent ( cout, all, 0, GetGanilParamNumber() ); }


 /*! Ecriture des param�tres GANIL de l'�v�nement courant dans un

  *  fichier: seuls les param�tres bruts de l'acquisition GANIL sont �cris.

  *  \param  file_name   nom du fichier de sortie

  *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris

  *                      les param�tres non affect�s */
inline void GanilRun::DumpGanilEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres GANIL de l'�v�nement courant dans un flux de
 *  sortie: seuls les param�tres bruts de l'acquisition GANIL sont �cris.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpGanilEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant sur la sortie
 *  standard.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const bool all ) const
  { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un
 *  fichier.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  */

 inline void GanilRun::DumpGanilEvent ( const string & file_name, const bool all ) const

   { DumpEvent ( file_name, all, 0, GetGanilParamNumber() ); }


 /*! Ecriture des param�tres GANIL de l'�v�nement courant dans un flux de

  *  sortie: seuls les param�tres bruts de l'acquisition GANIL sont �cris.

  *  \param  os        flux de sortie

  *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris

  *                    les param�tres non affect�s */
inline void GanilRun::DumpGanilEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, 0, GetGanilParamNumber() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant sur la sortie
 *  standard.
 *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris
 *                les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const bool all ) const
  { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un
 *  fichier.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  */

 inline void GanilRun::DumpGanilEvent ( ostream &os, const bool all ) const

   { DumpEvent ( os, all, 0, GetGanilParamNumber() ); }


 /*! Ecriture des param�tres utilisateurs de l'�v�nement courant sur la sortie

  *  standard.

  *  \param  all   indique s'il faut �crire tout l'�v�nement, y compris

  *                les param�tres non affect�s */
inline void GanilRun::DumpUserEvent ( const bool all ) const
  { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un
 *  fichier.
 *  \param  file_name   nom du fichier de sortie
 *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris
 *                      les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  */

 inline void GanilRun::DumpUserEvent ( const bool all ) const

   { DumpEvent ( cout, all, GetGanilParamNumber(), param_list.GetSize() ); }


 /*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un

  *  fichier.

  *  \param  file_name   nom du fichier de sortie

  *  \param  all         indique s'il faut �crire tout l'�v�nement, y compris

  *                      les param�tres non affect�s */
inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const
  { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }

/*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de
 *  sortie.
 *  \param  os        flux de sortie
 *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris
 *                    les param�tres non affect�s
 */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  */

 inline void GanilRun::DumpUserEvent ( const string & file_name, const bool all ) const

   { DumpEvent ( file_name, all, GetGanilParamNumber(), param_list.GetSize() ); }


 /*! Ecriture des param�tres utilisateurs de l'�v�nement courant dans un flux de

  *  sortie.

  *  \param  os        flux de sortie

  *  \param  all       indique s'il faut �crire tout l'�v�nement, y compris

  *                    les param�tres non affect�s */
inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const
  { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


//----------------------------------------------------------------------
//  AFFECTATION DES PARAMETRES
//----------------------------------------------------------------------
//  Surcharge de la classe EventManager pour prot�ger les param�tres
//  bruts

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  */

 inline void GanilRun::DumpUserEvent ( ostream &os, const bool all ) const

   { DumpEvent ( os, all, GetGanilParamNumber(), param_list.GetSize() ); }


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

 //  AFFECTATION DES PARAMETRES

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

 //  Surcharge de la classe EventManager pour prot�ger les param�tres

 //  bruts


 /*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur

  *  � partir d'une valeur donn�e par un type de base ou une instance

  *  de type Data.

  *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  courante du tableau qui est affect�e.

  *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle

  *  donn�e est ajout�e en fin de liste.

  *  Le type en retour est une r�f�rence sur l'instance Data associ�e au

  *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  num   num�ro de param�tre
 *  \param  val   valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                  + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e
 *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.

  *  \param  num   num�ro de param�tre

  *  \param  val   valeur � affecter (Data ou type de base)

  */

 template < class T > const Data & GanilRun::SetParam(

                                     const u_int num,

                                     const T    &val )

 {

   if (num >= param_list.GetSize())

   {

     return (EventManager::SetParam(num,val));

   }

   else

   {

     GLogWarning ( "SetParam(): Raw parameter "

                   + event[num].Name() + " not affectable");

     return (bad_data);

   }

 }


 /*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur

  *  � partir d'une valeur donn�e par un type de base ou une instance

  *  de type Data.

  *  Dans le cas d'un param�tre de type ParamArray, c'est la donn�e *  courante du tableau qui est affect�e.
 *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle
 *  donn�e est ajout�e en fin de liste.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  courante du tableau qui est affect�e.

  *  Dans le cas d'un param�tre de type ParamMultihit, une nouvelle

  *  donn�e est ajout�e en fin de liste.

  *  Le type en retour est une r�f�rence sur l'instance Data associ�e au

  *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  \param  par_name  nom du param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const string &par_name,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.

  *  \param  par_name  nom du param�tre

  *  \param  val       valeur � affecter (Data ou type de base)

  */

 template < class T > const Data & GanilRun::SetParam(

                                     const string &par_name,

                                     const T      &val )

 {

   u_int num = event.GetParamIndex(par_name);

   if (num < event.GetSize())

     return (SetParam(num,val));

   else

   {

     GLogWarning ( "GetParam(): no parameter " + par_name);

     return (bad_data);

   }

 }


 /*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur

  *  � partir d'une valeur donn�e par un type de base ou une instance

  *  de type Data.

  *  Le type en retour est une r�f�rence sur l'instance Data associ�e au

  *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  num     num�ro de param�tre
 *  \param  index   index de la valeur � affecter dans le param�tre
 *  \param  val     valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam(
                                    const u_int num,
                                    const u_int index,
                                    const T    &val )
{
  if (num >= param_list.GetSize())
  {
    return (EventManager::SetParam(num,index,val));
  }
  else
  {
    GLogWarning ( "SetParam(): Raw parameter "
                    + event[num].Name() + " not affectable");
    return (bad_data);
  }
}

/*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur
 *  � partir d'une valeur donn�e par un type de base ou une instance
 *  de type Data.
 *  Le type en retour est une r�f�rence sur l'instance Data associ�e au
 *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e
 *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.

  *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne

  *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.

  *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la

  *  m�thode sans sp�cification d'index.

  *  \param  num     num�ro de param�tre

  *  \param  index   index de la valeur � affecter dans le param�tre

  *  \param  val     valeur � affecter (Data ou type de base)

  */

 template < class T > const Data & GanilRun::SetParam(

                                     const u_int num,

                                     const u_int index,

                                     const T    &val )

 {

   if (num >= param_list.GetSize())

   {

     return (EventManager::SetParam(num,index,val));

   }

   else

   {

     GLogWarning ( "SetParam(): Raw parameter "

                     + event[num].Name() + " not affectable");

     return (bad_data);

   }

 }


 /*! M�thode patron qui sert � l'affectation d'un param�tre utilisateur

  *  � partir d'une valeur donn�e par un type de base ou une instance

  *  de type Data.

  *  Le type en retour est une r�f�rence sur l'instance Data associ�e au

  *  param�tre (apr�s affectation), avec le qualificatif const car la donn�e *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.
 *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne
 *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.
 *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la
 *  m�thode sans sp�cification d'index.
 *  \param  par_name  nom du param�tre
 *  \param  index     index de la valeur � affecter dans le param�tre
 *  \param  val       valeur � affecter (Data ou type de base)
 */
template < class T > const Data & GanilRun::SetParam (
                                    const string &par_name,
                                    const u_int  index,
                                    const T      &val )
{
  u_int num = event.GetParamIndex(par_name);
  if (num < event.GetSize())
    return (SetParam(num,index,val));
  else
  {
    GLogWarning ( "GetParam(): no parameter " + par_name);
    return (bad_data);
  }
}


//======================================================================
//  FONCTIONS UTILISATEUR SUPPLEMENTAIRES
//======================================================================

/*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.
 *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s
 *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  en retour (par r�f�rence) ne doit pas �tre modifi�e directement.

  *  Dans le cas d'un param�tre de type ParamMultihit, cette m�thode ne

  *  doit �tre appel�e que pour modifier une donn�e d�j� dans la liste.

  *  Pour ajouter une nouvelle donn�e � la liste il faut appeler la

  *  m�thode sans sp�cification d'index.

  *  \param  par_name  nom du param�tre

  *  \param  index     index de la valeur � affecter dans le param�tre

  *  \param  val       valeur � affecter (Data ou type de base)

  */

 template < class T > const Data & GanilRun::SetParam (

                                     const string &par_name,

                                     const u_int  index,

                                     const T      &val )

 {

   u_int num = event.GetParamIndex(par_name);

   if (num < event.GetSize())

     return (SetParam(num,index,val));

   else

   {

     GLogWarning ( "GetParam(): no parameter " + par_name);

     return (bad_data);

   }

 }


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

 //  FONCTIONS UTILISATEUR SUPPLEMENTAIRES

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


 /*! Fonction utilisateur par d�faut appel�e apr�s la lecture d'un buffer.

  *  Cette fonction est appel�e chaque fois qu'un buffer est lu, apr�s *  l'initialisation.
 */
inline int GanilRun::UserBuffer ( )
  { return (0); }

/*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.
 */
inline int GanilRun::UserScaler ( )
  { return (0); }


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

  *  l'initialisation.

  */

 inline int GanilRun::UserBuffer ( )

   { return (0); }


 /*! Fonction utilisateur par d�faut de traitement des buffers d'�chelles.

  */

 inline int GanilRun::UserScaler ( )

   { return (0); }


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

 #endif

GanilGlobal.hh

GanilRun::GetScalerLabel
u_int GetScalerLabel(const u_int n) const
Definition: GanilRun.hh:305

GanilRun::DumpGanilEvent
void DumpGanilEvent(const bool all=false) const
Definition: GanilRun.hh:376

GanilEndrunInfo::event_number
u_int event_number
Nombre d&#39;�v�nements dans le fichier.
Definition: GanilEndrunInfo.hh:33

GanilRun::GetRunNumber
u_int GetRunNumber() const
Definition: GanilRun.hh:262

GanilRun
Definition: GanilRun.hh:39

GanilRun::CreateEvent
virtual int CreateEvent()
Definition: GanilRun.cpp:701

GanilRun::Close
virtual int Close()
Definition: GanilRun.cpp:177

GanilScaler::GetNumber
u_int GetNumber() const
Definition: GanilScaler.hh:116

GanilRun::DumpUserEvent
void DumpUserEvent(const bool all=false) const
Definition: GanilRun.hh:402

GanilRun::ClassDef
ClassDef(GanilRun, 0)

bad_data
DataBad & bad_data
Definition: DataBad.cpp:51

GanilRun::StatInfo
virtual void StatInfo() const
Definition: GanilRun.hh:292

GanilRun::GObject
GObject(GanilRun)

RunBase::Open
virtual int Open()=0

GanilRun::GetScalerValue
u_int GetScalerValue(const u_int n) const
Definition: GanilRun.hh:311

GanilRun::GetScalerAcqStatus
u_int GetScalerAcqStatus() const
Definition: GanilRun.hh:334

GanilRun::SetParam
const Data & SetParam(const u_int num, const T &val)
Definition: GanilRun.hh:444

GanilRun::GetTotalBufferCount
u_int GetTotalBufferCount() const
Definition: GanilRun.hh:277

GanilRun::IsMSB
bool IsMSB() const
Definition: GanilRun.hh:359

GanilEndrunInfo::EndrunInfo
virtual void EndrunInfo()
Definition: GanilEndrunInfo.hh:73

GanilInfo
Definition: GanilInfo.hh:36

GanilEventInfo::run_number
u_int run_number
Num�ro du run.
Definition: GanilEventInfo.hh:35

GanilRun::EndOfRun
bool EndOfRun() const
Definition: GanilRun.hh:364

GanilRun::Open
virtual int Open()
Definition: GanilRun.cpp:86

GanilRun::GetScalerFreq
u_int GetScalerFreq(const u_int n) const
Definition: GanilRun.hh:317

GanilRun::SetOptionWarnEmptyBuffer
void SetOptionWarnEmptyBuffer(const bool b=true)
Definition: GanilRun.hh:241

GanilRun::ReadEvent
virtual int ReadEvent()
Definition: GanilRun.cpp:782

GanilRun::UserScaler
virtual int UserScaler()
Definition: GanilRun.hh:561

GanilRun::~GanilRun
virtual ~GanilRun()
Definition: GanilRun.cpp:44

EventManager::DumpEvent
virtual void DumpEvent(const bool all=false, const u_int pmin=0, const u_int pmax=0) const
Definition: EventManager.hh:1124

GanilBuffer.hh

GanilRun::buffer_data
GanilBuffer buffer_data
donn�es du buffer courant de fichier
Definition: GanilRun.hh:81

GanilRun::GetUserParamNumber
u_int GetUserParamNumber() const
Definition: GanilRun.hh:349

GanilRun::buffer_count
u_int buffer_count
compteur des buffers
Definition: GanilRun.hh:82

GanilRun::format
u_int format
format binaire
Definition: GanilRun.hh:72

GanilRun::GanilRun
GanilRun()
Definition: GanilRun.cpp:22

GanilRun::FileClose
virtual void FileClose()
Definition: GanilRun.cpp:203

GanilRun::SetGanilParamMultihit
bool SetGanilParamMultihit(const string &par_name)
Definition: GanilRun.cpp:575

GanilParamInfo::param_list
GListT< GanilParam > param_list
Liste des param�tres GANIL.
Definition: GanilParamInfo.hh:34

RunBase
Definition: RunBase.hh:90

GanilRun::RunInit
virtual int RunInit()
Definition: GanilRun.cpp:217

GanilRun::opt_warn_empty_buffer
bool opt_warn_empty_buffer
alerte en cas de buffer vide
Definition: GanilRun.hh:75

GanilRun::FileOpen
virtual int FileOpen()
Definition: GanilRun.cpp:134

GanilRun::UserBuffer
virtual int UserBuffer()
Definition: GanilRun.hh:556

Param
Definition: Param.hh:83

RunBase.hh

GanilInfo.hh

GanilRun::file_ptr
FILE * file_ptr
pointeur sur le fichier de runs
Definition: GanilRun.hh:78

GanilBuffer
Definition: GanilBuffer.hh:26

GanilRun::GetScalerNumber
u_int GetScalerNumber() const
Definition: GanilRun.hh:299

GanilRun::IsOpen
virtual bool IsOpen()
Definition: GanilRun.cpp:169

GanilRun::GetGanilParamNumber
u_int GetGanilParamNumber() const
Definition: GanilRun.hh:343

GanilScaler::GetLabel
u_int GetLabel(const u_int n) const
Definition: GanilScaler.hh:122

GanilRun::ReadBuffer
virtual int ReadBuffer()
Definition: GanilRun.cpp:754

GanilRun::scaler_data
GanilScaler scaler_data
information des buffers d&#39;�chelles
Definition: GanilRun.hh:85

GanilScaler.hh

GanilRun::IsLSB
bool IsLSB() const
Definition: GanilRun.hh:354

EventManager::SetParam
const Data & SetParam(const u_int num, const T &val)
Definition: EventManager.hh:806

GanilScaler::GetTics
u_int GetTics(const u_int n) const
Definition: GanilScaler.hh:140

GanilRun::AddParam
int AddParam(const Param &par)
Definition: GanilRun.cpp:737

GanilRun::BufferReset
virtual void BufferReset()
Definition: GanilRun.cpp:280

GanilScaler::GetAcqStatus
u_int GetAcqStatus() const
Definition: GanilScaler.hh:151

GanilRun::GanilStatus
GanilStatus
Bits d&#39;�tat des runs GANIL.
Definition: GanilRun.hh:51

GanilRun::GetBufferCount
u_int GetBufferCount() const
Definition: GanilRun.hh:272

GanilRun::ReadHeaders
virtual int ReadHeaders()
Definition: GanilRun.cpp:299

GanilScaler
Definition: GanilScaler.hh:54

RunBase::file_name
string file_name
nom effectif du fichier d&#39;entr�e
Definition: RunBase.hh:114

GanilScaler::GetStatus
int GetStatus(const u_int n) const
Definition: GanilScaler.hh:146

Data
Definition: Data.hh:153

GanilRun::GetEventNumber
u_int GetEventNumber() const
Definition: GanilRun.hh:267

GanilRun::SetGanilParamArray
bool SetGanilParamArray(const string &par_name, const int dim)
Definition: GanilRun.cpp:635

GanilRun::GanilFormat
GanilFormat
Format des donn�es binaires.
Definition: GanilRun.hh:44

GanilRun::total_buffer_count
u_int total_buffer_count
compteur des buffers
Definition: GanilRun.hh:83

GanilScaler::GetValue
u_int GetValue(const u_int n) const
Definition: GanilScaler.hh:128

GanilRun::GetBufferStat
u_int GetBufferStat(const u_int t) const
Definition: GanilRun.hh:283

GanilScaler::GetFreq
u_int GetFreq(const u_int n) const
Definition: GanilScaler.hh:134

GanilRun::GetScalerTics
u_int GetScalerTics(const u_int n) const
Definition: GanilRun.hh:323

GanilRun::Reset
virtual void Reset()
Definition: GanilRun.cpp:271

GanilRun::GetScalerStatus
int GetScalerStatus(const u_int n) const
Definition: GanilRun.hh:329

EventManager::event
Event event
Structure physique de l&#39;�v�nement.
Definition: EventManager.hh:68

GanilBuffer::GetBufferStat
u_int GetBufferStat(const u_int t) const
Definition: GanilBuffer.hh:212

GanilRun::status
u_int status
bits d&#39;�tat de l&#39;analyse
Definition: GanilRun.hh:71