GammaLink.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.             *
 ***************************************************************************/
 
#ifndef Gw_GammaLink
#include "GammaLink.h"
#endif

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

#include <iostream>
#include <iomanip>

using namespace std;
using namespace Gw;

Int_t GammaLink::fgMaxAttributes  = 6; 

//__________________________________________________________
GammaLink::GammaLink()
  : Link(),
    fAttrLabel("504")
{
    fEnergy.Set(0,0); fMixing.Set(0,0); fConv.Set(0.0,0.0); fEM = '-'; fLambda = 0; 
    fLog.GetProcessName() = "GammaLink";
}
    
//__________________________________________________________
GammaLink::GammaLink(const GammaLink &link) : Link(link)
{
   fEM          = link.fEM;
   fLambda      = link.fLambda;
   fEnergy      = link.fEnergy;
   fMixing      = link.fMixing;
   fConv        = link.fConv;
}

//__________________________________________________________
GammaLink& GammaLink::operator=(const GammaLink &link) 
{
  if (this == &link) return *this;
  Link::operator=(link);
  
  fEM           = link.fEM;
  fLambda       = link.fLambda;
  fEnergy       = link.fEnergy;
  fMixing       = link.fMixing;
  fConv         = link.fConv;
  
  return *this;
}

//__________________________________________________________
GammaLink::~GammaLink()
{
}

//__________________________________________________________
const char* GammaLink::GetLabel0()
{
  Int_t idx = fAttrLabel[0]-'0';
  
  TString tmp(GetAttr(idx));
  Int_t pos = tmp.Last(' ');
  if (pos != -1)
    tmp[pos] = '\0';
  
  return Form("%s", tmp.Data());
}

//__________________________________________________________
const char* GammaLink::GetLabel1()
{
  Int_t idx = fAttrLabel[1]-'0';
  
  TString tmp(GetAttr(idx));
  Int_t pos = tmp.Last(' ');
  if (pos != -1)
    tmp[pos] = '\0';

  return Form("%s", tmp.Data());
}

//__________________________________________________________
const char* GammaLink::GetLabel2() 
{
  Int_t idx = fAttrLabel[2]-'0';
  
  TString tmp(GetAttr(idx));
  Int_t pos = tmp.Last(' ');
  if (pos != -1)
    tmp[pos] = '\0';
  
  return Form("%s", tmp.Data());
}

//__________________________________________________________
void GammaLink::SetAttrLabel(const char *s)
{
  fLog.SetProcessMethod("SetAttrLabel(const char* )");
  
  TString st = s; Short_t end = (st.Length() < fgkMaxLinkLabel) ? st.Length(): fgkMaxLinkLabel;
  
  for( Short_t i = 0; i < end; ++i ) {
    if (st.CountChar(st[i]) > 1 && st[i]-'0' >= fgkMaxLinkLabel) {
      fAttrLabel = "504";
      fLog << warning << Form("Unambiguous position label pattern, set to %s", fAttrLabel.Data()) << nline;
      return;
    }
  }
  fLog << dolog;
        
  fAttrLabel = s;
}

//__________________________________________________________
const char* GammaLink::GetAttr(Int_t idx)
{
  
  switch (idx) {
    case 0:
      return GetAttr0(); 
    case 1:
      return GetAttr1(); 
    case 2:
      return GetAttr2(); 
    case 3:
      return GetAttr3(); 
    case 4:
      return GetAttr4(); 
    case 5:
      return GetAttr5(); 
    default:
      fLog.SetProcessMethod("GetAttr(Int_t )");
      fLog << warning << "wrong index, set to zero" << dolog;
      return GetAttr0();
  }
}

//__________________________________________________________
void GammaLink::SetGamma(const char* energy,   const char* multipolarity, 
                         const char* mixing,   const char* conversion,
                         const char* strength, const char* tau)
{
   fAttr0 = energy;     fAttr1 = multipolarity; fAttr2 = mixing;     fAttr3 = conversion;   fAttr4 = strength;            fAttr5 = tau;
   fEnergy.Set(energy); SetEM(multipolarity);   fMixing.Set(mixing); fConv.Set(conversion); GetStrength().Set(strength);  GetTau().Set(tau);

     
    for (Int_t i = 0; i < 3; ++i) {
      Int_t idx = fAttrLabel[i] - '0';
      TString tmp;
      
      switch (idx) {
        case 0:
          tmp = energy;
          break;
        case 1:
          tmp = multipolarity;
          break;
        case 2:
          tmp = mixing;
          break;
        case 3:
          tmp = conversion;
          break;
        case 4:
          tmp = strength;
          break;
        case 5:
          tmp = tau;
          break;
      }          
      
      Int_t pos = tmp.Last(' ');
      if (pos != -1)
        tmp[pos] = '\0';
      
      SetLabel(tmp.Data(), i);
    }

    SetPoints(GetX()[0]+(GetX()[2]-(GetX()[0]))/2.,GetX()[5]);
}

//__________________________________________________________
void GammaLink::SetEM(const char *em)
{
   TString s = em;

   fEM = '-'; fEM.SetInfo(InfoData::kUnknown);
   if ( s.BeginsWith("E") ) { fEM = 'E'; fEM.SetInfo(InfoData::kKnown); } 
   if ( s.BeginsWith("M") ) { fEM = 'M'; fEM.SetInfo(InfoData::kKnown); }
   
   s.Remove(0,1); 
 
   fLambda.SetInfo(InfoData::kUnknown);

   fLambda = 0;

   for (Int_t i = 0; i < 10; i++ )
   {
       if (((TString)s[0]).Atoi() == i )
       {
           fLambda.SetInfo(InfoData::kKnown);
           fLambda = i;
           break;
       }
   }

   /* pour version de root ou IsAlnum est defini
   if ( s.IsAlnum() == kFALSE ) { 
        fLambda.SetInfo(InfoData::kUnknown); fLambda = 0; 
   }
   else {
        UShort_t tmp; sprintf(s.Data(),"%d",&tmp); 
        fLambda.SetInfo(InfoData::kKnown); fLambda = tmp; 
   }
   */
}

//__________________________________________________________
void GammaLink::ls(Option_t* o) const 
{

  TString opt = o; string sep1, sep2;
  
  if ( opt.Contains("header") ) std::cout<< " Gamma energy (keV), \t Intensity, \t Multipolarity, \t Conversion" << std::endl;

  sep1 = sep2 = "";
  if ( fEnergy.IsData(InfoData::kTentative) ) { sep1 = '('; sep2 = ')'; }
  if ( fEnergy.IsData(InfoData::kTheo) )      { sep1 = '['; sep2 = ']'; }    
  if ( fEnergy.IsData(InfoData::kAbout) )     { sep1 = '~'; sep2 = ""; }    
  cout << sep1 << "Energy: " << fEnergy.GetValue() << " <" << fEnergy.GetError() << ">" << sep2 << "\t" ;
  
  sep1 = sep2 = "";
  if ( fStrength.IsData(InfoData::kTentative) ) { sep1 = '('; sep2 = ')'; }
  if ( fStrength.IsData(InfoData::kTheo) )      { sep1 = '['; sep2 = ']'; }    
  if ( fStrength.IsData(InfoData::kAbout) )     { sep1 = '~'; sep2 = ""; }    
  cout << sep1 << "Strength: " << fStrength.GetValue() << " <" << fStrength.GetError() << ">" << sep2 << "\t" ;
            
  if ( fConv.GetValue() != 0 ) {
        sep1 = sep2 = "";
        if ( fConv.IsData(InfoData::kTentative) ) { sep1 = '('; sep2 = ')'; }
        if ( fConv.IsData(InfoData::kTheo) )      { sep1 = '['; sep2 = ']'; }    
        if ( fConv.IsData(InfoData::kAbout) )     { sep1 = '~'; sep2 = ""; }    
    cout << sep1 << "Convertion: " << fConv.GetValue() << " <" << fConv.GetError() << ">" << sep2 << "\n" ;
  }
  else cout << endl;
      
  // if ( gDebug > 0 ) TLine::ls(o);
        
//        std::cout << "Gamma " << fEnergy.Get() << " " << fSpin << " " << fParity << std::endl;
}     

//__________________________________________________________
Int_t GammaLink::DoCascade(TSeqCollection &cas, Option_t */*opt*/)
{ 
        cas.Add(this);
    return 1;
}

ClassImp(GammaLink);