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.

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

genie::flux::GNuMIFluxXMLHelper::fVerbose

int fVerbose

how noisy to be when parsing XML

Definition: GNuMIFlux.cxx:94

genie::flux::GNuMIFluxXMLHelper::fGNuMI

GNuMIFlux * fGNuMI

Definition: GNuMIFlux.cxx:96

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

inline

Definition at line 76 of file GNuMIFlux.cxx.

76 { ; }

Member Function Documentation

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

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

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

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

bool GNuMIFluxXMLHelper::LoadParamSet	(	xmlDocPtr &	xml_doc,
		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;
 }

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::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.

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

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

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

 {
   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 & str )

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

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::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.

TRotation genie::flux::GNuMIFluxXMLHelper::fBeamRotXML

private

Definition at line 100 of file GNuMIFlux.cxx.

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

private

Definition at line 101 of file GNuMIFlux.cxx.

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

private

Definition at line 96 of file GNuMIFlux.cxx.

int genie::flux::GNuMIFluxXMLHelper::fVerbose

private

how noisy to be when parsing XML

Definition at line 94 of file GNuMIFlux.cxx.

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

Generator/src/Tools/Flux/GNuMIFlux.cxx

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation