LevelScheme.cpp

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.             *
 ***************************************************************************/
 
// root include's 

#ifndef ROOT_TArrow
#include "TArrow.h"
#endif

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

#ifndef ROOT_TObjArray
#include <TObjArray.h>
#endif

#ifndef ROOT_TPad
#include <TPad.h>
#endif

#ifndef ROOT_TString
#include <TString.h>
#endif

#ifndef ROOT_TStyle
#include <TStyle.h>
#endif


// gw include's 
#ifndef GW_ENSDF_H
#include "ENSDF.h"
#endif


#ifndef Gw_GLSPlayer
#include "GLSPlayer.h"
#endif

#ifndef Gw_LevelScheme
#include "LevelScheme.h"
#endif

#ifndef GW_NUCLEARLEVEL_H
#include "NuclearLevel.h"
#endif

#ifndef GW_XGAMMALINK_H
#include "XGammaLink.h"
#endif

using namespace Gw;
   
ClassImp(LevelScheme);

//__________________________________________________________
LevelScheme::LevelScheme()
 : TObject(),
   fCLink(0x0),
   fCLevel(0x0),
   fCCascade(0x0),
   fPlayer(0x0),
   fLog("LevelScheme")
{
  fLevels.SetOwner(kTRUE);   fLinks.SetOwner(kTRUE); 
  fCascades.SetOwner(kTRUE); fTexts.SetOwner(kTRUE);
  fArrows.SetOwner(kTRUE);
  
  fName.SetTextAlign(22);
  fName.SetTextColor(1);
}

//__________________________________________________________
LevelScheme::LevelScheme(const Char_t* filename, Option_t* opt)
 : TObject(),
   fCLink(0x0),
   fCLevel(0x0),
   fCCascade(0x0),
   fLog("LevelScheme")
{     
    fLevels.SetOwner(kTRUE);   fLinks.SetOwner(kTRUE); 
    fCascades.SetOwner(kTRUE); fTexts.SetOwner(kTRUE);
        fArrows.SetOwner(kTRUE);

    LevelScheme::Import(filename, opt);
    fName.SetTextAlign(22);
    fName.SetTextColor(1);
}

//__________________________________________________________
LevelScheme::~LevelScheme()
{
        if ( fPlayer ) 
                fPlayer->Disconnect();
        
  delete fPlayer;
  map<Int_t, TBits*>::iterator im; // iterator on the map prototype
  for (im = fCoincMap.begin() ; im !=  fCoincMap.end() ; ++im ) delete im->second;      
}


//__________________________________________________________
BaseLSPlayer* LevelScheme::GetPlayer(Option_t* opt)
{
  
  if (!fPlayer) {
        
        TString options(opt);
        if ( options.Contains("Graphical") )
          fPlayer = new GLSPlayer(this);
        else {
          fLog.SetProcessMethod("SetPlayer(Option_t* )");
          fLog << error << "Player type not defined" << dolog;
          return 0x0;
        }
        fPlayer->Connect();
  }
  
  return fPlayer;
}


//__________________________________________________________
void LevelScheme::AddLevel(Level* level)
{
  level->SetUniqueID(fLevels.GetEntries()); // for the moment
  fLevels.Add(level);
}

//__________________________________________________________
void LevelScheme::AddLink(Link* link)
{
  link->SetUniqueID(fLinks.GetEntries()); // for the moment
  fLinks.Add(link);
}

//__________________________________________________________
void LevelScheme::AddCascade(Cascade* cascade)
{
  fCascades.Add(cascade);
}

//__________________________________________________________
void LevelScheme::FillMap()
{
  TBits* bitMap   = 0x0;
  
  for (Int_t i = 0; i < fLinks.GetEntries(); ++i) {
    Link* link1 = static_cast<Link*> ( fLinks.At(i) );
    bitMap = new TBits(fLinks.GetEntries());

    for (Int_t j = 0; j < fLinks.GetEntries(); ++j) {
      if (j == i) continue;
      Link* link2 = static_cast<Link*> ( fLinks.At(j) ); 
      if( link1->GetIL() == link2->GetFL() ) 
        bitMap->SetBitNumber(link2->GetUniqueID(), true);
    }
    fCoincMap[i] = bitMap;
  }
  
}

//__________________________________________________________
TBits* LevelScheme::GetBitMap(Link* link) 
{
  // this method gives the bit map for the links in coincidence above a given link
  // WARNING: does not fully work for all cases
  
  fLog.SetProcessMethod("SGetBitMap(Link* l )");
  fLog << warning << "Method not fully implemented, results not reliable for all cases" << nline;

  static Bool_t first = true;
  
  if (first) {
    FillMap();
    first = false;
  }
  
  TBits* bitMap  = fCoincMap[link->GetUniqueID()];
  TBits* bitMapC = fCoincMap[link->GetUniqueID()];
  TBits* bitMapT = 0x0;
  
  Link* linkC    = 0x0;
  
  if ( !bitMapC->CountBits() ) return bitMap;
  
    for (UInt_t i = 0; i < bitMapC->GetNbits(); ++i) {
      if ( bitMapC->TestBitNumber(i) ) {
        linkC = static_cast<Link*> ( fLinks.At(i) );
        bitMapT = GetBitMap(linkC);
        bitMap->operator|=(*bitMapT);
      }
    }    
  
  fLog << dolog;
  
  return bitMap;
}

//__________________________________________________________
void LevelScheme::AddText(TLatex* text)
{
  fTexts.Add(text);
}

//__________________________________________________________
void LevelScheme::AddArrow(TArrow* arrow)
{
  fArrows.Add(arrow);
}

//__________________________________________________________
Level* LevelScheme::NewLevel(const char* /*name*/)
{
  Level* lev = new Level();
  return lev;
}

//__________________________________________________________
Link* LevelScheme::NewLink(const char* /*name*/)
{
  Link* link = new Link();
  return link;
}

//__________________________________________________________
Cascade* LevelScheme::NewCascade(const char* /*name*/)
{
  Cascade* cas = new Cascade();
  return cas;
}

//__________________________________________________________
TLatex* LevelScheme::NewText(const char* msg)
{
  TLatex* text = new TLatex(0., 0., msg);
  fTexts.Add(text);
  return text;
}

//__________________________________________________________
TArrow* LevelScheme::NewArrow(Float_t x1, Float_t y1, Float_t x2, Float_t y2)
{
  TArrow* arrow = new TArrow(x1, y1, x2, y2);
  fArrows.Add(arrow);
  return arrow;
}

//__________________________________________________________
void LevelScheme::Browse(TBrowser *b)
{
  if ( b ) this->Draw();        
}

//__________________________________________________________
Int_t LevelScheme::Import(const Char_t* filename, Option_t* opt)
{
  // import file with dedicated readers
  return GetPlayer()->ImportLevelScheme(filename, opt);

}   

//__________________________________________________________
Int_t LevelScheme::InitENSDF(const Char_t *filename, Option_t *opt)
{
  // for backward compatibility
  return GetPlayer()->ReadENSDF(filename, opt);

}

//__________________________________________________________
Int_t LevelScheme::InitAGS(const Char_t *filename, Option_t *opt)
{
  // for backward compatibility
  return GetPlayer()->ReadAGS(filename, opt);
}


//__________________________________________________________
void LevelScheme::Draw(Option_t *opt)
{
  // draw level scheme
  TString options(opt);
  options.ToLower();
  
  if (options.Contains("ground")) {
    fName.Draw();
    fLevels.Draw();
  } else if (fLevels.GetEntries() == 0) {
    GetPlayer()->Draw("new");
    return;
  } else {
     GetPlayer()->Draw(opt);
  }
  fTexts.Draw();
  fArrows.Draw();
  AppendPad(opt);  
}

//__________________________________________________________
Int_t LevelScheme::DistancetoPrimitive(Int_t px, Int_t py)
{
  Int_t d = fName.DistancetoPrimitive(px, py);
  return d;
}
 
//__________________________________________________________
void LevelScheme::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
  fName.ExecuteEvent(event, px, py);
}

//__________________________________________________________
TList* LevelScheme::FindLinkInCascade(Link* link) const
{
  TList* list = new TList();
  list->SetOwner(false);
  
  for (Int_t i = 0; i < fCascades.GetEntries(); ++i) {
    Cascade* cas = static_cast<Cascade*> ( fCascades.At(i) );
    if (cas->FindObject(link))
      list->Add(cas);
  }
    
  return list;
}

//__________________________________________________________
TList* LevelScheme::FindCLinkInCascade() const
{
  if (fCLink)
    return FindLinkInCascade(fCLink);
  else 
    return 0x0;
}

//__________________________________________________________
const TList* LevelScheme::FindLink(Level* level) const
{
  TIter next(&fLinks);
  
  TList* list = new TList();
  list->SetOwner(false);
  
  Link *link = 0x0;
  while ( (link = (Link *)next()) ){
    if (link->GetIL() == level || link->GetFL() == level)
      list->Add(link);
  }
  
  return list;
}

//__________________________________________________________
void LevelScheme::ls(Option_t *o) const 
{
        TString opt = o; 
        if ( opt.Contains("all") ) {
                cout << "Level Scheme: " << endl;
                cout << " " << GetName() << " (" << GetReference() << ") \n";
                cout << "Links/Levels List: " << endl;          
                TIter iter(&fLinks); Link *link;
                while ( (link = (Link *)iter()) ){
                        cout << " "; link->ls();
                        if ( link->GetIL() ) {
                                cout << "  From "; link->GetIL()->ls(o);
                        }
                        else cout << " Not linked " << endl;
                        if ( link->GetFL() ) {
                                cout << "  To   "; link->GetFL()->ls(o);
                        }
                        else cout << " Not linked " << endl;
                }
        }
        if ( opt.Contains("level") ) {
                cout << "Level Scheme: " << endl;
                cout << " " << GetName() << " (" << GetReference() << ") \n";
                cout << "Levels List: " << endl;
                fLevels.ls(opt);
        }
        if ( opt.Contains("gamma") ) { 
                cout << "Level Scheme: " << endl;
                cout << " " << GetName() << " (" << GetReference() << ") \n";
                cout << "Links List: " << endl;         
                fLinks.ls(opt);  
        }
}  

//__________________________________________________________
void LevelScheme::Clear(Option_t *)
{       
        // all collections are empty
        fCascades.Clear(); fLinks.Clear();fLevels.Clear(); fTexts.Clear();
        fArrows.Clear();
        // no name, no reference
        fName.Clear(); fReference.Clear();
}