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 LOscillatingPlate::operator<<(const magnet::xml::Node& XML) { range = shared_ptr<Range>(Range::getClass(XML,Sim)); try { e = XML.getAttribute("Elasticity").as<double>(); nhat << XML.getNode("Norm"); nhat /= nhat.nrm(); rw0 << XML.getNode("Origin"); rw0 *= Sim->dynamics.units().unitLength(); if (XML.hasAttribute("StrongPlate")) strongPlate = XML.getAttribute("StrongPlate").as<double>(); omega0 = XML.getAttribute("Omega0").as<double>() / Sim->dynamics.units().unitTime(); sigma = XML.getAttribute("Sigma").as<double>() * Sim->dynamics.units().unitLength(); delta = XML.getAttribute("Delta").as<double>() * Sim->dynamics.units().unitLength(); mass = XML.getAttribute("Mass").as<double>() * Sim->dynamics.units().unitMass(); timeshift = XML.getAttribute("TimeShift").as<double>() * Sim->dynamics.units().unitTime(); localName = XML.getAttribute("Name"); } catch (boost::bad_lexical_cast &) { M_throw() << "Failed a lexical cast in LOscillatingPlate"; } }
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!"; }
C2RPair::C2RPair(const magnet::xml::Node& XML, const dynamo::SimData* Sim) { if (strcmp(XML.getAttribute("Range"), "Pair")) M_throw() << "Attempting to load a pair from a non pair"; range1 = shared_ptr<Range>(Range::getClass(XML.getNode("Range1"), Sim)); range2 = shared_ptr<Range>(Range::getClass(XML.getNode("Range2"), Sim)); }
void IDSMC::operator<<(const magnet::xml::Node& XML) { Interaction::operator<<(XML); _length = Sim->_properties.getProperty(XML.getAttribute("Length"), Property::Units::Length()); _e = Sim->_properties.getProperty(XML.getAttribute("Elasticity"), Property::Units::Dimensionless()); ICapture::loadCaptureMap(XML); }
void OPRGyration::operator<<(const magnet::xml::Node& XML) { if (XML.hasAttribute("BinWidthGyration")) _binWidthGyration = XML.getAttribute("BinWidthGyration").as<double>(); if (XML.hasAttribute("BinWidthGyration")) _binWidthNematic = XML.getAttribute("BinWidthGyration").as<double>(); }
shared_ptr<Topology> Topology::getClass(const magnet::xml::Node& XML, dynamo::Simulation* Sim, size_t ID) { if (!strcmp(XML.getAttribute("Type"),"Chain")) return shared_ptr<Topology>(new TChain(XML, Sim, ID)); else M_throw() << XML.getAttribute("Type") << ", Unknown type of Topology encountered"; }
void SSleep::operator<<(const magnet::xml::Node& XML) { sysName = XML.getAttribute("Name"); _sleepVelocity = XML.getAttribute("SleepV").as<double>() * Sim->units.unitVelocity(); _sleepDistance = Sim->units.unitLength() * 0.01; _sleepTime = Sim->units.unitTime() * 0.0001; _range = shared_ptr<IDRange>(IDRange::getClass(XML.getNode("IDRange"), Sim)); }
Particle::Particle(const magnet::xml::Node& XML, unsigned long nID): _ID(nID), _peculiarTime(0.0), _state(DEFAULT) { if (XML.hasAttribute("Static")) clearState(DYNAMIC); _pos << XML.getNode("P"); _vel << XML.getNode("V"); }
inline ParticleProperty(const magnet::xml::Node& node): Property(Property::Units(node.getAttribute("Units").getValue())), _name(node.getAttribute("Name").getValue()) { //Move up to the particles nodes, and start loading the property values for (magnet::xml::Node pNode = node.getParent().getParent() .getNode("ParticleData").fastGetNode("Pt"); pNode.valid(); ++pNode) _values.push_back(pNode.getAttribute(_name).as<double>()); }
void GFrancesco::operator<<(const magnet::xml::Node& XML) { globName = XML.getAttribute("Name"); const double MFT = XML.getAttribute("MFT").as<double>() * Sim->units.unitTime(); const double MFTstddev = XML.getAttribute("MFTstddev").as<double>() * Sim->units.unitTime(); _dist = std::normal_distribution<>(MFT, MFTstddev); _vel = XML.getAttribute("Velocity").as<double>() * Sim->units.unitVelocity(); range = shared_ptr<IDRange>(IDRange::getClass(XML.getNode("IDRange"), Sim)); }
void SysRescale::operator<<(const magnet::xml::Node& XML) { if (strcmp(XML.getAttribute("Type"),"Rescale")) M_throw() << "Attempting to load Rescale from " << XML.getAttribute("Type") << " entry"; try { if (XML.hasAttribute("Freq")) _frequency = XML.getAttribute("Freq").as<size_t>(); if (XML.hasAttribute("kT")) _kT = XML.getAttribute("kT").as<double>(); _kT *= Sim->dynamics.units().unitEnergy(); if (XML.hasAttribute("TimeStep")) _timestep = XML.getAttribute("TimeStep").as<double>(); _timestep *= Sim->dynamics.units().unitTime(); sysName = XML.getAttribute("Name"); } catch (boost::bad_lexical_cast &) { M_throw() << "Failed a lexical cast in SysRescale"; } }
void CSUmbrella::operator<<(const magnet::xml::Node& XML) { if (strcmp(XML.getAttribute("Type"),"Umbrella")) M_throw() << "Attempting to load Umbrella from a " << XML.getAttribute("Type") << " entry"; try { sysName = XML.getAttribute("Name"); a = XML.getAttribute("a").as<double>() * Sim->dynamics.units().unitEnergy() / Sim->dynamics.units().unitArea(); b = XML.getAttribute("b").as<double>() * Sim->dynamics.units().unitLength(); delU = XML.getAttribute("delU").as<double>() * Sim->dynamics.units().unitEnergy(); range1.set_ptr(CRange::getClass(XML.getNode("Range1"), Sim)); range2.set_ptr(CRange::getClass(XML.getNode("Range2"), Sim)); if (XML.hasAttribute("currentulevel")) { ulevel = XML.getAttribute("currentulevel").as<size_t>(); ulevelset = true; } } catch (boost::bad_lexical_cast &) { M_throw() << "Failed a lexical cast in CSUmbrella"; } }
void BCLeesEdwards::operator<<(const magnet::xml::Node& XML) { if (XML.hasAttribute("DXD")) _dxd = XML.getAttribute("DXD").as<double>(); _dxd *= Sim->units.unitLength(); if (XML.hasAttribute("Rate")) _shearRate = XML.getAttribute("Rate").as<double>(); _shearRate /= Sim->units.unitTime(); }
IDPairRangeChainGroups(const magnet::xml::Node& XML, const dynamo::Simulation*): range1(0),range2(0), length(0) { range1 = XML.getAttribute("Start1").as<size_t>(); range2 = XML.getAttribute("Start2").as<size_t>(); length = XML.getAttribute("Length").as<size_t>(); //Guarrantee that they are ordered if (range1 > range2) std::swap(range1, range2); }
void OPStructureImaging::operator<<(const magnet::xml::Node& XML) { if (!XML.hasAttribute("Structure")) M_throw() << "You must specify the name of the structure to monitor for StructureImaging"; structureName = XML.getAttribute("Structure"); if (XML.hasAttribute("MaxImages")) imageCount = XML.getAttribute("MaxImages").as<size_t>(); }
shared_ptr<Potential> Potential::getClass(const magnet::xml::Node& XML) { if (!XML.getAttribute("Type").getValue().compare("Stepped")) return shared_ptr<Potential>(new PotentialStepped(XML)); else if (!XML.getAttribute("Type").getValue().compare("LennardJones")) return shared_ptr<Potential>(new PotentialLennardJones(XML)); else M_throw() << XML.getAttribute("Type").getValue() << ", Unknown type of Potential encountered"; }
void IHardSphere::operator<<(const magnet::xml::Node& XML) { Interaction::operator<<(XML); _diameter = Sim->_properties.getProperty(XML.getAttribute("Diameter"), Property::Units::Length()); if (XML.hasAttribute("Elasticity")) _e = Sim->_properties.getProperty(XML.getAttribute("Elasticity"), Property::Units::Dimensionless()); if (XML.hasAttribute("TangentialElasticity")) _et = Sim->_properties.getProperty(XML.getAttribute("TangentialElasticity"), Property::Units::Dimensionless()); }
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"; } for (magnet::xml::Node node = XML.fastGetNode("Molecule"); node.valid(); ++node) ranges.push_back(shared_ptr<Range>(Range::getClass(node, Sim))); }
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 OPMSDOrientationalCorrelator::operator<<(const magnet::xml::Node& XML) { try { if (XML.hasAttribute("Length")) length = XML.getAttribute("Length").as<size_t>(); } catch (boost::bad_lexical_cast &) { M_throw() << "Failed a lexical cast in OPMSDCorrelator"; } }
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>(); } }
C2RRings::C2RRings(const magnet::xml::Node& XML, const dynamo::SimData*): range1(0),range2(0), interval(0) { if (strcmp(XML.getAttribute("Range"),"Rings")) M_throw() << "Attempting to load a rings from a non rings"; range1 = XML.getAttribute("Start").as<unsigned long>(); range2 = XML.getAttribute("End").as<unsigned long>(); interval = XML.getAttribute("Interval").as<unsigned long>(); if ((range2-range1 + 1) % interval) M_throw() << "Range of C2RChains does not split evenly into interval"; }
shared_ptr<Dynamics> Dynamics::getClass(const magnet::xml::Node& XML, dynamo::Simulation* tmp) { if (!strcmp(XML.getAttribute("Type"),"Newtonian")) return shared_ptr<Dynamics>(new DynNewtonian(tmp)); if (!strcmp(XML.getAttribute("Type"),"NewtonianGravity")) return shared_ptr<Dynamics>(new DynGravity(tmp, XML)); else if (!strcmp(XML.getAttribute("Type"),"NewtonianMC")) return shared_ptr<Dynamics>(new DynNewtonianMC(tmp, XML)); else M_throw() << XML.getAttribute("Type") << ", Unknown type of Dynamics encountered"; }
void OPMFL::operator<<(const magnet::xml::Node& XML) { try { if (XML.hasAttribute("binwidth")) binwidth = XML.getAttribute("binwidth").as<double>(); } catch (boost::bad_lexical_cast&) { M_throw() << "Failed a lexical cast in OPMFL"; } }
shared_ptr<Scheduler> Scheduler::getClass(const magnet::xml::Node& XML, dynamo::Simulation* const Sim) { if (!XML.getAttribute("Type").getValue().compare("NeighbourList")) return shared_ptr<Scheduler>(new SNeighbourList(XML, Sim)); else if (!XML.getAttribute("Type").getValue().compare("Dumb")) return shared_ptr<Scheduler>(new SDumb(XML, Sim)); else if (!XML.getAttribute("Type").getValue().compare("SystemOnly")) return shared_ptr<Scheduler>(new SSystemOnly(XML, Sim)); else M_throw() << XML.getAttribute("Type").getValue() << ", Unknown type of Scheduler encountered"; }
void IThinThread::operator<<(const magnet::xml::Node& XML) { Interaction::operator<<(XML); _diameter = Sim->_properties.getProperty(XML.getAttribute("Diameter"), Property::Units::Length()); _lambda = Sim->_properties.getProperty(XML.getAttribute("Lambda"), Property::Units::Dimensionless()); _wellDepth = Sim->_properties.getProperty(XML.getAttribute("WellDepth"), Property::Units::Energy()); if (XML.hasAttribute("Elasticity")) _e = Sim->_properties.getProperty(XML.getAttribute("Elasticity"), Property::Units::Dimensionless()); else _e = Sim->_properties.getProperty(1.0, Property::Units::Dimensionless()); ICapture::loadCaptureMap(XML); }
void CSysGhost::operator<<(const magnet::xml::Node& XML) { if (strcmp(XML.getAttribute("Type"),"Andersen")) M_throw() << "Attempting to load Andersen from non Andersen entry"; try { meanFreeTime = XML.getAttribute("MFT").as<double>() * Sim->dynamics.units().unitTime(); Temp = XML.getAttribute("Temperature").as<double>() * Sim->dynamics.units().unitEnergy(); sysName = XML.getAttribute("Name"); if (XML.hasAttribute("SetFrequency") && XML.hasAttribute("SetPoint")) { tune = true; setFrequency = XML.getAttribute("SetFrequency").as<unsigned long long>(); setPoint = boost::lexical_cast<double>(XML.getAttribute("SetPoint")); } range = std::tr1::shared_ptr<CRange>(CRange::getClass(XML,Sim)); } catch (boost::bad_lexical_cast &) { M_throw() << "Failed a lexical cast in CGGlobal"; } }
void Liouvillean::loadParticleXMLData(const magnet::xml::Node& XML) { dout << "Loading Particle Data" << std::endl; bool outofsequence = false; for (magnet::xml::Node node = XML.getNode("ParticleData").fastGetNode("Pt"); node.valid(); ++node) { if (!node.hasAttribute("ID") || node.getAttribute("ID").as<size_t>() != Sim->particleList.size()) outofsequence = true; Particle part(node, Sim->particleList.size()); part.getVelocity() *= Sim->dynamics.units().unitVelocity(); part.getPosition() *= Sim->dynamics.units().unitLength(); Sim->particleList.push_back(part); } if (outofsequence) dout << "Particle ID's out of sequence!\n" << "This can result in incorrect capture map loads etc.\n" << "Erase any capture maps in the configuration file so they are regenerated." << std::endl; Sim->N = Sim->particleList.size(); dout << "Particle count " << Sim->N << std::endl; if (XML.getNode("ParticleData").hasAttribute("OrientationData")) { orientationData.resize(Sim->N); size_t i(0); for (magnet::xml::Node node = XML.getNode("ParticleData").fastGetNode("Pt"); node.valid(); ++node, ++i) { orientationData[i].orientation << node.getNode("U"); orientationData[i].angularVelocity << node.getNode("O"); double oL = orientationData[i].orientation.nrm(); if (!(oL > 0.0)) M_throw() << "Particle ID " << i << " orientation vector is zero!"; //Makes the vector a unit vector orientationData[i].orientation /= oL; } } }
void LWall::operator<<(const magnet::xml::Node& XML) { range = shared_ptr<IDRange>(IDRange::getClass(XML.getNode("IDRange"),Sim)); _diameter = Sim->_properties.getProperty(XML.getAttribute("Diameter"), Property::Units::Length()); if (_diameter->getMaxValue() == 0) M_throw() << "Cannot have a wall with a diameter of zero"; _e = Sim->_properties.getProperty(XML.getAttribute("Elasticity"), Property::Units::Dimensionless()); sqrtT = 0; if (XML.hasAttribute("Temperature")) sqrtT = sqrt(XML.getAttribute("Temperature").as<double>() * Sim->units.unitEnergy()); if (sqrtT < 0) M_throw() << "Cannot use negative temperatures on a Wall"; magnet::xml::Node xBrowseNode = XML.getNode("Norm"); localName = XML.getAttribute("Name"); vNorm << xBrowseNode; if (vNorm.nrm() == 0) M_throw() << "The normal for the Local Wall named \"" << getName() << "\" has a length of 0. Cannot load"; vNorm /= vNorm.nrm(); xBrowseNode = XML.getNode("Origin"); vPosition << xBrowseNode; vPosition *= Sim->units.unitLength(); }