C++ Node::getPath方法代码示例

  void 
  LBoundary::operator<<(const magnet::xml::Node& XML)
  {
    range = shared_ptr<IDRange>(IDRange::getClass(XML.getNode("IDRange"),Sim));
    localName = XML.getAttribute("Name");

    _oscillationData._origin << XML.getNode("Origin");
    _oscillationData._origin *= Sim->units.unitLength();
    _diameter = Sim->_properties.getProperty(XML.getAttribute("Diameter"), Property::Units::Length());
    if (_diameter->getMaxValue() == 0)
      M_throw() << "Cannot have a boundary with a diameter of zero";

    _oscillationData._amplitude = Vector();
    _oscillationData._freq = 0;
    _oscillationData._t_shift = 0;
    
    const size_t data_count = XML.hasNode("Amplitude") + XML.hasAttribute("Frequency") + XML.hasAttribute("Phase");
    if ((data_count != 3) && (data_count != 0))
      M_throw() << "For oscillating walls you must have an Amplitude, Frequency, and Phase specified."
		<< XML.getPath();

    if (data_count == 3) {
      _oscillationData._freq = XML.getAttribute("Frequency").as<double>() / Sim->units.unitTime();
      _oscillationData._t_shift = XML.getAttribute("Phase").as<double>() * Sim->units.unitTime();
      _oscillationData._amplitude << XML.getNode("Amplitude");
      _oscillationData._amplitude *= Sim->units.unitLength();
    }

    _kT = 0;
    if (XML.hasAttribute("kT")) {
      if (data_count == 3)
	M_throw() << "Cannot have both a thermalised wall and a oscillating wall" 
		  << XML.getPath();
      
      _kT = XML.getAttribute("kT").as<double>() * Sim->units.unitEnergy();
    }

    if (_kT < 0)
      M_throw() << "Temperature is less than zero" << XML.getPath();

    for (magnet::xml::Node node = XML.findNode("Object"); node.valid(); ++node)
      _objects.push_back(boundary::Object::getClass(node, Sim, _oscillationData));

    if (_objects.empty())
      M_throw() << "Boundary Locals must have at least one Object.\n" << XML.getPath();
  }

  void checkNodeNameAttribute(magnet::xml::Node node)
  {
    //Check for unique names
    std::set<std::string> names;
    for (; node.valid(); ++node)
      {
	std::string currentname = node.getAttribute("Name").as<std::string>();
	if (names.find(currentname) != names.end())
	  M_throw() << node.getName() << " at path :" << node.getPath() << "\n Does not have a unique name (Name=\"" << currentname << "\")";
	names.insert(currentname);
      }
  }

  void 
  PotentialLennardJones::operator<<(const magnet::xml::Node& XML) {
    _r_cache.clear();
    _u_cache.clear();

    _sigma = XML.getAttribute("Sigma").as<double>();
    _epsilon = XML.getAttribute("Epsilon").as<double>();
    _cutoff = XML.getAttribute("CutOff").as<double>();
    
    if (_cutoff <= minimum())
      M_throw() << "The cutoff (" << _cutoff << ") cannot be before the minimum (" 
		<< minimum() << ") in the potential for this Lennard-Jones potential due to the stepping parameters used. Please use a WCA potential instead (if available).";

    _r_cache.push_back(_cutoff);
    
    _attractiveSteps = XML.getAttribute("AttractiveSteps").as<double>();

    const std::string umode_string = XML.getAttribute("UMode").as<std::string>();
    if (!umode_string.compare("Midpoint"))    _U_mode = MIDPOINT;
    else if (!umode_string.compare("Left"))   _U_mode = LEFT;
    else if (!umode_string.compare("Right"))  _U_mode = RIGHT;
    else if (!umode_string.compare("Volume")) _U_mode = VOLUME;
    else if (!umode_string.compare("MidVolume")) _U_mode = MIDVOLUME;
    else if (!umode_string.compare("Virial")) 
      {
	_kT = XML.getAttribute("Temperature").as<double>();
	_U_mode = VIRIAL;
      }
    else
      M_throw() << "Unknown LennardJones UMode (" << umode_string << ") at " << XML.getPath();

    const std::string rmode_string = XML.getAttribute("RMode").as<std::string>();
    if (!rmode_string.compare("DeltaR"))      _R_mode = DELTAR;
    else if (!rmode_string.compare("DeltaU")) _R_mode = DELTAU;
    else if (!rmode_string.compare("DeltaV")) _R_mode = DELTAV;
    else
      M_throw() << "Unknown LennardJones RMode (" << rmode_string << ") at " << XML.getPath();
  }

  void 
  PotentialStepped::operator<<(const magnet::xml::Node& XML) {
    if (XML.getAttribute("Direction").as<std::string>() == "Left")
      _direction = false;
    else if (XML.getAttribute("Direction").as<std::string>() == "Right")
      _direction = true;
    else
      M_throw() << "Could not parse Direction, should be either \"Left\" or \"Right\"\nXML path:"
		<< XML.getPath();

    std::vector<std::pair<double, double> > steps;
    for (magnet::xml::Node node = XML.fastGetNode("Step"); node.valid(); ++node)
      steps.push_back(std::pair<double, double>(node.getAttribute("R").as<double>(),
						node.getAttribute("E").as<double>()));
    
    if (steps.empty())
      M_throw() << "You cannot load a stepped potential with no steps.\nXML path: " << XML.getPath();
    
    *this = PotentialStepped(steps, _direction);
  }

  void 
  GSOCells::operator<<(const magnet::xml::Node& XML)
  {
    globName = XML.getAttribute("Name");
    
    if (XML.hasNode("CellOrigins")) {
      Vector pos;
      for (magnet::xml::Node node = XML.getNode("CellOrigins").findNode("Origin"); node.valid(); ++node) {
	pos << node;
	pos *= Sim->units.unitLength();
	cell_origins.push_back(pos);
      }

      if (cell_origins.size() != Sim->N())
	M_throw() << "Number of CellOrigins (" << cell_origins.size() << ") does not match number of particles (" << Sim->N() << ")\n" << XML.getPath();
    }

    if (XML.hasAttribute("Diameter"))
      _cellD = XML.getAttribute("Diameter").as<double>() * Sim->units.unitLength();
  }