Analysis  version 7.0 - august 2014
TreeInfo.hh
Go to the documentation of this file.
1 //======================================================================
2 /*! \file TreeInfo.hh
3  *
4  * Déclaration de la classe TreeInfo qui permet de définir un TTree
5  * ROOT à partir des paramètres.
6  */
7 //======================================================================
8 
9 
10 #ifndef TREE_INFO_HH
11 #define TREE_INFO_HH
12 
13 // nécessaire pour la génération du dictionnaire ROOT parce que la classe
14 // GListT<T> (constructeur) a besoin de la définition de GVectT<T>
15 #include "GVectT.hh"
16 
17 #include "EventCommon.hh"
18 #include "Event.hh"
19 #include "Filter.hh"
20 #include "Data.hh"
21 #include "TreeParam.hh"
22 
23 class EventManager;
24 class TreeList;
25 
26 #include "RString.hh"
27 
28 #include <TTree.h>
29 #include <TBranch.h>
30 #include <TLeaf.h>
31 #include <TFile.h>
32 
33 #define TREE_BEGIN_ID "<TREE_BEGIN>" ///< Texte identifiant le début de définition d'un arbre dans un fichier
34 #define TREE_END_ID "<TREE_END>" ///< Texte identifiant la fin de définition d'un arbre dans un fichier
35 
36 
37 /// Bits d'état des arbres
38 enum TreeStatus
39 {
40  // bits liés à l'incrémentation de l'arbre
41  // - treeLocked l'arbre ne peut plus être modifié treeSuspended = 0x00000001, treeStopped = 0x00000002, treeLocked = 0x00000010 }; /// Modes de renouvellement des fichiers d'arbres enum TreeMode { allEventsTree = 0, // le fichier n'est fermé qu'à la fin d'analyse runFileNumberTree = 1, // un fichier arbre est créé pour chaque fichier de run, par numéro de fichier runFileNameTree = 2, // un fichier arbre est créé pour chaque fichier de run, par nom de fichier maxEventTree = 3 // un fichier est créé avec un nombre maxi d'événements }; //====================================================================== /*! \class TreeInfo * * Cette classe sert d'interface pour créer des fichiers contenant des * TTree pour ROOT dans des fichiers séparés. * A chaque arbre est associé un ensemble de fichiers numérotés, selon * le mode choisi: * - un seul fichier pour toute l'analyse * - un fichier pour chaque run de données * - un fichier par groupe d'événement, défini par un nombre maximum * d'événements par fichier * Le mode est défini à partir du nom de fichier et du nombre maxi * d'événements (voir fonction SetTreeFile): * - si le nom de fichier ne contient pas de format de type \b %nF alors * c'est un seul fichier pour toute l'analyse * - si le nom contient un format \b %nF, alors si le nombre maximum * d'événements est 0, c'est un fichier par run (et le format est * remplacé par le numéro de fichier), et si ce nombre est * différent de 0, c'est un fichier par paquet d'événements * - si le nom contient le format \b %B, alors c'est un fichier par run, * et le format est remplacé par le nom de base du fichier d'entrée. * * \note * En mode runFileNumberTree (un fichier par run), le numéro de fichier * doit être défini extérieurement à l'ouverture des fichiers de runs. * * Les paramètres d'arbre (classe TreeParam) ne servent que pendant * la phase de création de l'arbre. * Ensuite, toutes les informations sont reportées dans les tables de * la classe TreeInfo. * * L'arbre créé n'a qu'une branche pour des paramètres simples. * Pour des paramètres multihit (de dimension variable), une autre branche * est créée automatiquement, la première branche ne contenant que le * nombre de valeurs. * Pour les paramètres multihit, toutes les données de l'arbre doivent * avoir le même type. * */ class TreeInfo : public GNamed, protected GListT<TreeParam> { //---------------------------------------------------------------------- /*! \object_doc */ GObject(TreeInfo); //---------------------------------------------------------------------- friend class TreeList; friend class FilterList; /// Définition du type itérateur pour les listes de paramètres d'arbres typedef GListIterT<TreeParam> iterator; protected: const EventManager *evt_mgr; ///< pointeur sur le gestionnaire d'événement // données pour le TTree RString tree_file; ///< nom du fichier de sortie du TTree string file_name; ///< nom effectif du fichier en cours string tree_dir; ///< répertoire du TTree dans l'arborescence ROOT TTree *tree_ptr; ///< pointeur sur le TTree de ROOT TFile *file_ptr; ///< pointeur sur le fichier ROOT associé // pour la détermination automatique du nom Int_t file_number; ///< numéro de fichier associé Int_t file_sub; ///< numéro de fichier associé string file_base; ///< nom de base de fichier associé UInt_t tree_mode; ///< mode de création des fichiers UInt_t event_max; ///< nombre maxi d'événements UInt_t event_num; ///< nombre d'événements déjà placés // données pour les paramètres #ifndef __MAKECINT__ UInt_t branch_num; ///< nombre de branches string *branch_name; ///< table des noms des branches string *branch_def; ///< table des définitions des branches Int_t *branch_size; ///< table des tailles des branches (0 pour une branche variable) TBranch **branch_ptr; ///< table des pointeurs des branches char **branch_buffer; ///< table des buffers de données par branche Int_t *branch_leaf_num; ///< table des nombres de feuilles par branche TLeaf ***branch_leaf_ptr; ///< tables des pointeurs des feuilles pour chaque branche Int_t **branch_leaf_off; ///< tables des positions des données des feuilles pour chaque branche Int_t **branch_leaf_size; ///< tables des tailles de type des données des feuilles pour chaque branche const Param ***branch_leaf_par; ///< tables des paramètres associés feuilles pour chaque branche Bool_t **branch_leaf_cnt; ///< tables des indicateur de compteur pour un paramètre multihit #endif // autres informations u_int status; ///< mot d'état de l'arbre #ifndef __MAKECINT__ const Filter **filter_ptr; ///< pointeur sur le filtre associé #endif //---------------------------------------------------------------------- // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR //---------------------------------------------------------------------- public: // Constructeur TreeInfo ( const string &t_name, const EventManager *mgr, const string &f_name = "", UInt_t n_max = 10000000 ); // Constructeur de recopie TreeInfo ( const TreeInfo & original ); // Destructeur virtual ~TreeInfo (); //---------------------------------------------------------------------- // MISE EN OEUVRE DE L'ARBRE //---------------------------------------------------------------------- virtual Int_t GetFileNumber ( ) const; virtual void SetFileNumber ( const Int_t f_num, Int_t f_sub = 0 ); virtual string GetFileBase ( ) const; virtual void SetFileBase ( const string &f_base ); virtual Int_t SetTreeFile ( const string &f_name, const UInt_t n_max ); virtual string GetTreeFile ( ) const; virtual string GetFileName ( ) const; virtual UInt_t GetFileMode ( ) const; virtual TTree * GetTTreePtr ( ) const; virtual UInt_t GetMaxEvent ( ) const; virtual UInt_t GetParamNumber ( ) const; virtual string GetParamName ( const UInt_t par_num ) const; virtual Bool_t AddParam ( const Param * p_ptr ); virtual Bool_t AddParam ( const string & p_name ); virtual Bool_t AddParam ( const Int_t p_num ); virtual Int_t AddParamRange ( const Int_t p1, const Int_t p2 ); virtual Int_t AddAllParam ( ); virtual Int_t Init ( ); virtual Int_t Open ( ); virtual Int_t Close ( ); virtual Bool_t IsOpen ( ); virtual Bool_t IsClosed ( ); virtual Bool_t IsLocked ( ); // retourne le pointeur sur un paramètre const Param * GetEventParamPtr ( const u_int par_num ) const; const Param * GetEventParamPtr ( const string & par_name ) const; TreeParam * GetTreeParamPtr ( const u_int par_num ) const; TreeParam * GetTreeParamPtr ( const string & par_name ) const; TreeParam * Find ( const string &par_name ) const; TreeParam * Find ( const Int_t par_num ) const; TreeParam * Find ( const Param *par_ptr ) const; //---------------------------------------------------------------------- // FILTRAGE ET INCREMENTATION DE L'ARBRE //---------------------------------------------------------------------- public: // Modifie l'état d'incrémentation des arbres void Start ( ); void Stop ( ); void Suspend ( ); // Retourne l'état d'incrémentation d'un arbre bool IsStarted ( ) const; // démarré (suspendu ou non) bool IsStopped ( ) const; // arrêté bool IsSuspended ( ) const; // suspendu bool IsIncremented ( ) const; // démarré et non suspendu // test si un arbre utilise un contour ou un filtre // pour vérifier qu'il peut être effacé dans les listes. virtual bool UsesContour ( const RContour *ct, const bool rec = true ) const; virtual bool UsesFilter ( const Filter *f, const bool rec = true ) const; // Retourne vrai si le filtre associé à l'arbre est valide bool FilterCheck () const; // méthode générique pour l'incrémentation des arbres virtual void Increment ( ); protected: // Retourne la valeur précalculée du filtre bool FilterFastCheck ( ) const; // méthode générique pour l'incrémentation des arbres, avec // précalcul des filtres virtual void IncrementFast ( ); // méthode effective pour l'incrémentation des arbres // (il n'y a plus de vérification) virtual void IncrementTree ( ); public: string GetFilterName ( ) const; virtual string FilterInfo ( ) const; virtual const Filter *GetFilterPtr ( ) const; virtual void SetFilter ( const Filter *f ); virtual void ResetFilter ( ); //---------------------------------------------------------------------- // LECTURE / ECRITURE DE LA STRUCTURE DE L'ARBRE //---------------------------------------------------------------------- // Ecriture de l'arbre. virtual bool Write ( ostream & os ) const; virtual bool Write ( FILE * fptr ) const; // Lecture de la définition d'un spectre. static TreeInfo * ReadTreeInfo ( FILE *fptr, const EventManager * mgr, int & error ); //static TreeInfo * NewTreeInfo ( const string & str, const Event * evt, string & filt ); //static TreeInfo * NewTreeInfo ( const string & str, const Event * evt, string & filt, int & error ); //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(TreeInfo,0); }; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le nombre de paramètre de l'événement transférés dans le TTree.*/ inline UInt_t TreeInfo::GetParamNumber ( ) const { return (GetSize()); } /*! Retourne le nom d'un paramètre de l'événement transfére dans le TTree. * \param par_num numéro du paramètre */ inline string TreeInfo::GetParamName ( const UInt_t par_num ) const { return ( (par_num < GetSize()) ? GetTreeParamPtr(par_num)->GetParamPtr()->GetName() : "" ); } /*! Retourne le numéro de fichier associé à l'arbre. */ inline Int_t TreeInfo::GetFileNumber ( ) const { return (file_number); } /*! Retourne le nom de base de fichier associé à l'arbre. */ inline string TreeInfo::GetFileBase ( ) const { return (file_base); } /*! Retourne le nom générique de fichier d'arbre.*/ inline string TreeInfo::GetTreeFile ( ) const { return (tree_file); } /*! Retourne le nom courant de fichier d'arbre.*/ inline string TreeInfo::GetFileName ( ) const { return (file_name); } /*! Retourne le pointeur sur le TTree associé à l'arbre.*/ inline TTree * TreeInfo::GetTTreePtr ( ) const { return (tree_ptr); } /*! Retourne le nombre maxi d'événements par fichier. * Si l'arbre n'est pas en mode maxEventTree, la fonction retourne 0. */ inline UInt_t TreeInfo::GetMaxEvent ( ) const { return (event_max); } /*! Retourne le mode de création/fermeture des fichiers.*/ inline UInt_t TreeInfo::GetFileMode ( ) const { return (tree_mode); } //---------------------------------------------------------------------- /*! Retourne le pointeur du paramètre d'événement correspondant au numéro * de paramètre de l'arbre. * \param par_num numéro de paramètre de l'arbre */ inline const Param * TreeInfo::GetEventParamPtr ( const u_int par_num ) const { return ((GetSize() > par_num) ? GetTreeParamPtr(par_num)->GetParamPtr() : NULL); } /*! Retourne le pointeur du paramètre d'événement correspondant au nom * de paramètre de l'arbre. * \param par_name nom de paramètre de l'arbre */ inline const Param * TreeInfo::GetEventParamPtr ( const string & par_name ) const { TreeParam * tp = GetTreeParamPtr (par_name); return ( tp == NULL ? NULL : tp->GetParamPtr()); } /*! Retourne un pointeur du paramètre d'arbre donné par son nom. * \param par_name nom de paramètre de l'arbre */ inline TreeParam * TreeInfo::GetTreeParamPtr ( const string & par_name ) const { return (Find(par_name)); } //---------------------------------------------------------------------- /*! Retourne vrai si le fichier d'arbre est ouvert.*/ inline Bool_t TreeInfo::IsOpen ( ) { return ( (file_ptr != NULL) ? kTRUE : kFALSE ); } /*! Retourne vrai si le fichier d'arbre est fermé.*/ inline Bool_t TreeInfo::IsClosed ( ) { return ( (file_ptr == NULL) ? kTRUE : kFALSE ); } /*! Retourne vrai si le fichier d'arbre est verrouillé, c'est à dire * si sa définition est figée. */ inline Bool_t TreeInfo::IsLocked ( ) { return ( (status & treeLocked) != 0 ); } //---------------------------------------------------------------------- /*! Démarre l'arbre, ce qui autorise l'incrémentation.*/ inline void TreeInfo::Start() { status = status - (status & (treeStopped | treeSuspended)); } /*! Stoppe l'arbre, ce qui interdit l'incrémentation, jusqu'à ce que * l'arbre soit à nouveau démarré. */ inline void TreeInfo::Stop() { status = status | treeStopped; } /*! Suspend l'arbre, ce qui interdit l'incrémentation pour un seul * événement (en fait pour une tentative d'incrémentation: le bit * correspondant est remis à zéro par l'incrémentation). */ inline void TreeInfo::Suspend() { status = status | treeSuspended; } /*! Retourne vrai si l'arbre est démarré (il peut cependant être suspendu).*/ inline bool TreeInfo::IsStarted () const { return ( ((status & treeStopped) == 0) ? true : false ); } /*! Retourne vrai si l'arbre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool TreeInfo::IsIncremented () const { return ( ((status & (treeStopped | treeSuspended)) == 0) ? true : false ); } /*! Retourne vrai si l'arbre est arrêté.*/ inline bool TreeInfo::IsStopped () const { return ( ((status & treeStopped) != 0) ? true : false ); } /*! Retourne vrai si l'arbre est suspendu.*/ inline bool TreeInfo::IsSuspended () const { return ( ((status & treeSuspended) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne le nom du filtre associé au TTree, ou une chaîne vide.*/ inline string TreeInfo::GetFilterName() const { return ( (*filter_ptr) == NULL ? "" : (*filter_ptr)->GetName() ); } /*! Méthode qui retourne une chaîne décrivant le filtre d'un TTree.*/ inline string TreeInfo::FilterInfo ( ) const { return ( (*filter_ptr == NULL) ? "" : " Filter = " + (*filter_ptr)->GetName() + " [" + (*filter_ptr)->TypeName() + "]" ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé à l'arbre est valide.*/ inline bool TreeInfo::FilterCheck () const { if ((*filter_ptr) == NULL) return (true); else return ((*filter_ptr)->Ok()); } /*! Retourne la valeur précalculée du filtre, pour l'incrémentation * automatique plus rapide. */ inline bool TreeInfo::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else return ((*filter_ptr)->GetInternalValue()); } /*! Méthode générique pour l'incrémentation d'un arbre: la méthode * vérifie que l'arbre est démarré et l'état des filtres. */ inline void TreeInfo::Increment ( ) { if (IsIncremented() && FilterCheck()) IncrementTree ( ); // retire le bit de suspension status = status - (status & treeSuspended); } /*! Méthode générique pour l'incrémentation d'un arbre: la méthode * vérifie que l'arbre est démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void TreeInfo::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) IncrementTree ( ); // retire le bit de suspension de spectre status = status - (status & treeSuspended); } /*! Retourne le pointeur sur le filtre conditionnant l'arbre, ou NULL * si l'arbre n'est pas conditionné. */ inline const Filter *TreeInfo::GetFilterPtr ( ) const { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un arbre. * \param f pointeur sur le filtre */ inline void TreeInfo::SetFilter ( const Filter *f ) { (*filter_ptr) = f; } /*! Retire la condition sur un arbre.*/ inline void TreeInfo::ResetFilter ( ) { (*filter_ptr) = NULL; } //---------------------------------------------------------------------- #endif
42  treeSuspended = 0x00000001,
43  treeStopped = 0x00000002,
44  treeLocked = 0x00000010
45 };
46 
47 /// Modes de renouvellement des fichiers d'arbres
48 enum TreeMode
49 {
50  allEventsTree = 0, // le fichier n'est fermé qu'à la fin d'analyse
51  runFileNumberTree = 1, // un fichier arbre est créé pour chaque fichier de run, par numéro de fichier
52  runFileNameTree = 2, // un fichier arbre est créé pour chaque fichier de run, par nom de fichier
53  maxEventTree = 3 // un fichier est créé avec un nombre maxi d'événements
54 };
55 
56 //======================================================================
57 /*! \class TreeInfo
58  *
59  * Cette classe sert d'interface pour créer des fichiers contenant des
60  * TTree pour ROOT dans des fichiers séparés.
61  * A chaque arbre est associé un ensemble de fichiers numérotés, selon
62  * le mode choisi:
63  * - un seul fichier pour toute l'analyse
64  * - un fichier pour chaque run de données
65  * - un fichier par groupe d'événement, défini par un nombre maximum
66  * d'événements par fichier
67  * Le mode est défini à partir du nom de fichier et du nombre maxi
68  * d'événements (voir fonction SetTreeFile):
69  * - si le nom de fichier ne contient pas de format de type \b %nF alors
70  * c'est un seul fichier pour toute l'analyse
71  * - si le nom contient un format \b %nF, alors si le nombre maximum
72  * d'événements est 0, c'est un fichier par run (et le format est
73  * remplacé par le numéro de fichier), et si ce nombre est
74  * différent de 0, c'est un fichier par paquet d'événements
75  * - si le nom contient le format \b %B, alors c'est un fichier par run,
76  * et le format est remplacé par le nom de base du fichier d'entrée.
77  *
78  * \note
79  * En mode runFileNumberTree (un fichier par run), le numéro de fichier
80  * doit être défini extérieurement à l'ouverture des fichiers de runs.
81  *
82  * Les paramètres d'arbre (classe TreeParam) ne servent que pendant
83  * la phase de création de l'arbre.
84  * Ensuite, toutes les informations sont reportées dans les tables de
85  * la classe TreeInfo.
86  *
87  * L'arbre créé n'a qu'une branche pour des paramètres simples.
88  * Pour des paramètres multihit (de dimension variable), une autre branche
89  * est créée automatiquement, la première branche ne contenant que le
90  * nombre de valeurs.
91  * Pour les paramètres multihit, toutes les données de l'arbre doivent
92  * avoir le même type.
93  *
94  */
95 class TreeInfo : public GNamed, protected GListT<TreeParam>
96 {
97 //----------------------------------------------------------------------
98  /*! \object_doc */
99  GObject(TreeInfo);
100 //----------------------------------------------------------------------
101 
102  friend class TreeList;
103  friend class FilterList;
104 
105  /// Définition du type itérateur pour les listes de paramètres d'arbres
106  typedef GListIterT<TreeParam> iterator;
107 
108 
109  protected:
110  const EventManager *evt_mgr; ///< pointeur sur le gestionnaire d'événement
111 
112  // données pour le TTree
113  RString tree_file; ///< nom du fichier de sortie du TTree
114  string file_name; ///< nom effectif du fichier en cours
115 
116  string tree_dir; ///< répertoire du TTree dans l'arborescence ROOT
117  TTree *tree_ptr; ///< pointeur sur le TTree de ROOT
118  TFile *file_ptr; ///< pointeur sur le fichier ROOT associéent
119 
120  // pour la détermination automatique du nom
121  Int_t file_number; ///< numéro de fichier associéf4
122  Int_t file_sub; ///< numéro de fichier associéx80-\xFF]*
123  string file_base; ///< nom de base de fichier associé0fa2350297f6@
124 
125  UInt_t tree_mode; ///< mode de création des fichiers
126  UInt_t event_max; ///< nombre maxi d'événements
127  UInt_t event_num; ///< nombre d'événements déjà placés34b19c1a698@
128 
129  // données pour les paramètres
130 #ifndef __MAKECINT__
131  UInt_t branch_num; ///< nombre de branches
132  string *branch_name; ///< table des noms des branches
133  string *branch_def; ///< table des définitions des branches
134  Int_t *branch_size; ///< table des tailles des branches (0 pour une branche variable)
135  TBranch **branch_ptr; ///< table des pointeurs des branches
136  char **branch_buffer; ///< table des buffers de données par branche
137  Int_t *branch_leaf_num; ///< table des nombres de feuilles par branche
138  TLeaf ***branch_leaf_ptr; ///< tables des pointeurs des feuilles pour chaque branche
139  Int_t **branch_leaf_off; ///< tables des positions des données des feuilles pour chaque branche
140  Int_t **branch_leaf_size; ///< tables des tailles de type des données des feuilles pour chaque branche
141  const Param ***branch_leaf_par; ///< tables des paramètres associés feuilles pour chaque branche
142  Bool_t **branch_leaf_cnt; ///< tables des indicateur de compteur pour un paramètre multihit
143 #endif
144 
145  // autres informations
146  u_int status; ///< mot d'état de l'arbre
147 
148 #ifndef __MAKECINT__
149  const Filter **filter_ptr; ///< pointeur sur le filtre associé nom1
150 #endif
151 
152 
153 //----------------------------------------------------------------------
154 // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
155 //----------------------------------------------------------------------
156 
157  public:
158  // Constructeur
159  TreeInfo ( const string &t_name, const EventManager *mgr, const string &f_name = "", UInt_t n_max = 10000000 );
160 
161  // Constructeur de recopie
162  TreeInfo ( const TreeInfo & original );
163 
164  // Destructeur
165  virtual ~TreeInfo ();
166 
167 //----------------------------------------------------------------------
168 // MISE EN OEUVRE DE L'ARBRE
169 //----------------------------------------------------------------------
170 
171  virtual Int_t GetFileNumber ( ) const;
172  virtual void SetFileNumber ( const Int_t f_num, Int_t f_sub = 0 );
173 
174  virtual string GetFileBase ( ) const;
175  virtual void SetFileBase ( const string &f_base );
176 
177  virtual Int_t SetTreeFile ( const string &f_name, const UInt_t n_max );
178  virtual string GetTreeFile ( ) const;
179  virtual string GetFileName ( ) const;
180  virtual UInt_t GetFileMode ( ) const;
181 
182  virtual TTree * GetTTreePtr ( ) const;
183  virtual UInt_t GetMaxEvent ( ) const;
184 
185  virtual UInt_t GetParamNumber ( ) const;
186  virtual string GetParamName ( const UInt_t par_num ) const;
187 
188  virtual Bool_t AddParam ( const Param * p_ptr );
189  virtual Bool_t AddParam ( const string & p_name );
190  virtual Bool_t AddParam ( const Int_t p_num );
191  virtual Int_t AddParamRange ( const Int_t p1, const Int_t p2 );
192  virtual Int_t AddAllParam ( );
193 
194  virtual Int_t Init ( );
195  virtual Int_t Open ( );
196  virtual Int_t Close ( );
197 
198  virtual Bool_t IsOpen ( );
199  virtual Bool_t IsClosed ( );
200  virtual Bool_t IsLocked ( );
201 
202  // retourne le pointeur sur un paramètre
203  const Param * GetEventParamPtr ( const u_int par_num ) const;
204  const Param * GetEventParamPtr ( const string & par_name ) const;
205  TreeParam * GetTreeParamPtr ( const u_int par_num ) const;
206  TreeParam * GetTreeParamPtr ( const string & par_name ) const;
207 
208  TreeParam * Find ( const string &par_name ) const;
209  TreeParam * Find ( const Int_t par_num ) const;
210  TreeParam * Find ( const Param *par_ptr ) const;
211 
212 //----------------------------------------------------------------------
213 // FILTRAGE ET INCREMENTATION DE L'ARBRE
214 //----------------------------------------------------------------------
215 
216  public:
217 
218  // Modifie l'état d'incrémentation des arbres
219  void Start ( );
220  void Stop ( );
221  void Suspend ( );
222 
223  // Retourne l'état d'incrémentation d'un arbre
224  bool IsStarted ( ) const; // démarré (suspendu ou non)
225  bool IsStopped ( ) const; // arrêté
226  bool IsSuspended ( ) const; // suspendu
227  bool IsIncremented ( ) const; // démarré et non suspendu
228 
229  // test si un arbre utilise un contour ou un filtre
230  // pour vérifier qu'il peut être effacé dans les listes.
231  virtual bool UsesContour ( const RContour *ct, const bool rec = true ) const;
232  virtual bool UsesFilter ( const Filter *f, const bool rec = true ) const;
233 
234  // Retourne vrai si le filtre associé à l'arbre est valide
235  bool FilterCheck () const;
236 
237  // méthode générique pour l'incrémentation des arbres
238  virtual void Increment ( );
239 
240  protected:
241 
242  // Retourne la valeur précalculée du filtre
243  bool FilterFastCheck ( ) const;
244 
245  // méthode générique pour l'incrémentation des arbres, avec
246  // précalcul des filtres
247  virtual void IncrementFast ( );
248 
249  // méthode effective pour l'incrémentation des arbres
250  // (il n'y a plus de vérification)
251  virtual void IncrementTree ( );
252 
253  public:
254 
255  string GetFilterName ( ) const;
256  virtual string FilterInfo ( ) const;
257 
258  virtual const Filter *GetFilterPtr ( ) const;
259  virtual void SetFilter ( const Filter *f );
260  virtual void ResetFilter ( );
261 
262 //----------------------------------------------------------------------
263 // LECTURE / ECRITURE DE LA STRUCTURE DE L'ARBRE
264 //----------------------------------------------------------------------
265 
266  // Ecriture de l'arbre.
267  virtual bool Write ( ostream & os ) const;
268  virtual bool Write ( FILE * fptr ) const;
269 
270  // Lecture de la définition d'un spectre.
271  static TreeInfo * ReadTreeInfo ( FILE *fptr, const EventManager * mgr, int & error );
272  //static TreeInfo * NewTreeInfo ( const string & str, const Event * evt, string & filt );
273  //static TreeInfo * NewTreeInfo ( const string & str, const Event * evt, string & filt, int & error );
274 
275 
276 //----------------------------------------------------------------------
277 // pour ROOT...
278  public:
279  /*! Définition à usage de ROOT... */
280  ClassDef(TreeInfo,0);
281 };
282 
283 
284 //======================================================================
285 // METHODES INLINE
286 //======================================================================
287 
288 /*! Retourne le nombre de paramètre de l'événement transférés dans le TTree.*/
289 inline UInt_t TreeInfo::GetParamNumber ( ) const
290  { return (GetSize()); }
291 
292 /*! Retourne le nom d'un paramètre de l'événement transfére dans le TTree.
293  * \param par_num numéro du paramètre
294  */
295 inline string TreeInfo::GetParamName ( const UInt_t par_num ) const
296  { return ( (par_num < GetSize()) ? GetTreeParamPtr(par_num)->GetParamPtr()->GetName() : "" ); }
297 
298 
299 /*! Retourne le numéro de fichier associé à l'arbre. */
300 inline Int_t TreeInfo::GetFileNumber ( ) const
301  { return (file_number); }
302 
303 /*! Retourne le nom de base de fichier associé à l'arbre. */
304 inline string TreeInfo::GetFileBase ( ) const
305  { return (file_base); }
306 
307 /*! Retourne le nom générique de fichier d'arbre.*/
308 inline string TreeInfo::GetTreeFile ( ) const
309  { return (tree_file); }
310 
311 /*! Retourne le nom courant de fichier d'arbre.*/
312 inline string TreeInfo::GetFileName ( ) const
313  { return (file_name); }
314 
315 /*! Retourne le pointeur sur le TTree associé à l'arbre.*/
316 inline TTree * TreeInfo::GetTTreePtr ( ) const
317  { return (tree_ptr); }
318 
319 /*! Retourne le nombre maxi d'événements par fichier.
320  * Si l'arbre n'est pas en mode maxEventTree, la fonction retourne 0.
321  */
322 inline UInt_t TreeInfo::GetMaxEvent ( ) const
323  { return (event_max); }
324 
325 /*! Retourne le mode de création/fermeture des fichiers.*/
326 inline UInt_t TreeInfo::GetFileMode ( ) const
327  { return (tree_mode); }
328 
329 
330 //----------------------------------------------------------------------
331 
332 /*! Retourne le pointeur du paramètre d'événement correspondant au numéro
333  * de paramètre de l'arbre.
334  * \param par_num numéro de paramètre de l'arbre
335  */
336 inline const Param * TreeInfo::GetEventParamPtr ( const u_int par_num ) const
337  { return ((GetSize() > par_num) ? GetTreeParamPtr(par_num)->GetParamPtr() : NULL); }
338 
339 /*! Retourne le pointeur du paramètre d'événement correspondant au nom
340  * de paramètre de l'arbre.
341  * \param par_name nom de paramètre de l'arbre
342  */
343 inline const Param * TreeInfo::GetEventParamPtr ( const string & par_name ) const
344  {
345  TreeParam * tp = GetTreeParamPtr (par_name);
346  return ( tp == NULL ? NULL : tp->GetParamPtr());
347  }
348 
349 /*! Retourne un pointeur du paramètre d'arbre donné par son nom.
350  * \param par_name nom de paramètre de l'arbre
351  */
352 inline TreeParam * TreeInfo::GetTreeParamPtr ( const string & par_name ) const
353  { return (Find(par_name)); }
354 
355 //----------------------------------------------------------------------
356 
357 /*! Retourne vrai si le fichier d'arbre est ouvert.*/
358 inline Bool_t TreeInfo::IsOpen ( )
359  { return ( (file_ptr != NULL) ? kTRUE : kFALSE ); }
360 
361 /*! Retourne vrai si le fichier d'arbre est fermé./ inline Bool_t TreeInfo::IsClosed ( ) { return ( (file_ptr == NULL) ? kTRUE : kFALSE ); } /*! Retourne vrai si le fichier d'arbre est verrouillé, c'est à dire * si sa définition est figée. */ inline Bool_t TreeInfo::IsLocked ( ) { return ( (status & treeLocked) != 0 ); } //---------------------------------------------------------------------- /*! Démarre l'arbre, ce qui autorise l'incrémentation.*/ inline void TreeInfo::Start() { status = status - (status & (treeStopped | treeSuspended)); } /*! Stoppe l'arbre, ce qui interdit l'incrémentation, jusqu'à ce que * l'arbre soit à nouveau démarré. */ inline void TreeInfo::Stop() { status = status | treeStopped; } /*! Suspend l'arbre, ce qui interdit l'incrémentation pour un seul * événement (en fait pour une tentative d'incrémentation: le bit * correspondant est remis à zéro par l'incrémentation). */ inline void TreeInfo::Suspend() { status = status | treeSuspended; } /*! Retourne vrai si l'arbre est démarré (il peut cependant être suspendu).*/ inline bool TreeInfo::IsStarted () const { return ( ((status & treeStopped) == 0) ? true : false ); } /*! Retourne vrai si l'arbre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool TreeInfo::IsIncremented () const { return ( ((status & (treeStopped | treeSuspended)) == 0) ? true : false ); } /*! Retourne vrai si l'arbre est arrêté.*/ inline bool TreeInfo::IsStopped () const { return ( ((status & treeStopped) != 0) ? true : false ); } /*! Retourne vrai si l'arbre est suspendu.*/ inline bool TreeInfo::IsSuspended () const { return ( ((status & treeSuspended) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne le nom du filtre associé au TTree, ou une chaîne vide.*/ inline string TreeInfo::GetFilterName() const { return ( (*filter_ptr) == NULL ? "" : (*filter_ptr)->GetName() ); } /*! Méthode qui retourne une chaîne décrivant le filtre d'un TTree.*/ inline string TreeInfo::FilterInfo ( ) const { return ( (*filter_ptr == NULL) ? "" : " Filter = " + (*filter_ptr)->GetName() + " [" + (*filter_ptr)->TypeName() + "]" ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé à l'arbre est valide.*/ inline bool TreeInfo::FilterCheck () const { if ((*filter_ptr) == NULL) return (true); else return ((*filter_ptr)->Ok()); } /*! Retourne la valeur précalculée du filtre, pour l'incrémentation * automatique plus rapide. */ inline bool TreeInfo::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else return ((*filter_ptr)->GetInternalValue()); } /*! Méthode générique pour l'incrémentation d'un arbre: la méthode * vérifie que l'arbre est démarré et l'état des filtres. */ inline void TreeInfo::Increment ( ) { if (IsIncremented() && FilterCheck()) IncrementTree ( ); // retire le bit de suspension status = status - (status & treeSuspended); } /*! Méthode générique pour l'incrémentation d'un arbre: la méthode * vérifie que l'arbre est démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void TreeInfo::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) IncrementTree ( ); // retire le bit de suspension de spectre status = status - (status & treeSuspended); } /*! Retourne le pointeur sur le filtre conditionnant l'arbre, ou NULL * si l'arbre n'est pas conditionné. */ inline const Filter *TreeInfo::GetFilterPtr ( ) const { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un arbre. * \param f pointeur sur le filtre */ inline void TreeInfo::SetFilter ( const Filter *f ) { (*filter_ptr) = f; } /*! Retire la condition sur un arbre.*/ inline void TreeInfo::ResetFilter ( ) { (*filter_ptr) = NULL; } //---------------------------------------------------------------------- #endif */
362 inline Bool_t TreeInfo::IsClosed ( )
363  { return ( (file_ptr == NULL) ? kTRUE : kFALSE ); }
364 
365 /*! Retourne vrai si le fichier d'arbre est verrouillé, c'est à dire
366  * si sa définition est figée.
367  */
368 inline Bool_t TreeInfo::IsLocked ( )
369  { return ( (status & treeLocked) != 0 ); }
370 
371 //----------------------------------------------------------------------
372 
373 /*! Démarre l'arbre, ce qui autorise l'incrémentation.*/
374 inline void TreeInfo::Start()
375  { status = status - (status & (treeStopped | treeSuspended)); }
376 
377 /*! Stoppe l'arbre, ce qui interdit l'incrémentation, jusqu'à ce que
378  * l'arbre soit à nouveau démarré. */ inline void TreeInfo::Stop() { status = status | treeStopped; } /*! Suspend l'arbre, ce qui interdit l'incrémentation pour un seul * événement (en fait pour une tentative d'incrémentation: le bit * correspondant est remis à zéro par l'incrémentation). */ inline void TreeInfo::Suspend() { status = status | treeSuspended; } /*! Retourne vrai si l'arbre est démarré (il peut cependant être suspendu).*/ inline bool TreeInfo::IsStarted () const { return ( ((status & treeStopped) == 0) ? true : false ); } /*! Retourne vrai si l'arbre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool TreeInfo::IsIncremented () const { return ( ((status & (treeStopped | treeSuspended)) == 0) ? true : false ); } /*! Retourne vrai si l'arbre est arrêté.*/ inline bool TreeInfo::IsStopped () const { return ( ((status & treeStopped) != 0) ? true : false ); } /*! Retourne vrai si l'arbre est suspendu.*/ inline bool TreeInfo::IsSuspended () const { return ( ((status & treeSuspended) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne le nom du filtre associé au TTree, ou une chaîne vide.*/ inline string TreeInfo::GetFilterName() const { return ( (*filter_ptr) == NULL ? "" : (*filter_ptr)->GetName() ); } /*! Méthode qui retourne une chaîne décrivant le filtre d'un TTree.*/ inline string TreeInfo::FilterInfo ( ) const { return ( (*filter_ptr == NULL) ? "" : " Filter = " + (*filter_ptr)->GetName() + " [" + (*filter_ptr)->TypeName() + "]" ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé à l'arbre est valide.*/ inline bool TreeInfo::FilterCheck () const { if ((*filter_ptr) == NULL) return (true); else return ((*filter_ptr)->Ok()); } /*! Retourne la valeur précalculée du filtre, pour l'incrémentation * automatique plus rapide. */ inline bool TreeInfo::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else return ((*filter_ptr)->GetInternalValue()); } /*! Méthode générique pour l'incrémentation d'un arbre: la méthode * vérifie que l'arbre est démarré et l'état des filtres. */ inline void TreeInfo::Increment ( ) { if (IsIncremented() && FilterCheck()) IncrementTree ( ); // retire le bit de suspension status = status - (status & treeSuspended); } /*! Méthode générique pour l'incrémentation d'un arbre: la méthode * vérifie que l'arbre est démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void TreeInfo::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) IncrementTree ( ); // retire le bit de suspension de spectre status = status - (status & treeSuspended); } /*! Retourne le pointeur sur le filtre conditionnant l'arbre, ou NULL * si l'arbre n'est pas conditionné. */ inline const Filter *TreeInfo::GetFilterPtr ( ) const { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un arbre. * \param f pointeur sur le filtre */ inline void TreeInfo::SetFilter ( const Filter *f ) { (*filter_ptr) = f; } /*! Retire la condition sur un arbre.*/ inline void TreeInfo::ResetFilter ( ) { (*filter_ptr) = NULL; } //---------------------------------------------------------------------- #endif
379  */
380 inline void TreeInfo::Stop()
381  { status = status | treeStopped; }
382 
383 /*! Suspend l'arbre, ce qui interdit l'incrémentation pour un seul
384  * événement (en fait pour une tentative d'incrémentation: le bit
385  * correspondant est remis à zéro par l'incrémentation).
386  */
387 inline void TreeInfo::Suspend()
388  { status = status | treeSuspended; }
389 
390 
391 /*! Retourne vrai si l'arbre est démarré (il peut cependant être suspendu).*/
392 inline bool TreeInfo::IsStarted () const
393  { return ( ((status & treeStopped) == 0) ? true : false ); }
394 
395 /*! Retourne vrai si l'arbre est démarré et non suspendu: l'incrémentation
396  * est donc autorisée.
397  */
398 inline bool TreeInfo::IsIncremented () const
399  { return ( ((status & (treeStopped | treeSuspended)) == 0) ? true : false ); }
400 
401 /*! Retourne vrai si l'arbre est arrêté.*/
402 inline bool TreeInfo::IsStopped () const
403  { return ( ((status & treeStopped) != 0) ? true : false ); }
404 
405 /*! Retourne vrai si l'arbre est suspendu.*/
406 inline bool TreeInfo::IsSuspended () const
407  { return ( ((status & treeSuspended) != 0) ? true : false ); }
408 
409 //----------------------------------------------------------------------
410 
411 /*! Retourne le nom du filtre associé au TTree, ou une chaîne vide.*/
412 inline string TreeInfo::GetFilterName() const
413  { return ( (*filter_ptr) == NULL ? "" : (*filter_ptr)->GetName() ); }
414 
415 /*! Méthode qui retourne une chaîne décrivant le filtre d'un TTree.*/
416 inline string TreeInfo::FilterInfo ( ) const
417  { return ( (*filter_ptr == NULL) ? "" : " Filter = "
418  + (*filter_ptr)->GetName() + " ["
419  + (*filter_ptr)->TypeName() + "]" ); }
420 
421 //----------------------------------------------------------------------
422 
423 /*! Retourne vrai si le filtre associé à l'arbre est valide.*/
424 inline bool TreeInfo::FilterCheck () const
425  {
426  if ((*filter_ptr) == NULL)
427  return (true);
428  else
429  return ((*filter_ptr)->Ok());
430  }
431 
432 /*! Retourne la valeur précalculée du filtre, pour l'incrémentation
433  * automatique plus rapide.
434  */
435 inline bool TreeInfo::FilterFastCheck () const
436  {
437  if ((*filter_ptr) == NULL)
438  return (true);
439  else
440  return ((*filter_ptr)->GetInternalValue());
441  }
442 
443 /*! Méthode générique pour l'incrémentation d'un arbre: la méthode
444  * vérifie que l'arbre est démarré et l'état des filtres.
445  */
446 inline void TreeInfo::Increment ( )
447  {
448  if (IsIncremented() && FilterCheck()) IncrementTree ( );
449 
450  // retire le bit de suspension
451  status = status - (status & treeSuspended);
452  }
453 
454 /*! Méthode générique pour l'incrémentation d'un arbre: la méthode
455  * vérifie que l'arbre est démarré et l'état des filtres. Cette
456  * fonction est plus rapide que Increment, car les filtres ne sont
457  * pas recalculés */ inline void TreeInfo::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) IncrementTree ( ); // retire le bit de suspension de spectre status = status - (status & treeSuspended); } /*! Retourne le pointeur sur le filtre conditionnant l'arbre, ou NULL * si l'arbre n'est pas conditionné. */ inline const Filter *TreeInfo::GetFilterPtr ( ) const { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un arbre. * \param f pointeur sur le filtre */ inline void TreeInfo::SetFilter ( const Filter *f ) { (*filter_ptr) = f; } /*! Retire la condition sur un arbre.*/ inline void TreeInfo::ResetFilter ( ) { (*filter_ptr) = NULL; } //---------------------------------------------------------------------- #endif
458  */
459 inline void TreeInfo::IncrementFast ( )
460  {
461  if (IsIncremented() && FilterFastCheck()) IncrementTree ( );
462 
463  // retire le bit de suspension de spectre
464  status = status - (status & treeSuspended);
465  }
466 
467 /*! Retourne le pointeur sur le filtre conditionnant l'arbre, ou NULL
468  * si l'arbre n'est pas conditionné. */ inline const Filter *TreeInfo::GetFilterPtr ( ) const { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un arbre. * \param f pointeur sur le filtre */ inline void TreeInfo::SetFilter ( const Filter *f ) { (*filter_ptr) = f; } /*! Retire la condition sur un arbre.*/ inline void TreeInfo::ResetFilter ( ) { (*filter_ptr) = NULL; } //---------------------------------------------------------------------- #endif
469  */
470 inline const Filter *TreeInfo::GetFilterPtr ( ) const
471  { return ( *filter_ptr ); }
472 
473 /*! Applique un filtre comme condition sur un arbre.
474  * \param f pointeur sur le filtre
475  */
476 inline void TreeInfo::SetFilter ( const Filter *f )
477  { (*filter_ptr) = f; }
478 
479 /*! Retire la condition sur un arbre.*/
480 inline void TreeInfo::ResetFilter ( )
481  { (*filter_ptr) = NULL; }
482 
483 //----------------------------------------------------------------------
484 
485 #endif
TreeInfo::IsClosed
virtual Bool_t IsClosed()
Definition: TreeInfo.hh:362
TreeInfo::AddParamRange
virtual Int_t AddParamRange(const Int_t p1, const Int_t p2)
Definition: TreeInfo.cpp:328
TreeInfo::branch_leaf_off
Int_t ** branch_leaf_off
tables des positions des données des feuilles pour chaque branche
Definition: TreeInfo.hh:139
TreeInfo::SetTreeFile
virtual Int_t SetTreeFile(const string &f_name, const UInt_t n_max)
Definition: TreeInfo.cpp:170
TreeInfo::branch_size
Int_t * branch_size
table des tailles des branches (0 pour une branche variable)
Definition: TreeInfo.hh:134
TreeInfo::branch_ptr
TBranch ** branch_ptr
table des pointeurs des branches
Definition: TreeInfo.hh:135
TreeInfo::AddParam
virtual Bool_t AddParam(const Param *p_ptr)
Definition: TreeInfo.cpp:288
TreeInfo::evt_mgr
const EventManager * evt_mgr
pointeur sur le gestionnaire d&#39;événement
Definition: TreeInfo.hh:110
TreeParam
Definition: TreeParam.hh:29
TreeInfo::branch_leaf_cnt
Bool_t ** branch_leaf_cnt
tables des indicateur de compteur pour un paramètre multihit
Definition: TreeInfo.hh:142
TreeInfo::Write
virtual bool Write(ostream &os) const
Definition: TreeInfo.cpp:1052
TreeInfo::GetTreeFile
virtual string GetTreeFile() const
Definition: TreeInfo.hh:308
TreeInfo::~TreeInfo
virtual ~TreeInfo()
Definition: TreeInfo.cpp:116
TreeInfo::IsLocked
virtual Bool_t IsLocked()
Definition: TreeInfo.hh:368
TreeInfo::Start
void Start()
Definition: TreeInfo.hh:374
TreeInfo::tree_file
RString tree_file
nom du fichier de sortie du TTree
Definition: TreeInfo.hh:113
TreeInfo::tree_ptr
TTree * tree_ptr
pointeur sur le TTree de ROOT
Definition: TreeInfo.hh:117
TreeInfo::FilterCheck
bool FilterCheck() const
Definition: TreeInfo.hh:424
TreeInfo::status
u_int status
mot d&#39;état de l&#39;arbre
Definition: TreeInfo.hh:146
TreeInfo::event_max
UInt_t event_max
nombre maxi d&#39;événements
Definition: TreeInfo.hh:126
TreeInfo::SetFilter
virtual void SetFilter(const Filter *f)
Definition: TreeInfo.hh:476
TreeInfo::GetFileBase
virtual string GetFileBase() const
Definition: TreeInfo.hh:304
TreeInfo::GObject
GObject(TreeInfo)
TreeInfo
Definition: TreeInfo.hh:95
TreeInfo::file_number
Int_t file_number
numéro de fichier associé
Definition: TreeInfo.hh:121
TreeInfo::GetMaxEvent
virtual UInt_t GetMaxEvent() const
Definition: TreeInfo.hh:322
TreeList
Definition: TreeList.hh:26
TreeInfo::IncrementFast
virtual void IncrementFast()
Definition: TreeInfo.hh:459
TreeStatus
TreeStatus
Bits d&#39;état des arbres.
Definition: TreeInfo.hh:38
TreeInfo::branch_leaf_size
Int_t ** branch_leaf_size
tables des tailles de type des données des feuilles pour chaque branche
Definition: TreeInfo.hh:140
Filter
Definition: Filter.hh:50
TreeInfo::Close
virtual Int_t Close()
Definition: TreeInfo.cpp:822
TreeInfo::IsSuspended
bool IsSuspended() const
Definition: TreeInfo.hh:406
TreeInfo::ReadTreeInfo
static TreeInfo * ReadTreeInfo(FILE *fptr, const EventManager *mgr, int &error)
Definition: TreeInfo.cpp:1103
TreeInfo::branch_num
UInt_t branch_num
nombre de branches
Definition: TreeInfo.hh:131
TreeInfo::branch_buffer
char ** branch_buffer
table des buffers de données par branche
Definition: TreeInfo.hh:136
TreeInfo::GetTreeParamPtr
TreeParam * GetTreeParamPtr(const u_int par_num) const
Definition: TreeInfo.cpp:247
TreeInfo::filter_ptr
const Filter ** filter_ptr
pointeur sur le filtre associé
Definition: TreeInfo.hh:149
TreeParam::GetParamPtr
virtual const Param * GetParamPtr() const
Definition: TreeParam.hh:92
TreeInfo::event_num
UInt_t event_num
nombre d&#39;événements déjà placés
Definition: TreeInfo.hh:127
TreeInfo::Suspend
void Suspend()
Definition: TreeInfo.hh:387
TreeInfo::branch_leaf_num
Int_t * branch_leaf_num
table des nombres de feuilles par branche
Definition: TreeInfo.hh:137
TreeInfo::FilterInfo
virtual string FilterInfo() const
Definition: TreeInfo.hh:416
TreeInfo::ResetFilter
virtual void ResetFilter()
Definition: TreeInfo.hh:480
TreeInfo::Find
TreeParam * Find(const string &par_name) const
Definition: TreeInfo.cpp:354
TreeInfo::IncrementTree
virtual void IncrementTree()
Definition: TreeInfo.cpp:893
TreeInfo::GetEventParamPtr
const Param * GetEventParamPtr(const u_int par_num) const
Definition: TreeInfo.hh:336
TreeInfo::branch_name
string * branch_name
table des noms des branches
Definition: TreeInfo.hh:132
TreeInfo::ClassDef
ClassDef(TreeInfo, 0)
TreeInfo::FilterFastCheck
bool FilterFastCheck() const
Definition: TreeInfo.hh:435
FilterList
Definition: FilterList.hh:37
TreeInfo::branch_leaf_ptr
TLeaf *** branch_leaf_ptr
tables des pointeurs des feuilles pour chaque branche
Definition: TreeInfo.hh:138
TreeInfo::GetFilterPtr
virtual const Filter * GetFilterPtr() const
Definition: TreeInfo.hh:470
TreeInfo::IsOpen
virtual Bool_t IsOpen()
Definition: TreeInfo.hh:358
TreeInfo::file_name
string file_name
nom effectif du fichier en cours
Definition: TreeInfo.hh:114
Param
Definition: Param.hh:83
TreeInfo::GetParamName
virtual string GetParamName(const UInt_t par_num) const
Definition: TreeInfo.hh:295
TreeInfo::SetFileBase
virtual void SetFileBase(const string &f_base)
Definition: TreeInfo.cpp:449
TreeInfo::file_sub
Int_t file_sub
numéro de fichier associé
Definition: TreeInfo.hh:122
TreeInfo::TreeInfo
TreeInfo(const string &t_name, const EventManager *mgr, const string &f_name="", UInt_t n_max=10000000)
Definition: TreeInfo.cpp:25
TreeInfo::AddAllParam
virtual Int_t AddAllParam()
Definition: TreeInfo.cpp:318
TreeInfo::Increment
virtual void Increment()
Definition: TreeInfo.hh:446
TreeInfo::tree_mode
UInt_t tree_mode
mode de création des fichiers
Definition: TreeInfo.hh:125
TreeInfo::IsIncremented
bool IsIncremented() const
Definition: TreeInfo.hh:398
TreeInfo::branch_leaf_par
const Param *** branch_leaf_par
tables des paramètres associés feuilles pour chaque branche
Definition: TreeInfo.hh:141
TreeInfo::UsesContour
virtual bool UsesContour(const RContour *ct, const bool rec=true) const
Definition: TreeInfo.cpp:860
TreeInfo::GetTTreePtr
virtual TTree * GetTTreePtr() const
Definition: TreeInfo.hh:316
TreeInfo::GetParamNumber
virtual UInt_t GetParamNumber() const
Definition: TreeInfo.hh:289
TreeInfo::Stop
void Stop()
Definition: TreeInfo.hh:380
TreeInfo::tree_dir
string tree_dir
répertoire du TTree dans l&#39;arborescence ROOT
Definition: TreeInfo.hh:116
TreeInfo::GetFileNumber
virtual Int_t GetFileNumber() const
Definition: TreeInfo.hh:300
TreeMode
TreeMode
Modes de renouvellement des fichiers d&#39;arbres.
Definition: TreeInfo.hh:48
TreeInfo::Init
virtual Int_t Init()
Definition: TreeInfo.cpp:470
TreeInfo::IsStopped
bool IsStopped() const
Definition: TreeInfo.hh:402
TreeInfo::GetFilterName
string GetFilterName() const
Definition: TreeInfo.hh:412
TreeInfo::file_ptr
TFile * file_ptr
pointeur sur le fichier ROOT associé
Definition: TreeInfo.hh:118
TreeInfo::GetFileName
virtual string GetFileName() const
Definition: TreeInfo.hh:312
TreeInfo::Open
virtual Int_t Open()
Definition: TreeInfo.cpp:702
TreeInfo::file_base
string file_base
nom de base de fichier associé
Definition: TreeInfo.hh:123
TreeInfo::IsStarted
bool IsStarted() const
Definition: TreeInfo.hh:392
TreeInfo::UsesFilter
virtual bool UsesFilter(const Filter *f, const bool rec=true) const
Definition: TreeInfo.cpp:877
TreeInfo::branch_def
string * branch_def
table des définitions des branches
Definition: TreeInfo.hh:133
TreeInfo::SetFileNumber
virtual void SetFileNumber(const Int_t f_num, Int_t f_sub=0)
Definition: TreeInfo.cpp:428
TreeInfo::GetFileMode
virtual UInt_t GetFileMode() const
Definition: TreeInfo.hh:326
EventManager
Definition: EventManager.hh:59
TreeInfo::iterator
GListIterT< TreeParam > iterator
Définition du type itérateur pour les listes de paramètres d&#39;arbres.
Definition: TreeInfo.hh:106