Analysis  version 7.0 - august 2014
Spectrum.hh
Go to the documentation of this file.
1 //======================================================================
2 /*! \file Spectrum.hh
3  *
4  * Déclaration des fonctions de la classe Spectrum qui est la classe
5  * de base pour les spectres associés aux paramètres d'un événement.
6  *
7  * Les spectres peuvent être protégés pour empêcher qu'ils ne soient
8  * sauvegardés ou supprimés dans les listes (en particulier par
9  * l'interface graphique).
10  *
11  *
12  * octobre 2011
13  * - protection contre sauvegarde et suppression
14  * 8 septembre 2009
15  * - spectres tridim
16  * 19 mai 2009
17  * - spectres conditionnés par plusieurs filtres
18  */
19 //======================================================================
20 
21 #ifndef SPECTRUM_HH
22 #define SPECTRUM_HH
23 
24 #include "EventCommon.hh"
25 #include "Event.hh"
26 #include "Filter.hh"
27 
28 #define SPECTRUM_ID "SPECTRUM: " ///< Texte identifiant un spectre dans un fichier
29 
30 class TH1;
31 class SpectrumList;
32 class SpectrumFamily;
33 
34 //======================================================================
35 
36 /// Bits d'état des spectres
37 enum SpectrumStatus
38 {
39  // bits liés à l'incrémentation du spectre
40  spectrumSuspended = 0x00000001,
41  spectrumStopped = 0x00000002,
42 
43  // bits liés à la sélection de spectres
44  spectrumSelection = 0x00000100,
45  spectrumSaveSelection = 0x00000200,
46  spectrumDeleteSelection = 0x00000400,
47 
48  // bit indiquant qu'un spectre calculé vient d'être mis à jour
49  // ce bit est positionné par la fonction Update() et retiré par la
50  // fonction d'incrémentation (pour les spectres calculés)
51  spectrumUpdated = 0x00001000,
52 
53  // bits de protection contre certaines actions
54  spectrumSaveProtect = 0x00100000,
55  spectrumDeleteProtect = 0x00200000
56 
57 };
58 
59 /// Types de spectres
60 enum SpectrumTypes
61 {
62  spectrumTypeUndefined = 0, // Spectrum type: non défini
63  spectrumTypeMono = 1, // Spectrum type: Mono
64  spectrumTypeBidim = 2, // Spectrum type: Bidim
65  spectrumTypeTridim = 3, // Spectrum type: Tridim
66  spectrumTypeDistrib = 4, // Spectrum type: Distrib
67  spectrumTypeTrace = 5, // Spectrum type: Trace
68  spectrumTypeCumul = 6, // Spectrum type: Cumul
69 
70  // spectres sans paramètres ni opérandes
71  spectrumTypeHisto = 7, // Spectrum type: Histogramme défini en externe
72  spectrumTypeExtern = 8, // Spectrum type: Histogramme d'un fichier externe
73  spectrumTypeUser1D = 9, // Spectrum type: utilisateur 1D
74  spectrumTypeUser2D = 10, // Spectrum type: utilisateur 2D
75 
76  // spectres opération: 1 opérande
77  spectrumTypeNorm = 11, // Spectrum type: normalisé spectrumTypeSqrt = 12, // Spectrum type: racine carrée spectrumTypeInv = 13, // Spectrum type: inverse // spectres opération: 2 opérandes spectrumTypeSum = 14, // Spectrum type: somme spectrumTypeProd = 15, // Spectrum type: produit spectrumTypeDiv = 16, // Spectrum type: division // spectres opération: N opérandes spectrumTypeSumN = 17, // Spectrum type: somme de N spectres spectrumTypeHSum = 18, // Spectrum type: summed histogram or spectrum spectrumTypeHMean = 19, // Spectrum type: average histogram or spectrum spectrumTypeHCumul = 20 // Spectrum type: cumulated 1D histogram or spectrum }; ///! Maximum number of different spectra types #define SPECTRUM_TYPE_MAX 32 // Types de spectres #define SPECTRUM_TYPE_TXT_MONO "Mono" ///< Nom du type de spectre: Mono #define SPECTRUM_TYPE_TXT_BIDIM "Bidim" ///< Nom du type de spectre: Bidim #define SPECTRUM_TYPE_TXT_TRIDIM "Tridim" ///< Nom du type de spectre: Tridim #define SPECTRUM_TYPE_TXT_DISTRIB "Distrib" ///< Nom du type de spectre: Distrib #define SPECTRUM_TYPE_TXT_TRACE "Trace" ///< Nom du type de spectre: Trace #define SPECTRUM_TYPE_TXT_CUMUL "Cumul" ///< Nom du type de spectre: Cumul #define SPECTRUM_TYPE_TXT_HISTO "Histo" ///< Nom du type de spectre: histogramme externe #define SPECTRUM_TYPE_TXT_EXTERN "Extern" ///< Nom du type de spectre: Histo d'un fichier externe #define SPECTRUM_TYPE_TXT_USER1D "User1D" ///< Nom du type de spectre: utilisateur 1D #define SPECTRUM_TYPE_TXT_USER2D "User2D" ///< Nom du type de spectre: utilisateur 2D #define SPECTRUM_TYPE_TXT_NORM "Norm" ///< Nom du type de spectre: opération normalisation #define SPECTRUM_TYPE_TXT_SQRT "Sqrt" ///< Nom du type de spectre: opération racine carrée #define SPECTRUM_TYPE_TXT_INV "Inv" ///< Nom du type de spectre: opération inversion #define SPECTRUM_TYPE_TXT_SUM "Sum" ///< Nom du type de spectre: somme de 2 spectres #define SPECTRUM_TYPE_TXT_PROD "Product" ///< Nom du type de spectre: produit de spectres #define SPECTRUM_TYPE_TXT_DIV "Division" ///< Nom du type de spectre: division de spectres #define SPECTRUM_TYPE_TXT_SUM_N "SumN" ///< Nom du type de spectre: somme de N spectres #define SPECTRUM_TYPE_TXT_HSUM "HSum" ///< Nom du type de spectre: event by event summed histogram #define SPECTRUM_TYPE_TXT_HMEAN "HMean" ///< Nom du type de spectre: event by event averaged histogram #define SPECTRUM_TYPE_TXT_HCUMUL "HCumul" ///< Nom du type de spectre: event by event superimosed 1D histogram // Etat des spectres #define SPECTRUM_STATUS_TXT_STARTED "started" ///< Etat du spectre: démarré #define SPECTRUM_STATUS_TXT_STOPPED "stopped" ///< Etat du spectre: arrêté #define SPECTRUM_STATUS_TXT_SUSPENDED "suspended" ///< Etat du spectre: suspendu /*! Bits de comparaison de spectres: * - type de spectres. * - dimension (1D / 2D) des spectres. * - taille des spectres (nombre de canaux), qui implique également * la même dimension. * - bornes des axes, qui implique également la même dimension. */ enum SpectrumCompare { specCompType = 0x00000001, specCompDim = 0x00000002, specCompSize = 0x00000004, specCompBounds = 0x00000008 }; /// Identificateur des types de spectres extern const char *spectrumTypeId[]; //====================================================================== /*! \class Spectrum * * C'est la classe de base des spectres associés aux paramètres de * l'événement. * On distingue trois types de spectres: * - les spectres incrémentés à partir de paramètres * - les spectres constants, obtenus à partir d'un histogramme dans un * fichier externe * - les spectres calculés à partir d'autres spectres * * Pour les spectres est liés à un ou plusieurs paramètres, l'incrémentation * se fait à partir des valeurs de ces paramètres, événement par * événement. * Les spectres calculés sont mis à jour (recalculés) seulement si nécessaire: * pour la sauvegarde, l'affichage, ... Pour ces spectres, l'appel à la * fonction d'incrémentation (en principe après traitement d'un événement), * retire le bit indiquant que le spectre est à jour. * Les spectres provenant d'histogrammes de fichiers externes ne sont ni * incrémentés, ni mis à jour. * * * \par Filtrage des spectres * * Les filtres n'ont pas d'effet sur les spectres externes ou les spectres * calculés. * * Un spectre peut être dans différents états: * - \b démarré: l'incrémentation du spectre est alors autorisée; c'est * l'état d'un spectre à sa création. * - \b arrêté: l'incrémentation du spectre n'est alors pas autorisée, et * ce jusqu'à ce que le spectre soit à nouveau démarré. * - \b suspendu: l'incrémentation du spectre est interdite une fois; après * cette tentative, le bit d'état correspondant à la suspension est * remis à 0. * * \note * Les méthodes liées aux familles de spectres sont protégées, car c'est * le gestionnaire de spectres (SpectrumList) qui s'en occuppe. * * Filtres des spectres (voir SetFilter, SetFilters, ResetFilter,...) * - on peut associer un filtre à un spectre, afin de conditionner son * incrémentation (uniquement pour les spectres incrémentés à partir * des valeurs de paramètres, et non pour des spectres calculés). * - on peut aussi conditionner avec plusieurs filtres, dans ce cas un * filtre intermédiaire (ET logique) est créé. * * Dans le cas d'une condition avec plusieurs filtres, la procédure * d'incrémentation des spectres est un peu ralentie, parce que le filtre * créé localement n'est pas pré-testé, ne faisant pas partie de la liste * de filtres de l'analyse. * * \par protection des spectres * * Les spectres peuvent être protégés pour empêcher qu'ils ne soient * sauvegardés ou supprimés dans les listes (en particulier par * l'interface graphique). * * Ceci présente un intérêt dans le cas de spectres qui sont créés par * programme et qui ne doivent donc pas être sauvegardés ou détruits * de façon inconsidérée, en particulier dans l'interface graphique. * * En principe, il s'agit essentiellement de spectres créés dans le * code, dont la suppression risque de générer un plantage du programme, * ou que la sauvegarde dans le cadre d'une analyse complète risque * de duppliquer en cas de chargement de l'analyse lors d'une nouvelle * exécution du programme. * * \note * Attention, dans le cas des spectres opérations ou des spectres * utilisés comme opérande pour des spectres opérations, ces * protections peuvent conduire à des situations indésirables. * Par exemple un spectre opérande pourrait être détruit alors * que le spectre opération est protégé ! * Il est conseillé d'utiliser plutôt les fonctions de la classe * EventManager, qui veillent à la cohérence de ces protections. */ class Spectrum : public GNamed { //---------------------------------------------------------------------- /*! \object_doc */ GObjectV(Spectrum); //---------------------------------------------------------------------- friend class SpectrumList; friend class SpectrumFamily; friend class FilterList; protected: static u_int name_len; ///< Longueur d'affichage des noms de spectres static u_int type_len; ///< Longueur d'affichage des types de spectres static u_int param_name_len; ///< Longueur d'affichage des noms de paramètres static u_int dim_len; ///< Longueur d'affichage des dimensions static u_int bound_len; ///< Longueur d'affichage des limites de spectre static u_int bound_prec; ///< Précision d'affichage des limites de spectre u_int status; ///< Mot d'état du spectre TH1 * histo_ptr; ///< Pointeur sur l'histogramme Root #ifndef __CINT__ /*! Indicateur de famille du spectre (c'est un pointeur de pointeur * pour que la famille de spectre puisse être modifiée dans un * spectre déclaré constant) */ SpectrumFamily **family_ptr; const Filter **filter_ptr; ///< Pointeur sur filtre associé bool *filter_local; ///< Indique si le filtre est créé localement comme un "ET" d'un ensemble de filtres #endif public: //---------------------------------------------------------------------- // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR //---------------------------------------------------------------------- // Constructeur Spectrum ( const string & spec_name ); // Constructeur de recopie Spectrum ( const Spectrum & original ); // Destructeur virtual ~Spectrum (); //---------------------------------------------------------------------- // //---------------------------------------------------------------------- // renvoit un nom de spectre valide static string ValidName ( const string s_name ); // Retourne le nom des axes du spectre string GetTitleX() const; string GetTitleY() const; string GetTitleZ() const; string GetFamilyName() const; string GetFilterName() const; // Retourne le pointeur sur l'histogramme ROOT TH1 * GetHistoPtr() const; // Ecriture du spectre. virtual bool Write ( ostream & os ); virtual bool Write ( FILE * fptr ); /*! Ecriture des données du filtre dans une chaîne de définition.*/ virtual string DefinitionString ( ) const = 0; // données de base virtual string BaseDefinitionString ( ) const; // Lecture de la définition d'un spectre. static Spectrum * ReadSpectrum ( FILE *fptr, const EventManager * evt_mgr, string & fam, string & filt, int & error ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt, int & error ); //---------------------------------------------------------------------- // Fonctions liées à l'état des spectres // Modifie l'état d'incrémentation des spectres virtual void Start ( ); virtual void Stop ( ); virtual void Suspend ( ); // Retourne l'état d'incrémentation des spectres virtual bool IsStarted ( ) const; // démarré (suspendu ou non) virtual bool IsStopped ( ) const; // arrêté virtual bool IsSuspended ( ) const; // suspendu virtual bool IsIncremented ( ) const; // démarré et non suspendu virtual bool IsUpdated ( ) const; // pas besoin de MAJ // Bits de sélections virtual void SetSelectionBit ( const bool b = true ); virtual void SetSaveSelectionBit ( const bool b = true ); virtual void SetDeleteSelectionBit ( const bool b = true ); virtual bool GetSelectionBit ( ) const; virtual bool GetSaveSelectionBit ( ) const; virtual bool GetDeleteSelectionBit ( ) const; // bits de protection virtual void SetSaveProtection ( const bool b = true ); virtual void SetDeleteProtection ( const bool b = true ); virtual bool GetSaveProtection ( ) const; virtual bool GetDeleteProtection ( ) const; //---------------------------------------------------------------------- // Retourne vrai si le filtre associé au spectre est valide bool FilterCheck () const; // Retourne une chaîne décrivant l'état du spectre virtual string StatusString () const; // Remise à zéro d'un spectre. virtual void Reset ( ); // Function called before new event processing virtual void ClearEvent ( ); // inline // Fonction générique pour l'incrémentation des spectres (sur des paramètres) virtual void Increment ( ); protected: // méthode générique pour l'incrémentation des spectres, avec // précalcul des filtres virtual void IncrementFast ( ); public: // Fonction générique pour la mise à jour des spectres (calculés) virtual void Update ( ); protected: // Retourne la valeur précalculée du filtre bool FilterFastCheck ( ) const; bool FilterFastLocalCheck ( ) const; public: virtual SpectrumFamily * GetFamilyPtr ( ); virtual const SpectrumFamily * GetFamilyPtr ( ) const; virtual bool SetFamily ( SpectrumFamily *family ); virtual void ResetFamily ( ); virtual const Filter * GetFilterPtr ( ); virtual void SetFilter ( const Filter *f ); virtual bool SetFilters ( const string &filt_names, const EventManager *evt_mgr ); virtual void ResetFilter ( ); // test si un spectre 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; virtual bool UsesSpectrum ( const Spectrum *sp, const bool rec = true ) const; // fonctions de comparaison de spectres static bool Compare ( const Spectrum *spec1, const Spectrum *spec2, const UInt_t flags ); static Int_t Compare ( const Spectrum *spec1, const Spectrum *spec2 ); static bool Compare ( const int sp_num, const Spectrum **sp_tab, const UInt_t flags ); /*! Redéfinition de la fonction pour GNamedListT (pour liste pouvant être triée). * C'est le résultat de GNamed::Compare. * \param spec spectre à comparer */ inline virtual int Compare ( const Spectrum &spec ) const { return (GNamed::Compare(spec)); } //---------------------------------------------------------------------- // FONCTIONS VIRTUELLES PURES //---------------------------------------------------------------------- /*! Méthode virtuelle pure qui retourne la dimension d'un spectre. */ virtual u_int Dimension ( ) const = 0; /*! Méthode virtuelle pure qui retourne l'identificateur du type * de spectre. */ virtual u_int TypeId ( ) const = 0; /*! Méthode virtuelle pure qui retourne le nom du type * de spectre. */ virtual string Type ( ) const = 0; /*! Fonction qui renvoit le pointeur sur le paramètre * X du spectre, ou NULL. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetXParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Y du spectre, ou NULL s'il n'y a pas de paramètre Y pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetYParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
78  spectrumTypeSqrt = 12, // Spectrum type: racine carrée spectrumTypeInv = 13, // Spectrum type: inverse // spectres opération: 2 opérandes spectrumTypeSum = 14, // Spectrum type: somme spectrumTypeProd = 15, // Spectrum type: produit spectrumTypeDiv = 16, // Spectrum type: division // spectres opération: N opérandes spectrumTypeSumN = 17, // Spectrum type: somme de N spectres spectrumTypeHSum = 18, // Spectrum type: summed histogram or spectrum spectrumTypeHMean = 19, // Spectrum type: average histogram or spectrum spectrumTypeHCumul = 20 // Spectrum type: cumulated 1D histogram or spectrum }; ///! Maximum number of different spectra types #define SPECTRUM_TYPE_MAX 32 // Types de spectres #define SPECTRUM_TYPE_TXT_MONO "Mono" ///< Nom du type de spectre: Mono #define SPECTRUM_TYPE_TXT_BIDIM "Bidim" ///< Nom du type de spectre: Bidim #define SPECTRUM_TYPE_TXT_TRIDIM "Tridim" ///< Nom du type de spectre: Tridim #define SPECTRUM_TYPE_TXT_DISTRIB "Distrib" ///< Nom du type de spectre: Distrib #define SPECTRUM_TYPE_TXT_TRACE "Trace" ///< Nom du type de spectre: Trace #define SPECTRUM_TYPE_TXT_CUMUL "Cumul" ///< Nom du type de spectre: Cumul #define SPECTRUM_TYPE_TXT_HISTO "Histo" ///< Nom du type de spectre: histogramme externe #define SPECTRUM_TYPE_TXT_EXTERN "Extern" ///< Nom du type de spectre: Histo d'un fichier externe #define SPECTRUM_TYPE_TXT_USER1D "User1D" ///< Nom du type de spectre: utilisateur 1D #define SPECTRUM_TYPE_TXT_USER2D "User2D" ///< Nom du type de spectre: utilisateur 2D #define SPECTRUM_TYPE_TXT_NORM "Norm" ///< Nom du type de spectre: opération normalisation #define SPECTRUM_TYPE_TXT_SQRT "Sqrt" ///< Nom du type de spectre: opération racine carrée #define SPECTRUM_TYPE_TXT_INV "Inv" ///< Nom du type de spectre: opération inversion #define SPECTRUM_TYPE_TXT_SUM "Sum" ///< Nom du type de spectre: somme de 2 spectres #define SPECTRUM_TYPE_TXT_PROD "Product" ///< Nom du type de spectre: produit de spectres #define SPECTRUM_TYPE_TXT_DIV "Division" ///< Nom du type de spectre: division de spectres #define SPECTRUM_TYPE_TXT_SUM_N "SumN" ///< Nom du type de spectre: somme de N spectres #define SPECTRUM_TYPE_TXT_HSUM "HSum" ///< Nom du type de spectre: event by event summed histogram #define SPECTRUM_TYPE_TXT_HMEAN "HMean" ///< Nom du type de spectre: event by event averaged histogram #define SPECTRUM_TYPE_TXT_HCUMUL "HCumul" ///< Nom du type de spectre: event by event superimosed 1D histogram // Etat des spectres #define SPECTRUM_STATUS_TXT_STARTED "started" ///< Etat du spectre: démarré #define SPECTRUM_STATUS_TXT_STOPPED "stopped" ///< Etat du spectre: arrêté #define SPECTRUM_STATUS_TXT_SUSPENDED "suspended" ///< Etat du spectre: suspendu /*! Bits de comparaison de spectres: * - type de spectres. * - dimension (1D / 2D) des spectres. * - taille des spectres (nombre de canaux), qui implique également * la même dimension. * - bornes des axes, qui implique également la même dimension. */ enum SpectrumCompare { specCompType = 0x00000001, specCompDim = 0x00000002, specCompSize = 0x00000004, specCompBounds = 0x00000008 }; /// Identificateur des types de spectres extern const char *spectrumTypeId[]; //====================================================================== /*! \class Spectrum * * C'est la classe de base des spectres associés aux paramètres de * l'événement. * On distingue trois types de spectres: * - les spectres incrémentés à partir de paramètres * - les spectres constants, obtenus à partir d'un histogramme dans un * fichier externe * - les spectres calculés à partir d'autres spectres * * Pour les spectres est liés à un ou plusieurs paramètres, l'incrémentation * se fait à partir des valeurs de ces paramètres, événement par * événement. * Les spectres calculés sont mis à jour (recalculés) seulement si nécessaire: * pour la sauvegarde, l'affichage, ... Pour ces spectres, l'appel à la * fonction d'incrémentation (en principe après traitement d'un événement), * retire le bit indiquant que le spectre est à jour. * Les spectres provenant d'histogrammes de fichiers externes ne sont ni * incrémentés, ni mis à jour. * * * \par Filtrage des spectres * * Les filtres n'ont pas d'effet sur les spectres externes ou les spectres * calculés. * * Un spectre peut être dans différents états: * - \b démarré: l'incrémentation du spectre est alors autorisée; c'est * l'état d'un spectre à sa création. * - \b arrêté: l'incrémentation du spectre n'est alors pas autorisée, et * ce jusqu'à ce que le spectre soit à nouveau démarré. * - \b suspendu: l'incrémentation du spectre est interdite une fois; après * cette tentative, le bit d'état correspondant à la suspension est * remis à 0. * * \note * Les méthodes liées aux familles de spectres sont protégées, car c'est * le gestionnaire de spectres (SpectrumList) qui s'en occuppe. * * Filtres des spectres (voir SetFilter, SetFilters, ResetFilter,...) * - on peut associer un filtre à un spectre, afin de conditionner son * incrémentation (uniquement pour les spectres incrémentés à partir * des valeurs de paramètres, et non pour des spectres calculés). * - on peut aussi conditionner avec plusieurs filtres, dans ce cas un * filtre intermédiaire (ET logique) est créé. * * Dans le cas d'une condition avec plusieurs filtres, la procédure * d'incrémentation des spectres est un peu ralentie, parce que le filtre * créé localement n'est pas pré-testé, ne faisant pas partie de la liste * de filtres de l'analyse. * * \par protection des spectres * * Les spectres peuvent être protégés pour empêcher qu'ils ne soient * sauvegardés ou supprimés dans les listes (en particulier par * l'interface graphique). * * Ceci présente un intérêt dans le cas de spectres qui sont créés par * programme et qui ne doivent donc pas être sauvegardés ou détruits * de façon inconsidérée, en particulier dans l'interface graphique. * * En principe, il s'agit essentiellement de spectres créés dans le * code, dont la suppression risque de générer un plantage du programme, * ou que la sauvegarde dans le cadre d'une analyse complète risque * de duppliquer en cas de chargement de l'analyse lors d'une nouvelle * exécution du programme. * * \note * Attention, dans le cas des spectres opérations ou des spectres * utilisés comme opérande pour des spectres opérations, ces * protections peuvent conduire à des situations indésirables. * Par exemple un spectre opérande pourrait être détruit alors * que le spectre opération est protégé ! * Il est conseillé d'utiliser plutôt les fonctions de la classe * EventManager, qui veillent à la cohérence de ces protections. */ class Spectrum : public GNamed { //---------------------------------------------------------------------- /*! \object_doc */ GObjectV(Spectrum); //---------------------------------------------------------------------- friend class SpectrumList; friend class SpectrumFamily; friend class FilterList; protected: static u_int name_len; ///< Longueur d'affichage des noms de spectres static u_int type_len; ///< Longueur d'affichage des types de spectres static u_int param_name_len; ///< Longueur d'affichage des noms de paramètres static u_int dim_len; ///< Longueur d'affichage des dimensions static u_int bound_len; ///< Longueur d'affichage des limites de spectre static u_int bound_prec; ///< Précision d'affichage des limites de spectre u_int status; ///< Mot d'état du spectre TH1 * histo_ptr; ///< Pointeur sur l'histogramme Root #ifndef __CINT__ /*! Indicateur de famille du spectre (c'est un pointeur de pointeur * pour que la famille de spectre puisse être modifiée dans un * spectre déclaré constant) */ SpectrumFamily **family_ptr; const Filter **filter_ptr; ///< Pointeur sur filtre associé bool *filter_local; ///< Indique si le filtre est créé localement comme un "ET" d'un ensemble de filtres #endif public: //---------------------------------------------------------------------- // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR //---------------------------------------------------------------------- // Constructeur Spectrum ( const string & spec_name ); // Constructeur de recopie Spectrum ( const Spectrum & original ); // Destructeur virtual ~Spectrum (); //---------------------------------------------------------------------- // //---------------------------------------------------------------------- // renvoit un nom de spectre valide static string ValidName ( const string s_name ); // Retourne le nom des axes du spectre string GetTitleX() const; string GetTitleY() const; string GetTitleZ() const; string GetFamilyName() const; string GetFilterName() const; // Retourne le pointeur sur l'histogramme ROOT TH1 * GetHistoPtr() const; // Ecriture du spectre. virtual bool Write ( ostream & os ); virtual bool Write ( FILE * fptr ); /*! Ecriture des données du filtre dans une chaîne de définition.*/ virtual string DefinitionString ( ) const = 0; // données de base virtual string BaseDefinitionString ( ) const; // Lecture de la définition d'un spectre. static Spectrum * ReadSpectrum ( FILE *fptr, const EventManager * evt_mgr, string & fam, string & filt, int & error ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt, int & error ); //---------------------------------------------------------------------- // Fonctions liées à l'état des spectres // Modifie l'état d'incrémentation des spectres virtual void Start ( ); virtual void Stop ( ); virtual void Suspend ( ); // Retourne l'état d'incrémentation des spectres virtual bool IsStarted ( ) const; // démarré (suspendu ou non) virtual bool IsStopped ( ) const; // arrêté virtual bool IsSuspended ( ) const; // suspendu virtual bool IsIncremented ( ) const; // démarré et non suspendu virtual bool IsUpdated ( ) const; // pas besoin de MAJ // Bits de sélections virtual void SetSelectionBit ( const bool b = true ); virtual void SetSaveSelectionBit ( const bool b = true ); virtual void SetDeleteSelectionBit ( const bool b = true ); virtual bool GetSelectionBit ( ) const; virtual bool GetSaveSelectionBit ( ) const; virtual bool GetDeleteSelectionBit ( ) const; // bits de protection virtual void SetSaveProtection ( const bool b = true ); virtual void SetDeleteProtection ( const bool b = true ); virtual bool GetSaveProtection ( ) const; virtual bool GetDeleteProtection ( ) const; //---------------------------------------------------------------------- // Retourne vrai si le filtre associé au spectre est valide bool FilterCheck () const; // Retourne une chaîne décrivant l'état du spectre virtual string StatusString () const; // Remise à zéro d'un spectre. virtual void Reset ( ); // Function called before new event processing virtual void ClearEvent ( ); // inline // Fonction générique pour l'incrémentation des spectres (sur des paramètres) virtual void Increment ( ); protected: // méthode générique pour l'incrémentation des spectres, avec // précalcul des filtres virtual void IncrementFast ( ); public: // Fonction générique pour la mise à jour des spectres (calculés) virtual void Update ( ); protected: // Retourne la valeur précalculée du filtre bool FilterFastCheck ( ) const; bool FilterFastLocalCheck ( ) const; public: virtual SpectrumFamily * GetFamilyPtr ( ); virtual const SpectrumFamily * GetFamilyPtr ( ) const; virtual bool SetFamily ( SpectrumFamily *family ); virtual void ResetFamily ( ); virtual const Filter * GetFilterPtr ( ); virtual void SetFilter ( const Filter *f ); virtual bool SetFilters ( const string &filt_names, const EventManager *evt_mgr ); virtual void ResetFilter ( ); // test si un spectre 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; virtual bool UsesSpectrum ( const Spectrum *sp, const bool rec = true ) const; // fonctions de comparaison de spectres static bool Compare ( const Spectrum *spec1, const Spectrum *spec2, const UInt_t flags ); static Int_t Compare ( const Spectrum *spec1, const Spectrum *spec2 ); static bool Compare ( const int sp_num, const Spectrum **sp_tab, const UInt_t flags ); /*! Redéfinition de la fonction pour GNamedListT (pour liste pouvant être triée). * C'est le résultat de GNamed::Compare. * \param spec spectre à comparer */ inline virtual int Compare ( const Spectrum &spec ) const { return (GNamed::Compare(spec)); } //---------------------------------------------------------------------- // FONCTIONS VIRTUELLES PURES //---------------------------------------------------------------------- /*! Méthode virtuelle pure qui retourne la dimension d'un spectre. */ virtual u_int Dimension ( ) const = 0; /*! Méthode virtuelle pure qui retourne l'identificateur du type * de spectre. */ virtual u_int TypeId ( ) const = 0; /*! Méthode virtuelle pure qui retourne le nom du type * de spectre. */ virtual string Type ( ) const = 0; /*! Fonction qui renvoit le pointeur sur le paramètre * X du spectre, ou NULL. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetXParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Y du spectre, ou NULL s'il n'y a pas de paramètre Y pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetYParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
79  spectrumTypeInv = 13, // Spectrum type: inverse
80 
81  // spectres opération: 2 opérandes
82  spectrumTypeSum = 14, // Spectrum type: somme
83  spectrumTypeProd = 15, // Spectrum type: produit
84  spectrumTypeDiv = 16, // Spectrum type: division
85 
86  // spectres opération: N opérandes
87  spectrumTypeSumN = 17, // Spectrum type: somme de N spectres
88 
89  spectrumTypeHSum = 18, // Spectrum type: summed histogram or spectrum
90  spectrumTypeHMean = 19, // Spectrum type: average histogram or spectrum
91 
92  spectrumTypeHCumul = 20 // Spectrum type: cumulated 1D histogram or spectrum
93 };
94 
95 ///! Maximum number of different spectra types
96 #define SPECTRUM_TYPE_MAX 32
97 
98 
99 // Types de spectres
100 #define SPECTRUM_TYPE_TXT_MONO "Mono" ///< Nom du type de spectre: Mono
101 #define SPECTRUM_TYPE_TXT_BIDIM "Bidim" ///< Nom du type de spectre: Bidim
102 #define SPECTRUM_TYPE_TXT_TRIDIM "Tridim" ///< Nom du type de spectre: Tridim
103 #define SPECTRUM_TYPE_TXT_DISTRIB "Distrib" ///< Nom du type de spectre: Distrib
104 #define SPECTRUM_TYPE_TXT_TRACE "Trace" ///< Nom du type de spectre: Trace
105 #define SPECTRUM_TYPE_TXT_CUMUL "Cumul" ///< Nom du type de spectre: Cumul
106 #define SPECTRUM_TYPE_TXT_HISTO "Histo" ///< Nom du type de spectre: histogramme externe
107 #define SPECTRUM_TYPE_TXT_EXTERN "Extern" ///< Nom du type de spectre: Histo d'un fichier externe
108 #define SPECTRUM_TYPE_TXT_USER1D "User1D" ///< Nom du type de spectre: utilisateur 1D
109 #define SPECTRUM_TYPE_TXT_USER2D "User2D" ///< Nom du type de spectre: utilisateur 2D
110 #define SPECTRUM_TYPE_TXT_NORM "Norm" ///< Nom du type de spectre: opération normalisation
111 #define SPECTRUM_TYPE_TXT_SQRT "Sqrt" ///< Nom du type de spectre: opération racine carrée
112 #define SPECTRUM_TYPE_TXT_INV "Inv" ///< Nom du type de spectre: opération inversion
113 #define SPECTRUM_TYPE_TXT_SUM "Sum" ///< Nom du type de spectre: somme de 2 spectres
114 #define SPECTRUM_TYPE_TXT_PROD "Product" ///< Nom du type de spectre: produit de spectres
115 #define SPECTRUM_TYPE_TXT_DIV "Division" ///< Nom du type de spectre: division de spectres
116 #define SPECTRUM_TYPE_TXT_SUM_N "SumN" ///< Nom du type de spectre: somme de N spectres
117 #define SPECTRUM_TYPE_TXT_HSUM "HSum" ///< Nom du type de spectre: event by event summed histogram
118 #define SPECTRUM_TYPE_TXT_HMEAN "HMean" ///< Nom du type de spectre: event by event averaged histogram
119 #define SPECTRUM_TYPE_TXT_HCUMUL "HCumul" ///< Nom du type de spectre: event by event superimosed 1D histogram
120 
121 // Etat des spectres
122 #define SPECTRUM_STATUS_TXT_STARTED "started" ///< Etat du spectre: démarréroduit de spectres@
123 #define SPECTRUM_STATUS_TXT_STOPPED "stopped" ///< Etat du spectre: arrêté
124 #define SPECTRUM_STATUS_TXT_SUSPENDED "suspended" ///< Etat du spectre: suspendu
125 
126 
127 /*! Bits de comparaison de spectres:
128  * - type de spectres.
129  * - dimension (1D / 2D) des spectres.
130  * - taille des spectres (nombre de canaux), qui implique également
131  * la même dimension.
132  * - bornes des axes, qui implique également la même dimension.
133  */
134 enum SpectrumCompare
135 {
136  specCompType = 0x00000001,
137  specCompDim = 0x00000002,
138  specCompSize = 0x00000004,
139  specCompBounds = 0x00000008
140 };
141 
142 /// Identificateur des types de spectres
143 extern const char *spectrumTypeId[];
144 
145 //======================================================================
146 /*! \class Spectrum
147  *
148  * C'est la classe de base des spectres associés aux paramètres de
149  * l'événement.
150  * On distingue trois types de spectres:
151  * - les spectres incrémentés à partir de paramètres
152  * - les spectres constants, obtenus à partir d'un histogramme dans un
153  * fichier externe
154  * - les spectres calculés à partir d'autres spectres
155  *
156  * Pour les spectres est liés à un ou plusieurs paramètres, l'incrémentation
157  * se fait à partir des valeurs de ces paramètres, événement par
158  * événement.
159  * Les spectres calculés sont mis à jour (recalculés) seulement si nécessaire:
160  * pour la sauvegarde, l'affichage, ... Pour ces spectres, l'appel à la
161  * fonction d'incrémentation (en principe après traitement d'un événement),
162  * retire le bit indiquant que le spectre est à jour.
163  * Les spectres provenant d'histogrammes de fichiers externes ne sont ni
164  * incrémentés, ni mis à jour.
165  *
166  *
167  * \par Filtrage des spectres
168  *
169  * Les filtres n'ont pas d'effet sur les spectres externes ou les spectres
170  * calculés.
171  *
172  * Un spectre peut être dans différents états:
173  * - \b démarré: l'incrémentation du spectre est alors autorisée; c'est
174  * l'état d'un spectre à sa création.
175  * - \b arrêté: l'incrémentation du spectre n'est alors pas autorisée, et
176  * ce jusqu'à ce que le spectre soit à nouveau démarré. * - \b suspendu: l'incrémentation du spectre est interdite une fois; après * cette tentative, le bit d'état correspondant à la suspension est * remis à 0. * * \note * Les méthodes liées aux familles de spectres sont protégées, car c'est * le gestionnaire de spectres (SpectrumList) qui s'en occuppe. * * Filtres des spectres (voir SetFilter, SetFilters, ResetFilter,...) * - on peut associer un filtre à un spectre, afin de conditionner son * incrémentation (uniquement pour les spectres incrémentés à partir * des valeurs de paramètres, et non pour des spectres calculés). * - on peut aussi conditionner avec plusieurs filtres, dans ce cas un * filtre intermédiaire (ET logique) est créé. * * Dans le cas d'une condition avec plusieurs filtres, la procédure * d'incrémentation des spectres est un peu ralentie, parce que le filtre * créé localement n'est pas pré-testé, ne faisant pas partie de la liste * de filtres de l'analyse. * * \par protection des spectres * * Les spectres peuvent être protégés pour empêcher qu'ils ne soient * sauvegardés ou supprimés dans les listes (en particulier par * l'interface graphique). * * Ceci présente un intérêt dans le cas de spectres qui sont créés par * programme et qui ne doivent donc pas être sauvegardés ou détruits * de façon inconsidérée, en particulier dans l'interface graphique. * * En principe, il s'agit essentiellement de spectres créés dans le * code, dont la suppression risque de générer un plantage du programme, * ou que la sauvegarde dans le cadre d'une analyse complète risque * de duppliquer en cas de chargement de l'analyse lors d'une nouvelle * exécution du programme. * * \note * Attention, dans le cas des spectres opérations ou des spectres * utilisés comme opérande pour des spectres opérations, ces * protections peuvent conduire à des situations indésirables. * Par exemple un spectre opérande pourrait être détruit alors * que le spectre opération est protégé ! * Il est conseillé d'utiliser plutôt les fonctions de la classe * EventManager, qui veillent à la cohérence de ces protections. */ class Spectrum : public GNamed { //---------------------------------------------------------------------- /*! \object_doc */ GObjectV(Spectrum); //---------------------------------------------------------------------- friend class SpectrumList; friend class SpectrumFamily; friend class FilterList; protected: static u_int name_len; ///< Longueur d'affichage des noms de spectres static u_int type_len; ///< Longueur d'affichage des types de spectres static u_int param_name_len; ///< Longueur d'affichage des noms de paramètres static u_int dim_len; ///< Longueur d'affichage des dimensions static u_int bound_len; ///< Longueur d'affichage des limites de spectre static u_int bound_prec; ///< Précision d'affichage des limites de spectre u_int status; ///< Mot d'état du spectre TH1 * histo_ptr; ///< Pointeur sur l'histogramme Root #ifndef __CINT__ /*! Indicateur de famille du spectre (c'est un pointeur de pointeur * pour que la famille de spectre puisse être modifiée dans un * spectre déclaré constant) */ SpectrumFamily **family_ptr; const Filter **filter_ptr; ///< Pointeur sur filtre associé bool *filter_local; ///< Indique si le filtre est créé localement comme un "ET" d'un ensemble de filtres #endif public: //---------------------------------------------------------------------- // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR //---------------------------------------------------------------------- // Constructeur Spectrum ( const string & spec_name ); // Constructeur de recopie Spectrum ( const Spectrum & original ); // Destructeur virtual ~Spectrum (); //---------------------------------------------------------------------- // //---------------------------------------------------------------------- // renvoit un nom de spectre valide static string ValidName ( const string s_name ); // Retourne le nom des axes du spectre string GetTitleX() const; string GetTitleY() const; string GetTitleZ() const; string GetFamilyName() const; string GetFilterName() const; // Retourne le pointeur sur l'histogramme ROOT TH1 * GetHistoPtr() const; // Ecriture du spectre. virtual bool Write ( ostream & os ); virtual bool Write ( FILE * fptr ); /*! Ecriture des données du filtre dans une chaîne de définition.*/ virtual string DefinitionString ( ) const = 0; // données de base virtual string BaseDefinitionString ( ) const; // Lecture de la définition d'un spectre. static Spectrum * ReadSpectrum ( FILE *fptr, const EventManager * evt_mgr, string & fam, string & filt, int & error ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt, int & error ); //---------------------------------------------------------------------- // Fonctions liées à l'état des spectres // Modifie l'état d'incrémentation des spectres virtual void Start ( ); virtual void Stop ( ); virtual void Suspend ( ); // Retourne l'état d'incrémentation des spectres virtual bool IsStarted ( ) const; // démarré (suspendu ou non) virtual bool IsStopped ( ) const; // arrêté virtual bool IsSuspended ( ) const; // suspendu virtual bool IsIncremented ( ) const; // démarré et non suspendu virtual bool IsUpdated ( ) const; // pas besoin de MAJ // Bits de sélections virtual void SetSelectionBit ( const bool b = true ); virtual void SetSaveSelectionBit ( const bool b = true ); virtual void SetDeleteSelectionBit ( const bool b = true ); virtual bool GetSelectionBit ( ) const; virtual bool GetSaveSelectionBit ( ) const; virtual bool GetDeleteSelectionBit ( ) const; // bits de protection virtual void SetSaveProtection ( const bool b = true ); virtual void SetDeleteProtection ( const bool b = true ); virtual bool GetSaveProtection ( ) const; virtual bool GetDeleteProtection ( ) const; //---------------------------------------------------------------------- // Retourne vrai si le filtre associé au spectre est valide bool FilterCheck () const; // Retourne une chaîne décrivant l'état du spectre virtual string StatusString () const; // Remise à zéro d'un spectre. virtual void Reset ( ); // Function called before new event processing virtual void ClearEvent ( ); // inline // Fonction générique pour l'incrémentation des spectres (sur des paramètres) virtual void Increment ( ); protected: // méthode générique pour l'incrémentation des spectres, avec // précalcul des filtres virtual void IncrementFast ( ); public: // Fonction générique pour la mise à jour des spectres (calculés) virtual void Update ( ); protected: // Retourne la valeur précalculée du filtre bool FilterFastCheck ( ) const; bool FilterFastLocalCheck ( ) const; public: virtual SpectrumFamily * GetFamilyPtr ( ); virtual const SpectrumFamily * GetFamilyPtr ( ) const; virtual bool SetFamily ( SpectrumFamily *family ); virtual void ResetFamily ( ); virtual const Filter * GetFilterPtr ( ); virtual void SetFilter ( const Filter *f ); virtual bool SetFilters ( const string &filt_names, const EventManager *evt_mgr ); virtual void ResetFilter ( ); // test si un spectre 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; virtual bool UsesSpectrum ( const Spectrum *sp, const bool rec = true ) const; // fonctions de comparaison de spectres static bool Compare ( const Spectrum *spec1, const Spectrum *spec2, const UInt_t flags ); static Int_t Compare ( const Spectrum *spec1, const Spectrum *spec2 ); static bool Compare ( const int sp_num, const Spectrum **sp_tab, const UInt_t flags ); /*! Redéfinition de la fonction pour GNamedListT (pour liste pouvant être triée). * C'est le résultat de GNamed::Compare. * \param spec spectre à comparer */ inline virtual int Compare ( const Spectrum &spec ) const { return (GNamed::Compare(spec)); } //---------------------------------------------------------------------- // FONCTIONS VIRTUELLES PURES //---------------------------------------------------------------------- /*! Méthode virtuelle pure qui retourne la dimension d'un spectre. */ virtual u_int Dimension ( ) const = 0; /*! Méthode virtuelle pure qui retourne l'identificateur du type * de spectre. */ virtual u_int TypeId ( ) const = 0; /*! Méthode virtuelle pure qui retourne le nom du type * de spectre. */ virtual string Type ( ) const = 0; /*! Fonction qui renvoit le pointeur sur le paramètre * X du spectre, ou NULL. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetXParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Y du spectre, ou NULL s'il n'y a pas de paramètre Y pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetYParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
177  * - \b suspendu: l'incrémentation du spectre est interdite une fois; après * cette tentative, le bit d'état correspondant à la suspension est * remis à 0. * * \note * Les méthodes liées aux familles de spectres sont protégées, car c'est * le gestionnaire de spectres (SpectrumList) qui s'en occuppe. * * Filtres des spectres (voir SetFilter, SetFilters, ResetFilter,...) * - on peut associer un filtre à un spectre, afin de conditionner son * incrémentation (uniquement pour les spectres incrémentés à partir * des valeurs de paramètres, et non pour des spectres calculés). * - on peut aussi conditionner avec plusieurs filtres, dans ce cas un * filtre intermédiaire (ET logique) est créé. * * Dans le cas d'une condition avec plusieurs filtres, la procédure * d'incrémentation des spectres est un peu ralentie, parce que le filtre * créé localement n'est pas pré-testé, ne faisant pas partie de la liste * de filtres de l'analyse. * * \par protection des spectres * * Les spectres peuvent être protégés pour empêcher qu'ils ne soient * sauvegardés ou supprimés dans les listes (en particulier par * l'interface graphique). * * Ceci présente un intérêt dans le cas de spectres qui sont créés par * programme et qui ne doivent donc pas être sauvegardés ou détruits * de façon inconsidérée, en particulier dans l'interface graphique. * * En principe, il s'agit essentiellement de spectres créés dans le * code, dont la suppression risque de générer un plantage du programme, * ou que la sauvegarde dans le cadre d'une analyse complète risque * de duppliquer en cas de chargement de l'analyse lors d'une nouvelle * exécution du programme. * * \note * Attention, dans le cas des spectres opérations ou des spectres * utilisés comme opérande pour des spectres opérations, ces * protections peuvent conduire à des situations indésirables. * Par exemple un spectre opérande pourrait être détruit alors * que le spectre opération est protégé ! * Il est conseillé d'utiliser plutôt les fonctions de la classe * EventManager, qui veillent à la cohérence de ces protections. */ class Spectrum : public GNamed { //---------------------------------------------------------------------- /*! \object_doc */ GObjectV(Spectrum); //---------------------------------------------------------------------- friend class SpectrumList; friend class SpectrumFamily; friend class FilterList; protected: static u_int name_len; ///< Longueur d'affichage des noms de spectres static u_int type_len; ///< Longueur d'affichage des types de spectres static u_int param_name_len; ///< Longueur d'affichage des noms de paramètres static u_int dim_len; ///< Longueur d'affichage des dimensions static u_int bound_len; ///< Longueur d'affichage des limites de spectre static u_int bound_prec; ///< Précision d'affichage des limites de spectre u_int status; ///< Mot d'état du spectre TH1 * histo_ptr; ///< Pointeur sur l'histogramme Root #ifndef __CINT__ /*! Indicateur de famille du spectre (c'est un pointeur de pointeur * pour que la famille de spectre puisse être modifiée dans un * spectre déclaré constant) */ SpectrumFamily **family_ptr; const Filter **filter_ptr; ///< Pointeur sur filtre associé bool *filter_local; ///< Indique si le filtre est créé localement comme un "ET" d'un ensemble de filtres #endif public: //---------------------------------------------------------------------- // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR //---------------------------------------------------------------------- // Constructeur Spectrum ( const string & spec_name ); // Constructeur de recopie Spectrum ( const Spectrum & original ); // Destructeur virtual ~Spectrum (); //---------------------------------------------------------------------- // //---------------------------------------------------------------------- // renvoit un nom de spectre valide static string ValidName ( const string s_name ); // Retourne le nom des axes du spectre string GetTitleX() const; string GetTitleY() const; string GetTitleZ() const; string GetFamilyName() const; string GetFilterName() const; // Retourne le pointeur sur l'histogramme ROOT TH1 * GetHistoPtr() const; // Ecriture du spectre. virtual bool Write ( ostream & os ); virtual bool Write ( FILE * fptr ); /*! Ecriture des données du filtre dans une chaîne de définition.*/ virtual string DefinitionString ( ) const = 0; // données de base virtual string BaseDefinitionString ( ) const; // Lecture de la définition d'un spectre. static Spectrum * ReadSpectrum ( FILE *fptr, const EventManager * evt_mgr, string & fam, string & filt, int & error ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt ); static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt, int & error ); //---------------------------------------------------------------------- // Fonctions liées à l'état des spectres // Modifie l'état d'incrémentation des spectres virtual void Start ( ); virtual void Stop ( ); virtual void Suspend ( ); // Retourne l'état d'incrémentation des spectres virtual bool IsStarted ( ) const; // démarré (suspendu ou non) virtual bool IsStopped ( ) const; // arrêté virtual bool IsSuspended ( ) const; // suspendu virtual bool IsIncremented ( ) const; // démarré et non suspendu virtual bool IsUpdated ( ) const; // pas besoin de MAJ // Bits de sélections virtual void SetSelectionBit ( const bool b = true ); virtual void SetSaveSelectionBit ( const bool b = true ); virtual void SetDeleteSelectionBit ( const bool b = true ); virtual bool GetSelectionBit ( ) const; virtual bool GetSaveSelectionBit ( ) const; virtual bool GetDeleteSelectionBit ( ) const; // bits de protection virtual void SetSaveProtection ( const bool b = true ); virtual void SetDeleteProtection ( const bool b = true ); virtual bool GetSaveProtection ( ) const; virtual bool GetDeleteProtection ( ) const; //---------------------------------------------------------------------- // Retourne vrai si le filtre associé au spectre est valide bool FilterCheck () const; // Retourne une chaîne décrivant l'état du spectre virtual string StatusString () const; // Remise à zéro d'un spectre. virtual void Reset ( ); // Function called before new event processing virtual void ClearEvent ( ); // inline // Fonction générique pour l'incrémentation des spectres (sur des paramètres) virtual void Increment ( ); protected: // méthode générique pour l'incrémentation des spectres, avec // précalcul des filtres virtual void IncrementFast ( ); public: // Fonction générique pour la mise à jour des spectres (calculés) virtual void Update ( ); protected: // Retourne la valeur précalculée du filtre bool FilterFastCheck ( ) const; bool FilterFastLocalCheck ( ) const; public: virtual SpectrumFamily * GetFamilyPtr ( ); virtual const SpectrumFamily * GetFamilyPtr ( ) const; virtual bool SetFamily ( SpectrumFamily *family ); virtual void ResetFamily ( ); virtual const Filter * GetFilterPtr ( ); virtual void SetFilter ( const Filter *f ); virtual bool SetFilters ( const string &filt_names, const EventManager *evt_mgr ); virtual void ResetFilter ( ); // test si un spectre 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; virtual bool UsesSpectrum ( const Spectrum *sp, const bool rec = true ) const; // fonctions de comparaison de spectres static bool Compare ( const Spectrum *spec1, const Spectrum *spec2, const UInt_t flags ); static Int_t Compare ( const Spectrum *spec1, const Spectrum *spec2 ); static bool Compare ( const int sp_num, const Spectrum **sp_tab, const UInt_t flags ); /*! Redéfinition de la fonction pour GNamedListT (pour liste pouvant être triée). * C'est le résultat de GNamed::Compare. * \param spec spectre à comparer */ inline virtual int Compare ( const Spectrum &spec ) const { return (GNamed::Compare(spec)); } //---------------------------------------------------------------------- // FONCTIONS VIRTUELLES PURES //---------------------------------------------------------------------- /*! Méthode virtuelle pure qui retourne la dimension d'un spectre. */ virtual u_int Dimension ( ) const = 0; /*! Méthode virtuelle pure qui retourne l'identificateur du type * de spectre. */ virtual u_int TypeId ( ) const = 0; /*! Méthode virtuelle pure qui retourne le nom du type * de spectre. */ virtual string Type ( ) const = 0; /*! Fonction qui renvoit le pointeur sur le paramètre * X du spectre, ou NULL. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetXParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Y du spectre, ou NULL s'il n'y a pas de paramètre Y pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetYParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
178  * cette tentative, le bit d'état correspondant à la suspension est
179  * remis à 0.
180  *
181  * \note
182  * Les méthodes liées aux familles de spectres sont protégées, car c'est
183  * le gestionnaire de spectres (SpectrumList) qui s'en occuppe.
184  *
185  * Filtres des spectres (voir SetFilter, SetFilters, ResetFilter,...)
186  * - on peut associer un filtre à un spectre, afin de conditionner son
187  * incrémentation (uniquement pour les spectres incrémentés à partir
188  * des valeurs de paramètres, et non pour des spectres calculés).
189  * - on peut aussi conditionner avec plusieurs filtres, dans ce cas un
190  * filtre intermédiaire (ET logique) est créé.
191  *
192  * Dans le cas d'une condition avec plusieurs filtres, la procédure
193  * d'incrémentation des spectres est un peu ralentie, parce que le filtre
194  * créé localement n'est pas pré-testé, ne faisant pas partie de la liste
195  * de filtres de l'analyse.
196  *
197  * \par protection des spectres
198  *
199  * Les spectres peuvent être protégés pour empêcher qu'ils ne soient
200  * sauvegardés ou supprimés dans les listes (en particulier par
201  * l'interface graphique).
202  *
203  * Ceci présente un intérêt dans le cas de spectres qui sont créés par
204  * programme et qui ne doivent donc pas être sauvegardés ou détruits
205  * de façon inconsidérée, en particulier dans l'interface graphique.
206  *
207  * En principe, il s'agit essentiellement de spectres créés dans le
208  * code, dont la suppression risque de générer un plantage du programme,
209  * ou que la sauvegarde dans le cadre d'une analyse complète risque
210  * de duppliquer en cas de chargement de l'analyse lors d'une nouvelle
211  * exécution du programme.
212  *
213  * \note
214  * Attention, dans le cas des spectres opérations ou des spectres
215  * utilisés comme opérande pour des spectres opérations, ces
216  * protections peuvent conduire à des situations indésirables.
217  * Par exemple un spectre opérande pourrait être détruit alors
218  * que le spectre opération est protégé !
219  * Il est conseillé d'utiliser plutôt les fonctions de la classe
220  * EventManager, qui veillent à la cohérence de ces protections.
221  */
222 class Spectrum : public GNamed
223 {
224 //----------------------------------------------------------------------
225  /*! \object_doc */
226  GObjectV(Spectrum);
227 //----------------------------------------------------------------------
228 
229  friend class SpectrumList;
230  friend class SpectrumFamily;
231  friend class FilterList;
232 
233  protected:
234  static u_int name_len; ///< Longueur d'affichage des noms de spectres
235  static u_int type_len; ///< Longueur d'affichage des types de spectres
236  static u_int param_name_len; ///< Longueur d'affichage des noms de paramètres
237  static u_int dim_len; ///< Longueur d'affichage des dimensions
238  static u_int bound_len; ///< Longueur d'affichage des limites de spectre
239  static u_int bound_prec; ///< Précision d'affichage des limites de spectre
240 
241  u_int status; ///< Mot d'état du spectre
242 
243  TH1 * histo_ptr; ///< Pointeur sur l'histogramme Root
244 
245 #ifndef __CINT__
246  /*! Indicateur de famille du spectre (c'est un pointeur de pointeur
247  * pour que la famille de spectre puisse être modifiée dans un
248  * spectre déclaré constant)
249  */
250  SpectrumFamily **family_ptr;
251 
252  const Filter **filter_ptr; ///< Pointeur sur filtre associémpBounqî
253  bool *filter_local; ///< Indique si le filtre est créé localement comme un "ET" d'un ensemble de filtres
254 #endif
255 
256  public:
257 
258 //----------------------------------------------------------------------
259 // CONSTRUCTEUR / AFFECTATION / DESTRUCTEUR
260 //----------------------------------------------------------------------
261 
262  // Constructeur
263  Spectrum ( const string & spec_name );
264 
265  // Constructeur de recopie
266  Spectrum ( const Spectrum & original );
267 
268  // Destructeur
269  virtual ~Spectrum ();
270 
271 //----------------------------------------------------------------------
272 //
273 //----------------------------------------------------------------------
274 
275  // renvoit un nom de spectre valide
276  static string ValidName ( const string s_name );
277 
278  // Retourne le nom des axes du spectre
279  string GetTitleX() const;
280  string GetTitleY() const;
281  string GetTitleZ() const;
282 
283  string GetFamilyName() const;
284  string GetFilterName() const;
285 
286  // Retourne le pointeur sur l'histogramme ROOT
287  TH1 * GetHistoPtr() const;
288 
289  // Ecriture du spectre.
290  virtual bool Write ( ostream & os );
291  virtual bool Write ( FILE * fptr );
292 
293  /*! Ecriture des données du filtre dans une chaîne de définition.*/
294  virtual string DefinitionString ( ) const = 0;
295 
296  // données de base
297  virtual string BaseDefinitionString ( ) const;
298 
299  // Lecture de la définition d'un spectre.
300  static Spectrum * ReadSpectrum ( FILE *fptr, const EventManager * evt_mgr, string & fam, string & filt, int & error );
301  static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt );
302  static Spectrum * NewSpectrum ( const string & str, const EventManager * evt_mgr, string & fam, string & filt, int & error );
303 
304 //----------------------------------------------------------------------
305 // Fonctions liées à l'état des spectres
306 
307  // Modifie l'état d'incrémentation des spectres
308  virtual void Start ( );
309  virtual void Stop ( );
310  virtual void Suspend ( );
311 
312  // Retourne l'état d'incrémentation des spectres
313  virtual bool IsStarted ( ) const; // démarré (suspendu ou non)
314  virtual bool IsStopped ( ) const; // arrêté
315  virtual bool IsSuspended ( ) const; // suspendu
316  virtual bool IsIncremented ( ) const; // démarré et non suspendu
317  virtual bool IsUpdated ( ) const; // pas besoin de MAJ
318 
319  // Bits de sélections
320  virtual void SetSelectionBit ( const bool b = true );
321  virtual void SetSaveSelectionBit ( const bool b = true );
322  virtual void SetDeleteSelectionBit ( const bool b = true );
323 
324  virtual bool GetSelectionBit ( ) const;
325  virtual bool GetSaveSelectionBit ( ) const;
326  virtual bool GetDeleteSelectionBit ( ) const;
327 
328  // bits de protection
329  virtual void SetSaveProtection ( const bool b = true );
330  virtual void SetDeleteProtection ( const bool b = true );
331  virtual bool GetSaveProtection ( ) const;
332  virtual bool GetDeleteProtection ( ) const;
333 
334 //----------------------------------------------------------------------
335 
336  // Retourne vrai si le filtre associé au spectre est valide
337  bool FilterCheck () const;
338 
339  // Retourne une chaîne décrivant l'état du spectre
340  virtual string StatusString () const;
341 
342  // Remise à zéro d'un spectre.
343  virtual void Reset ( );
344 
345  // Function called before new event processing
346  virtual void ClearEvent ( ); // inline
347 
348  // Fonction générique pour l'incrémentation des spectres (sur des paramètres)
349  virtual void Increment ( );
350 
351  protected:
352  // méthode générique pour l'incrémentation des spectres, avec
353  // précalcul des filtres
354  virtual void IncrementFast ( );
355 
356  public:
357  // Fonction générique pour la mise à jour des spectres (calculés)
358  virtual void Update ( );
359 
360  protected:
361  // Retourne la valeur précalculée du filtre
362  bool FilterFastCheck ( ) const;
363  bool FilterFastLocalCheck ( ) const;
364 
365  public:
366  virtual SpectrumFamily * GetFamilyPtr ( );
367  virtual const SpectrumFamily * GetFamilyPtr ( ) const;
368  virtual bool SetFamily ( SpectrumFamily *family );
369  virtual void ResetFamily ( );
370 
371  virtual const Filter * GetFilterPtr ( );
372  virtual void SetFilter ( const Filter *f );
373  virtual bool SetFilters ( const string &filt_names, const EventManager *evt_mgr );
374  virtual void ResetFilter ( );
375 
376  // test si un spectre utilise un contour ou un filtre
377  // pour vérifier qu'il peut être effacé dans les listes.
378  virtual bool UsesContour ( const RContour *ct, const bool rec = true ) const;
379  virtual bool UsesFilter ( const Filter *f, const bool rec = true ) const;
380  virtual bool UsesSpectrum ( const Spectrum *sp, const bool rec = true ) const;
381 
382  // fonctions de comparaison de spectres
383  static bool Compare ( const Spectrum *spec1, const Spectrum *spec2, const UInt_t flags );
384  static Int_t Compare ( const Spectrum *spec1, const Spectrum *spec2 );
385 
386  static bool Compare ( const int sp_num, const Spectrum **sp_tab, const UInt_t flags );
387 
388  /*! Redéfinition de la fonction pour GNamedListT (pour liste pouvant être triée).
389  * C'est le résultat de GNamed::Compare.
390  * \param spec spectre à comparer
391  */
392  inline virtual int Compare ( const Spectrum &spec ) const
393  { return (GNamed::Compare(spec)); }
394 
395 //----------------------------------------------------------------------
396 // FONCTIONS VIRTUELLES PURES
397 //----------------------------------------------------------------------
398 
399  /*! Méthode virtuelle pure qui retourne la dimension d'un spectre.
400  */
401  virtual u_int Dimension ( ) const = 0;
402 
403  /*! Méthode virtuelle pure qui retourne l'identificateur du type
404  * de spectre.
405  */
406  virtual u_int TypeId ( ) const = 0;
407 
408  /*! Méthode virtuelle pure qui retourne le nom du type
409  * de spectre.
410  */
411  virtual string Type ( ) const = 0;
412 
413  /*! Fonction qui renvoit le pointeur sur le paramètre
414  * X du spectre, ou NULL.
415  * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetXParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Y du spectre, ou NULL s'il n'y a pas de paramètre Y pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetYParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
416  * par les classes dérivées définissant des spectres avec des paramètres.
417  */
418  inline virtual const Param * GetXParamPtr ( ) const { return (NULL); }
419 
420  /*! Fonction qui renvoit le pointeur sur le paramètre
421  * Y du spectre, ou NULL s'il n'y a pas de paramètre Y pour le spectre.
422  * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetYParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le pointeur sur le paramètre * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre. * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
423  * par les classes dérivées définissant des spectres avec des paramètres.
424  */
425  inline virtual const Param * GetYParamPtr ( ) const { return (NULL); }
426 
427  /*! Fonction qui renvoit le pointeur sur le paramètre
428  * Z du spectre, ou NULL s'il n'y a pas de paramètre Z pour le spectre.
429  * Par défaut la fonction renvoit NULL, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual const Param * GetZParamPtr ( ) const { return (NULL); } /*! Fonction qui renvoit le nombre de paramètres associés au spectre. * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul * définit un spectre de dimension 2, mais avec 1 seul paramètre. * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
430  * par les classes dérivées définissant des spectres avec des paramètres.
431  */
432  inline virtual const Param * GetZParamPtr ( ) const { return (NULL); }
433 
434  /*! Fonction qui renvoit le nombre de paramètres associés au spectre.
435  * Il ne s'agit pas de sa dimension: par exemple, la classe SpecCumul
436  * définit un spectre de dimension 2, mais avec 1 seul paramètre.
437  * Par défaut la fonction renvoit 0, mais elle doit être surchargée * par les classes dérivées définissant des spectres avec des paramètres. */ inline virtual Int_t GetParamNumber ( ) const { return (0); } //virtual Int_t GetParamNumber ( ) const = 0; /*! Méthode virtuelle pure qui retourne une chaîne décrivant * un spectre. */ virtual string Definition ( ) const = 0; // Méthode qui retourne une chaîne décrivant le filtre d'un spectre. virtual string FilterInfo ( ) const; // Renomme un spectre et éventuellement ses axes virtual void Rename ( const string &name, const string &name_x = "", const string &name_y = "", const string &name_z = "" ); protected: /*! Fonction par défaut pour l'incrémentation automatique du * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
438  * par les classes dérivées définissant des spectres avec des paramètres.
439  */
440  inline virtual Int_t GetParamNumber ( ) const { return (0); }
441  //virtual Int_t GetParamNumber ( ) const = 0;
442 
443  /*! Méthode virtuelle pure qui retourne une chaîne décrivant
444  * un spectre.
445  */
446  virtual string Definition ( ) const = 0;
447 
448  // Méthode qui retourne une chaîne décrivant le filtre d'un spectre.
449  virtual string FilterInfo ( ) const;
450 
451  // Renomme un spectre et éventuellement ses axes
452  virtual void Rename ( const string &name,
453  const string &name_x = "",
454  const string &name_y = "",
455  const string &name_z = "" );
456 
457  protected:
458 
459  /*! Fonction par défaut pour l'incrémentation automatique du
460  * spectre à partir du paramètre associé. * Cette fonction doit être surchargée pour les classes dérivées. */ virtual void IncrementSpectrum ( ) { }; //---------------------------------------------------------------------- // pour ROOT... public: /*! Définition à usage de ROOT... */ ClassDef(Spectrum,0); } ; //====================================================================== // METHODES INLINE //====================================================================== /*! Retourne le pointeur sur l'histogramme ROOT. */ inline TH1 * Spectrum::GetHistoPtr() const { return (histo_ptr); } //---------------------------------------------------------------------- /*! Démarre le spectre, ce qui autorise l'incrémentation.*/ inline void Spectrum::Start() { status = status - (status & (spectrumStopped | spectrumSuspended)); } /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
461  * Cette fonction doit être surchargée pour les classes dérivées.
462  */
463  virtual void IncrementSpectrum ( ) { };
464 
465 
466 //----------------------------------------------------------------------
467 // pour ROOT...
468  public:
469  /*! Définition à usage de ROOT... */
470  ClassDef(Spectrum,0);
471 } ;
472 
473 
474 //======================================================================
475 // METHODES INLINE
476 //======================================================================
477 
478 /*! Retourne le pointeur sur l'histogramme ROOT.
479  */
480 inline TH1 * Spectrum::GetHistoPtr() const
481  { return (histo_ptr); }
482 
483 //----------------------------------------------------------------------
484 
485 /*! Démarre le spectre, ce qui autorise l'incrémentation.*/
486 inline void Spectrum::Start()
487  { status = status - (status & (spectrumStopped | spectrumSuspended)); }
488 
489 /*! Stoppe le spectre, ce qui interdit l'incrémentation, jusqu'à ce que le
490  * spectre soit à nouveau démarré. */ inline void Spectrum::Stop() { status = status | spectrumStopped; } /*! Suspend le spectre, 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 Spectrum::Suspend() { status = status | spectrumSuspended; } /*! Function called at the beginning of an event. * For most spectra types, the function does nothing. */ inline void Spectrum::ClearEvent() { } /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/ inline bool Spectrum::IsStarted () const { return ( ((status & spectrumStopped) == 0) ? true : false ); } /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation * est donc autorisée. */ inline bool Spectrum::IsIncremented () const { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); } /*! Retourne vrai si le spectre est arrêté.*/ inline bool Spectrum::IsStopped () const { return ( ((status & spectrumStopped) != 0) ? true : false ); } /*! Retourne vrai si le spectre est suspendu.*/ inline bool Spectrum::IsSuspended () const { return ( ((status & spectrumSuspended) != 0) ? true : false ); } /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/ inline bool Spectrum::IsUpdated () const { return ( ((status & spectrumUpdated) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de sélection du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; } /*! Positionne le bit de sélection pour sauvegarde du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetSaveSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; } /*! Positionne le bit de sélection pour suppression du spectre. * \param b état du bit de sélection */ inline void Spectrum::SetDeleteSelectionBit ( const bool b ) { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; } /*! Retourne vrai si le bit de sélection du spectre est actif.*/ inline bool Spectrum::GetSelectionBit () const { return ( ((status & spectrumSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif. * Ce bit est remis à zéro lors d'une sauvegarde. */ inline bool Spectrum::GetSaveSelectionBit () const { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); } /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif. */ inline bool Spectrum::GetDeleteSelectionBit () const { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Positionne le bit de protection contre la sauvegarde du spectre. * Cette protection n'est effective que dans les sauvegardes de listes. * \param b état du bit de protection */ inline void Spectrum::SetSaveProtection ( const bool b ) { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; } /*! Positionne le bit de protection contre la suppression du spectre. * Cette protection n'est effective que dans les supressions de listes. * \param b état du bit de protection */ inline void Spectrum::SetDeleteProtection ( const bool b ) { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; } /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/ inline bool Spectrum::GetSaveProtection () const { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); } /*! Retourne l'état du bit de protection contre la suppression du spectre.*/ inline bool Spectrum::GetDeleteProtection () const { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); } //---------------------------------------------------------------------- /*! Retourne vrai si le filtre associé au spectre est valide.*/ inline bool Spectrum::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 Spectrum::FilterFastCheck () const { if ((*filter_ptr) == NULL) return (true); else { if (*filter_local) // filtre local : pas de test rapide possible return (FilterFastLocalCheck()); else return ((*filter_ptr)->GetInternalValue()); } } /*! Fonction générique pour l'incrémentation d'un spectre: la fonction * vérifie que le spectre et démarré et l'état des filtres. */ inline void Spectrum::Increment ( ) { if (IsIncremented() && FilterCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour l'incrémentation d'un spectre: la méthode * vérifie que le spectre et démarré et l'état des filtres. Cette * fonction est plus rapide que Increment, car les filtres ne sont * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
491  */
492 inline void Spectrum::Stop()
493  { status = status | spectrumStopped; }
494 
495 /*! Suspend le spectre, ce qui interdit l'incrémentation pour un seul
496  * événement (en fait pour une tentative d'incrémentation: le bit
497  * correspondant est remis à zéro par l'incrémentation).
498  */
499 inline void Spectrum::Suspend()
500  { status = status | spectrumSuspended; }
501 
502 /*! Function called at the beginning of an event.
503  * For most spectra types, the function does nothing.
504  */
505 inline void Spectrum::ClearEvent()
506  { }
507 
508 /*! Retourne vrai si le spectre est démarré (il peut cependant être suspendu).*/
509 inline bool Spectrum::IsStarted () const
510  { return ( ((status & spectrumStopped) == 0) ? true : false ); }
511 
512 /*! Retourne vrai si le spectre est démarré et non suspendu: l'incrémentation
513  * est donc autorisée.
514  */
515 inline bool Spectrum::IsIncremented () const
516  { return ( ((status & (spectrumStopped | spectrumSuspended)) == 0) ? true : false ); }
517 
518 /*! Retourne vrai si le spectre est arrêté.*/
519 inline bool Spectrum::IsStopped () const
520  { return ( ((status & spectrumStopped) != 0) ? true : false ); }
521 
522 /*! Retourne vrai si le spectre est suspendu.*/
523 inline bool Spectrum::IsSuspended () const
524  { return ( ((status & spectrumSuspended) != 0) ? true : false ); }
525 
526 /*! Retourne vrai si le spectre n'a pas besoin d'être mis à jour.*/
527 inline bool Spectrum::IsUpdated () const
528  { return ( ((status & spectrumUpdated) != 0) ? true : false ); }
529 
530 //----------------------------------------------------------------------
531 
532 /*! Positionne le bit de sélection du spectre.
533  * \param b état du bit de sélection
534  */
535 inline void Spectrum::SetSelectionBit ( const bool b )
536  { status = ( b ) ? status|spectrumSelection : (status|spectrumSelection) - spectrumSelection; }
537 
538 /*! Positionne le bit de sélection pour sauvegarde du spectre.
539  * \param b état du bit de sélection
540  */
541 inline void Spectrum::SetSaveSelectionBit ( const bool b )
542  { status = ( b ) ? status|spectrumSaveSelection : (status|spectrumSaveSelection) - spectrumSaveSelection; }
543 
544 /*! Positionne le bit de sélection pour suppression du spectre.
545  * \param b état du bit de sélection
546  */
547 inline void Spectrum::SetDeleteSelectionBit ( const bool b )
548  { status = ( b ) ? status|spectrumDeleteSelection : (status|spectrumDeleteSelection) - spectrumDeleteSelection; }
549 
550 
551 /*! Retourne vrai si le bit de sélection du spectre est actif.*/
552 inline bool Spectrum::GetSelectionBit () const
553  { return ( ((status & spectrumSelection) != 0) ? true : false ); }
554 
555 /*! Retourne vrai si le bit de sélection pour sauvegarde du spectre est actif.
556  * Ce bit est remis à zéro lors d'une sauvegarde.
557  */
558 inline bool Spectrum::GetSaveSelectionBit () const
559  { return ( ((status & spectrumSaveSelection) != 0) ? true : false ); }
560 
561 /*! Retourne vrai si le bit de sélection pour suppression du spectre est actif.
562  */
563 inline bool Spectrum::GetDeleteSelectionBit () const
564  { return ( ((status & spectrumDeleteSelection) != 0) ? true : false ); }
565 
566 //----------------------------------------------------------------------
567 
568 /*! Positionne le bit de protection contre la sauvegarde du spectre.
569  * Cette protection n'est effective que dans les sauvegardes de listes.
570  * \param b état du bit de protection
571  */
572 inline void Spectrum::SetSaveProtection ( const bool b )
573  { status = ( b ) ? status|spectrumSaveProtect : (status|spectrumSaveProtect) - spectrumSaveProtect; }
574 
575 /*! Positionne le bit de protection contre la suppression du spectre.
576  * Cette protection n'est effective que dans les supressions de listes.
577  * \param b état du bit de protection
578  */
579 inline void Spectrum::SetDeleteProtection ( const bool b )
580  { status = ( b ) ? status|spectrumDeleteProtect : (status|spectrumDeleteProtect) - spectrumDeleteProtect; }
581 
582 /*! Retourne l'état du bit de protection contre la sauvegarde du spectre.*/
583 inline bool Spectrum::GetSaveProtection () const
584  { return ( ((status & spectrumSaveProtect) != 0) ? true : false ); }
585 
586 /*! Retourne l'état du bit de protection contre la suppression du spectre.*/
587 inline bool Spectrum::GetDeleteProtection () const
588  { return ( ((status & spectrumDeleteProtect) != 0) ? true : false ); }
589 
590 //----------------------------------------------------------------------
591 
592 /*! Retourne vrai si le filtre associé au spectre est valide.*/
593 inline bool Spectrum::FilterCheck () const
594  {
595  if ((*filter_ptr) == NULL)
596  return (true);
597  else
598  return ((*filter_ptr)->Ok());
599  }
600 
601 /*! Retourne la valeur précalculée du filtre, pour l'incrémentation
602  * automatique plus rapide.
603  */
604 inline bool Spectrum::FilterFastCheck () const
605  {
606  if ((*filter_ptr) == NULL)
607  return (true);
608  else
609  {
610  if (*filter_local) // filtre local : pas de test rapide possible
611  return (FilterFastLocalCheck());
612  else
613  return ((*filter_ptr)->GetInternalValue());
614  }
615  }
616 
617 /*! Fonction générique pour l'incrémentation d'un spectre: la fonction
618  * vérifie que le spectre et démarré et l'état des filtres.
619  */
620 inline void Spectrum::Increment ( )
621  {
622  if (IsIncremented() && FilterCheck())
623  {
624  IncrementSpectrum ( );
625 
626  // on retire le bit de mise à jour (pour utilisation récursive)
627  status = status - (status & spectrumUpdated);
628  }
629 
630  // retire le bit de suspension de spectre
631  status = status - (status & spectrumSuspended);
632  }
633 
634 /*! Fonction générique pour l'incrémentation d'un spectre: la méthode
635  * vérifie que le spectre et démarré et l'état des filtres. Cette
636  * fonction est plus rapide que Increment, car les filtres ne sont
637  * pas recalculés */ inline void Spectrum::IncrementFast ( ) { if (IsIncremented() && FilterFastCheck()) { IncrementSpectrum ( ); // on retire le bit de mise à jour (pour utilisation récursive) status = status - (status & spectrumUpdated); } // retire le bit de suspension de spectre status = status - (status & spectrumSuspended); } /*! Fonction générique pour la mise à jour des spectres (pour les * spetres calculés). * Par défaut, cette fonction ne fait rien: à définir dans les * classes dérivées. */ inline void Spectrum::Update ( ) { status = status | spectrumUpdated; } //---------------------------------------------------------------------- /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline SpectrumFamily * Spectrum::GetFamilyPtr ( ) { return ( *family_ptr ); } /*! Retourne le pointeur sur la famille du spectre, ou NULL * si elle n'est pas définie. */ inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const { return ( *family_ptr ); } /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
638  */
639 inline void Spectrum::IncrementFast ( )
640  {
641  if (IsIncremented() && FilterFastCheck())
642  {
643  IncrementSpectrum ( );
644 
645  // on retire le bit de mise à jour (pour utilisation récursive)
646  status = status - (status & spectrumUpdated);
647  }
648 
649  // retire le bit de suspension de spectre
650  status = status - (status & spectrumSuspended);
651  }
652 
653 /*! Fonction générique pour la mise à jour des spectres (pour les
654  * spetres calculés).
655  * Par défaut, cette fonction ne fait rien: à définir dans les
656  * classes dérivées.
657  */
658 inline void Spectrum::Update ( )
659  { status = status | spectrumUpdated; }
660 
661 //----------------------------------------------------------------------
662 
663 /*! Retourne le pointeur sur la famille du spectre, ou NULL
664  * si elle n'est pas définie.
665  */
666 inline SpectrumFamily * Spectrum::GetFamilyPtr ( )
667  { return ( *family_ptr ); }
668 
669 /*! Retourne le pointeur sur la famille du spectre, ou NULL
670  * si elle n'est pas définie.
671  */
672 inline const SpectrumFamily * Spectrum::GetFamilyPtr ( ) const
673  { return ( *family_ptr ); }
674 
675 /*! Retourne le pointeur sur le filtre conditionnant le spectre, ou NULL
676  * si le spectre n'est pas conditionné. */ inline const Filter * Spectrum::GetFilterPtr ( ) { return ( *filter_ptr ); } /*! Applique un filtre comme condition sur un spectre. * Si un filtre était préalablement défini, il est retiré au préalable. * \param f pointeur sur le filtre */ inline void Spectrum::SetFilter ( const Filter *f ) { ResetFilter(); (*filter_ptr) = f; } //---------------------------------------------------------------------- /*! Teste si la définition d'un spectre utilise un autre spectre. * \param sp pointeur sur le spectre auquel il est fait référence * \param rec indique s'il faut chercher récursivement */ inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const { return (false); } //====================================================================== #endif
677  */
678 inline const Filter * Spectrum::GetFilterPtr ( )
679  { return ( *filter_ptr ); }
680 
681 /*! Applique un filtre comme condition sur un spectre.
682  * Si un filtre était préalablement défini, il est retiré au préalable.
683  * \param f pointeur sur le filtre
684  */
685 inline void Spectrum::SetFilter ( const Filter *f )
686  { ResetFilter(); (*filter_ptr) = f; }
687 
688 //----------------------------------------------------------------------
689 
690 /*! Teste si la définition d'un spectre utilise un autre spectre.
691  * \param sp pointeur sur le spectre auquel il est fait référence
692  * \param rec indique s'il faut chercher récursivement
693  */
694 inline bool Spectrum::UsesSpectrum ( const Spectrum *sp, const bool rec ) const
695  { return (false); }
696 
697 //======================================================================
698 #endif
Spectrum::GetSaveSelectionBit
virtual bool GetSaveSelectionBit() const
Definition: Spectrum.hh:558
Spectrum::GetFamilyName
string GetFamilyName() const
Definition: Spectrum.cpp:331
Spectrum::Rename
virtual void Rename(const string &name, const string &name_x="", const string &name_y="", const string &name_z="")
Definition: Spectrum.cpp:251
Spectrum::Type
virtual string Type() const =0
Spectrum::param_name_len
static u_int param_name_len
Longueur d&#39;affichage des noms de paramètres.
Definition: Spectrum.hh:236
Spectrum::GetTitleY
string GetTitleY() const
Definition: Spectrum.cpp:220
Spectrum::UsesContour
virtual bool UsesContour(const RContour *ct, const bool rec=true) const
Definition: Spectrum.cpp:439
SpectrumFamily
Definition: SpectrumFamily.hh:25
Spectrum::IncrementSpectrum
virtual void IncrementSpectrum()
Definition: Spectrum.hh:463
Spectrum::Increment
virtual void Increment()
Definition: Spectrum.hh:620
spectrumTypeId
const char * spectrumTypeId[]
Identificateur des types de spectres.
Definition: Spectrum.cpp:16
Spectrum::Definition
virtual string Definition() const =0
Spectrum::Spectrum
Spectrum(const string &spec_name)
Definition: Spectrum.cpp:36
Spectrum::GetDeleteProtection
virtual bool GetDeleteProtection() const
Definition: Spectrum.hh:587
Spectrum::FilterCheck
bool FilterCheck() const
Definition: Spectrum.hh:593
Spectrum::GetTitleX
string GetTitleX() const
Definition: Spectrum.cpp:207
Spectrum::GetDeleteSelectionBit
virtual bool GetDeleteSelectionBit() const
Definition: Spectrum.hh:563
Spectrum::SetSaveProtection
virtual void SetSaveProtection(const bool b=true)
Definition: Spectrum.hh:572
Spectrum::SetSelectionBit
virtual void SetSelectionBit(const bool b=true)
Definition: Spectrum.hh:535
Spectrum::Compare
static bool Compare(const Spectrum *spec1, const Spectrum *spec2, const UInt_t flags)
Definition: Spectrum.cpp:481
Spectrum::ValidName
static string ValidName(const string s_name)
Definition: Spectrum.cpp:96
Spectrum::SetDeleteProtection
virtual void SetDeleteProtection(const bool b=true)
Definition: Spectrum.hh:579
Spectrum::filter_ptr
const Filter ** filter_ptr
Pointeur sur filtre associé
Definition: Spectrum.hh:252
Filter
Definition: Filter.hh:50
Spectrum::type_len
static u_int type_len
Longueur d&#39;affichage des types de spectres.
Definition: Spectrum.hh:235
Spectrum::filter_local
bool * filter_local
Indique si le filtre est créé localement comme un &quot;ET&quot; d&#39;un ensemble de filtres.
Definition: Spectrum.hh:253
Spectrum::IsSuspended
virtual bool IsSuspended() const
Definition: Spectrum.hh:523
Spectrum::GetFilterPtr
virtual const Filter * GetFilterPtr()
Definition: Spectrum.hh:678
Spectrum::SetFilters
virtual bool SetFilters(const string &filt_names, const EventManager *evt_mgr)
Definition: Spectrum.cpp:347
Spectrum
Definition: Spectrum.hh:222
Spectrum::IsUpdated
virtual bool IsUpdated() const
Definition: Spectrum.hh:527
Spectrum::StatusString
virtual string StatusString() const
Definition: Spectrum.cpp:176
Spectrum::FilterFastCheck
bool FilterFastCheck() const
Definition: Spectrum.hh:604
Spectrum::IsIncremented
virtual bool IsIncremented() const
Definition: Spectrum.hh:515
Spectrum::dim_len
static u_int dim_len
Longueur d&#39;affichage des dimensions.
Definition: Spectrum.hh:237
SpectrumStatus
SpectrumStatus
Bits d&#39;état des spectres.
Definition: Spectrum.hh:37
Spectrum::name_len
static u_int name_len
Longueur d&#39;affichage des noms de spectres.
Definition: Spectrum.hh:234
Spectrum::~Spectrum
virtual ~Spectrum()
Definition: Spectrum.cpp:74
Spectrum::status
u_int status
Mot d&#39;état du spectre.
Definition: Spectrum.hh:241
Spectrum::GetZParamPtr
virtual const Param * GetZParamPtr() const
Definition: Spectrum.hh:432
Spectrum::ClearEvent
virtual void ClearEvent()
Definition: Spectrum.hh:505
Spectrum::DefinitionString
virtual string DefinitionString() const =0
Spectrum::Suspend
virtual void Suspend()
Definition: Spectrum.hh:499
Spectrum::bound_len
static u_int bound_len
Longueur d&#39;affichage des limites de spectre.
Definition: Spectrum.hh:238
Spectrum::bound_prec
static u_int bound_prec
Précision d&#39;affichage des limites de spectre.
Definition: Spectrum.hh:239
Spectrum::NewSpectrum
static Spectrum * NewSpectrum(const string &str, const EventManager *evt_mgr, string &fam, string &filt)
Definition: Spectrum.cpp:1066
Spectrum::UsesFilter
virtual bool UsesFilter(const Filter *f, const bool rec=true) const
Definition: Spectrum.cpp:456
SpectrumCompare
SpectrumCompare
Definition: Spectrum.hh:134
Spectrum::BaseDefinitionString
virtual string BaseDefinitionString() const
Definition: Spectrum.cpp:731
FilterList
Definition: FilterList.hh:37
Spectrum::Write
virtual bool Write(ostream &os)
Definition: Spectrum.cpp:672
Spectrum::Update
virtual void Update()
Definition: Spectrum.hh:658
Spectrum::GetTitleZ
string GetTitleZ() const
Definition: Spectrum.cpp:233
Spectrum::GetHistoPtr
TH1 * GetHistoPtr() const
Definition: Spectrum.hh:480
Param
Definition: Param.hh:83
Spectrum::FilterInfo
virtual string FilterInfo() const
Definition: Spectrum.cpp:148
Spectrum::GObjectV
GObjectV(Spectrum)
Spectrum::GetParamNumber
virtual Int_t GetParamNumber() const
Definition: Spectrum.hh:440
Spectrum::FilterFastLocalCheck
bool FilterFastLocalCheck() const
Definition: Spectrum.cpp:399
Spectrum::Start
virtual void Start()
Definition: Spectrum.hh:486
Spectrum::GetFilterName
string GetFilterName() const
Definition: Spectrum.cpp:122
Spectrum::SetDeleteSelectionBit
virtual void SetDeleteSelectionBit(const bool b=true)
Definition: Spectrum.hh:547
Spectrum::SetFamily
virtual bool SetFamily(SpectrumFamily *family)
Definition: Spectrum.cpp:306
Spectrum::SetSaveSelectionBit
virtual void SetSaveSelectionBit(const bool b=true)
Definition: Spectrum.hh:541
Spectrum::Reset
virtual void Reset()
Definition: Spectrum.cpp:194
Spectrum::ClassDef
ClassDef(Spectrum, 0)
Spectrum::GetSelectionBit
virtual bool GetSelectionBit() const
Definition: Spectrum.hh:552
Spectrum::SetFilter
virtual void SetFilter(const Filter *f)
Definition: Spectrum.hh:685
Spectrum::family_ptr
SpectrumFamily ** family_ptr
Definition: Spectrum.hh:250
Spectrum::GetFamilyPtr
virtual SpectrumFamily * GetFamilyPtr()
Definition: Spectrum.hh:666
Spectrum::Stop
virtual void Stop()
Definition: Spectrum.hh:492
Spectrum::TypeId
virtual u_int TypeId() const =0
Spectrum::Dimension
virtual u_int Dimension() const =0
Spectrum::Compare
virtual int Compare(const Spectrum &spec) const
Definition: Spectrum.hh:392
SpectrumList
Definition: SpectrumList.hh:30
Spectrum::IsStarted
virtual bool IsStarted() const
Definition: Spectrum.hh:509
Spectrum::UsesSpectrum
virtual bool UsesSpectrum(const Spectrum *sp, const bool rec=true) const
Definition: Spectrum.hh:694
Spectrum::IncrementFast
virtual void IncrementFast()
Definition: Spectrum.hh:639
Spectrum::GetSaveProtection
virtual bool GetSaveProtection() const
Definition: Spectrum.hh:583
Spectrum::histo_ptr
TH1 * histo_ptr
Pointeur sur l&#39;histogramme Root.
Definition: Spectrum.hh:243
Spectrum::IsStopped
virtual bool IsStopped() const
Definition: Spectrum.hh:519
Spectrum::ReadSpectrum
static Spectrum * ReadSpectrum(FILE *fptr, const EventManager *evt_mgr, string &fam, string &filt, int &error)
Definition: Spectrum.cpp:757
Spectrum::GetYParamPtr
virtual const Param * GetYParamPtr() const
Definition: Spectrum.hh:425
Spectrum::GetXParamPtr
virtual const Param * GetXParamPtr() const
Definition: Spectrum.hh:418
Spectrum::ResetFamily
virtual void ResetFamily()
Definition: Spectrum.cpp:320
EventManager
Definition: EventManager.hh:59
Spectrum::ResetFilter
virtual void ResetFilter()
Definition: Spectrum.cpp:384
SpectrumTypes
SpectrumTypes
Types de spectres.
Definition: Spectrum.hh:60