BaseNucleus.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 ROOT_TNamed
#include <TNamed.h>
#endif

#ifndef ROOT_TXMLNode
#include <TXMLNode.h>
#endif

#ifndef ROOT_TDOMParser
#include <TDOMParser.h>
#endif

#ifndef ROOT_TXMLAttr
#include <TXMLAttr.h>
#endif

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,15,0)
#include "TList.h"
#endif

#ifndef GW_ENV_H
#include "Env.h"
#endif

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

#include <iostream>
#include <cstdlib>

using namespace std;
using namespace Gw;

ClassImp(BaseNucleus);

TMap *BaseNucleus::gTable = new TMap();

//Defaut constructor
BaseNucleus::BaseNucleus(): fA(0), fN(0), fZ(0)
{
}

//Constructor
BaseNucleus::BaseNucleus(Int_t A, Int_t Z, Int_t N)
{
        SetAZN(A,Z,N);
}

//Constructor
BaseNucleus::~BaseNucleus() 
{
    fA = fZ = fN = 0;
}

bool BaseNucleus::SetAZN(Int_t A, Int_t Z)
{
        if ( A < 0 || Z < 0 || A < Z ) return false;
        else {
                fA = A; fZ = Z; fN = fA - fZ;
        }
        return true;    
}


bool BaseNucleus::SetAZN(Int_t A, Int_t Z, Int_t N)
{ 
        if ( A < 0 || Z < 0 || N < 0 ) return false;
    
        fA = A; fZ = Z; fN = N;
    
        // now check if it is consistant
        if ( N != (A-Z) ) {
                cout << " - ! - in BaseNucleus::Set N != A - Z " << endl; 
                fN = fA - fZ;
        }
        return true;
}

bool BaseNucleus::SetAZN(const char *s, Int_t A)
{
        if ((s == NULL) || A < 0) return false;
        
        if (gTable->GetSize() == 0) {  //test gTable
                //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
                //return -1;
                LoadTable();    
        }
        Int_t Z = WhichZ(s);
        if ( (Z < 0) || (A-Z < 0) ) return false;
        SetAZN(A,Z,A-Z);
        return true;
}

bool BaseNucleus::SetAZN(const char *s)
{
        if (s == NULL) return false;
        
        if (gTable->GetSize() == 0) {
                //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
                //return -1;
                LoadTable();    
        }
        Int_t Z = WhichZ(s); 
        if ( Z < 0) return false;
        
        BaseNucleus *bn = (BaseNucleus *)gTable->GetValue(s);
        SetA(bn->GetA());
        SetZ(bn->GetZ());
        SetN(bn->GetN());
        
        return true;
}

const char *BaseNucleus::WhichSymbol(Int_t Z){
        if (gTable->GetSize() == 0) {
                //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
                //return 0;
                LoadTable();    
        }
        TMapIter *iter = (TMapIter *)gTable->MakeIterator();  //Iterator to loop on gTable
        TNamed *str;
        BaseNucleus *bn;
        while ((str = (TNamed *)iter->Next())){  //loop on gTable
                bn = (BaseNucleus *)gTable->GetValue(str); 
                if (bn->fZ == Z) {
                        return str->GetName();  
                }
        }
        
        cout << " - ! - No Nucleus with Z = "<< Z << " found in the table - Please check Z" << endl; 
        return "";
}

const char *BaseNucleus::WhichSymbol(Int_t Z, Int_t A){
        if (gTable->GetSize() == 0) {
          //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
          //return 0;
          LoadTable();  
        }
        TMapIter *iter = (TMapIter *)gTable->MakeIterator();  //Iterator to loop on gTable
        TNamed *str;
        BaseNucleus *bn;
        while ((str = (TNamed *)iter->Next())){  //loop on gTable
                bn = (BaseNucleus *)gTable->GetValue(str); 
                if (bn->fZ == Z) {                  
                      return Form("%d%s", A, str->GetName() );  
                }
        }
        
        cout << " - ! - No Nucleus with Z = "<< Z << " found in the table - Please check Z" << endl; 
        return "";
}


Int_t BaseNucleus::WhichZ(const char *s){
        if (s == NULL) return -1;
        if (gTable->GetSize() == 0) {
                //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
                //return -1;
                LoadTable();    
        }
        TString sym(s);
        BaseNucleus *bn = (BaseNucleus *)gTable->GetValue(s);
        if (bn == NULL) {
                cout << " - !- No Nucleus named "<< s << " found in the table - Please check the symbol !!!" << endl; 
                return -1;
        } else {
                return bn->GetZ();              
        }
}

const char* BaseNucleus::WhichFullName(const char *s){
        if (s == NULL) return "";
        if (gTable->GetSize() == 0) {
                //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
                //return -1;
                LoadTable();    
        }
        TMapIter *iter = (TMapIter *)gTable->MakeIterator();  //Iterator to loop on gTable
        TNamed *str;
        while ((str = (TNamed *)iter->Next())){  //loop on gTable
                if (strcmp(str->GetName(), s) == 0) {
                        return str->GetTitle();
                }
        }
        cout << " - ! - No Nucleus with symbol = "<< s<< " found in the table - Please check the symbol" << endl; 
        return "";
}

const char* BaseNucleus::WhichFullName(Int_t Z){
        if (gTable->GetSize() == 0) {
                //cout << "MapTable undefined, please use Gw::BaseNucleus::LoadTable()" <<endl;
                //return 0;
                LoadTable();    
        }
        TMapIter *iter = (TMapIter *)gTable->MakeIterator();  //Iterator to loop on gTable
        TNamed *str;
        BaseNucleus *bn;
        while ((str = (TNamed *)iter->Next())){  //loop on gTable
                bn = (BaseNucleus *)gTable->GetValue(str); 
                if (bn->fZ == Z) {
                        return str->GetTitle(); 
                }
        }
        
        cout << " - ! - No Nucleus with Z = "<< Z << " found in the table - Please check Z" << endl; 
        return "";
}

bool BaseNucleus::LoadTable(const char *xmlfile)
{       
        // method to Fill gTable, i.e. a map to give the correspondance between Z and the atomic symbol. 
        // The input file is a xml file (default is file "TableNucleus.xml", stored in /where/I/install/gammaware/ndb directory
        // For each element, a couple of key/value is defined
        // key = TNamed to store the symbol (name) and the full name (title)
        // value = BaseNucleus object (default is the most abundant stable nucleus)
        
        TString strxml = xmlfile;
        if (strxml.IsNull()) { //Set the default xml file
                strxml = Gw::Env::GetPath("NdbPath"); if ( strxml.EndsWith("/") == kFALSE ) strxml += "/"; 
                strxml += "TableNucleus.xml";
        }       
        TDOMParser *domParser = new TDOMParser();
        Int_t parsecode = domParser->ParseFile(strxml.Data()); //Check validity of the xmlfile respect to the corresponding .dtd file

        TMap table; 
        
        if (parsecode < 0) {
                cout << domParser->GetParseCodeMessage(parsecode) << endl;
                return false;
        }       

        TXMLNode *node = domParser->GetXMLDocument()->GetRootNode();
        
        TXMLNode *node2 = NULL;
        TXMLNode *node3 = NULL;
        
        TNamed *str = NULL;
        BaseNucleus *bn = NULL;
        
        TString sym,name,strtmp;
                        
        node = node->GetChildren();

        //Begin the reading
        for (; node; node = node->GetNextNode()) {
                if (node->GetNodeType() == TXMLNode::kXMLElementNode) { // First Element Node before the rootnode
                        if (strcmp(node->GetNodeName(), "nucleus") == 0) {
                                if (node->HasAttributes()) {
                                        TList *attrList = node->GetAttributes();
                                        TXMLAttr *attr = 0;
                                        TIter next(attrList);
                                        while ((attr=(TXMLAttr*)next())) {
                                                if (strcmp(attr->GetName(), "symbol") == 0) {
                                                        sym = attr->GetValue();
                                                }
                                                if (strcmp(attr->GetName(), "name") == 0) {
                                                        name = attr->GetValue();
                                                }       
                                        }
                                        str = new TNamed(sym.Data(),name.Data());
                                        //cout << str->GetName() << " " << endl;
                                }
                                node2 = node->GetChildren();
                                for ( ; node2; node2 = node2->GetNextNode()) {
                                        if (node2->GetNodeType() == TXMLNode::kXMLElementNode) { // Element Node
                                                if (strcmp(node2->GetNodeName(), "Z") == 0) {
                                                        node3 = node2->GetChildren();
                                                        strtmp = node3->GetContent();
                                                        bn = new BaseNucleus( strtmp.Atoi(), strtmp.Atoi() , 0); //A BaseNucleus with Z=A, N=0 is declared (Z is required in the xmlfile)
                                                }
                                                
                                                if (strcmp(node2->GetNodeName(), "A") == 0) {
                                                        node3 = node2->GetChildren();
                                                        strtmp = node3->GetContent();
                                                        bn->SetA(strtmp.Atoi());
                                                }
                                                
                                                if (strcmp(node2->GetNodeName(), "N") == 0) {
                                                        node3 = node2->GetChildren();
                                                        strtmp = node3->GetContent();
                                                        bn->SetN(strtmp.Atoi());
                                                }
                                                
                                                
                                        }       
                                }
                                // Fill the map
                                table.Add(str,bn);
                        }
                }
        }
         
        
        if (gTable->GetSize() != 0) { // A table was previously defined, delete all elements of gTable
                gTable->DeleteAll();   // Objects are NOT deleted, TMap is not owner
                        
        }
        //copy all elements of the new table in gTable
        TMapIter *iter = (TMapIter *)table.MakeIterator();
        while ((str = (TNamed *)iter->Next())){
                bn = (BaseNucleus *)table.GetValue(str);
                gTable->Add(str,bn);
        }
        
        //cout << "Table loaded from file \"" << strxml.Data() <<"\""<<endl;
        return true;

}