ENSDF.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_ENSDF_H
#include "ENSDF.h"
#endif

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

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

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

#include <iostream>
#include <sstream>

using namespace std;
using namespace Gw;

ClassImp(ENSDF);

ENSDF::ENSDF()
{
}

ENSDF::~ENSDF() { ; }

Link  *ENSDF::GetLink(const char *record, TString &/*opt*/)
{
        string s, tmp; Link *newlink;
        
        newlink = NULL; s = "";
        if ( IsRecord(record,"GAMMA") ) {
                if ( GetCC(record) == 0 ) {
                        newlink = new GammaLink;
                } else {
                        newlink = new XGammaLink;
                        ((GammaLink *)newlink)->GetConversion().Set(GetCC(record), GetDCC(record));
                }

                // possible offset in energy is ignored ..
                tmp = "";
                ((GammaLink *)newlink)->GetEnergy().Set(GetE(record,tmp), GetDE(record));
                if ( tmp.find("?") != string::npos ) 
                        { ((GammaLink *)newlink)->GetEnergy().SetInfo(InfoData::kTentative);} 
                        
                tmp = "";               
                newlink->GetStrength().Set(GetRI(record,tmp), GetDRI(record));
                if ( tmp.find("?") != string::npos ) 
                        { newlink->GetStrength().SetInfo(InfoData::kTentative);} 
                        
                if ( record[77] == 'C' || record[77] == '?' ) {
                        ((GammaLink *)newlink)->GetEnergy().SetInfo(InfoData::kTentative);
                }
        } // if gamma
        
        return newlink;
}    

Level *ENSDF::GetLevel(const char *record, TString &opt)
{
        static char spinoffset[] = "JKLMNOPQRSTUVWXYZABCDEFGHI";
        
        string s,tmp1, tmp2; NuclearLevel *lev;

        lev = NULL; s = "";     
        if ( IsRecord(record,"LEVEL") ) { // a new level

        lev = new NuclearLevel();
                
                // half-life and energy related
                Float_t unit_t; 
                unit_t = 0.0;
                lev->GetT().Set(GetT(record,unit_t,tmp1),GetDT(record));
                if ( tmp1.find("?")  != string::npos ) 
                        { lev->GetT().SetInfo(InfoData::kTentative); } // tentative
                
                // printf("Energy %f \n",GetE(record,tmp1));
                lev->GetEnergy().Set(GetE(record,tmp1),GetDE(record)); 
                // lev->GetEnergy().Set(10.0,GetDE(record));            
                if ( tmp1.find("?") != string::npos ) { 
                        lev->GetE().SetInfo(InfoData::kTentative);
                        lev->SetStyle(Level::kTentative);       
                        tmp1.erase(tmp1.find("?"),1); 
                } 
                else {
                        lev->GetE().SetInfo(InfoData::kKnown);
                        lev->SetStyle(Level::kKnown);   
                }
                // lev->ls();
                s = tmp1;  // copy the possible offset in s
                
                // spin-parity related
                // supposed to be known since they are about to be read ..
                lev->GetSpin().SetInfo(InfoData::kKnown);lev->GetParity().SetInfo(InfoData::kKnown);
                
                // the spin-parity field is complexe to be decoded !!! 
                // What is done here:
                // 
                        
                tmp1 = GetJPI(record);
                if (tmp1.find("NATURAL/UNNATURAL") != string::npos) {
                        if ( gDebug == 1) printf("NATURAL/UNNATURAL J in ENSDF::GetLevel() \n");
                        lev->GetSpin().SetInfo(InfoData::kUnknown); 
                        lev->GetParity().SetInfo(InfoData::kUnknown); 
                } // I don't know what this means !
                if (tmp1.find("NOT") != string::npos) {
                        if ( gDebug == 1) printf("NOT J in ENSDF::GetLevel()\n");
                        lev->GetSpin().SetInfo(InfoData::kUnknown); 
                        lev->GetParity().SetInfo(InfoData::kUnknown); 
                } // I don't know what this means !
                
                // check out if there is an offset. if true, the corresponding 
                // character is added to the s string.          
                size_t l; 
                for (int i = 0; i < 26; i++) { 
                        // WARNING tmp2 = spinoffset[i] + "+" doesn't work !            
                        tmp2 = spinoffset[i]; tmp2 += "+" ; 
                        if ( (l = tmp1.find(tmp2,0)) != string::npos ) 
                                { s += spinoffset[i]; tmp1.erase(l,2); break; } 
                        if ( (l = tmp1.find(spinoffset[i],0)) != string::npos ) 
                                { s += spinoffset[i]; tmp1.erase(l,1); break; }
                } 
                // now determine the parity part.
                if ( tmp1.find("-") != string::npos && tmp1.find("+") != string::npos ) {
                        if ( gDebug == 1) printf(" - and + in ENSDF::GetLevel()\n");
                        lev->GetParity().SetInfo(InfoData::kUnknown); // both value => Unknown !
                }
                else { // only one or no value.
                        lev->GetParity().SetInfo(InfoData::kUnknown);
                        lev->SetLabel("",1);    
                        lev->SetColor(Level::kUnknown);
                        if ( tmp1.find("-") != string::npos ) {
                          lev->GetParity().Set(Parity::kMinus);                 
                          lev->GetParity().SetInfo(InfoData::kKnown);
                          lev->SetLabel("-",1);
                          lev->SetColor(Level::kMinus); 
                          if ( gDebug == 1) printf(" - in ENSDF::GetLevel()\n");          
                        }
                        if ( tmp1.find("-)") != string::npos ) {
                          lev->GetParity().Set(Parity::kMinus);                 
                          lev->GetParity().SetInfo(InfoData::kTentative);
                          lev->SetLabel("(-)",1);
                          lev->SetColor(Level::kMinus);  
                          if ( gDebug == 1) printf(" -? in ENSDF::GetLevel()\n");         
                        }                       
                        if ( tmp1.find("+") != string::npos ) {
                          lev->GetParity().Set(Parity::kPlus);  
                          lev->GetParity().SetInfo(InfoData::kKnown);
                          lev->SetLabel("+",1);
                          lev->SetColor(Level::kPlus);    
                          if ( gDebug == 1) printf(" + in ENSDF::GetLevel()\n");          
                        }
                        if ( tmp1.find("+)") != string::npos ) {
                          lev->GetParity().Set(Parity::kPlus);                  
                          lev->GetParity().SetInfo(InfoData::kTentative);
                          lev->SetLabel("(+)",1);
                          lev->SetColor(Level::kPlus);   
                          if ( gDebug == 1) printf(" +? in ENSDF::GetLevel()\n");         
                        }                       
                }
                // now keep only the first assumption in case of several possibilities
                // case 2, 3, 4, and 6 in the ENSDF doc.
                if ( gDebug > 0 )cout << " Multiple values of spin and/or parity "<<  tmp1 << endl;             
                bool multiple = false; l = string::npos;
                if ( (l = tmp1.find("OR"))  != string::npos ) { tmp1.erase(l); multiple = true;}
                if ( (l = tmp1.find(","))   != string::npos ) { tmp1.erase(l); multiple = true;}
                if ( (l = tmp1.find("AND")) != string::npos ) { tmp1.erase(l); multiple = true;}
                if ( (l = tmp1.find("&"))   != string::npos ) { tmp1.erase(l); multiple = true;}
                if ( (l = tmp1.find("TO"))  != string::npos ) { tmp1.erase(l); multiple = true;}
                if ( (l = tmp1.find(":"))   != string::npos ) { tmp1.erase(l); multiple = true;}
                if ( (l = tmp1.find("AP"))  != string::npos ) { tmp1.erase(l,2); multiple = true;}
                if ( (l = tmp1.find("LE"))  != string::npos ) { tmp1.erase(l,2); multiple = true;}
                if ( (l = tmp1.find("GE"))  != string::npos ) { tmp1.erase(l,2); multiple = true;}
                if ( multiple ) {  
                  if ( gDebug > 0 ) cout << " Multiple values of spin and/or parity "<<  tmp1 << endl;
                  lev->GetSpin().SetInfo(InfoData::kTentative);
                } // tentative value for spin since several values are proposed
                
                // !Unknown means there might be something to decode
                if ( ! lev->GetSpin().IsData(InfoData::kUnknown)  ) {
                        if ( (l = tmp1.find("("))  != string::npos ) { 
                                tmp1.erase(l,1); lev->GetSpin().SetInfo(InfoData::kTentative);
                        }
                        if ( (l = tmp1.find(")"))  != string::npos ) { 
                                tmp1.erase(l,1); lev->GetSpin().SetInfo(InfoData::kTentative);
                        }
                        
                        // now try to read the spin value
                        Int_t n, d;

                        d = 1;
                        if ( (l = tmp1.find("/2"))  != string::npos ) {
                                tmp1.erase(l,2); d = 2;
                        }
                        istringstream spinstring(tmp1); spinstring >> n ;
                        if ( spinstring.fail() ) { // cannot read the value for some reason 
                                lev->GetSpin().Set(0);
                                lev->GetSpin().SetInfo(InfoData::kUnknown);
                        }
                        else {
                                lev->GetSpin().Set(n,d);
                                
                        }       
                } // spin decoding
                
                // drawing part related 
                lev->SetY1(lev->GetEnergy().GetValue());
                lev->SetX1(-50); lev->SetX2(50);                
        }
        
        opt = s.data(); return lev;
}

void ENSDF::ls(std::ostream &/*out*/) const
{
        BaseENSDF::ls(cout);
}
       
void ENSDF::test()
{
        TString tmp;
        
        char *record = BlankRecord();
        
        Open("DY_ENSDF.ens"); BaseENSDF::ls(cout);
        
        unsigned int idset; bool ok;
        
        idset = IsDataSet("152DY");
        if ( idset > 0 ) {
                ok = FirstRecord(idset,record);
                while( ok ) {
                        if ( IsRecord(record,"LEVEL") ) { 
                                GetLevel(record,tmp)->ls();
                        }
                        if ( IsRecord(record,"GAMMA") ) {
                                //GetLink(record,tmp)->ls();
                        }
                        ok = NextRecord(idset,record);
                }
        }
        else { printf("Cannot find data set in test \n "); } 
        
        Close(); 
        
        delete record;
}