void
AGActivityGenHandler::parseStreets(const SUMOSAXAttributes& attrs) {
try {
SUMOReal pop = 0;
SUMOReal work = 0;
if (attrs.hasAttribute(AGEN_ATTR_POPULATION)) {
pop = attrs.getFloat(AGEN_ATTR_POPULATION);
}
if (attrs.hasAttribute(AGEN_ATTR_OUT_WORKPOSITION)) {
work = attrs.getFloat(AGEN_ATTR_OUT_WORKPOSITION);
}
std::string eid = attrs.getString(SUMO_ATTR_EDGE);
AGStreet* street = dynamic_cast<AGStreet*>(net->getEdge(eid));
if (street == 0) {
WRITE_ERROR("Edge '" + eid + "' is not known.");
return;
}
street->setPopulation(pop * street->getLength());
street->setWorkplaceNumber(work * street->getLength());
myCity.streets.push_back(street);
} catch (const std::exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_STREET) + ": " +
e.what());
throw ProcessError();
}
}
void
TrajectoriesHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
bool ok = true;
switch (element) {
case SUMO_TAG_TRAJECTORIES:
myStepSize = attrs.getFloat("timeStepSize") / 1000.;
break;
case SUMO_TAG_TIMESTEP:
myCurrentTime = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, 0, ok);
break;
case SUMO_TAG_VEHICLE:
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
SUMOReal v = attrs.getFloat(SUMO_ATTR_SPEED);
SUMOReal a = INVALID_VALUE;
SUMOReal s = INVALID_VALUE;
writeEmissions(std::cout, attrs.getString(SUMO_ATTR_ID), myDefaultClass, STEPS2TIME(myCurrentTime), v, a, s);
} else {
const std::string acId = attrs.getString(SUMO_ATTR_ACTORCONFIG);
const std::string id = attrs.getString(SUMO_ATTR_ID);
if (myEmissionClassByType.count(acId) == 0) {
WRITE_WARNING("Unknown actor configuration '" + acId + "' for vehicle '" + id + "'!");
} else {
myEmissionClassByVehicle[id] = myEmissionClassByType.count(acId) > 0 ? myEmissionClassByType[acId] : myDefaultClass;
}
}
break;
case SUMO_TAG_ACTORCONFIG: {
const std::string id = attrs.getString(SUMO_ATTR_ID);
const std::string vClass = attrs.getString(SUMO_ATTR_VEHICLECLASS);
const std::string fuel = attrs.getString(SUMO_ATTR_FUEL);
const std::string eClass = attrs.getString(SUMO_ATTR_EMISSIONCLASS);
const SUMOReal weight = attrs.getOpt<SUMOReal>(SUMO_ATTR_WEIGHT, id.c_str(), ok, 0.) * 10.;
myEmissionClassByType[id] = PollutantsInterface::getClass(myDefaultClass, vClass, fuel, eClass, weight);
break;
}
case SUMO_TAG_MOTIONSTATE: {
const std::string id = attrs.getString(SUMO_ATTR_VEHICLE);
if (myEmissionClassByVehicle.count(id) == 0) {
WRITE_WARNING("Motion state for unknown vehicle '" + id + "'!");
myEmissionClassByVehicle[id] = myDefaultClass;
}
const SUMOEmissionClass c = myEmissionClassByVehicle[id];
SUMOReal v = attrs.getFloat(SUMO_ATTR_SPEED) / 100.;
SUMOReal a = attrs.hasAttribute(SUMO_ATTR_ACCELERATION) ? attrs.get<SUMOReal>(SUMO_ATTR_ACCELERATION, id.c_str(), ok) / 1000. : INVALID_VALUE;
SUMOReal s = attrs.hasAttribute(SUMO_ATTR_SLOPE) ? RAD2DEG(asin(attrs.get<SUMOReal>(SUMO_ATTR_SLOPE, id.c_str(), ok) / 10000.)) : INVALID_VALUE;
const SUMOTime time = attrs.getOpt<int>(SUMO_ATTR_TIME, id.c_str(), ok, INVALID_VALUE);
if (myXMLOut != 0) {
writeXMLEmissions(id, c, time, v, a, s);
}
if (myStdOut != 0) {
writeEmissions(*myStdOut, id, c, STEPS2TIME(time), v, a, s);
}
break;
}
default:
break;
}
}
void
AGActivityGenHandler::parseCityGates(const SUMOSAXAttributes& attrs) {
try {
string edge = attrs.getString(SUMO_ATTR_EDGE);
SUMOReal positionOnEdge = attrs.getFloat(SUMO_ATTR_POSITION);
AGPosition posi(myCity.getStreet(edge), positionOnEdge);
myCity.statData.incoming[(int)myCity.cityGates.size()] = attrs.getFloat(AGEN_ATTR_INCOMING);
myCity.statData.outgoing[(int)myCity.cityGates.size()] = attrs.getFloat(AGEN_ATTR_OUTGOING);
myCity.cityGates.push_back(posi);
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_CITYGATES) + ": " +
e.what());
throw ProcessError();
}
}
void
AGActivityGenHandler::parseClosingHour(const SUMOSAXAttributes& attrs) {
if (myCurrentObject == "workHours") {
try {
myCity.statData.endWorkHours[attrs.getInt(AGEN_ATTR_HOUR)] = attrs.getFloat(AGEN_ATTR_PROP);
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_CLOSING) + ": "
+ e.what());
throw ProcessError();
}
}
}
void
AGActivityGenHandler::parseStreets(const SUMOSAXAttributes& attrs) {
try {
SUMOReal pop = 0;
SUMOReal work = 0;
if (attrs.hasAttribute(AGEN_ATTR_POPULATION)) {
pop = attrs.getFloat(AGEN_ATTR_POPULATION);
}
if (attrs.hasAttribute(AGEN_ATTR_OUT_WORKPOSITION)) {
work = attrs.getFloat(AGEN_ATTR_OUT_WORKPOSITION);
}
AGStreet str(net->getEdge(attrs.getString(SUMO_ATTR_EDGE)), pop, work);
myCity.streets.push_back(str);
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_STREET) + ": " +
e.what());
throw ProcessError();
}
}
void
SAXWeightsHandler::tryParse(const SUMOSAXAttributes& attrs, bool isEdge) {
// !!!! no error handling!
std::vector<ToRetrieveDefinition*>::iterator i;
if (isEdge) {
// process all that want values directly from the edge
for (i = myDefinitions.begin(); i != myDefinitions.end(); ++i) {
if ((*i)->myAmEdgeBased) {
if (attrs.hasAttribute((*i)->myAttributeName)) {
(*i)->myAggValue = attrs.getFloat((*i)->myAttributeName);
(*i)->myNoLanes = 1;
(*i)->myHadAttribute = true;
} else {
(*i)->myHadAttribute = false;
}
} else {
(*i)->myAggValue = 0;
(*i)->myNoLanes = 0;
}
}
} else {
// process the current lane values
for (i = myDefinitions.begin(); i != myDefinitions.end(); ++i) {
if (!(*i)->myAmEdgeBased) {
try {
(*i)->myAggValue += attrs.getFloat((*i)->myAttributeName);
++((*i)->myNoLanes);
(*i)->myHadAttribute = true;
} catch (EmptyData&) {
WRITE_ERROR("Missing value '" + (*i)->myAttributeName + "' in edge '" + myCurrentEdgeID + "'.");
} catch (NumberFormatException&) {
WRITE_ERROR("The value should be numeric, but is not.\n In edge '" + myCurrentEdgeID + "' at time step " + toString(myCurrentTimeBeg) + ".");
}
}
}
}
}
void
AGActivityGenHandler::parseBusStation(const SUMOSAXAttributes& attrs) {
try {
string edge = attrs.getString(SUMO_ATTR_EDGE);
SUMOReal positionOnEdge = attrs.getFloat(SUMO_ATTR_POSITION);
int id = attrs.getInt(SUMO_ATTR_ID);
AGPosition posi(myCity.getStreet(edge), positionOnEdge);
myCity.statData.busStations.insert(std::pair<int, AGPosition>(id, posi));
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_BUSSTATION) + ": " +
e.what());
throw ProcessError();
}
}
void
NIImporter_SUMO::addLane(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string id = attrs.get<std::string>(SUMO_ATTR_ID, 0, ok);
if (!ok) {
return;
}
if (!myCurrentEdge) {
WRITE_ERROR("Found lane '" + id + "' not within edge element");
return;
}
if (attrs.getOpt<bool>(SUMO_ATTR_CUSTOMSHAPE, 0, ok, false)) {
const std::string nodeID = NBNode::getNodeIDFromInternalLane(id);
myCustomShapeMaps[nodeID][id] = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok);
}
myCurrentLane = new LaneAttrs;
if (myCurrentEdge->func == EDGEFUNC_CROSSING) {
// save the width and the lane id of the crossing but don't do anything else
std::vector<Crossing>& crossings = myPedestrianCrossings[SUMOXMLDefinitions::getJunctionIDFromInternalEdge(myCurrentEdge->id)];
assert(crossings.size() > 0);
crossings.back().width = attrs.get<SUMOReal>(SUMO_ATTR_WIDTH, id.c_str(), ok);
return;
} else if (myCurrentEdge->func == EDGEFUNC_INTERNAL || myCurrentEdge->func == EDGEFUNC_WALKINGAREA) {
myHaveSeenInternalEdge = true;
return; // skip internal lanes
}
if (attrs.hasAttribute("maxspeed")) {
// !!! deprecated
myCurrentLane->maxSpeed = attrs.getFloat("maxspeed");
} else {
myCurrentLane->maxSpeed = attrs.get<SUMOReal>(SUMO_ATTR_SPEED, id.c_str(), ok);
}
try {
myCurrentLane->allow = attrs.getOpt<std::string>(SUMO_ATTR_ALLOW, id.c_str(), ok, "", false);
} catch (EmptyData e) {
// !!! deprecated
myCurrentLane->allow = "";
}
myCurrentLane->disallow = attrs.getOpt<std::string>(SUMO_ATTR_DISALLOW, id.c_str(), ok, "");
myCurrentLane->width = attrs.getOpt<SUMOReal>(SUMO_ATTR_WIDTH, id.c_str(), ok, (SUMOReal) NBEdge::UNSPECIFIED_WIDTH);
myCurrentLane->endOffset = attrs.getOpt<SUMOReal>(SUMO_ATTR_ENDOFFSET, id.c_str(), ok, (SUMOReal) NBEdge::UNSPECIFIED_OFFSET);
myCurrentLane->shape = attrs.get<PositionVector>(SUMO_ATTR_SHAPE, id.c_str(), ok);
// lane coordinates are derived (via lane spread) do not include them in convex boundary
NBNetBuilder::transformCoordinates(myCurrentLane->shape, false, myLocation);
}
void
AGActivityGenHandler::parseSchool(const SUMOSAXAttributes& attrs) {
try {
string edge = attrs.getString(SUMO_ATTR_EDGE);
SUMOReal positionOnEdge = attrs.getFloat(SUMO_ATTR_POSITION);
AGPosition posi(myCity.getStreet(edge), positionOnEdge);
int beginAge = attrs.getInt(AGEN_ATTR_BEGINAGE);
int endAge = attrs.getInt(AGEN_ATTR_ENDAGE);
int capacity = attrs.getInt(AGEN_ATTR_CAPACITY);
int openingHour = attrs.getInt(AGEN_ATTR_OPENING);
int closingHour = attrs.getInt(AGEN_ATTR_CLOSING);
AGSchool sch(capacity, posi, beginAge, endAge, openingHour, closingHour);
myCity.schools.push_back(sch);
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_SCHOOL) + ": " +
e.what());
throw ProcessError();
}
}
void
MSStateHandler::myStartElement(int element, const SUMOSAXAttributes& attrs) {
MSVehicleControl& vc = MSNet::getInstance()->getVehicleControl();
switch (element) {
case SUMO_TAG_SNAPSHOT: {
myTime = attrs.getInt(SUMO_ATTR_TIME);
const std::string& version = attrs.getString(SUMO_ATTR_VERSION);
if (version != VERSION_STRING) {
WRITE_WARNING("State was written with sumo version " + version + " (present: " + VERSION_STRING + ")!");
}
break;
}
case SUMO_TAG_DELAY: {
vc.setState(attrs.getInt(SUMO_ATTR_NUMBER), attrs.getInt(SUMO_ATTR_END),
attrs.getFloat(SUMO_ATTR_DEPART), attrs.getFloat(SUMO_ATTR_TIME));
break;
}
case SUMO_TAG_ROUTE: {
const std::string id = attrs.getString(SUMO_ATTR_ID);
if (MSRoute::dictionary(id) == 0) {
MSEdgeVector edges;
MSEdge::parseEdgesList(attrs.getString(SUMO_ATTR_EDGES), edges, id);
MSRoute* r = new MSRoute(id, edges, attrs.getBool(SUMO_ATTR_STATE),
0, std::vector<SUMOVehicleParameter::Stop>());
MSRoute::dictionary(id, r);
}
break;
}
case SUMO_TAG_ROUTE_DISTRIBUTION: {
const std::string id = attrs.getString(SUMO_ATTR_ID);
if (MSRoute::dictionary(id) == 0) {
RandomDistributor<const MSRoute*>* dist = new RandomDistributor<const MSRoute*>();
std::vector<std::string> routeIDs;
std::istringstream iss(attrs.getString(SUMO_ATTR_PROBS));
SUMOSAXAttributes::parseStringVector(attrs.getString(SUMO_ATTR_ROUTES), routeIDs);
for (std::vector<std::string>::const_iterator it = routeIDs.begin(); it != routeIDs.end(); ++it) {
SUMOReal prob;
iss >> prob;
const MSRoute* r = MSRoute::dictionary(*it);
assert(r != 0);
dist->add(prob, r, false);
r->addReference();
}
MSRoute::dictionary(id, dist, attrs.getBool(SUMO_ATTR_STATE));
}
break;
}
case SUMO_TAG_VTYPE: {
myCurrentVType = SUMOVehicleParserHelper::beginVTypeParsing(attrs, getFileName());
break;
}
case SUMO_TAG_VTYPE_DISTRIBUTION: {
const std::string id = attrs.getString(SUMO_ATTR_ID);
if (vc.getVType(id) == 0) {
RandomDistributor<MSVehicleType*>* dist = new RandomDistributor<MSVehicleType*>();
std::vector<std::string> typeIDs;
std::istringstream iss(attrs.getString(SUMO_ATTR_PROBS));
SUMOSAXAttributes::parseStringVector(attrs.getString(SUMO_ATTR_VTYPES), typeIDs);
for (std::vector<std::string>::const_iterator it = typeIDs.begin(); it != typeIDs.end(); ++it) {
SUMOReal prob;
iss >> prob;
MSVehicleType* t = vc.getVType(*it);
assert(t != 0);
dist->add(prob, t, false);
}
vc.addVTypeDistribution(id, dist);
}
break;
}
