genie::FermiMomentumTablePool Class Reference

Singleton class to load & serve tables of Fermi momentum constants. More...

#include <FermiMomentumTablePool.h>

Classes
struct	Cleaner

Public Member Functions
const FermiMomentumTable *	GetTable (string name)

Static Public Member Functions
static FermiMomentumTablePool *	Instance (void)

Private Member Functions
	FermiMomentumTablePool ()
	FermiMomentumTablePool (const FermiMomentumTablePool &fmc)
virtual	~FermiMomentumTablePool ()
bool	LoadTables (void)
XmlParserStatus_t	ParseXMLTables (string filename)

Private Attributes
map< string, FermiMomentumTable * >	fKFSets

Static Private Attributes
static FermiMomentumTablePool *	fInstance = 0

Friends
struct	Cleaner

Detailed Description

Singleton class to load & serve tables of Fermi momentum constants.

Author

Costas Andreopoulos <constantinos.andreopoulos cern.ch> University of Liverpool & STFC Rutherford Appleton Laboratory

August 18, 2005

Copyright (c) 2003-2020, The GENIE Collaboration For the full text of the license visit http://copyright.genie-mc.org

Definition at line 34 of file FermiMomentumTablePool.h.

Constructor & Destructor Documentation

FermiMomentumTablePool::FermiMomentumTablePool ( )

private

Definition at line 42 of file FermiMomentumTablePool.cxx.

{
  if( ! this->LoadTables() ) {
   LOG("FermiP", pERROR) << "FermiMomentumTablePool initialization failed!";
  }
  fInstance =  0;
}

genie::FermiMomentumTablePool::FermiMomentumTablePool ( const FermiMomentumTablePool &  fmc )

private

FermiMomentumTablePool::~FermiMomentumTablePool ( )

privatevirtual

Definition at line 50 of file FermiMomentumTablePool.cxx.

{
  map<string, FermiMomentumTable *>::iterator titer;
  for(titer = fKFSets.begin(); titer != fKFSets.end(); ++titer) {
    FermiMomentumTable * t = titer->second;
    if(t) delete t;
    t=0;
  }
  fKFSets.clear();
  fInstance = 0;
}

Member Function Documentation

const FermiMomentumTable * FermiMomentumTablePool::GetTable

(

string

name

)

Definition at line 76 of file FermiMomentumTablePool.cxx.

{
  string defopt = "Default"; // default option

  map<string, FermiMomentumTable *>::const_iterator table_iter;
  FermiMomentumTable * table = 0;

  if(fKFSets.count(name) == 1) {
     table_iter = fKFSets.find(name);
     table = table_iter->second;
     if(table) return table;
  }
  if(fKFSets.count(defopt) == 1) {
     LOG("FermiP", pWARN)
         << "Fermi momentum table: [" << name << "] was not found! "
                               << "Switching to table: [" << defopt << "]";
     table_iter = fKFSets.find(defopt);
     table = table_iter->second;
     if(table) return table;
  }
  LOG("FermiP", pERROR)
            << "Not even the default Fermi momentum table was not found!";
  return 0;
}

FermiMomentumTablePool * FermiMomentumTablePool::Instance ( void  )

static

Definition at line 62 of file FermiMomentumTablePool.cxx.

{
  if(fInstance == 0) {

    LOG("FermiP", pINFO) << "FermiMomentumTablePool late initialization";

    static FermiMomentumTablePool::Cleaner cleaner;
    cleaner.DummyMethodAndSilentCompiler();

    fInstance = new FermiMomentumTablePool;
  }
  return fInstance;
}

bool FermiMomentumTablePool::LoadTables ( void  )

private

Definition at line 101 of file FermiMomentumTablePool.cxx.

{
  bool loaded = true;

  //-- Fermi momenta sets XML file using GXMLPATH + default locations
  string filename = utils::xml::GetXMLFilePath("FermiMomentumTables.xml");

  LOG("FermiP", pINFO)  << "Loading Fermi momenta from file: " << filename;

  bool is_accessible = ! (gSystem->AccessPathName( filename.c_str() ));

  if(is_accessible) {
      XmlParserStatus_t status = this->ParseXMLTables(filename);
      if(status != kXmlOK) {
         LOG("FermiP", pWARN)
            << "XML parser status: " << XmlParserStatus::AsString(status)
            << " - Couldn't read file: " << filename;
         loaded = false;
      }
  } else {
      LOG("FermiP", pWARN) << "Not accessible file: " << filename;
      loaded = false;
  }
  return loaded;
};

XmlParserStatus_t FermiMomentumTablePool::ParseXMLTables ( string  filename )

private

Definition at line 127 of file FermiMomentumTablePool.cxx.

{
  LOG("FermiP", pDEBUG) << "Reading XML file: " << filename;

  xmlDocPtr xml_doc = xmlParseFile(filename.c_str());
  if(xml_doc == NULL) return kXmlNotParsed;

  xmlNodePtr xml_root = xmlDocGetRootElement(xml_doc);
  if(xml_root==NULL)
  {
          xmlFreeDoc(xml_doc);
          return kXmlEmpty;
  } 

  const xmlChar * xml_root_name = (const xmlChar *)"fermi_momentum_const";
  if( xmlStrcmp(xml_root->name, xml_root_name) )
  {
          xmlFreeDoc(xml_doc);
          return kXmlInvalidRoot;
  } 

  xmlNodePtr xml_kft = xml_root->xmlChildrenNode; // <kf_table>'s

  // loop over <kf_table> nodes
  while (xml_kft != NULL) {
    if( (!xmlStrcmp(xml_kft->name, (const xmlChar *) "kf_table")) ) {

       string name = utils::str::TrimSpaces(
                       utils::xml::GetAttribute(xml_kft, "name"));

       LOG("FermiP", pDEBUG) << "Reading Fermi momenta table: " << name;

       FermiMomentumTable * kftable = new FermiMomentumTable; // new table

       // loop over <kf> nodes
       xmlNodePtr xml_kf = xml_kft->xmlChildrenNode; // <kf_table> children
       while (xml_kf != NULL) {
         if( (!xmlStrcmp(xml_kf->name, (const xmlChar *) "kf")) ) {

           string spdgc = utils::str::TrimSpaces(
                       utils::xml::GetAttribute(xml_kf, "nucleus_pdgc"));
           int    pdgc = atoi (spdgc.c_str());

           xmlNodePtr xml_cur = xml_kf->xmlChildrenNode; // <kf> children
           const xmlChar * ntag = (const xmlChar *)"n";
           const xmlChar * ptag = (const xmlChar *)"p";
           double kfp=0, kfn=0, kf=0;
           // loop over <kf> children
           while (xml_cur != NULL) {
             bool isp = !xmlStrcmp(xml_cur->name, ptag);
             bool isn = !xmlStrcmp(xml_cur->name, ntag);
             if(isn || isp) {
               string skf = utils::xml::TrimSpaces(
                  xmlNodeListGetString(xml_doc, xml_cur->xmlChildrenNode, 1));
               kf = atof(skf.c_str());
             }
             if(isp) kfp = kf;
             if(isn) kfn = kf;
             xml_cur = xml_cur->next;
           }
           xmlFreeNode(xml_cur);

           KF_t kft;
           kft.p = kfp;
           kft.n = kfn;

           LOG("FermiP", pDEBUG)
              << "Add KF table entry: PDGC = " << pdgc
                  << " --> " << "kf(p) = " << kft.p << ", kf(n) = " << kft.n;
           kftable->AddTableEntry(pdgc,kft);
         } //<x> == <kf>
         xml_kf = xml_kf->next;
      } //<kf> loop
      xmlFreeNode(xml_kf);

      fKFSets.insert(
                map<string, FermiMomentumTable *>::value_type(name,kftable));

    } //<x> == <kf_table>
    xml_kft = xml_kft->next;
  } //<kf_table> loop
  xmlFreeNode(xml_kft);
  xmlFreeDoc(xml_doc);

  return kXmlOK;
}

Friends And Related Function Documentation

friend struct Cleaner

friend

Definition at line 62 of file FermiMomentumTablePool.h.

Member Data Documentation

FermiMomentumTablePool * FermiMomentumTablePool::fInstance = 0

staticprivate

Definition at line 49 of file FermiMomentumTablePool.h.

map<string, FermiMomentumTable *> genie::FermiMomentumTablePool::fKFSets

private

Definition at line 51 of file FermiMomentumTablePool.h.

---

The documentation for this class was generated from the following files:

• Generator/src/Physics/NuclearState/FermiMomentumTablePool.h
• Generator/src/Physics/NuclearState/FermiMomentumTablePool.cxx