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 More...
GNuMIFlux *	fGNuMI
TVector3	fBeamPosXML
TRotation	fBeamRotXML
TVector3	fFluxWindowPtXML [3]

Detailed Description

Definition at line 73 of file GNuMIFlux.cxx.

Constructor & Destructor Documentation

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

inline

Definition at line 75 of file GNuMIFlux.cxx.

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

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

inline

Definition at line 76 of file GNuMIFlux.cxx.

{ ; }

Member Function Documentation

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

private

Definition at line 2876 of file GNuMIFlux.cxx.

Referenced by ParseBeamDir().

{
  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]);
}

std::vector< double > GNuMIFluxXMLHelper::GetDoubleVector

(

std::string

str

)

Definition at line 2450 of file GNuMIFlux.cxx.

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

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

{
  // 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;
}

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

(

std::string

str

)

Definition at line 2473 of file GNuMIFlux.cxx.

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

Referenced by ParseParamSet().

{
  // 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;
}

bool GNuMIFluxXMLHelper::LoadConfig

(

std::string

cfg

)

Definition at line 2496 of file GNuMIFlux.cxx.

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

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

{
  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;

}

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

private

Definition at line 2539 of file GNuMIFlux.cxx.

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

Referenced by LoadConfig(), and ParseParamSet().

{

  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;
}

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

private

Definition at line 2650 of file GNuMIFlux.cxx.

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

Referenced by ParseParamSet().

{
  fBeamRotXML.SetToIdentity(); // start fresh

  string dirtype =
    utils::str::TrimSpaces(
      utils::xml::GetAttribute(xml_beamdir,"type"));

  string pval  =
    utils::xml::TrimSpaces(
      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;
  }

}

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

private

Definition at line 2724 of file GNuMIFlux.cxx.

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

Referenced by ParseParamSet().

{
  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;
  }
}

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

private

Definition at line 2750 of file GNuMIFlux.cxx.

References fGNuMI, fVerbose, GetDoubleVector(), genie::flux::GNuMIFlux::SetMaxEFudge(), genie::flux::GNuMIFlux::SetMaxEnergy(), and genie::flux::GNuMIFlux::SetMaxWgtScan().

Referenced by ParseParamSet().

{
  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;
    }
  }
}

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

private

Definition at line 2569 of file GNuMIFlux.cxx.

References fBeamPosXML, fBeamRotXML, fFluxWindowPtXML, fGNuMI, fVerbose, GetDoubleVector(), GetIntVector(), LoadParamSet(), ParseBeamDir(), ParseBeamPos(), ParseEnuMax(), ParseWindowSeries(), pFATAL, pINFO, pWARN, genie::flux::GNuMIFlux::SetBeamCenter(), genie::flux::GNuMIFlux::SetBeamRotation(), genie::flux::GNuMIFlux::SetEntryReuse(), genie::flux::GNuMIFlux::SetFluxWindow(), genie::flux::GNuMIFlux::SetLengthUnits(), genie::flux::GFluxFileConfigI::SetUpstreamZ(), SLOG, genie::utils::xml::TrimSpaces(), and genie::utils::units::UnitFromString().

Referenced by LoadParamSet().

{
  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::TrimSpaces(
              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);
}

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

private

Definition at line 2778 of file GNuMIFlux.cxx.

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

Referenced by ParseBeamDir().

{
  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::TrimSpaces(
          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);
}

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

private

Definition at line 2895 of file GNuMIFlux.cxx.

References GetDoubleVector(), pWARN, and SLOG.

{
  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]);

}

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

private

Definition at line 2825 of file GNuMIFlux.cxx.

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

Referenced by ParseParamSet().

{
  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::TrimSpaces(
          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);
}

Member Data Documentation

TVector3 genie::flux::GNuMIFluxXMLHelper::fBeamPosXML

private

Definition at line 99 of file GNuMIFlux.cxx.

Referenced by ParseBeamPos(), and ParseParamSet().

TRotation genie::flux::GNuMIFluxXMLHelper::fBeamRotXML

private

Definition at line 100 of file GNuMIFlux.cxx.

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

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

private

Definition at line 101 of file GNuMIFlux.cxx.

Referenced by ParseParamSet(), and ParseWindowSeries().

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

private

Definition at line 96 of file GNuMIFlux.cxx.

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

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(), ParseBeamDir(), ParseBeamPos(), ParseEnuMax(), ParseParamSet(), ParseRotSeries(), and ParseWindowSeries().

---

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

• GNuMIFlux.cxx