GLSPlayer.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004-2006 by Olivier Stezowski & Christian Finck        *
 *   stezow(AT)ipnl.in2p3.fr, cfinck(AT)ires.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.             *
 ***************************************************************************/

#include <Riostream.h>

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

#ifndef Gw_CSManager
#include "CSManager.h"
#endif

#ifndef Gw_CubicFilter
#include "CubicFilter.h"
#endif

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

#ifndef ROOT_TCanvas
#include "TCanvas.h"
#endif

#ifndef ROOT_TClass
#include "TClass.h"
#endif

#ifndef ROOT_TContextMenu
#include "TContextMenu.h"
#endif

#ifndef ROOT_TFile
#include "TFile.h"
#endif

#ifndef ROOT_TFolder
#include "TFolder.h"
#endif

#ifndef ROOT_TGaxis
#include "TGaxis.h"
#endif

#ifndef ROOT_TGraphErrors
#include "TGraphErrors.h"
#endif

#ifndef ROOT_TH1F
#include "TH1F.h"
#endif

#ifndef ROOT_TAxis
#include "TAxis.h"
#endif

#ifndef ROOT_TLatex
#include "TLatex.h"
#endif

#ifndef ROOT_TList
#include "TList.h"
#endif

#ifndef ROOT_TMath
#include "TMath.h"
#endif

#ifndef ROOT_TObjString
#include "TObjString.h"
#endif

#ifndef ROOT_TROOT
#include "TROOT.h"
#endif

#ifndef ROOT_TSystem
#include "TSystem.h"
#endif

#ifndef ROOT_TVirtualPad
#include "TVirtualPad.h"
#endif


#ifndef Gw_BaseNucleus
#include "BaseNucleus.h"
#endif

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

#ifndef Gw_GSPlayer
#include "GSPlayer.h"
#endif

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

#ifndef Gw_Peak1D
#include "Peak1D.h"
#endif


using namespace Gw;

//__________________________________________________________
GLSPlayer:: GLSPlayer(LevelScheme* levelScheme) :
    BaseLSPlayer(levelScheme),
    fCSManager(new CSManager(Form("%s_%s", "CSManager", levelScheme->GetName()),
                         Form("%s %s", "CS Manager for", levelScheme->GetName())))
{
    fLog.GetProcessName() = "GLSPlayer";
    SetName("GLSPlayer");
    
    fPathtoSaveLS = "./";
    
    //Default Constructor
}

//__________________________________________________________
GLSPlayer::~ GLSPlayer()
{
    // default destructor
    delete fCSManager;
}

//__________________________________________________________
void GLSPlayer::Draw(Option_t *opt)
{
    TString option(opt);
    option.ToLower();
    
    TSeqCollection* listCanvas = gROOT->GetListOfCanvases();
    
    TString name(GetName());
    TCanvas* canvas = 0x0;
    TIter next(listCanvas);
    while ( (canvas = (TCanvas*)next()) ) {
        if ( name.CompareTo(canvas->GetName()) == 0 ) {
            break;
        }
    }
    
    // create default canvas if not existing
    if (!canvas) {
        canvas = gROOT->MakeDefCanvas();
        canvas->SetName(GetName());
        canvas->SetTitle(GetName());
        Connect(canvas);
    } else {
        if ( !canvas->HasConnection("ProcessedEvent(Int_t, Int_t, Int_t, TObject*)") ) // should not be the case
            Connect();
    }
    
    if ( option.Contains("new") ) {
        Double_t xmin  = GetDefaultSize()[0];
        Double_t xmax  = GetDefaultSize()[1];
        Double_t ymin  = GetDefaultSize()[2];
        Double_t ymax  = GetDefaultSize()[3];
        
        TVirtualPad* pad = TVirtualPad::Pad();
        pad->cd();
        
        pad->Range(GetXRmin(xmin, xmax), GetYRmin(ymin, ymax),
                   GetXRmax(xmin, xmax), GetYRmax(ymin, ymax));
        
        fPositionLabels = BaseLSPlayer::GetYLabels(ymin, ymax);
        fAxis->SetX1(BaseLSPlayer::GetXAxis(xmin, xmax));
        fAxis->SetX2(BaseLSPlayer::GetXAxis(xmin, xmax));
        fAxis->SetY1(0.0); fAxis->SetY2(ymax);
        fAxis->SetWmin(0.0);
        fAxis->SetWmax(ymax);
        fAxis->Draw();
        AppendPad();
        return;
    }
    
    BaseLSPlayer::Draw(opt);
}

//__________________________________________________________
void GLSPlayer::AddGroundLevel(Int_t z, Int_t a, Option_t* opt, Float_t energy, Float_t errEnergy)
{
    // add ground state level
    fLog.SetProcessMethod( "AddGroundLevel(Int_t, Int_t, Option_t*, Float_t, Float_t )");
    
    const Char_t* nucleus =  BaseNucleus::WhichSymbol(z,a);
    fLevelScheme->SetName(nucleus);
    TObjString* sNucleus = new TObjString(nucleus);
    fNucleiList->Add(sNucleus);
    Int_t nbNuclei = fNucleiList->GetEntries();
    
    TString spin(opt), parity("+"); Ssiz_t parity_offset = spin.Length();
    if ( !spin.Contains("+") ) {
        if ( !spin.Contains("-") ) {
            parity = "?";
        }
        else {
            parity = "-";
            parity_offset = spin.Index("-");
        }
    }
    else{
        parity = "+";
        parity_offset = spin.Index("+");
    }
    spin.Remove(parity_offset);
    
    Double_t xRmin  = 0;
    Double_t xRmax  = 0;
    Double_t yRmin  = 0;
    Double_t yRmax  = 0;
    Double_t width  = GetDefaultWidth();
    
    static Double_t deltaR = 0;
    static Double_t delta  = 0;
    
    TVirtualPad* pad = TVirtualPad::Pad();
    if (!pad) {
        fLog << error << "Pad not existing" << dolog;
        return;
    }
    
    pad->cd();
    
    static Double_t xmin = 0;
    static Double_t xmax = 0;
    
    pad->GetRange(xRmin, yRmin, xRmax, yRmax);
    
    if (nbNuclei == 1) {
        xmin = GetXMin(xRmin, xRmax);
        xmax = GetXMax(xRmin, xRmax);
        deltaR = xRmax - xRmin;
        delta  = xmax - xmin;
    } else {
        xRmax += deltaR;
        pad->Range(xRmin, yRmin, xRmax, yRmax);
        fAxis->SetLabelSize(0.03);
        fLog << warning << "Adding new ground level to the same level scheme" << nline;
    }
    
    // nuclear level
    NuclearLevel* level = new NuclearLevel();
    level->GetEnergy().Set(energy);    level->GetEnergy().SetError(errEnergy);
    level->SetX1((xmax+xmin-width)/2+delta*(nbNuclei-1)); level->SetX2((xmax+xmin+width)/2+delta*(nbNuclei-1));
    level->SetY1(energy);              level->SetY2(energy);
    level->SetLineWidth(3);
    level->SetLineColor( Level::GetDefaultColor(level->GetDefaultColor()) );
    
    level->GetSpin().Set(spin.Data());
    if (parity.Contains("+")) {
        level->GetParity().Set(Parity::kPlus);
    }
    if (parity.Contains("-")) {
        level->GetParity().Set(Parity::kMinus);
    }
    if (parity.Contains("?")) {
        level->GetParity().SetInfo(InfoData::kKnown);
    }
    
    level->SetDefaultLabels();
    TList* levels = &GetLevelList();
    levels->Add(level);
    
    TLatex* label = &GetNameLatex();
    label->SetNDC();
    label->SetX(0.55); label->SetY(0.95);
    
    AppendPad();
    fLevelScheme->Draw("ground");
        
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::SetLevelVisLabel(const char* s)
{
    for (Int_t i = 0; i < GetLevelList().GetSize(); ++i) {
        Level* level = static_cast<Level*>(GetLevelList().At(i));
        level->SetVisLabel(s);
    }
}

//__________________________________________________________
void GLSPlayer::SetLevelLabelsSize(Float_t size)
{
    Level::SetDefaultLabelSize(size);
    for (Int_t i = 0; i < GetLevelList().GetSize(); ++i) {
        Level* level = static_cast<Level*>(GetLevelList().At(i));
        level->SetDefaultLabels();
    }
}

//__________________________________________________________
void GLSPlayer::SetLevelLabelsColor(Color_t color)
{
    Level::SetDefaultLabelColor(color);
    for (Int_t i = 0; i < GetLevelList().GetSize(); ++i) {
        Level* level = static_cast<Level*>(GetLevelList().At(i));
        level->SetDefaultLabels();
    }
}

//__________________________________________________________
void GLSPlayer::SetLinkVisLabel(const char* s)
{
    for (Int_t i = 0; i < GetLinkList().GetSize(); ++i) {
        Link* link = static_cast<Link*>(GetLinkList().At(i));
        link->SetVisLabel(s);
    }
}

//__________________________________________________________
void GLSPlayer::SetLinkLabelsSize(Float_t size)
{
    Link::SetDefaultLabelSize(size);
    for (Int_t i = 0; i < GetLinkList().GetSize(); ++i) {
        Link* link = static_cast<Link*>(GetLinkList().At(i));
        link->SetDefaultLabels();
    }
}

//__________________________________________________________
void GLSPlayer::SetLinkLabelsColor(Color_t color)
{
    Link::SetDefaultLabelColor(color);
    for (Int_t i = 0; i < GetLinkList().GetSize(); ++i) {
        Link* link = static_cast<Link*>(GetLinkList().At(i));
        link->SetDefaultLabels();
    }
}

//__________________________________________________________
void GLSPlayer::WriteLS(const char* nameLS, const char *path, Int_t write)
{
    fLog.SetProcessMethod("WriteLS(const char*,const char *,Int_t)");
    
    TString nameFile(path);
    //
    if ( nameFile.EndsWith(".root") ) { // means it saves LS into a root file
    }
    else {
        if ( nameFile.Sizeof() && !nameFile.EndsWith("/")  )
            nameFile += "/";
        nameFile += nameLS; nameFile += ".root";
    }
    
    TSeqCollection* list = gROOT->GetListOfFiles();
    TFile* file = 0x0;
    if ( (file = (TFile*)list->FindObject(nameFile.Data())) ) {
        file->ReOpen("UPDATE");
    }
    if (file == 0x0)
        file = new TFile(nameFile.Data(), "UPDATE");
    fLevelScheme->Write(nameLS, write);
    file->Close();
    
    delete file;
    
    fLog << info << Form("Write level scheme in %s file", nameFile.Data()) << dolog;
}

//__________________________________________________________
void GLSPlayer::DeleteLink()
{
    fLog.SetProcessMethod("DeleteLink()");
    
    Link* cLink = GetCurrentLink();
    if (cLink == 0x0) {
        fLog << error << "No selected link available" << dolog;
        return;
    }
    
    // remove from list
    GetLinkList().Remove(cLink);
    
    // remove from cascade if any
    TList* listCascade = fLevelScheme->FindCLinkInCascade();
    for (Int_t i = 0; i < listCascade->GetEntries(); ++i) {
        Cascade* cas = static_cast<Cascade*>( listCascade->At(i) );
        cas->Remove(cLink);
    }
    delete listCascade;
    
    // delete from pad
    TVirtualPad* pad = TVirtualPad::Pad();
    if (!pad) {
        fLog << error << "Pb with deleting link from pad" << dolog;
        return;
    }
    TSeqCollection* list =  pad->GetListOfPrimitives();
    list->Remove(cLink);
    
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::DeleteLevel()
{
    fLog.SetProcessMethod("DeleteLevel()");
    
    Level* cLevel = GetCurrentLevel();
    if (cLevel == 0x0) {
        fLog << error << "No selected level available" << dolog;
        return;
    }
    
    // remove from LS list
    GetLevelList().Remove(cLevel);
    
    // remove from pad
    TVirtualPad* pad = TVirtualPad::Pad();
    if (pad) {
        TSeqCollection* list =  pad->GetListOfPrimitives();
        list->Remove(cLevel);
    }
    
    delete cLevel;
    
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::AddLinkToCascade()
{
    fLog.SetProcessMethod("AddLinkToCascade()");
    
    Link* cLink = GetCurrentLink();
    if (cLink == 0x0) {
        fLog << error << "No selected link available" << dolog;
        return;
    }
    
    Cascade* cCas = GetCurrentCascade();
    if (cCas->FindObject(cLink)){
        fLog << error << "link already belongs to cascade" << dolog;
        return;
    }
    
    if (cCas == 0x0) {
        fLog << error << "No selected cascade available" << dolog;
        return;
    }
    
    cCas->Add(cLink);
}

//__________________________________________________________
void GLSPlayer::Select()
{
    for (Int_t i = 0; i < GetLinkList().GetSize(); ++i) {
        Link* link =  static_cast<Link*>(GetLinkList().At(i));
        if (!link->IsSelected()) {
            link->SetFillColor(fCColorSelectedLink);
            link->Selected();
        }
    }
    
    for (Int_t i = 0; i < GetLevelList().GetSize(); ++i) {
        Level* level = static_cast<Level*>(GetLevelList().At(i));
        if (!level->IsSelected()) {
            level->SetLineColor( Level::GetDefaultColor(Level::kSelected) );
            level->Selected();
        }
    }
    
    for (Int_t i = 0; i < GetCascadeList().GetSize(); ++i) {
        Cascade* cas = static_cast<Cascade*>(GetCascadeList().At(i));
        if (!cas->IsSelected()) {
            cas->SetLabelColor( Cascade::kSelected );
            cas->Selected();
        }
    }
}

//__________________________________________________________
void GLSPlayer::DeSelect()
{
    for (Int_t i = 0; i < GetLinkList().GetSize(); ++i) {
        Link* link =  static_cast<Link*>(GetLinkList().At(i));
        if (link->IsSelected()) {
            link->SetFillColor( Link::GetDefaultColor() );
            link->DeSelected();
        }
    }
    
    fLevelScheme->SetCLink(0x0);
    for (Int_t i = 0; i < GetLevelList().GetSize(); ++i) {
        Level* level = static_cast<Level*>(GetLevelList().At(i));
        if (level->IsSelected()) {
            level->SetLineColor( Level::GetDefaultColor(level->GetDefaultColor()) );
            level->DeSelected();
        }
    }
    
    fLevelScheme->SetCLevel(0x0);
    for (Int_t i = 0; i < GetCascadeList().GetSize(); ++i) {
        Cascade* cas = static_cast<Cascade*>(GetCascadeList().At(i));
        if (cas->IsSelected()) {
            cas->SetLabelColor(Cascade::kDefault);
            cas->DeSelected();
        }
    }
    fLevelScheme->SetCCascade(0x0);
    fSelectedLinks->Clear();
    fSelectedLevels->Clear();
    fSelectedCascades->Clear();
}

//__________________________________________________________
void GLSPlayer::RegisterCS(const Char_t* fileName, const Char_t* name)
{
    fLog.SetProcessMethod("RegisterCS(const Char_t*, const Char_t* )");
    
    TFile* fileIn = new TFile(fileName, "READ");
    if (fileIn == 0x0){
        fLog << error << "File not found" << dolog;
        return;
    }
        
    CorrelatedSpace* coor = (Gw::CorrelatedSpace*)fileIn->Get(name);
    if (coor == 0x0) {
        fLog << error << "Correlated space not found in file" << dolog;
        return;
    }
    
    fCSManager->Register(coor);
}

//__________________________________________________________
void GLSPlayer::PopupDoProject()
{
    TMethod* m = Class()->GetMethod("DoProject", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupDoProject()");
        fLog << error << "Cannot Popup DoProject dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupAddLink()
{
    TMethod* m = Class()->GetMethod("AddLink", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupAddLink()");
        fLog << error << "Cannot Popup AddLink dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupAddLevel()
{
    TMethod* m = Class()->GetMethod("AddLevel", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupAddLevel()");
        fLog << error << "Cannot Popup AddLevel dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupAddFirstLevel()
{
    TMethod* m = Class()->GetMethod("AddFirstLevel", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupAddFirstLevel()");
        fLog << error << "Cannot Popup AddFirstLevel dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupAddGroundLevel()
{
    TMethod* m = Class()->GetMethod("AddGroundLevel", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("AddGroundLevel()");
        fLog << error << "Cannot Popup AddGroundLevel dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupAddArrow()
{
    TMethod* m = Class()->GetMethod("AddArrow", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupAddArrow()");
        fLog << error << "Cannot Popup AddArrow dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupAddText()
{
    TMethod* m = Class()->GetMethod("AddText", "");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupAddText()");
        fLog << error << "Cannot Popup AddText dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::PopupWriteLS()
{
    TMethod* m = Class()->GetMethodWithPrototype("WriteLS", "const char*,const char *,Int_t");
    
    if (m != 0x0 && fContextMenu != 0x0)
        fContextMenu->Action(this, m);
    else {
        fLog.SetProcessMethod("PopupWriteLS()");
        fLog << error << "Cannot Popup WriteLS dialog box" << dolog;
    }
}

//__________________________________________________________
void GLSPlayer::AddLink(Float_t strength, Float_t errStrength, Float_t energy,  Float_t errEnergy, const Char_t* mult)
{
    fLog.SetProcessMethod("AddLink()");
    
    if ( (GetCurrentLink() != 0 || GetCurrentLevel() != 0) && fSelectedLevels->GetEntries() != 2) {
        AddLinkOnTop(strength, energy, errStrength, errEnergy, mult);
    } else if (fSelectedLevels->GetEntries() == 2 && GetCurrentLink() == 0) {
        InsertLink(strength, errStrength, mult);
    } else {
        fLog << error << "Ambigous selection, please re-select objects" << nline;
    }
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::AddArrow(Option_t* opt)
{
    fLog.SetProcessMethod("AddArrow()");
    
    // first collect selected levels
    if (fSelectedLevels->GetEntries() != 2) {
        fLog << error << "Wrong number of selected levels" << dolog;
        return;
    }
    
    NuclearLevel* level1 = dynamic_cast<NuclearLevel*> ( fSelectedLevels->At(0) );
    NuclearLevel* level2 = dynamic_cast<NuclearLevel*> ( fSelectedLevels->At(1) );
    
    if (level1 == 0x0 || level2 == 0x0) {
        fLog << error << "Selected levels are not nuclear levels" << dolog;
        return;
    }
    
    //deselect levels
    level1->SetLineColor( Level::GetDefaultColor(GetCurrentLevel()->GetDefaultColor()) );
    level1->DeSelected();
    level2->SetLineColor( Level::GetDefaultColor(GetCurrentLevel()->GetDefaultColor()) );
    level2->DeSelected();
    
    NuclearLevel* levelI = 0x0;
    NuclearLevel* levelF = 0x0;
    
    Float_t x1I, x2I;
    Float_t x1F, x2F;
    Float_t yI, yF;
    
    // re-ordered initial - final
    if (level1->GetEnergy().Get() > level2->GetEnergy().Get()) {
        levelI = level1;
        levelF = level2;
    } else {
        levelI = level2;
        levelF = level1;
    }
    
    x1I = levelI->GetX1();
    x2I = levelI->GetX2();
    yI  = levelI->GetY1();
    
    x1F = levelF->GetX1();
    x2F = levelF->GetX2();
    yF  = levelF->GetY1();
    
    Float_t offsetX = (x2I - x1I)*0.02;
    Float_t offsetY =  (yI - yF)*0.01;
    
    //TArrow::SetDefaultArrowSize(0.01);
    if (x1I > x2F) {
        TArrow* arrow = fLevelScheme->NewArrow(x1I-offsetX, yI-offsetY, x2F+offsetX, yF+offsetY);
        arrow->SetLineWidth(levelI->GetLineWidth());
        arrow->SetArrowSize(0.02);
        arrow->SetOption(opt);
    }
    
    if (x1F > x2I) {
        TArrow* arrow = fLevelScheme->NewArrow(x2I+offsetX, yI-offsetY, x1F-offsetX, yF+offsetY);
        arrow->SetLineWidth(levelI->GetLineWidth());
        arrow->SetArrowSize(0.02);
        arrow->SetOption(opt);
    }
        
    fSelectedLevels->Clear();
    
    fLevelScheme->Draw();
}

//__________________________________________________________
void GLSPlayer::AddText(const Char_t* msg)
{
    TLatex* text = fLevelScheme->NewText(msg);
    text->SetX(gPad->AbsPixeltoX(GetLastX())); text->SetY(gPad->AbsPixeltoY(GetLastY()));
    text->SetTextSize(Cascade::GetDefaultLabelSize());
    fLevelScheme->Draw();
}

//__________________________________________________________
void GLSPlayer::AddLinkOnTop(Measure<Float_t> strength, Measure<Float_t> energy)
{
    AddLinkOnTop(strength.Get(), energy.Get(), strength.GetError(), energy.GetError());
}

//__________________________________________________________
void GLSPlayer::AddLinkBetween(Float_t strength, Float_t energy, Float_t errStrength, Float_t errEnergy)
{
    fLog.SetProcessMethod("AddLinkBetween()");
    
    if (GetCurrentLink() == 0) {
        fLog << error << "No selected link available" << dolog;
        return;
    }
    
    Float_t x1c, x2c;
    Float_t y1IL, y2IL, y1c, y2c;
    
    y1IL = y2IL = 0.;
    
    x1c = GetCurrentLink()->GetIL()->GetX1();
    y1c = GetCurrentLink()->GetIL()->GetY1();
    x2c = GetCurrentLink()->GetIL()->GetX2();
    y2c = GetCurrentLink()->GetIL()->GetY2();
    
    y1IL = y1c + energy;
    y2IL = y2c + energy;
    
    // creation of new link and level
    GammaLink* newLink = new GammaLink();
    newLink->GetStrength().Set(strength, errStrength);
    newLink->SetFillColor( Link::GetDefaultColor() );
    newLink->GetEnergy().Set(energy, errEnergy);
    NuclearLevel* newLevel = new NuclearLevel();
    newLevel->SetLineColor( Level::GetDefaultColor(newLevel->GetDefaultColor()) );
    newLevel->SetX1(x1c);  newLevel->SetX2(x2c);
    newLevel->SetY1(y1IL); newLevel->SetY2(y2IL);
    
    newLink->SetFL(GetCurrentLink()->GetIL());
    newLink->SetIL(newLevel);
    newLink->SetPoints();
    
    GetLinkList().Add(newLink);
    GetLevelList().Add(newLevel);
    
    TList* list = fLevelScheme->FindCLinkInCascade();
    
    // move all links/levels above the current link
    for (Int_t i = 0; i < list->GetEntries(); ++i) {
        Cascade* cas = static_cast<Cascade*> ( list->At(i) );
        Int_t index  = cas->IndexOf(GetCurrentLink())+1;
        
        for (Int_t j = index; j < cas->GetEntries(); ++j) {
            Link*  link   = static_cast<Link*> ( cas->At(j) );
            Level* levelI = link->GetIL();
            
            if (j == index)
                link->SetFL(newLevel);
            
            levelI->SetY1(levelI->GetY1()+energy); levelI->SetY2(levelI->GetY2()+energy);
            link->SetPoints();
        }
        cas->AddAfter(GetCurrentLink(), newLink);
    }
    
    fLevelScheme->Draw();
}

//__________________________________________________________
void GLSPlayer::AddLinkOnTop(Float_t strength, Float_t energy, Float_t errStrength, Float_t errEnergy, const Char_t* mult)
{
    fLog.SetProcessMethod("AddLinkOnTop()");
    
    if (GetCurrentLink() == 0 && GetCurrentLevel() == 0) {
        fLog << error << "No selected link/level available" << dolog;
        return;
    }
    
    TString em(mult);
    em.ToUpper();
    
    if (em.Length() > 2 && em.Length() < 1) {
        fLog << warning << "Multipolarity of the link not readable set to E1" << dolog;
        em = "E1";
    }
    
    Float_t x1c, x2c;
    Float_t y1IL, y2IL, y/*1c, y2c*/;
    Float_t errY1IL = 0;
    y1IL = y2IL = 0.;
    
    if ( GetCurrentLink() ) {

        NuclearLevel* level = (NuclearLevel*)GetCurrentLink()->GetIL();

        x1c = level->GetX1();
//        y1c = level->GetY1();
        x2c = level->GetX2();
//        y2c = level->GetY2();
        y = level->GetEnergy().GetValue();

        // deselect current link
        GammaLink* link = (GammaLink*)fSelectedLinks->Last();

        if(link == 0x0)
        {
            fLog << warning << "bad link selection" << dolog;
            return;
        }

        errY1IL = link->GetEnergy().GetError();
        GetCurrentLink()->SetFillColor( Link::GetDefaultColor() );
        GetCurrentLink()->DeSelected();
        fSelectedLinks->Remove(GetCurrentLink());
    }
    else
    {
        NuclearLevel* level = (NuclearLevel*)GetCurrentLevel();
        if(level==0x0) return;

        x1c = GetCurrentLevel()->GetX1();
//        y1c = GetCurrentLevel()->GetY1();
        x2c = GetCurrentLevel()->GetX2();
//        y2c = GetCurrentLevel()->GetY2();
        y = level->GetEnergy().GetValue();

//        // deselect current level
//        NuclearLevel* level = (NuclearLevel*)fSelectedLevels->Last();
//        if(level==0x0) return;

        errY1IL = level->GetEnergy().GetError();
        GetCurrentLevel()->SetLineColor( Level::GetDefaultColor(GetCurrentLevel()->GetDefaultColor()) );
        GetCurrentLevel()->DeSelected();
        fSelectedLevels->Remove( GetCurrentLevel());
    }
    
    y1IL = y/*1c*/ + energy;
    y2IL = y/*2c*/ + energy;
    
    // creation of new link and level
    GammaLink* newLink = new GammaLink();
    newLink->GetStrength().Set(strength, errStrength);
    newLink->SetFillColor( Link::GetDefaultColor() );
    newLink->GetEnergy().Set(energy, errEnergy);
    newLink->SetEM(em.Data());
    
    NuclearLevel* newLevel = new NuclearLevel();
    newLevel->SetLineColor( Level::GetDefaultColor(newLevel->GetDefaultColor()) );
    newLevel->SetX1(x1c);  newLevel->SetX2(x2c);
    newLevel->SetY1(y1IL); newLevel->SetY2(y2IL);
    errY1IL = TMath::Sqrt(errY1IL*errY1IL + errEnergy*errEnergy);
    newLevel->GetEnergy().Set(y1IL, errY1IL); //right computing of error
    
    if ( GetCurrentLink() )
        newLink->SetFL(GetCurrentLink()->GetIL());
    else
        newLink->SetFL(GetCurrentLevel());
    
    // set spin/parity
    NuclearLevel* levelF = static_cast<NuclearLevel*> ( newLink->GetFL() );
    Spin spin = levelF->GetSpin();
    spin     += newLink->GetLambda();
    newLevel->GetSpin().Set(spin.GetString());
    
    if ( (newLink->IsE() && levelF->GetParity().IsParity(Parity::kPlus)) ||
        (newLink->IsM() && levelF->GetParity().IsParity(Parity::kMinus)) )
        newLevel->GetParity().Set(Parity::kPlus);
    else
        newLevel->GetParity().Set(Parity::kMinus);
    newLevel->SetDefaultLabels();
    
    newLink->SetIL(newLevel);
    newLink->SetPoints();

    newLink->SetDefaultLabels();
    
    GetLinkList().Add(newLink);
    GetLevelList().Add(newLevel);
    
    fLevelScheme->Draw();
    
    fLog << dolog;
}

//__________________________________________________________
Bool_t GLSPlayer::CheckPolarity(GammaLink& link)
{
    fLog.SetProcessMethod("CheckPolarity(GammaLink& )");
    
    NuclearLevel* level1 = dynamic_cast<NuclearLevel*> ( fSelectedLevels->At(0) );
    NuclearLevel* level2 = dynamic_cast<NuclearLevel*> ( fSelectedLevels->At(1) );
    
    if (level1 == 0x0 || level2 == 0x0) {
        fLog << error << "Selected levels are not nuclear levels" << dolog;
        return false;
    }
    
    Float_t spin1 = level1->GetSpin().Get(); Parity parity1 = level1->GetParity();
    Float_t spin2 = level2->GetSpin().Get(); Parity parity2 = level2->GetParity();
    
    Parity p(parity1);
    p *= parity2;
    Bool_t isOk = true;
    
    // default values
    char em;
    UShort_t lambda = link.GetLambda();
    if (link.IsE())
        em = 'E';
    else if (link.IsM())
        em = 'M';
    else
        em = '-';
    
    // change parity if necessary
    if (em == 'E' && p.IsParity(Parity::kMinus)) {
        em = 'M';
        isOk = false;
    }
    
    if (em == 'M' && p.IsParity(Parity::kPlus)) {
        em = 'E';
        isOk = false;
    }
    
    // take lowest spin if selection rule not valid
    if (link.GetLambda() > spin1+spin2 || link.GetLambda() < TMath::Abs(spin1-spin2)) {
        lambda = UShort_t(TMath::Abs(spin1-spin2)+0.5);
        isOk = false;
    }
    
    // change EM if necessary
    if (!isOk)
        link.SetEM(Form("%c%d", em, lambda));
    
    fLog << dolog;
    
    return isOk;
}

//__________________________________________________________
void GLSPlayer::InsertLink(Measure<Float_t> strength)
{
    InsertLink(strength.Get(), strength.GetError());
}

//__________________________________________________________
void GLSPlayer::InsertLink(Float_t strength, Float_t errStrength, const Char_t* mult)
{
    // add link from two selected levels
    
    fLog.SetProcessMethod("InsertLink(Float_t, Float_t, const Char_t* )");
    
    // first collect selected levels
    if (fSelectedLevels->GetEntries() != 2) {
        fLog << error << "Wrong number of selected levels" << dolog;
        return;
    }
    
    NuclearLevel* level1 = dynamic_cast<NuclearLevel*> ( fSelectedLevels->At(0) );
    NuclearLevel* level2 = dynamic_cast<NuclearLevel*> ( fSelectedLevels->At(1) );
    
    if (level1 == 0x0 || level2 == 0x0) {
        fLog << error << "Selected levels are not nuclear levels" << dolog;
        return;
    }
    
    //deselect levels
    level1->SetLineColor( Level::GetDefaultColor(GetCurrentLevel()->GetDefaultColor()) );
    level1->DeSelected();
    level2->SetLineColor( Level::GetDefaultColor(GetCurrentLevel()->GetDefaultColor()) );
    level2->DeSelected();
    
    NuclearLevel* levelI = 0x0;
    NuclearLevel* levelF = 0x0;
    
    Float_t energyI = 0;
    Float_t energyF = 0;
    
    // re-ordered initial - final
    if (level1->GetEnergy().Get() > level2->GetEnergy().Get()) {
        levelI = level1;
        levelF = level2;
    } else {
        levelI = level2;
        levelF = level1;
    }
    
    energyI = levelI->GetEnergy().Get();
    energyF = levelF->GetEnergy().Get();
    
    // compute energy
    Float_t energy    = energyI - energyF;
    Float_t errEnergy = TMath::Sqrt( (levelI->GetEnergy().GetError()/energyI)*(levelI->GetEnergy().GetError()/energyI) +
                                    (levelF->GetEnergy().GetError()/energyF)*(levelF->GetEnergy().GetError()/energyF) );
    
    // new gamma link
    GammaLink* newLink = new GammaLink();
    newLink->GetStrength().Set(strength, errStrength);
    newLink->SetFillColor( Link::GetDefaultColor() );
    newLink->GetEnergy().Set(energy, errEnergy);
    newLink->SetEM(mult);
    
    if (!CheckPolarity(*newLink)) {
        if (newLink->IsE()) {
            fLog << warning << Form("Selection rule not valided, change multi-polarity from %s to E%d", mult, newLink->GetLambda()) << nline;
        } else {
            fLog << warning << Form("Selection rule not valided, change multi-polarity from %s to M%d", mult, newLink->GetLambda()) << nline;
        }
    }
    
    newLink->SetFL(levelF);
    newLink->SetIL(levelI);
    newLink->SetPoints();
    newLink->SetDefaultLabels();
    GetLinkList().Add(newLink);
    
    fSelectedLevels->Clear();
    
    fLevelScheme->Draw();
    
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::MoveCascade(Float_t mv, Bool_t lastLevel)
{
    fLog.SetProcessMethod("MoveCascade(Float_t, Bool_t )");
    
    Cascade* cCas = GetCurrentCascade();
    if  (cCas == 0x0) {
        fLog << error << "No cascade selected" << dolog;
        return;
    }
    
    Int_t idxFirstLink = 0;
    Double_t min       = 9999999.;
    Link*  link        = 0x0;
    Level* level       = 0x0;
    
    for (Int_t j = 0; j < cCas->GetEntries(); ++j) {
        link   = static_cast<Link*> ( cCas->At(j) );
        // deselect selected links
        link->SetFillColor( Link::GetDefaultColor() );
        link->DeSelected();
        level = link->GetIL();
        
        if (level->GetY1() < min) {
            min = level->GetY1();
            idxFirstLink = j;
        }
        
        if (level){
            level->SetX1(level->GetX1()+mv);
            level->SetX2(level->GetX2()+mv);
            if ( level->HasExtraLine() ) {
                TLine* extra = &level->GetExtraLine();
                if (extra->GetX1() == level->GetX2()-mv) {
                    extra->SetX1(extra->GetX1()+mv);
                }
                if (extra->GetX2() == level->GetX1()-mv) {
                    extra->SetX2(extra->GetX2()+mv);
                }
            }
        }
        link->SetPoints();
    }
    
    if (lastLevel) {
        // last final level
        link   = static_cast<Link*> ( cCas->At(idxFirstLink) );
        level = link->GetFL();
        if (level){
            level->SetX1(level->GetX1()+mv);
            level->SetX2(level->GetX2()+mv);
        }
        link->SetPoints();
    }
    
    // move labels
    TLatex* name  = &cCas->GetLatex();
    name->SetX(name->GetX()+mv);
    
    // clear selection
    cCas->SetLabelColor(Cascade::kDefault);
    cCas->DeSelected();
    fSelectedCascades->Clear();
    fLevelScheme->SetCCascade(0x0);
    Draw();
}

//__________________________________________________________
void GLSPlayer::AddLevel(Float_t energy, Float_t errEnergy, const Char_t* dJp)
{
    fLog.SetProcessMethod("AddLevel(Float_t, Float_t, const Char_t* )");
    
    if (GetCurrentLevel() == 0) {
        fLog << error << "No level selected" << dolog;
        return;
    }
    
    TString spin(dJp), parity("+"); Ssiz_t parity_offset = spin.Length();
    if ( !spin.Contains("+") ) {
        if ( !spin.Contains("-") ) {
            parity = "?";
        }
        else {
            parity = "-";
            parity_offset = spin.Index("-");
        }
    }
    else{
        parity = "+";
        parity_offset = spin.Index("+");
    }
    spin.Remove(parity_offset);
    
    TList* levels = &GetLevelList();
    
    Float_t x1    = GetCurrentLevel()->GetX1();
    Float_t x2    = GetCurrentLevel()->GetX2();
    
    GetCurrentLevel()->SetLineColor( Level::GetDefaultColor(GetCurrentLevel()->GetDefaultColor()) );
    GetCurrentLevel()->DeSelected();
    fSelectedLevels->Remove( GetCurrentLevel());
    
    // create new level
    NuclearLevel* level = new NuclearLevel();
    level->GetEnergy().Set(energy); level->GetEnergy().SetError(errEnergy);
    level->SetX1(x1);               level->SetX2(x2);
    level->SetY1(energy);           level->SetY2(energy);
    level->SetLineWidth(2);         level->SetLineColor( Level::GetDefaultColor(level->GetDefaultColor()) );
    
    //set spin/aprity
    level->GetSpin().Set(spin.Data());
    if (parity.Contains("+")) {
        level->GetParity().Set(Parity::kPlus);
    }
    if (parity.Contains("-")) {
        level->GetParity().Set(Parity::kMinus);
    }
    if (parity.Contains("?")) {
        level->GetParity().SetInfo(InfoData::kKnown);
    }

    level->SetDefaultLabels();
    levels->Add(level);
    
    fLevelScheme->Draw();
        
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::AddFirstLevel(Float_t energy, Float_t errEnergy,
                              const Char_t* jp, Option_t* opt)
{
    fLog.SetProcessMethod("AddFirstLevel(Float_t, Float_t, Option_t* )");
    
    TString option(opt);
    
    if (GetCurrentLink() == 0 && GetCurrentLevel() == 0) {
        fLog << error << "No link/level selected" << dolog;
        return;
    }
    
    TString spin(jp), parity("+"); Ssiz_t parity_offset = spin.Length();
    if ( !spin.Contains("+") ) {
        if ( !spin.Contains("-") ) {
            parity = "?";
        }
        else {
            parity = "-";
            parity_offset = spin.Index("-");
        }
    }
    else{
        parity = "+";
        parity_offset = spin.Index("+");
    }
    spin.Remove(parity_offset);
    
    TList* levels = &GetLevelList();
    
    Float_t limit = 0.;
    Float_t width = GetDefaultWidth();
    Float_t x1    = 0.;
    Float_t x2    = 0.;
    
    // define position of current cascade
    Float_t min;
    Float_t max;
    
    if (GetCurrentLink() != 0x0) {
        Link* link = static_cast<Link*> ( fSelectedLinks->First() );
        if (!link) {
            fLog << warning << "No Link selected" << dolog;
            return;
        }
        min = link->GetFL()->GetX1();
        max = link->GetFL()->GetX2();
        
        for (Int_t j = 0; j < fSelectedLinks->GetEntries(); ++j) {
            Link*  link   = static_cast<Link*> ( fSelectedLinks->At(j) );
            // deselect selected links
            link->SetFillColor( Link::GetDefaultColor() );
            link->DeSelected();
            Level* level = link->GetIL();
            if (level->GetX2() > max) max = level->GetX2();
            if (level->GetX1() <= min) min = level->GetX1();
        }
    } else {
        Level* level = static_cast<Level*> ( fSelectedLevels->First() );
        if (!level) {
            fLog << warning << "No Level selected" << dolog;
            return;
        }
        min = level->GetX1();
        max = level->GetX2();
        
        for (Int_t j = 0; j < fSelectedLevels->GetEntries(); ++j) {
            Level*  level   = static_cast<Level*> ( fSelectedLevels->At(j) );
            // deselect selected levels
            level->SetLineColor( Level::GetDefaultColor( level->GetDefaultColor()) );
            level->DeSelected();
            if (level->GetX2() > max) max = level->GetX2();
            if (level->GetX1() <= min) min = level->GetX1();
        }
    }
    
    fLevelScheme->SetCLink(0x0);
    fLevelScheme->SetCLevel(0x0);
    
    fSelectedLinks->Clear();
    fSelectedLevels->Clear();
    
    if (option.Contains("left")) {
        limit = min;
        x1 = limit-1.5*width;
        x2 = limit-0.5*width;
    }
    if (option.Contains("right")) {
        limit = max;
        x1 = limit+0.5*width;
        x2 = limit+1.5*width;
    }
    if ( option.Contains("+") ) {
        TList* links     = &GetLinkList();
        TList* cascades  = &GetCascadeList();
        
        x1 = limit-width/2.;
        x2 = limit+width/2.;
        
        // move levels at right/left
        for (Int_t i = 0; i < levels->GetEntries(); ++i) {
            Level* level = static_cast<Level*> ( levels->At(i) );
            if (option.Contains("left")) {
                if ( level->GetX1() >= limit) {
                    level->SetX1(level->GetX1()+width);
                    level->SetX2(level->GetX2()+width);
                }
            } else {
                if ( level->GetX1() <= limit) {
                    level->SetX1(level->GetX1()-width);
                    level->SetX2(level->GetX2()-width);
                }
            }
        }
        
        // move links at right/left
        for (Int_t i = 0; i < links->GetEntries(); ++i) {
            Link* link = static_cast<Link*> ( links->At(i) );
            if (option.Contains("left")) {
                if ( link->GetX()[1] >= limit) {
                    link->SetPoints();
                }
            } else {
                if ( link->GetX()[1] <= limit) {
                    link->SetPoints();
                }
            }
        }
        
        // move cascades labels at right/left
        for (Int_t i = 0; i < cascades->GetEntries(); ++i) {
            Cascade* cas1 = static_cast<Cascade*> ( cascades->At(i) );
            TLatex* name  = &cas1->GetLatex();
            if (option.Contains("left")) {
                if ( name->GetX() >= limit) {
                    name->SetX(name->GetX()+width);
                }
            } else {
                if ( name->GetX() <= limit)
                    name->SetX(name->GetX()-width);
            }
        }
    }
    
    // create new level
    NuclearLevel* level = new NuclearLevel();
    level->GetEnergy().Set(energy); level->GetEnergy().SetError(errEnergy);
    level->SetX1(x1);               level->SetX2(x2);
    level->SetY1(energy);           level->SetY2(energy);
    level->SetLineWidth(2);         level->SetLineColor( Level::GetDefaultColor(level->GetDefaultColor()) );
    
    //set spin/aprity
    level->GetSpin().Set(spin.Data());
    if (parity.Contains("+")) {
        level->GetParity().Set(Parity::kPlus);
    }
    if (parity.Contains("-")) {
        level->GetParity().Set(Parity::kMinus);
    }
    if (parity.Contains("?")) {
        level->GetParity().SetInfo(InfoData::kKnown);
    }
    
    level->SetDefaultLabels();
    levels->Add(level);
    
    fLevelScheme->Draw();
    
    fLog << dolog;
}

//__________________________________________________________
void GLSPlayer::MakeCascade(const Char_t* label)
{
    fLog.SetProcessMethod("MakeCascade(Option_t* )");
    
    if (fSelectedLinks->GetEntries() == 0) {
        fLog << error << "No link selected" << dolog;
        return;
    }
    
    TList* cascades  = &GetCascadeList();
    
    // create new cascade and add to list
    Cascade* cas = new Cascade();
    cas->SetName(label);
    cascades->Add(cas);
    
    //  Double_t xmin = 0.;
    //  Double_t xmax = 0.;
    //  Double_t ymin = 0.;
    //  Double_t ymax = 0.;
    Double_t xRmin, xRmax, yRmin, yRmax;
    
    
    // define position of current cascade
    Float_t moy = 0.;
    fLevelScheme->SetCLink(0x0);
    for (Int_t j = 0; j < fSelectedLinks->GetEntries(); ++j) {
        Link* link = static_cast<Link*> ( fSelectedLinks->At(j) );
        // deselect selected links
        link->SetFillColor( Link::GetDefaultColor() );
        link->DeSelected();
        Level* level = link->GetIL();
        moy += (level->GetX1() + level->GetX2())/2.;
        cas->Add(link);
    }
    
    moy /= fSelectedLinks->GetEntries();
    
    fSelectedLinks->Clear();
    
    
    if ( TVirtualPad::Pad() != 0 ) {  // in principle, gpad exists
        TVirtualPad::Pad()->GetRange(xRmin, yRmin, xRmax, yRmax);
        //    xmin = GetXMin(xRmin, xRmax);
        //    xmax = GetXMax(xRmin, xRmax);
        
        //    ymin = GetYMin(yRmin, yRmax);
        //    ymax = GetYMax(yRmin, yRmax);
    }
    
    TLatex* name  = &cas->GetLatex();
    
    name->SetX(moy); name->SetY(fPositionLabels);
    
    cascades->Draw();
}

//__________________________________________________________
void GLSPlayer::AlignLinks()
{
    // Align selected links respect to first selected link
    
    fLog.SetProcessMethod("AlignLinks()");
    
    Int_t nLinks = fSelectedLinks->GetEntries();
    
    if (nLinks == 0) {
        fLog << warning << "No specific link selected" << dolog;
        return;
    }
    
    GammaLink* link = 0x0;
    link = static_cast<GammaLink*> ( fSelectedLinks->At(0) );
    Float_t x1i =  link->GetX()[1];
    Float_t x2i =  link->GetX()[5];
    
    
    for  (Int_t i = 0; i < nLinks; ++i) {
        link = static_cast<GammaLink*> ( fSelectedLinks->At(i) );
        link->SetPoints(x1i,x2i);
        link->SetFillColor( Link::GetDefaultColor() );
        link->DeSelected();
    }
    
    fSelectedLinks->Clear();
}

//__________________________________________________________
void GLSPlayer::AlignLevels()
{
    fLog.SetProcessMethod("AlignLevels()");
    
    Int_t nLevels = fSelectedLevels->GetEntries();
    
    if (nLevels == 0) {
        fLog << warning << "No specific level selected" << dolog;
        return;
    }
    
    NuclearLevel* level = 0x0;
    
    level =  static_cast<NuclearLevel*> ( fSelectedLevels->At(0) );
    
    Float_t x1i =  level->GetX1();
    Float_t x2i =  level->GetX2();
    
    for  (Int_t i = 1; i < nLevels; ++i) {
        level =  static_cast<NuclearLevel*> ( fSelectedLevels->At(i) );
        level->SetX1(x1i);
        level->SetX2(x2i);
    }
    
    for  (Int_t i = 0; i < nLevels; ++i) {
        level = static_cast<NuclearLevel*> ( fSelectedLevels->At(i) );
        level->SetLineColor( Level::GetDefaultColor( level->GetDefaultColor()) );
        level->DeSelected();
    }
    
    fSelectedLevels->Clear();
}

//__________________________________________________________
void GLSPlayer::AlignCascade()
{
    fLog.SetProcessMethod("AlignCascade()");
    
    Cascade* cas = GetCurrentCascade();
    
    if (cas == 0x0) {
        fLog << warning << "No cascade selected" << dolog;
        return;
    }
    
    if (cas->IsSelected()) {
        cas->SetLabelColor(Cascade::kDefault);
        cas->DeSelected();
    }
    
    Int_t nEntries = cas->GetEntries();
    
    GammaLink* link = 0x0;
    
    // respect to this first gamma
    link =  static_cast<GammaLink*> ( cas->At(0) );
    
    Float_t x1i =  link->GetFL()->GetX1();
    Float_t x2i =  link->GetFL()->GetX2();
    
    for  (Int_t i = 0; i < nEntries; ++i) {
        link = static_cast<GammaLink*> ( cas->At(i) );
        link->GetFL()->SetX1(x1i);
        link->GetFL()->SetX2(x2i);
    }
    
    // IL of last gamma
    link = static_cast<GammaLink*> ( cas->At(nEntries-1) );
    link->GetIL()->SetX1(x1i);
    link->GetIL()->SetX2(x2i);
    
    // set points
    for  (Int_t i = 0; i < nEntries; ++i) {
        link = static_cast<GammaLink*> ( cas->At(i) );
        link->SetPoints();
        if (link->IsSelected()) {
            link->SetFillColor( Link::GetDefaultColor() );
            link->DeSelected();
        }
    }
    
    fLevelScheme->SetCCascade(0x0);
}

//__________________________________________________________
void GLSPlayer::DoJ1(Option_t* opt) const
{
    fLog.SetProcessMethod("DoJ1()");
    
    const Cascade* cas = fLevelScheme->GetCCascade();
    if (cas == 0) {
        fLog << error << "Current cascade not selected" << dolog;
        return;
    }
    
    TGraphErrors* gr = cas->DoJ1();
    
    if (gr == 0x0) {
        fLog << error << "Graph is empty" << dolog;
        return;
    }
    
    TString name("cObservables");
    TCanvas* hJ1 = (TCanvas*)gROOT->FindObject(name);
    
    if (hJ1)
        hJ1->cd();
    else {
        hJ1 = new TCanvas(name,"J1",10,10,700,500);
        hJ1->Draw();
    }
    
    Int_t nPoints = gr->GetN();
    Double_t*  y  = gr->GetY();
    Double_t*  dy = gr->GetEY();
    
    // switch to MeV
    for (Int_t i = 0; i < nPoints; ++i) {
        y[i]  *= 1000;
        dy[i] *= 1000;
    }
    
    Float_t max = TMath::MaxElement(nPoints, y)*1.2;
    Float_t min = TMath::MinElement(nPoints, y)*0.8;
    
    gr->SetMarkerColor(2);
    gr->SetMarkerStyle(20);
    gr->SetTitle(cas->GetName());
    gr->SetMinimum(min);
    gr->SetMaximum(max);
    
    gr->GetHistogram()->SetYTitle("#Jgothic^{(1)} (#hbar^{2}/MeV)");
    gr->GetHistogram()->SetXTitle("#omega (keV)");
    
    gr->GetHistogram()->SetTitleOffset(1.0,"X");
    gr->GetHistogram()->SetTitleOffset(1.1,"Y");
    gr->GetHistogram()->SetTitleSize(0.04,"X");
    gr->GetHistogram()->SetTitleSize(0.04,"Y");
    gr->GetXaxis()->SetLabelSize(0.04);
    gr->GetXaxis()->SetLabelOffset(0.01);
    gr->GetXaxis()->SetLabelSize(0.04);
    gr->GetYaxis()->SetLabelOffset(0.01);
    
    gr->Draw(opt);
}

//__________________________________________________________
void GLSPlayer::DoJ2(Option_t* opt) const
{
    fLog.SetProcessMethod("DoJ2()");
    
    const Cascade* cas = fLevelScheme->GetCCascade();
    if (cas == 0) {
        fLog << error << "Current cascade not selected" << dolog;
        return;
    }
    
    TGraphErrors* gr = cas->DoJ2();
    
    if (gr == 0x0) {
        fLog << error << "Graph is empty" << dolog;
        return;
    }
    
    TString name("cObservables");
    TCanvas* hJ2 = (TCanvas*)gROOT->FindObject(name);
    
    if (hJ2)
        hJ2->cd();
    else {
        hJ2 = new TCanvas(name,"J2",10,10,700,500);
        hJ2->Draw();
    }
    
    Int_t nPoints = gr->GetN();
    Double_t*  y  = gr->GetY();
    Double_t*  dy = gr->GetEY();
    
    // switch to MeV
    for (Int_t i = 0; i < nPoints; ++i) {
        y[i]  *= 1000;
        dy[i] *= 1000;
    }
    
    Float_t max = TMath::MaxElement(nPoints, y)*1.2;
    Float_t min = TMath::MinElement(nPoints, y)*0.8;
    
    gr->SetMarkerColor(2);
    gr->SetMarkerStyle(20);
    gr->SetTitle(cas->GetName());
    gr->SetMinimum(min);
    gr->SetMaximum(max);
    
    gr->GetHistogram()->SetYTitle("#Jgothic^{(2)} (#hbar^{2}/MeV)");
    gr->GetHistogram()->SetXTitle("#omega (keV)");
    
    gr->GetHistogram()->SetTitleOffset(1.0,"X");
    gr->GetHistogram()->SetTitleOffset(1.1,"Y");
    gr->GetHistogram()->SetTitleSize(0.04,"X");
    gr->GetHistogram()->SetTitleSize(0.04,"Y");
    gr->GetXaxis()->SetLabelSize(0.04);
    gr->GetXaxis()->SetLabelOffset(0.01);
    gr->GetXaxis()->SetLabelSize(0.04);
    gr->GetYaxis()->SetLabelOffset(0.01);
    
    gr->Draw(opt);
}

//__________________________________________________________
void GLSPlayer::ShowGate(Option_t* /*opt*/)
{
    fLog.SetProcessMethod("ShowGate(Option_t* )");
    
    // collect link
    CollectLinks();
    Int_t nLinks = fSelectedLinks->GetEntries();
    
    if (!nLinks) {
        fLog << error << "No Link selected" << dolog;
        return;
    }
    
    // find last drawn histo 
    TVirtualPad* pad = 0x0;
    
    TObject* obj = 0x0;
    
    Int_t entries = fCSManager->GetRegCSList()->GetEntries();
    TVirtualPad* cpad = 0x0;
    
    for (Int_t i = 0; i < entries; ++i) {
        
        cpad = fCSManager->GetProjTotPad(i);
        
        TIter next(cpad->GetListOfPrimitives());
        while ( (obj = next()) )  {
            if ( obj->InheritsFrom("TH1") ) 
                pad = cpad;
        }
        
        if ( !pad ) {
            fLog << error << "Pad not existing" << dolog; 
            return;
        }
        
        pad->cd();
        
        // draw gate with peak creator
        PeakCreator *pc = PeakCreator::AddPeakCreator();
        
        for  (Int_t i = 0; i < nLinks; ++i) {
            GammaLink* link = static_cast<GammaLink*> ( fSelectedLinks->At(i) );
            Float_t energy = link->GetEnergy().Get();
            Peak1D* peak = static_cast<Peak1D*> (pc->CreatePeak(energy,"bg") );
            if (Peak1D::IsvalideGateColor(link->GetFillColor()) )
                peak->SetLineColorPeak(link->GetFillColor());
            peak->SetDrawAs(Peak1D::kGate);
        }
        
        pad->Modified();
        pad->Update();
    }
}

//__________________________________________________________
void GLSPlayer::Project(Option_t* axis)
{
    fCSManager->Project(axis);
}

//__________________________________________________________
void GLSPlayer::DrawProj(Option_t* opt)
{
    fCSManager->DrawProj(opt);
}

//__________________________________________________________
void GLSPlayer::DrawProjTot(Option_t* opt)
{
    fCSManager->DrawProjTot(opt);
}

//__________________________________________________________
void GLSPlayer::DoProject(Option_t* axis,  Option_t* gateName, Option_t* optFilter, Option_t* optDraw)
{
    fCSManager->SetFilterBaseName(gateName);
    if (CollectGate(optFilter)) {  
        Project(axis);
        DrawProj(optDraw);
    }
}

//__________________________________________________________
Int_t GLSPlayer::CollectGate(Option_t* opt)
{
    return fCSManager->CollectGate(opt);
}

//__________________________________________________________
void GLSPlayer::SetLevelColorPalette(Color_t plus, Color_t minus, Color_t unknown, Color_t selected)
{
    Color_t pal[] = {plus, minus, unknown, selected};
    
    Level::SetColorPalette(pal);
    Select();
    DeSelect();
}

//__________________________________________________________
void GLSPlayer::SetLevelStylePalette(Color_t known, Color_t tentative)
{
    Color_t pal[] = {known, tentative};
    
    Level::SetStylePalette(pal);
    UpdateDrawingOptions();
}

//__________________________________________________________
void GLSPlayer::SetLinkDefaultColor(Color_t color)
{
    Link::SetDefaultColor(color);
    UpdateDrawingOptions();
}

//__________________________________________________________
void GLSPlayer::SetCascadeColorPalette(Color_t def, Color_t selected)
{
    Color_t pal[] = {def, selected};
    
    Cascade::SetColorPalette(pal);
    UpdateDrawingOptions();
}

//__________________________________________________________
void GLSPlayer::UpdateDrawingOptions()
{
    for (Int_t i = 0; i < GetLinkList().GetSize(); ++i) {
        Link* link =  static_cast<Link*>(GetLinkList().At(i));
        link->SetFillColor( Link::GetDefaultColor() );
    }
    
    for (Int_t i = 0; i < GetLevelList().GetSize(); ++i) {
        Level* level = static_cast<Level*>(GetLevelList().At(i));
        level->SetLineColor( Level::GetDefaultColor(level->GetDefaultColor()) );
        level->SetLineStyle( Level::GetDefaultStyle(level->GetDefaultStyle()) );
    }
    
    for (Int_t i = 0; i < GetCascadeList().GetSize(); ++i) {
        Cascade* cas = static_cast<Cascade*>(GetCascadeList().At(i));
        cas->SetLabelColor(Cascade::kDefault);
    }
}

ClassImp( GLSPlayer)