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

  void 
  GVolumetricPotential::operator<<(const magnet::xml::Node& XML) {
    globName = XML.getAttribute("Name");
    _fileName = XML.getAttribute("RawFile");
    _sampleBytes = XML.getAttribute("SampleBytes").as<size_t>();


    //Load the dimensions of the data set (and its subset of data if
    //only processing a smaller section)
    auto XMLdim = XML.getNode("Dimensions");
    _imageDimensions = std::array<size_t, 3>{{XMLdim.getAttribute("x").as<size_t>(), XMLdim.getAttribute("y").as<size_t>(), XMLdim.getAttribute("z").as<size_t>()}};
    
    _offset = std::array<size_t, 3>{{0, 0, 0}};
    if (XML.hasNode("Offset"))
      {
	auto XMLdim = XML.getNode("Offset");
	_offset = std::array<size_t, 3>{{XMLdim.getAttribute("x").as<size_t>(), XMLdim.getAttribute("y").as<size_t>(), XMLdim.getAttribute("z").as<size_t>()}};
      }

    std::array<size_t, 3> sampleDimensions = _imageDimensions;
    if (XML.hasNode("SampleDimensions"))
      {
	auto XMLdim = XML.getNode("SampleDimensions");
	sampleDimensions = std::array<size_t, 3>{{XMLdim.getAttribute("x").as<size_t>(), XMLdim.getAttribute("y").as<size_t>(), XMLdim.getAttribute("z").as<size_t>()}};
      }

    Ordering fileOrdering(_imageDimensions);
    std::vector<unsigned char> fileData(fileOrdering.size() * _sampleBytes);
    dout << "Opening " << _fileName << std::endl;
    std::ifstream file(_fileName.c_str(), std::ifstream::binary);

    if (!file.good())
      M_throw() << "Failed open the file " << _fileName;
    dout << "Reading " << fileOrdering.size() * _sampleBytes << " bytes of data into memory" <<  std::endl;
    file.read(reinterpret_cast<char*>(fileData.data()), fileOrdering.size() * _sampleBytes);
    
    if (!file)
      M_throw() << "Failed reading volumetric data (read " << file.gcount() << " bytes of an expected " << fileOrdering.size() * _sampleBytes << "  from " << _fileName << ")";
    file.close();

    _ordering = Ordering(sampleDimensions);
    _volumeData.resize(_ordering.size());

    dout << "Resampling " << _ordering.size() << " bytes of data from the file into the simulation" <<  std::endl;
    if (_sampleBytes == 1)
      {
	if (sampleDimensions == _imageDimensions)
	  std::swap(_volumeData, fileData);
	else
	  for (size_t z = 0; z < sampleDimensions[2]; ++z)
	    for (size_t y = 0; y < sampleDimensions[1]; ++y)
	      {
		size_t startindex = fileOrdering.toIndex(std::array<size_t, 3>{{_offset[0], y + _offset[1], z + _offset[2]}});
		std::copy(fileData.begin() + startindex, fileData.begin() + startindex + sampleDimensions[0], _volumeData.begin() + _ordering.toIndex(std::array<size_t, 3>{{0, y, z}}));
	      }
      }
    else
      M_throw() << "Do not have an optimised loader for resampling data yet";
    dout << "Loading complete" <<  std::endl;
  }

void 
IStepped::operator<<(const magnet::xml::Node& XML)
{
  if (strcmp(XML.getAttribute("Type"),"Stepped"))
    M_throw() << "Attempting to load Stepped from non Stepped entry";
  
  range.set_ptr(C2Range::getClass(XML,Sim));
  
  try {
    intName = XML.getAttribute("Name");

    if (!XML.hasNode("Step"))
      M_throw() << "No steppings defined for stepped potential " 
		<< intName;

    for (magnet::xml::Node node = XML.fastGetNode("Step"); node.valid(); ++node)
      steps.push_back(steppair(node.getAttribute("R").as<double>(),
			       node.getAttribute("E").as<double>()));
    
    std::sort(steps.rbegin(), steps.rend());

    IMultiCapture::loadCaptureMap(XML);
  }
  catch (boost::bad_lexical_cast &)
    {
      M_throw() << "Failed a lexical cast in CIStepped";
    }

  if (steps.empty())
    M_throw() << "No steps defined in SteppedPotential Interaction with name " 
	      << getName();
}

 void 
 Topology::operator<<(const magnet::xml::Node& XML)
 {
   _name = XML.getAttribute("Name");
   
   if (!XML.hasNode("Molecule"))
     M_throw() << "Cannot load a Topology which has no molecules!";
 }

  void 
  ICapture::loadCaptureMap(const magnet::xml::Node& XML)
  {
    if (XML.hasNode("CaptureMap"))
      {
	_mapUninitialised = false;
	clear();

	for (magnet::xml::Node node = XML.getNode("CaptureMap").findNode("Pair"); node.valid(); ++node)
	  Map::operator[](Map::key_type(node.getAttribute("ID1").as<size_t>(), node.getAttribute("ID2").as<size_t>()))
	    = node.getAttribute("val").as<size_t>();
      }
  }

LNewtonianMC::LNewtonianMC(dynamo::SimData* tmp, const magnet::xml::Node& XML):
  LNewtonian(tmp),
  EnergyPotentialStep(1)
{
  if (strcmp(XML.getAttribute("Type"),"NewtonianMC"))
    M_throw() << "Attempting to load NewtonianMC from " 
	      << XML.getAttribute("Type")
	      << " entry";
  try 
    {     
      if (XML.hasNode("PotentialDeformation"))
	if (XML.getNode("PotentialDeformation").hasAttribute("EnergyStep"))
	  EnergyPotentialStep 
	    = XML.getNode("PotentialDeformation").getAttribute("EnergyStep").as<double>();
      
      EnergyPotentialStep /= Sim->dynamics.units().unitEnergy();
      
      if (dynamic_cast<const dynamo::EnsembleNVT*>(Sim->ensemble.get()) == NULL)
	M_throw() << "Multi-canonical simulations require an NVT ensemble";

      if (XML.hasNode("PotentialDeformation"))
	for (magnet::xml::Node node = XML.getNode("PotentialDeformation").fastGetNode("W"); 
	     node.valid(); ++node)
	  {
	    double energy = node.getAttribute("Energy").as<double>() / Sim->dynamics.units().unitEnergy();	    
	    double Wval = node.getAttribute("Value").as<double>();
	    
	    //Here, the Wval needs to be multiplied by kT to turn it
	    //into an Energy, but the Ensemble is not yet initialised,
	    //we must do this conversion later, when we actually use the W val.
	    _W[lrint(energy / EnergyPotentialStep)] = Wval;
	  }
    }
  catch (boost::bad_lexical_cast &)
    { M_throw() << "Failed a lexical cast in LNewtonianMC"; }
}

void
IMultiCapture::loadCaptureMap(const magnet::xml::Node& XML)
{
    if (XML.hasNode("CaptureMap"))
    {
        noXmlLoad = false;
        clear();

        for (magnet::xml::Node node = XML.getNode("CaptureMap").fastGetNode("Pair");
                node.valid(); ++node)
            captureMap[cMapKey(node.getAttribute("ID1").as<size_t>(),
                               node.getAttribute("ID2").as<size_t>())]
                = node.getAttribute("val").as<size_t>();
    }
}

  void 
  Topology::operator<<(const magnet::xml::Node& XML)
  {
    try { spName = XML.getAttribute("Name"); } 
    catch (boost::bad_lexical_cast &)
      {
	M_throw() << "Failed a lexical cast in CTopology";
      }
    
    if (!XML.hasNode("Molecule"))
      M_throw() << "Cannot load a Topology which has no molecules!";

    for (magnet::xml::Node node = XML.fastGetNode("Molecule"); node.valid(); ++node)
      ranges.push_back(shared_ptr<IDRange>(IDRange::getClass(node.getNode("IDRange"), Sim)));
  }

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

DynNewtonianMCCMap::DynNewtonianMCCMap(dynamo::Simulation* tmp, const magnet::xml::Node& XML):
    DynNewtonian(tmp)
{
    _interaction_name = XML.getAttribute("Interaction");

    if (XML.hasNode("Potential"))
    {
        for (magnet::xml::Node map_node = XML.getNode("Potential").findNode("Map");
                map_node.valid(); ++map_node)
        {
            double Wval = map_node.getAttribute("W").as<double>();
            size_t distance = map_node.getAttribute("Distance").as<size_t>();

            detail::CaptureMap map;
            for (magnet::xml::Node entry_node = map_node.findNode("Contact"); entry_node.valid(); ++entry_node)
                map[detail::CaptureMap::key_type(entry_node.getAttribute("ID1").as<size_t>(), entry_node.getAttribute("ID2").as<size_t>())]
                    = entry_node.getAttribute("State").as<size_t>();
            _W.push_back(std::make_pair(map, WData(distance, Wval)));
        }
    }
}

  DynNewtonianMC::DynNewtonianMC(dynamo::Simulation* tmp, const magnet::xml::Node& XML):
    DynNewtonian(tmp),
    EnergyPotentialStep(1)
  {
    if (XML.hasNode("PotentialDeformation"))
      {
	EnergyPotentialStep 
	  = XML.getNode("PotentialDeformation").getAttribute("EnergyStep").as<double>()
	  / Sim->units.unitEnergy();

	for (magnet::xml::Node node = XML.getNode("PotentialDeformation").fastGetNode("W"); 
	     node.valid(); ++node)
	  {
	    double energy = node.getAttribute("Energy").as<double>() / Sim->units.unitEnergy();	    
	    double Wval = node.getAttribute("Value").as<double>();
		
	    //Here, the Wval needs to be multiplied by kT to turn it
	    //into an Energy, but the Ensemble is not yet initialised,
	    //we must do this conversion later, when we actually use the W val.
	    _W[lrint(energy / EnergyPotentialStep)] = Wval;
	  }
      }
  }