genie::utils::xml Namespace Reference

Functions
string	TrimSpaces (xmlChar *xmls)
string	GetAttribute (xmlNodePtr xml_cur, string attr_name)
string	GetXMLPathList (bool add_tune=true)
string	GetXMLDefaultPath ()
string	GetXMLFilePath (string basename)
xmlNodePtr	FindNode (xmlDocPtr xml_doc, string node_path)
bool	GetBool (xmlDocPtr xml_doc, string node_path)
int	GetInt (xmlDocPtr xml_doc, string node_path)
vector< int >	GetIntArray (xmlDocPtr xml_doc, string node_path)
double	GetDouble (xmlDocPtr xml_doc, string node_path)
vector< double >	GetDoubleArray (xmlDocPtr xml_doc, string node_path)
string	GetString (xmlDocPtr xml_doc, string node_path)
string	GetROOTFileName (xmlDocPtr xml_doc, string node_path)
string	GetROOTObjName (xmlDocPtr xml_doc, string node_path)
string	GetROOTObjType (xmlDocPtr xml_doc, string node_path)
TFile *	GetTFile (xmlDocPtr xml_doc, string node_path, string base_dir="<env>")
TH1F *	GetTH1F (xmlDocPtr xml_doc, string node_path, string base_dir="<env>")
TH1D *	GetTH1D (xmlDocPtr xml_doc, string node_path, string base_dir="<env>")
TH2D *	GetTH2D (xmlDocPtr xml_doc, string node_path, string base_dir="<env>")
TVectorD *	GetTVectorD (xmlDocPtr xml_doc, string node_path, string base_dir="<env>")

Function Documentation

xmlNodePtr genie::utils::xml::FindNode	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 128 of file XmlParserUtils.cxx.

{
  xmlNodePtr root_node = xmlDocGetRootElement(xml_doc);
  if(root_node==NULL) {
     LOG("XML", pERROR) << "Null root XML node";
     return NULL;
  }

  vector<string> node_path_vec = genie::utils::str::Split(node_path,"/");

  unsigned int ndepth = node_path_vec.size();
  unsigned int idepth = 0;

  xmlNodePtr curr_node = root_node;

  while (curr_node != NULL) {
    if( (!xmlStrcmp(
       curr_node->name, (const xmlChar *) node_path_vec[idepth].c_str())) )
    {
        idepth++;
        if(idepth == ndepth) {
          return curr_node;
        } else {
          curr_node = curr_node->xmlChildrenNode;
        }
    }
    curr_node = curr_node->next;
  }

  xmlFree(curr_node);
  return NULL;
}

string genie::utils::xml::GetAttribute	(	xmlNodePtr	xml_cur,
		string	attr_name
	)

Definition at line 44 of file XmlParserUtils.cxx.

                                                                        {
  xmlChar * xmls = xmlGetProp(xml_cur, (const xmlChar *) attr_name.c_str());
  string str = TrimSpaces(xmls);
  xmlFree(xmls);
  return str;
}

bool genie::utils::xml::GetBool	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 161 of file XmlParserUtils.cxx.

{
  xmlNodePtr node = genie::utils::xml::FindNode(xml_doc, node_path);
  if(node==NULL) {
    return false;
  }
  string content = genie::utils::xml::TrimSpaces(
      xmlNodeListGetString(xml_doc, node->xmlChildrenNode, 1) );

  if(content == "true" ||
     content == "TRUE" ||
     content == "True" ||
     content == "on"   ||
     content == "ON"   ||
     content == "On"   ||
     content == "1"    ||
     content == "I") return true;

  if(content == "false" ||
     content == "FALSE" ||
     content == "False" ||
     content == "off"   ||
     content == "OFF"   ||
     content == "Off"   ||
     content == "0"     ||
     content == "O") return false;

  LOG("XML", pERROR)
       << "Could not interpret content (" << content
       << ") found at node_path: " << node_path << " as a boolean!";
  return false;
}

double genie::utils::xml::GetDouble	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 228 of file XmlParserUtils.cxx.

{
  xmlNodePtr node = genie::utils::xml::FindNode(xml_doc, node_path);
  if(node==NULL) {
    return -999999;
  }
  string content = genie::utils::xml::TrimSpaces(
      xmlNodeListGetString(xml_doc, node->xmlChildrenNode, 1) );
  double value = atof(content.c_str());
  return value;
}

vector< double > genie::utils::xml::GetDoubleArray	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 241 of file XmlParserUtils.cxx.

{
  vector<double> array;

  xmlNodePtr node = genie::utils::xml::FindNode(xml_doc, node_path);
  if(node==NULL) {
    return array;
  }

  string content = genie::utils::xml::TrimSpaces(
      xmlNodeListGetString(xml_doc, node->xmlChildrenNode, 1) );

  vector<string> str_tokens = genie::utils::str::Split(content, ",");
  vector<string>::const_iterator str_tokens_iter = str_tokens.begin();
  for( ; str_tokens_iter != str_tokens.end(); ++str_tokens_iter) {
     string token = genie::utils::str::TrimSpaces(*str_tokens_iter);
     if (not token.size() ) continue;
     array.push_back( atof(token.c_str()) );
  }
  return array;
}

int genie::utils::xml::GetInt	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 194 of file XmlParserUtils.cxx.

{
  xmlNodePtr node = genie::utils::xml::FindNode(xml_doc, node_path);
  if(node==NULL) {
    return -999999;
  }
  string content = genie::utils::xml::TrimSpaces(
      xmlNodeListGetString(xml_doc, node->xmlChildrenNode, 1) );
  int value = atoi(content.c_str());
  return value;
}

vector< int > genie::utils::xml::GetIntArray	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 206 of file XmlParserUtils.cxx.

{
  vector<int> array;

  xmlNodePtr node = genie::utils::xml::FindNode(xml_doc, node_path);
  if(node==NULL) {
    return array;
  }

  string content = genie::utils::xml::TrimSpaces(
      xmlNodeListGetString(xml_doc, node->xmlChildrenNode, 1) );

  vector<string> str_tokens = genie::utils::str::Split(content, ",");
  vector<string>::const_iterator str_tokens_iter = str_tokens.begin();
  for( ; str_tokens_iter != str_tokens.end(); ++str_tokens_iter) {
     string token = genie::utils::str::TrimSpaces(*str_tokens_iter);
     if (not token.size() ) continue;
     array.push_back( atoi(token.c_str()) );
  }
  return array;
}

string genie::utils::xml::GetROOTFileName	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 274 of file XmlParserUtils.cxx.

{
  return genie::utils::xml::GetString(xml_doc, node_path+"/filename");
}

string genie::utils::xml::GetROOTObjName	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 279 of file XmlParserUtils.cxx.

{
  return genie::utils::xml::GetString(xml_doc, node_path+"/objname");
}

string genie::utils::xml::GetROOTObjType	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 284 of file XmlParserUtils.cxx.

{
  return genie::utils::xml::GetString(xml_doc, node_path+"/objtype");
}

string genie::utils::xml::GetString	(	xmlDocPtr	xml_doc,
		string	node_path
	)

Definition at line 263 of file XmlParserUtils.cxx.

{
  xmlNodePtr node = genie::utils::xml::FindNode(xml_doc, node_path);
  if(node==NULL) {
    return "";
  }
  string content = genie::utils::xml::TrimSpaces(
      xmlNodeListGetString(xml_doc, node->xmlChildrenNode, 1) );
  return content;
}

TFile * genie::utils::xml::GetTFile	(	xmlDocPtr	xml_doc,
		string	node_path,
		string	base_dir = "<env>"
	)

Definition at line 289 of file XmlParserUtils.cxx.

{
  LOG("XML", pINFO) << "Reading info at XML node node_path: " << node_path;

  string filename = genie::utils::xml::GetROOTFileName(xml_doc,node_path);

  string used_base_dir = base_dir;
  if(base_dir.find("<env>") != string::npos) {
    used_base_dir = gSystem->Getenv("GENIE");
  }

  const char * full_filename =
     Form("%s/%s", used_base_dir.c_str(), filename.c_str());
  TFile * file = new TFile(full_filename,"read");
  if(!file) {
    LOG("XML",pERROR) << "No file: " << full_filename << " found";
    return 0;
  }
  if(file->IsZombie()) {
    LOG("XML",pERROR) << "File is a zombie: " << full_filename;
    return 0;
  }

  return file;
}

TH1D * genie::utils::xml::GetTH1D	(	xmlDocPtr	xml_doc,
		string	node_path,
		string	base_dir = "<env>"
	)

Definition at line 339 of file XmlParserUtils.cxx.

{
  TFile * file = genie::utils::xml::GetTFile(xml_doc,node_path,base_dir);
  if(!file) return 0;

  string objname = genie::utils::xml::GetROOTObjName(xml_doc,node_path);
  TH1D * h = (TH1D*)file->Get(objname.c_str());
  if(!h) {
    LOG("XML",pERROR) << "No " << objname;
    file->Close();
    delete file;
    return 0;
  }

  TH1D * hcopy = new TH1D(*h);
  hcopy->SetDirectory(0);
  file->Close();
  delete file;

  return hcopy;
}

TH1F * genie::utils::xml::GetTH1F	(	xmlDocPtr	xml_doc,
		string	node_path,
		string	base_dir = "<env>"
	)

Definition at line 316 of file XmlParserUtils.cxx.

{
  TFile * file = genie::utils::xml::GetTFile(xml_doc,node_path,base_dir);
  if(!file) return 0;

  string objname = genie::utils::xml::GetROOTObjName(xml_doc,node_path);
  TH1F * h = (TH1F*)file->Get(objname.c_str());
  if(!h) {
    LOG("XML",pERROR) << "No " << objname;
    file->Close();
    delete file;
    return 0;
  }

  TH1F * hcopy = new TH1F(*h);
  hcopy->SetDirectory(0);
  file->Close();
  delete file;

  return hcopy;
}

TH2D * genie::utils::xml::GetTH2D	(	xmlDocPtr	xml_doc,
		string	node_path,
		string	base_dir = "<env>"
	)

Definition at line 362 of file XmlParserUtils.cxx.

{
  TFile * file = genie::utils::xml::GetTFile(xml_doc,node_path,base_dir);
  if(!file) return 0;

  string objname = genie::utils::xml::GetROOTObjName(xml_doc,node_path);
  TH2D * h = (TH2D*)file->Get(objname.c_str());
  if(!h) {
    LOG("XML",pERROR) << "No " << objname;
    file->Close();
    delete file;
    return 0;
  }

  TH2D * hcopy = new TH2D(*h);
  hcopy->SetDirectory(0);
  file->Close();
  delete file;

  return hcopy;
}

TVectorD * genie::utils::xml::GetTVectorD	(	xmlDocPtr	xml_doc,
		string	node_path,
		string	base_dir = "<env>"
	)

Definition at line 385 of file XmlParserUtils.cxx.

{
  TFile * file = genie::utils::xml::GetTFile(xml_doc,node_path,base_dir);
  if(!file) return 0;

  string objname = genie::utils::xml::GetROOTObjName(xml_doc,node_path);
  TVectorD * vec = (TVectorD*)file->Get(objname.c_str());
  if(!vec) {
    LOG("XML",pERROR) << "No " << objname;
    file->Close();
    delete file;
    return 0;
  }

  TVectorD * veccopy = new TVectorD(*vec);
  file->Close();
  delete file;

  return veccopy;
}

string genie::utils::xml::GetXMLDefaultPath ( )

inline

Definition at line 76 of file XmlParserUtils.h.

{ return "$GENIE/config" ; }

string genie::utils::xml::GetXMLFilePath

(

string

basename

)

Definition at line 96 of file XmlParserUtils.cxx.

                                                     {
  // return a full path to a real XML file
  // e.g. passing in "GNuMIFlux.xml"
  //   will return   "/blah/GENIE/HEAD/config/GNuMIFlux.xml"
  // allow ::colon:: ::semicolon:: and ::comma:: as path item separators

  // empty basename should just be returned
  // otherwise one will end up with a directory rather than a file
  // as  AccessPathName() isn't checking file vs. directory
  if ( basename == "" ) return basename;

  std::string pathlist = genie::utils::xml::GetXMLPathList();
  std::vector<std::string> paths = genie::utils::str::Split(pathlist,":;,");
  // expand any wildcards, etc.
  size_t np = paths.size();
  for ( size_t i=0; i< np; ++i ) {
    const char* tmppath = paths[i].c_str();
    std::string onepath = gSystem->ExpandPathName(tmppath);
    onepath += "/";
    onepath += basename;
    bool noAccess = gSystem->AccessPathName(onepath.c_str());
    if ( ! noAccess ) {
      //    LOG("XmlParserUtils", pDEBUG ) << onepath ;
      return onepath;  // found one
    }
  }
  // didn't find any, return basename in case it is in "." and that
  // wasn't listed in the XML path list.   If you want "." to take
  // precedence then it needs to be explicitly listed in $GXMLPATH.
  return basename;
}

string genie::utils::xml::GetXMLPathList

(

bool

add_tune = true

)

Definition at line 53 of file XmlParserUtils.cxx.

                                                      {

  // Get a colon separated list of potential locations for xml files
  // e.g. ".:$MYSITEXML:/path/to/exp/version:$GALGCONF:$GENIE/config"
  // user additions should be in $GXMLPATH
  // All of the environment variaables have lower priority than the --xml-path command line argument

  string pathlist;
  std::string p0 = RunOpt::Instance()->XMLPath();
  if ( p0.size() ) { pathlist += std::string(p0) + ":" ; }
  const char* p1 = std::getenv( "GXMLPATH" );
  if ( p1 ) { pathlist += std::string(p1) + ":" ; }
  const char* p2 = std::getenv( "GXMLPATHS" );  // handle extra 's'
  if ( p2 ) { pathlist += std::string(p2) + ":" ; }

  // add originally supported alternative path
  const char* p3 = std::getenv( "GALGCONF" );
  if ( p3 ) { pathlist += std::string(p3) + ":" ; }

  if ( add_tune && RunOpt::Instance() -> Tune() ) {

    if ( RunOpt::Instance() -> Tune() -> IsConfigured() ) {

      if ( ! RunOpt::Instance() -> Tune() -> IsValidated() ) {
        LOG( "XmlParser", pFATAL) << "Tune not validated" ;
        exit(0) ;
      }

      if ( ! RunOpt::Instance() -> Tune() -> OnlyConfiguration() )
        pathlist += RunOpt::Instance() -> Tune() -> TuneDirectory() + ":" ;

      pathlist += RunOpt::Instance() -> Tune() -> CMCDirectory()  + ':' ;

    }  //tune not set in run option
  }  // requested tune and there is a tune

  pathlist += GetXMLDefaultPath() ;  // standard path in case no env
  pathlist += ":$GENIE/src/Tools/Flux/GNuMINtuple";  // special case

  return pathlist;
}

string genie::utils::xml::TrimSpaces

(

xmlChar *

xmls

)

Definition at line 28 of file XmlParserUtils.cxx.

                                               {

  // trim the leading/trailing spaces from an parsed xml string like in:
  //
  // "      I am a string with lots of spaces      " ---->
  //                                  "I am a string with lots of spaces"
  //
  // In this method, "\n" is treated as 'empty space' so as to trim not only
  // empty spaces in the line that contains the string but also all leading
  // and trailing empty lines

  string str = string( (const char *) xmls );
  return utils::str::TrimSpaces(str);
}