Cascade.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.             *
 ***************************************************************************/
 
#include <iostream>

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

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

#ifndef ROOT_TPad
#include "TPad.h"
#endif

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

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

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

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

using namespace Gw;
using namespace std;

ClassImp(Cascade);

const Int_t Cascade::fgkMaxColor          = 2;
const Int_t Cascade::fgkMaxStyle          = 2;
Float_t Cascade::fgDefaultLabelSize       = 0.03; 
Style_t Cascade::fgDefaultStyle[fgkMaxStyle] = {1, 2};    
Color_t Cascade::fgDefaultColor[fgkMaxColor] = {1, 4};   

//__________________________________________________________
Cascade::Cascade()
 :  TList(),
    fName(0,0,""),
    fType(0,0,"ND"),
    fDefaultStyle(kKnown),
    fDefaultColor(kDefault),
    fIsSelected(false),
    fIsVisible(true),
    fLog("Cascade"),
    fXName(0.0),
    fYName(0.0)
{
  SetOwner(kFALSE); 
  fName.SetTextAlign(22);
  fName.SetTextColor(1);
  fName.SetTextSize(fgDefaultLabelSize);
  fType.SetTextAlign(22);
}

//__________________________________________________________
Cascade::~Cascade()
{

}

//__________________________________________________________
TLatex& Cascade::GetLatex(Option_t *opt)
{
        TString o = opt;
        if ( o.Contains("name") ) return fName;
        else return fType;
}

//__________________________________________________________
void Cascade::SetLabels(const Char_t* name, const Char_t* type, Double_t x, Double_t y)  
{ 
   fType.SetTitle(type); 
   if (x != 0 && y != 0) 
          fName.SetText(x, y, name); 
   else
          fName.SetTitle(name); 
}

//__________________________________________________________
void Cascade::Paint(Option_t* opt)
{
  // paint  
  fName.Paint(opt);  
}

//__________________________________________________________
void Cascade::Draw(Option_t* opt)
{
  // draw
  fName.Draw(opt);
  AppendPad(opt);
}

//__________________________________________________________
void Cascade::SetVisible(Bool_t visu) 
{
  fIsVisible = visu;
  
  TIter next(this);
  
  Link* link;
  while ( (link = (Link*)next()) ){
    if ( IsVisible() ) {
      link->SetVisible();
      link->GetIL()->SetVisible();
      link->GetFL()->SetVisible();
    } else {
      link->SetUnvisible();
      link->GetIL()->SetUnvisible();
      link->GetFL()->SetUnvisible();
    }
  }
}

//__________________________________________________________
Int_t Cascade::DistancetoPrimitive(Int_t px, Int_t py)
{
  Int_t d = fName.DistancetoPrimitive(px, py);
  return d;
}


//__________________________________________________________
void Cascade::ExecuteEvent(Int_t event, Int_t px, Int_t py)
{
  fName.ExecuteEvent(event, px, py);
}


//__________________________________________________________
void Cascade::ls(Option_t* /*opt*/) const
{
  for (Int_t i = 0; i < GetEntries(); ++i) {
    cout << Form("Link # %d", i) << endl;
    Link* link = static_cast<Link*> ( At(i) );
    link->ls();
  }
}

//__________________________________________________________
TGraphErrors* Cascade::DoJ1() const
{
  
  fLog.SetProcessMethod("DoJ1()");
  
  Float_t j1[GetEntries()];
  Float_t deltaJ1[GetEntries()];
  Float_t omega[GetEntries()];
  Float_t deltaOmega[GetEntries()];
  Int_t nPoints = 0;
  
  for (Int_t i =  0; i < GetEntries(); ++i ) {
    Link* link1 = static_cast<Link*> ( At(i) );
    NuclearLevel* level1 = dynamic_cast<NuclearLevel*>( link1->GetFL() );
    NuclearLevel* level2 = dynamic_cast<NuclearLevel*>( link1->GetIL() );
    
    if (level1 == 0x0 || level2 == 0x0) {
      fLog << error << "Energy and/or Spin not defined for these levels " << dolog;
      return 0x0;
    }
        
    
    Float_t E1 =  level1->GetEnergy().Get();
    Float_t E2 =  level2->GetEnergy().Get();
    Float_t deltaE1 =  level1->GetEnergy().GetError();
    Float_t deltaE2 =  level2->GetEnergy().GetError();
    
    Float_t deltaE = TMath::Abs( E2 - E1);
    if (deltaE == 0)  {
      fLog << warning << "Delta E is null" << nline;
      continue;
    }
    
    if (level2->GetSpin().Get() == 0 ||  level1->GetSpin().Get() == 0) {
      fLog << warning << "Spin I is null" << nline;
      continue;
    }
    
    Float_t deltaI = TMath::Abs( level2->GetSpin().Get() - level1->GetSpin().Get() );
    if (deltaI == 0)  {
      fLog << warning << "Delta I is null" << nline;
      continue;
    }
    
    
    j1[nPoints]    =  deltaI/deltaE*level1->GetSpin().Get();
    omega[nPoints] =  TMath::Abs( E2 - E1 )/deltaI;
    
    deltaJ1[nPoints]    = TMath::Sqrt( (deltaE1/E1)*(deltaE1/E1) + (deltaE2/E2)*(deltaE2/E2) );
    
    deltaOmega[nPoints] = TMath::Sqrt( (deltaE1/E1)*(deltaE1/E1) +  (deltaE2/E2)*(deltaE2/E2) );
    nPoints++;
  } 
        
        fLog << dolog;
  
  if (nPoints != 0)
    return new TGraphErrors(nPoints, omega, j1, deltaOmega, deltaJ1);
  else
    return 0x0;
        
}

//__________________________________________________________
TGraphErrors* Cascade::DoJ2() const
{
  
  fLog.SetProcessMethod("DoJ2()");

  Float_t j2[GetEntries()-1];
  Float_t deltaJ2[GetEntries()-1];
  Float_t omega[GetEntries()-1];
  Float_t deltaOmega[GetEntries()-1];
  Int_t nPoints = 0;
  
  for (Int_t i =  0; i < GetEntries() - 1; ++i ) {
    Link* link1 = static_cast<Link*> ( At(i) );
    Link* link2 = static_cast<Link*> ( At(i+1) );
    NuclearLevel* level1 = dynamic_cast<NuclearLevel*>( link1->GetFL() );
    NuclearLevel* level2 = dynamic_cast<NuclearLevel*>( link1->GetIL() );
    NuclearLevel* level3 = dynamic_cast<NuclearLevel*>( link2->GetIL() );
    
    if (level1 == 0x0 || level2 == 0x0 || level3 == 0x0) {
      fLog << error << "Energy and/or Spin not defined for these levels " << dolog;
      return 0x0;
    }    
    
    Float_t E1 =  level1->GetEnergy().Get();
    Float_t E2 =  level2->GetEnergy().Get();
    Float_t E3 =  level3->GetEnergy().Get();
    Float_t deltaE1 =  level1->GetEnergy().GetError();
    Float_t deltaE2 =  level2->GetEnergy().GetError();
    Float_t deltaE3 =  level3->GetEnergy().GetError(); 
        
    
    Float_t deltaE = TMath::Abs( E1 - 2*E2 + E3);
    if (deltaE == 0) {
      fLog << warning << "Delta E is null" << dolog;
      continue;
    }
    
    if (level2->GetSpin().Get() == 0 ||  level1->GetSpin().Get() == 0) {
      fLog << warning << "Spin I is null" << nline;
      continue;
    }
    
    
    Float_t deltaI = TMath::Abs( level1->GetSpin().Get() - level3->GetSpin().Get() );
    if (deltaI == 0) {
      fLog << warning << "Delta I is null" << nline ;
      continue;
    }

    j2[nPoints]    =  deltaI/deltaE;
    omega[nPoints] =  TMath::Abs( E1 - E3 )/deltaI;
    
    deltaJ2[nPoints]    = TMath::Sqrt( (deltaE1/E1)*(deltaE1/E1) + 4*(deltaE2/E2)*(deltaE2/E2) 
                                   + (deltaE3/E3)*(deltaE3/E3) );
    
    deltaOmega[nPoints] = TMath::Sqrt( (deltaE1/E1)*(deltaE1/E1) +  (deltaE3/E3)*(deltaE3/E3) );
    nPoints++;
  } 
        
        fLog << dolog; 
  
  if (nPoints != 0)
    return new TGraphErrors(nPoints, omega, j2, deltaOmega, deltaJ2);
  else
    return 0x0;
        

}