LevelScheme.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
 
#ifndef GW_LEVELSCHEME_H
#define GW_LEVELSCHEME_H
#define Gw_LevelScheme GW_LEVELSCHEME_H

#ifndef ROOT_TBits
#include "TBits.h"
#endif

#ifndef ROOT_TObject
#include <TObject.h>
#endif

#ifndef ROOT_TList
#include <TList.h>
#endif

#ifndef ROOT_TLatex
#include <TLatex.h>
#endif

#include "GwLogMessage.h"

#ifndef GW_LEVEL_H
#include "Level.h"
#endif

#ifndef GW_LINK_H
#include "Link.h"
#endif

#ifndef GW_CASCADE_H
#include "Cascade.h"
#endif

#include <map>

class TArrow;
namespace Gw {

  class BaseLevelSchemeReader;
  class BaseLSPlayer;
class LevelScheme : public TObject
{
  friend class BaseLevelSchemeReader;
  friend class BaseLSPlayer;
    
private:
    
    Link*     fCLink;    
    Level*    fCLevel;   
    Cascade*  fCCascade; 
  
    std::map <Int_t, TBits*> fCoincMap; // map of gamma coincidence

  
protected:
    TList fLevels;         // list of levels
    TList fLinks;          // list of links
    TList fCascades;   // list of cascades
    
    TLatex fName;           // LevelScheme's name
    TLatex fReference;  // some information concerning the origin of this level scheme
        TList  fTexts;      // a list of additional TLatex text to add some comments on the level scheme
    TList  fArrows;         // a list of additional TArrow  to add some arrows on the level scheme

    BaseLSPlayer* fPlayer; 
  
protected:
  
  void AddLevel(Level* level);

  void AddLink(Link* link);
  
  void AddCascade(Cascade* Cascade);
  
  void AddText(TLatex* latex);
  
  void AddArrow(TArrow* arrow);

  TList& GetLevelList()   { return fLevels; }
  TList& GetLinkList()    { return fLinks; }
  TList& GetCascadeList() { return fCascades; }
  TList& GetTextList()   { return fTexts; }
  Link* GetCurrentLink() { return fCLink; } 
  Level* GetCurrentLevel() { return fCLevel; } 
  Cascade* GetCurrentCascade() { return fCCascade; } 
  TLatex& GetNameLatex() { return fName; }
  TLatex& GetRefLatex() { return fReference; }

  virtual void FillMap();
  
public:
    LevelScheme();
    LevelScheme(const Char_t *, Option_t *);
    virtual ~LevelScheme();
    
    virtual void Browse(TBrowser *b);
    
    virtual void SetName(const Char_t* name); //*MENU* *ARGS={name=>fName}
    virtual const char* GetName() const; 
    virtual void SetReference(const Char_t *);
    virtual const Char_t * GetReference() const;
  
    Level* NewLevel(const char* name);
    
    Link* NewLink(const char* name);
    
    Cascade* NewCascade(const char* name);
    
    TLatex* NewText(const char* msg);
  
        TArrow* NewArrow(Float_t x1, Float_t y1, Float_t x2, Float_t y2);
  
    const TList & GetLevels();
    const TList & GetLinks();
    const TList & GetCascades();
    const TList & GetTexts();
     
    void SetCLink(Link* link) { fCLink = link; }
    
    const Link* GetCLink() { return fCLink; } 
    
    void SetCLevel(Level* level) { fCLevel = level; }
    
    const Level* GetCLevel() { return fCLevel; } 
    
    void SetCCascade(Cascade* cascade) { fCCascade = cascade; }
    
    const Cascade* GetCCascade() { return fCCascade; } 
  
        BaseLSPlayer* GetPlayer(Option_t* opt="Graphical");
  

    virtual Int_t InitAGS(const Char_t *filename, Option_t *opt = "152Dy");
    

    virtual Int_t InitENSDF(const Char_t *, Option_t *);   
    

    virtual Int_t Import(const Char_t *, Option_t *);    
        
    virtual void Clear(Option_t *opt = ""); 
                         
    virtual void Draw(Option_t *opt = "");
  
    virtual void ls(Option_t* option = "all") const ;

    virtual Int_t DistancetoPrimitive(Int_t px, Int_t py);
  
    virtual void ExecuteEvent(Int_t event, Int_t px, Int_t py);
  
    virtual TList* FindLinkInCascade(Link* link) const;
  
    virtual TList* FindCLinkInCascade() const;

    virtual const TList* FindLink(Level* level) const;
  
    virtual void SortLevels(Bool_t order = kSortAscending) { fLevels.Sort(order); }
  
    virtual TBits* GetBitMap(Link* link);
  
protected:
  
  mutable LogMessage fLog; 
  

    ClassDef(LevelScheme,4); // a level scheme is a list of levels, links and cascades
};
// inline members
inline const TList & LevelScheme::GetLevels() { return fLevels;}
inline const TList & LevelScheme::GetLinks()  { return fLinks; }
inline const TList & LevelScheme::GetCascades() { return fCascades; }
inline const TList & LevelScheme::GetTexts() { return fTexts; }
inline void  LevelScheme::SetName(const Char_t *name) { fName.SetTitle(name); }
inline void  LevelScheme::SetReference(const Char_t *ref) { fReference.SetTitle(ref); }
inline const Char_t * LevelScheme::GetName() const { return fName.GetTitle(); }
inline const Char_t * LevelScheme::GetReference() const { return fReference.GetTitle(); }
}
#endif