genie::flux::GNuMIFluxXMLHelper Class Reference

Collaboration diagram for genie::flux::GNuMIFluxXMLHelper:

Public Member Functions
	GNuMIFluxXMLHelper (GNuMIFlux *gnumi)
	~GNuMIFluxXMLHelper ()
bool	LoadConfig (std::string cfg)
std::vector< double >	GetDoubleVector (std::string str)
std::vector< long int >	GetIntVector (std::string str)

Private Member Functions
bool	LoadParamSet (xmlDocPtr &, std::string cfg)
void	ParseParamSet (xmlDocPtr &, xmlNodePtr &)
void	ParseBeamDir (xmlDocPtr &, xmlNodePtr &)
void	ParseBeamPos (std::string)
void	ParseRotSeries (xmlDocPtr &, xmlNodePtr &)
void	ParseWindowSeries (xmlDocPtr &, xmlNodePtr &)
void	ParseEnuMax (std::string)
TVector3	AnglesToAxis (double theta, double phi, std::string units="deg")
TVector3	ParseTV3 (const std::string &)

Private Attributes
int	fVerbose
	how noisy to be when parsing XML
GNuMIFlux *	fGNuMI
TVector3	fBeamPosXML
TRotation	fBeamRotXML
TVector3	fFluxWindowPtXML [3]

Detailed Description

Definition at line 73 of file GNuMIFlux.cxx.

Constructor & Destructor Documentation

GNuMIFluxXMLHelper()

genie::flux::GNuMIFluxXMLHelper::GNuMIFluxXMLHelper ( GNuMIFlux * gnumi )

inline

Definition at line 75 of file GNuMIFlux.cxx.

: fVerbose(0), fGNuMI(gnumi) { ; }

References fGNuMI, and fVerbose.

~GNuMIFluxXMLHelper()

genie::flux::GNuMIFluxXMLHelper::~GNuMIFluxXMLHelper ( )

inline

Definition at line 76 of file GNuMIFlux.cxx.

{ ; }

Member Function Documentation

AnglesToAxis()

TVector3 GNuMIFluxXMLHelper::AnglesToAxis ( double theta, double phi, std::string units = "deg" )

private

Definition at line 2876 of file GNuMIFlux.cxx.

{
  double xyz[3];
  // assume radians unless given a hint that it's degrees
  double scale = ('d'==units[0]||'D'==units[0]) ? TMath::DegToRad() : 1.0 ;
 
  xyz[0] = TMath::Cos(scale*phi)*TMath::Sin(scale*theta);
  xyz[1] = TMath::Sin(scale*phi)*TMath::Sin(scale*theta);
  xyz[2] = TMath::Cos(scale*theta);
  // condition vector to eliminate most floating point errors
  for (int i=0; i<3; ++i) {
    const double eps = 1.0e-15;
    if (TMath::Abs(xyz[i])   < eps ) xyz[i] =  0;
    if (TMath::Abs(xyz[i]-1) < eps ) xyz[i] =  1;
    if (TMath::Abs(xyz[i]+1) < eps ) xyz[i] = -1;
  }
  return TVector3(xyz[0],xyz[1],xyz[2]);
}

Referenced by ParseBeamDir().

GetDoubleVector()

std::vector< double > GNuMIFluxXMLHelper::GetDoubleVector

(

std::string

str

)

Definition at line 2450 of file GNuMIFlux.cxx.

{
  // turn string into vector<double>
  // be liberal about separators, users might punctuate for clarity
  std::vector<std::string> strtokens = genie::utils::str::Split(str," ,;:()[]=");
  std::vector<double> vect;
  size_t ntok = strtokens.size();
 
  if ( fVerbose > 2 )
    std::cout << "GetDoubleVector \"" << str << "\"" << std::endl;
 
  for (size_t i=0; i < ntok; ++i) {
    std::string trimmed = utils::str::TrimSpaces(strtokens[i]);
    if ( " " == trimmed || "" == trimmed ) continue;  // skip empty strings
    double val = strtod(trimmed.c_str(), (char**)NULL);
    if ( fVerbose > 2 )
      std::cout << "(" << vect.size() << ") = " << val << std::endl;
    vect.push_back(val);
  }
 
  return vect;
}

References fVerbose, genie::utils::str::Split(), and genie::utils::str::TrimSpaces().

Referenced by ParseBeamDir(), ParseBeamPos(), ParseEnuMax(), ParseParamSet(), ParseTV3(), and ParseWindowSeries().

GetIntVector()

std::vector< long int > GNuMIFluxXMLHelper::GetIntVector

(

std::string

str

)

Definition at line 2473 of file GNuMIFlux.cxx.

{
  // turn string into vector<long int>
  // be liberal about separators, users might punctuate for clarity
  std::vector<std::string> strtokens = genie::utils::str::Split(str," ,;:()[]=");
  std::vector<long int> vect;
  size_t ntok = strtokens.size();
 
  if ( fVerbose > 2 )
    std::cout << "GetIntVector \"" << str << "\"" << std::endl;
 
  for (size_t i=0; i < ntok; ++i) {
    std::string trimmed = utils::str::TrimSpaces(strtokens[i]);
    if ( " " == trimmed || "" == trimmed ) continue;  // skip empty strings
    long int val = strtol(trimmed.c_str(),(char**)NULL,10);
    if ( fVerbose > 2 )
      std::cout << "(" << vect.size() << ") = " << val << std::endl;
    vect.push_back(val);
  }
 
  return vect;
}

References fVerbose, genie::utils::str::Split(), and genie::utils::str::TrimSpaces().

Referenced by ParseParamSet().

LoadConfig()

bool GNuMIFluxXMLHelper::LoadConfig

(

std::string

cfg

)

Definition at line 2496 of file GNuMIFlux.cxx.

{
  string fname = utils::xml::GetXMLFilePath(fGNuMI->GetXMLFileBase());
 
  bool is_accessible = ! (gSystem->AccessPathName(fname.c_str()));
  if (!is_accessible) {
    SLOG("GNuMIFlux", pERROR)
      << "The XML doc doesn't exist! (filename: " << fname << ")";
    return false;
  }
 
  xmlDocPtr xml_doc = xmlParseFile( fname.c_str() );
  if ( xml_doc == NULL) {
    SLOG("GNuMIFlux", pERROR)
      << "The XML doc can't be parsed! (filename: " << fname << ")";
    return false;
  }
 
  xmlNodePtr xml_root = xmlDocGetRootElement( xml_doc );
  if ( xml_root == NULL ) {
    SLOG("GNuMIFlux", pERROR)
      << "The XML doc is empty! (filename: " << fname << ")";
    return false;
  }
 
  string rootele = "gnumi_config";
  if ( xmlStrcmp(xml_root->name, (const xmlChar*)rootele.c_str() ) ) {
    SLOG("GNuMIFlux", pERROR)
      << "The XML doc has invalid root element! (filename: " << fname << ")"
      << " expected \"" << rootele << "\", saw \"" << xml_root->name << "\"";
    return false;
  }
 
  SLOG("GNuMIFlux", pINFO) << "Attempt to load config \"" << cfg
                           << "\" from file: " << fname;
 
  bool found = this->LoadParamSet(xml_doc,cfg);
 
  xmlFree(xml_doc);
  return found;
 
}

References fGNuMI, genie::utils::xml::GetXMLFilePath(), LoadParamSet(), pERROR, pINFO, and SLOG.

Referenced by genie::flux::GNuMIFlux::LoadConfig().

LoadParamSet()

bool GNuMIFluxXMLHelper::LoadParamSet ( xmlDocPtr & , std::string cfg )

private

Definition at line 2539 of file GNuMIFlux.cxx.

{
 
  xmlNodePtr xml_root = xmlDocGetRootElement( xml_doc );
 
  // loop over all xml tree nodes that are children of the root node
  // read the entries looking for "param_set" of the right name
 
  // loop looking for particular config
  bool found = false;
  xmlNodePtr xml_pset = xml_root->xmlChildrenNode;
  for ( ; xml_pset != NULL ; xml_pset = xml_pset->next ) {
    if ( ! xmlStrEqual(xml_pset->name, (const xmlChar*)"param_set") ) continue;
    // every time there is a 'param_set' tag
    string param_set_name =
      utils::str::TrimSpaces(utils::xml::GetAttribute(xml_pset,"name"));
 
    if ( param_set_name != cfg ) continue;
 
    SLOG("GNuMIFlux", pINFO) << "Found config \"" << cfg;
 
    this->ParseParamSet(xml_doc,xml_pset);
    found = true;
 
  } // loop over elements of root
  xmlFree(xml_pset);
 
  return found;
}

References genie::utils::xml::GetAttribute(), ParseParamSet(), pINFO, SLOG, and genie::utils::str::TrimSpaces().

Referenced by LoadConfig(), and ParseParamSet().

ParseBeamDir()

void GNuMIFluxXMLHelper::ParseBeamDir ( xmlDocPtr & xml_doc, xmlNodePtr & xml_beamdir )

private

Definition at line 2650 of file GNuMIFlux.cxx.

{
  fBeamRotXML.SetToIdentity(); // start fresh
 
  string dirtype =
    utils::str::TrimSpaces(
      utils::xml::GetAttribute(xml_beamdir,"type"));
 
  string pval  =
    utils::xml::TrimSpacesClean(
      xmlNodeListGetString(xml_doc, xml_beamdir->xmlChildrenNode, 1));
 
  if        ( dirtype == "series" ) {
    // series of rotations around an axis
    ParseRotSeries(xml_doc,xml_beamdir);
 
  } else if ( dirtype == "thetaphi3") {
    // G3 style triplet of (theta,phi) pairs
    std::vector<double> thetaphi3 = GetDoubleVector(pval);
    string units =
      utils::str::TrimSpaces(utils::xml::GetAttribute(xml_beamdir,"units"));
    if ( thetaphi3.size() == 6 ) {
      TRotation fTempRot;
      TVector3 newX = AnglesToAxis(thetaphi3[0],thetaphi3[1],units);
      TVector3 newY = AnglesToAxis(thetaphi3[2],thetaphi3[3],units);
      TVector3 newZ = AnglesToAxis(thetaphi3[4],thetaphi3[5],units);
      fTempRot.RotateAxes(newX,newY,newZ);
      fBeamRotXML = fTempRot;  //.Inverse();
    } else {
      SLOG("GNuMIFlux", pWARN)
        << " type=\"" << dirtype << "\" within <beamdir> needs 6 values";
    }
 
  } else if ( dirtype == "newxyz" ) {
    // G4 style new axis values
    std::vector<double> newdir = GetDoubleVector(pval);
    if ( newdir.size() == 9 ) {
      TRotation fTempRot;
      TVector3 newX = TVector3(newdir[0],newdir[1],newdir[2]).Unit();
      TVector3 newY = TVector3(newdir[3],newdir[4],newdir[5]).Unit();
      TVector3 newZ = TVector3(newdir[6],newdir[7],newdir[8]).Unit();
      fTempRot.RotateAxes(newX,newY,newZ);
      fBeamRotXML = fTempRot.Inverse(); // weirdly necessary: frame vs. obj rot
    } else {
      SLOG("GNuMIFlux", pWARN)
        << " type=\"" << dirtype << "\" within <beamdir> needs 9 values";
    }
 
  } else {
    // yet something else ... what? 3 choices weren't sufficient?
    SLOG("GNuMIFlux", pWARN)
      << " UNHANDLED type=\"" << dirtype << "\" within <beamdir>";
  }
 
  if ( fVerbose > 1 ) {
    int w=10, p=6;
    std::cout << " fBeamRotXML: " << std::setprecision(p) << std::endl;
    std::cout << " [ "
              << std::setw(w) << fBeamRotXML.XX() << " "
              << std::setw(w) << fBeamRotXML.XY() << " "
              << std::setw(w) << fBeamRotXML.XZ() << endl
              << "   "
              << std::setw(w) << fBeamRotXML.YX() << " "
              << std::setw(w) << fBeamRotXML.YY() << " "
              << std::setw(w) << fBeamRotXML.YZ() << endl
              << "   "
              << std::setw(w) << fBeamRotXML.ZX() << " "
              << std::setw(w) << fBeamRotXML.ZY() << " "
              << std::setw(w) << fBeamRotXML.ZZ() << " ] " << std::endl;
    std::cout << std::endl;
  }
 
}

References AnglesToAxis(), fBeamRotXML, fVerbose, genie::utils::xml::GetAttribute(), GetDoubleVector(), ParseRotSeries(), pWARN, SLOG, genie::utils::str::TrimSpaces(), and genie::utils::xml::TrimSpacesClean().

Referenced by ParseParamSet().

ParseBeamPos()

void GNuMIFluxXMLHelper::ParseBeamPos ( std::string str )

private

Definition at line 2724 of file GNuMIFlux.cxx.

{
  std::vector<double> xyz = GetDoubleVector(str);
  if ( xyz.size() == 3 ) {
    fBeamPosXML = TVector3(xyz[0],xyz[1],xyz[2]);
  } else if ( xyz.size() == 6 ) {
    // should check for '=' between triplets but we won't be so pedantic
    // ( userx, usery, userz ) = ( beamx, beamy, beamz )
    TVector3 userpos(xyz[0],xyz[1],xyz[2]);
    TVector3 beampos(xyz[3],xyz[4],xyz[5]);
    fBeamPosXML = userpos - fBeamRotXML*beampos;
  } else {
    SLOG("GNuMIFlux", pWARN)
      << "Unable to parse " << xyz.size() << " values in <beampos>";
    return;
   }
  if ( fVerbose > 1 ) {
    int w=16, p=10;
    std::cout << " fBeamPosXML: [ " << std::setprecision(p)
              << std::setw(w) << fBeamPosXML.X() << " , "
              << std::setw(w) << fBeamPosXML.Y() << " , "
              << std::setw(w) << fBeamPosXML.Z() << " ] "
              << std::endl;
  }
}

References fBeamPosXML, fBeamRotXML, fVerbose, GetDoubleVector(), pWARN, and SLOG.

Referenced by ParseParamSet().

ParseEnuMax()

void GNuMIFluxXMLHelper::ParseEnuMax ( std::string str )

private

Definition at line 2750 of file GNuMIFlux.cxx.

{
  std::vector<double> v = GetDoubleVector(str);
  size_t n = v.size();
  if ( n > 0 ) {
    fGNuMI->SetMaxEnergy(v[0]);
    if ( fVerbose > 1 )
      std::cout << "ParseEnuMax SetMaxEnergy(" << v[0] << ") " << std::endl;
  }
  if ( n > 1 ) {
    fGNuMI->SetMaxEFudge(v[1]);
    if ( fVerbose > 1 )
      std::cout << "ParseEnuMax SetMaxEFudge(" << v[1] << ")" << std::endl;
  }
  if ( n > 2 ) {
    if ( n == 3 ) {
      fGNuMI->SetMaxWgtScan(v[2]);
      if ( fVerbose > 1 )
        std::cout << "ParseEnuMax SetMaxWgtScan(" << v[2] << ")" << std::endl;
    } else {
      long int nentries = (long int)v[3];
      fGNuMI->SetMaxWgtScan(v[2],nentries);
      if ( fVerbose > 1 )
        std::cout << "ParseEnuMax SetMaxWgtScan(" << v[2] << "," << nentries << ")" << std::endl;
    }
  }
}

References fGNuMI, fVerbose, and GetDoubleVector().

Referenced by ParseParamSet().

ParseParamSet()

void GNuMIFluxXMLHelper::ParseParamSet ( xmlDocPtr & xml_doc, xmlNodePtr & xml_pset )

private

Definition at line 2569 of file GNuMIFlux.cxx.

{
  xmlNodePtr xml_child = xml_pset->xmlChildrenNode;
  for ( ; xml_child != NULL ; xml_child = xml_child->next ) {
    // handle basic gnumi_config/param_set
    // bad cast away const on next line, but function sig requires it
    string pname =
      utils::xml::TrimSpaces(const_cast<xmlChar*>(xml_child->name));
    if ( pname == "text" || pname == "comment" ) continue;
    string pval  =
      utils::xml::TrimSpacesClean(
              xmlNodeListGetString(xml_doc, xml_child->xmlChildrenNode, 1));
 
    if ( fVerbose > 1 )
      SLOG("GNuMIFlux", pINFO)
        << "   pname \"" << pname << "\", string value \"" << pval << "\"";
 
    if        ( pname == "verbose" ) {
      fVerbose = atoi(pval.c_str());
 
    } else if ( pname == "using_param_set" ) {
      SLOG("GNuMIFlux", pWARN) << "start using_param_set: \"" << pval << "\"";
      bool found = this->LoadParamSet(xml_doc,pval); // recurse
      if ( ! found ) {
        SLOG("GNuMIFlux", pFATAL) << "using_param_set: \"" << pval << "\" NOT FOUND";
        assert(found);
      }
      SLOG("GNuMIFlux", pWARN) << "done using_param_set: \"" << pval << "\"";
    } else if ( pname == "units" ) {
      double scale = genie::utils::units::UnitFromString(pval);
      fGNuMI->SetLengthUnits(scale);
      SLOG("GNuMIFlux", pINFO) << "set user units to \"" << pval << "\"";
 
    } else if ( pname == "beamdir" ) {
      ParseBeamDir(xml_doc,xml_child);
      fGNuMI->SetBeamRotation(fBeamRotXML);
 
    } else if ( pname == "beampos" ) {
      ParseBeamPos(pval);
      fGNuMI->SetBeamCenter(fBeamPosXML);
 
    } else if ( pname == "window" ) {
      ParseWindowSeries(xml_doc,xml_child);
      // RWH  !!!! MEMORY LEAK!!!!
      //std::cout << " flux window " << std::endl
      //          << " [0] " << utils::print::X4AsString(new TLorentzVector(fFluxWindowPt[0],0)) << std::endl
      //          << " [1] " << utils::print::X4AsString(new TLorentzVector(fFluxWindowPt[1],0)) << std::endl
      //          << " [2] " << utils::print::X4AsString(new TLorentzVector(fFluxWindowPt[2],0)) << std::endl;
 
      fGNuMI->SetFluxWindow(fFluxWindowPtXML[0],
                            fFluxWindowPtXML[1],
                            fFluxWindowPtXML[2]);
 
    } else if ( pname == "enumax" ) {
      ParseEnuMax(pval);
 
    } else if ( pname == "upstreamz" ) {
      double z0usr = -3.4e38;
      std::vector<double> v = GetDoubleVector(pval);
      if ( v.size() > 0 ) z0usr = v[0];
      fGNuMI->SetUpstreamZ(z0usr);
      SLOG("GNuMIFlux", pINFO) << "set upstreamz = " << z0usr;
 
    } else if ( pname == "reuse" ) {
      long int nreuse = 1;
      std::vector<long int> v = GetIntVector(pval);
      if ( v.size() > 0 ) nreuse = v[0];
      fGNuMI->SetEntryReuse(nreuse);
      SLOG("GNuMIFlux", pINFO) << "set entry reuse = " << nreuse;
 
    } else {
      SLOG("GNuMIFlux", pWARN)
        << "  NOT HANDLED: pname \"" << pname
        << "\", string value \"" << pval << "\"";
 
    }
 
  } // loop over param_set contents
  xmlFree(xml_child);
}

References fBeamPosXML, fBeamRotXML, fFluxWindowPtXML, fGNuMI, fVerbose, GetDoubleVector(), GetIntVector(), LoadParamSet(), ParseBeamDir(), ParseBeamPos(), ParseEnuMax(), ParseWindowSeries(), pFATAL, pINFO, pWARN, SLOG, genie::utils::xml::TrimSpaces(), genie::utils::xml::TrimSpacesClean(), and genie::utils::units::UnitFromString().

Referenced by LoadParamSet().

ParseRotSeries()

void GNuMIFluxXMLHelper::ParseRotSeries ( xmlDocPtr & xml_doc, xmlNodePtr & xml_pset )

private

Definition at line 2778 of file GNuMIFlux.cxx.

{
  TRotation fTempRot; // reset matrix
 
  xmlNodePtr xml_child = xml_pset->xmlChildrenNode;
  for ( ; xml_child != NULL ; xml_child = xml_child->next ) {
    // in a <beamdir> of type "series"
    // should be a sequence of <rotation> entries
    string name =
      utils::xml::TrimSpaces(const_cast<xmlChar*>(xml_child->name));
    if ( name == "text" || name == "comment" ) continue;
 
    if ( name == "rotation" ) {
      string val = utils::xml::TrimSpacesClean(
          xmlNodeListGetString(xml_doc, xml_child->xmlChildrenNode, 1));
      string axis =
        utils::str::TrimSpaces(utils::xml::GetAttribute(xml_child,"axis"));
 
      string units =
        utils::str::TrimSpaces(utils::xml::GetAttribute(xml_child,"units"));
 
      double rot = atof(val.c_str());
      // assume radians unless given a hint that it's degrees
      if ( 'd' == units[0] || 'D' == units[0] ) rot *= TMath::DegToRad();
 
      if ( fVerbose > 0 )
        SLOG("GNuMIFlux", pINFO)
          << " rotate " << rot << " radians around " << axis << " axis";
 
      if      ( axis[0] == 'x' || axis[0] == 'X' ) fTempRot.RotateX(rot);
      else if ( axis[0] == 'y' || axis[0] == 'Y' ) fTempRot.RotateY(rot);
      else if ( axis[0] == 'z' || axis[0] == 'Z' ) fTempRot.RotateZ(rot);
      else {
        SLOG("GNuMIFlux", pINFO)
          << " no " << axis << " to rotate around";
      }
 
    } else {
      SLOG("GNuMIFlux", pWARN)
        << " found <" << name << "> within <beamdir type=\"series\">";
    }
  }
  // TRotation rotates objects not frames, so we want the inverse
  fBeamRotXML = fTempRot.Inverse();
  xmlFree(xml_child);
}

References fBeamRotXML, fVerbose, genie::utils::xml::GetAttribute(), pINFO, pWARN, SLOG, genie::utils::str::TrimSpaces(), genie::utils::xml::TrimSpaces(), and genie::utils::xml::TrimSpacesClean().

Referenced by ParseBeamDir().

ParseTV3()

TVector3 GNuMIFluxXMLHelper::ParseTV3 ( const std::string & )

private

Definition at line 2895 of file GNuMIFlux.cxx.

{
  std::vector<double> xyz = GetDoubleVector(str);
  if ( xyz.size() != 3 ) {
    return TVector3();
    SLOG("GNuMIFlux", pWARN)
      << " ParseTV3 \"" << str << "\" had " << xyz.size() << " elements ";
  }
  return TVector3(xyz[0],xyz[1],xyz[2]);
 
}

References GetDoubleVector(), pWARN, and SLOG.

ParseWindowSeries()

void GNuMIFluxXMLHelper::ParseWindowSeries ( xmlDocPtr & xml_doc, xmlNodePtr & xml_pset )

private

Definition at line 2825 of file GNuMIFlux.cxx.

{
  int ientry = -1;
 
  xmlNodePtr xml_child = xml_pset->xmlChildrenNode;
  for ( ; xml_child != NULL ; xml_child = xml_child->next ) {
    // in a <windowr> element
    // should be a sequence of <point> entries
    string name =
      utils::xml::TrimSpaces(const_cast<xmlChar*>(xml_child->name));
    if ( name == "text" || name == "comment" ) continue;
 
    if ( name == "point" ) {
      string val  =
        utils::xml::TrimSpacesClean(
          xmlNodeListGetString(xml_doc, xml_child->xmlChildrenNode, 1));
      string coord =
        utils::str::TrimSpaces(utils::xml::GetAttribute(xml_child,"coord"));
 
      std::vector<double> xyz = GetDoubleVector(val);
      if ( xyz.size() != 3 || coord != "det" ) {
        SLOG("GNuMIFlux", pWARN)
          << "parsing <window> found <point> but size=" << xyz.size()
          << " (expect 3) and coord=\"" << coord << "\" (expect \"det\")"
          << " IGNORE problem";
      }
      ++ientry;
      if ( ientry < 3 && ientry >= 0 ) {
        TVector3 pt(xyz[0],xyz[1],xyz[2]);
        if ( fVerbose > 0 ) {
          int w=16, p=10;
          std::cout << " point[" << ientry <<"] = [ " << std::setprecision(p)
                    << std::setw(w) << pt.X() << " , "
                    << std::setw(w) << pt.Y() << " , "
                    << std::setw(w) << pt.Z() << " ] "
                    << std::endl;
        }
        fFluxWindowPtXML[ientry] = pt;  // save the point
      } else {
        SLOG("GNuMIFlux", pWARN)
          << " <window><point> ientry " << ientry << " out of range (0-2)";
      }
 
    } else {
      SLOG("GNuMIFlux", pWARN)
        << " found <" << name << "> within <window>";
    }
  }
  xmlFree(xml_child);
}

References fFluxWindowPtXML, fVerbose, genie::utils::xml::GetAttribute(), GetDoubleVector(), pWARN, SLOG, genie::utils::str::TrimSpaces(), genie::utils::xml::TrimSpaces(), and genie::utils::xml::TrimSpacesClean().

Referenced by ParseParamSet().

Member Data Documentation

fBeamPosXML

TVector3 genie::flux::GNuMIFluxXMLHelper::fBeamPosXML

private

Definition at line 99 of file GNuMIFlux.cxx.

Referenced by ParseBeamPos(), and ParseParamSet().

fBeamRotXML

TRotation genie::flux::GNuMIFluxXMLHelper::fBeamRotXML

private

Definition at line 100 of file GNuMIFlux.cxx.

Referenced by ParseBeamDir(), ParseBeamPos(), ParseParamSet(), and ParseRotSeries().

fFluxWindowPtXML

TVector3 genie::flux::GNuMIFluxXMLHelper::fFluxWindowPtXML[3]

private

Definition at line 101 of file GNuMIFlux.cxx.

Referenced by ParseParamSet(), and ParseWindowSeries().

fGNuMI

GNuMIFlux* genie::flux::GNuMIFluxXMLHelper::fGNuMI

private

Definition at line 96 of file GNuMIFlux.cxx.

Referenced by GNuMIFluxXMLHelper(), LoadConfig(), ParseEnuMax(), and ParseParamSet().

fVerbose

int genie::flux::GNuMIFluxXMLHelper::fVerbose

private

how noisy to be when parsing XML

Definition at line 94 of file GNuMIFlux.cxx.

Referenced by GetDoubleVector(), GetIntVector(), GNuMIFluxXMLHelper(), ParseBeamDir(), ParseBeamPos(), ParseEnuMax(), ParseParamSet(), ParseRotSeries(), and ParseWindowSeries().

---

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

• GNuMIFlux.cxx