void
MSVehicleTransfer::loadState(const SUMOSAXAttributes& attrs, const SUMOTime offset, MSVehicleControl& vc) {
MSVehicle* veh = dynamic_cast<MSVehicle*>(vc.getVehicle(attrs.getString(SUMO_ATTR_ID)));
assert(veh != 0);
SUMOTime proceedTime = (SUMOTime)attrs.getLong(SUMO_ATTR_DEPART);
MSLane* parkingLane = attrs.hasAttribute(SUMO_ATTR_PARKING) ? MSLane::dictionary(attrs.getString(SUMO_ATTR_PARKING)): 0;
myVehicles.push_back(VehicleInformation(veh, proceedTime + offset, parkingLane != 0));
if (parkingLane != 0) {
myParkingVehicles[parkingLane].insert(veh);
veh->setTentativeLaneAndPosition(parkingLane, veh->getPositionOnLane());
veh->processNextStop(veh->getSpeed());
}
MSNet::getInstance()->getInsertionControl().alreadyDeparted(veh);
}
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
MSDevice_Tripinfo::loadState(const SUMOSAXAttributes& attrs) {
std::istringstream bis(attrs.getString(SUMO_ATTR_STATE));
bis >> myDepartLane;
bis >> myDepartPosLat;
bis >> myDepartSpeed;
}
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
SUMORouteHandler::addParam(const SUMOSAXAttributes& attrs) {
bool ok = true;
const std::string key = attrs.get<std::string>(SUMO_ATTR_KEY, 0, ok);
// circumventing empty string test
const std::string val = attrs.hasAttribute(SUMO_ATTR_VALUE) ? attrs.getString(SUMO_ATTR_VALUE) : "";
if (myVehicleParameter != 0) {
myVehicleParameter->addParameter(key, val);
} else if (myCurrentVType != 0) {
myCurrentVType->addParameter(key, val);
}
}
void
AGActivityGenHandler::parseBusLine(const SUMOSAXAttributes& attrs) {
try {
myCurrentObject = "busLine";
AGBusLine busL(attrs.getString(SUMO_ATTR_ID));
busL.setMaxTripTime(attrs.getInt(AGEN_ATTR_MAX_TRIP_DURATION));
myCity.busLines.push_front(busL);
currentBusLine = &*myCity.busLines.begin();
} catch (const exception& e) {
WRITE_ERROR("Error while parsing the element " +
SUMOXMLDefinitions::Tags.getString(AGEN_TAG_BUSLINE) + ": " +
e.what());
throw ProcessError();
}
}
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
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::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
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
MSRouteHandler::openRoute(const SUMOSAXAttributes& attrs) {
// check whether the id is really necessary
std::string rid;
if (myCurrentRouteDistribution != 0) {
myActiveRouteID = myCurrentRouteDistributionID + "#" + toString(myCurrentRouteDistribution->getProbs().size()); // !!! document this
rid = "distribution '" + myCurrentRouteDistributionID + "'";
} else if (myVehicleParameter != 0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myActiveRouteID = "!" + myVehicleParameter->id; // !!! document this
if (attrs.hasAttribute(SUMO_ATTR_ID)) {
WRITE_WARNING("Ids of internal routes are ignored (vehicle '" + myVehicleParameter->id + "').");
}
} else {
bool ok = true;
myActiveRouteID = attrs.getStringReporting(SUMO_ATTR_ID, 0, ok, false);
if (!ok) {
return;
}
rid = "'" + myActiveRouteID + "'";
}
if (myVehicleParameter != 0) { // have to do this here for nested route distributions
rid = "for vehicle '" + myVehicleParameter->id + "'";
}
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, myActiveRouteID.c_str(), ok), myActiveRoute, rid);
}
myActiveRouteRefID = attrs.getOptStringReporting(SUMO_ATTR_REFID, myActiveRouteID.c_str(), ok, "");
if (attrs.hasAttribute(SUMO_ATTR_REFID__DEPRECATED)) {
myActiveRouteRefID = attrs.getOptStringReporting(SUMO_ATTR_REFID__DEPRECATED, myActiveRouteID.c_str(), ok, "");
if (!myHaveWarnedAboutDeprecatedRefID) {
myHaveWarnedAboutDeprecatedRefID = true;
WRITE_WARNING("'" + toString(SUMO_ATTR_REFID__DEPRECATED) + "' is deprecated, please use '" + toString(SUMO_ATTR_REFID) + "' instead.");
}
}
if (myActiveRouteRefID != "" && MSRoute::dictionary(myActiveRouteRefID) == 0) {
WRITE_ERROR("Invalid reference to route '" + myActiveRouteRefID + "' in route " + rid + ".");
}
myActiveRouteProbability = attrs.getOptSUMORealReporting(SUMO_ATTR_PROB, myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? RGBColor::parseColorReporting(attrs.getString(SUMO_ATTR_COLOR), attrs.getObjectType(), myActiveRouteID.c_str(), true, ok) : RGBColor::getDefaultColor();
}
void
NIXMLEdgesHandler::myStartElement(int element,
const SUMOSAXAttributes& attrs) {
switch (element) {
case SUMO_TAG_EDGE:
addEdge(attrs);
break;
case SUMO_TAG_LANE:
addLane(attrs);
break;
case SUMO_TAG_NEIGH:
myCurrentEdge->getLaneStruct((int)myCurrentEdge->getNumLanes() - 1).oppositeID = attrs.getString(SUMO_ATTR_LANE);
break;
case SUMO_TAG_SPLIT:
addSplit(attrs);
break;
case SUMO_TAG_DELETE:
deleteEdge(attrs);
break;
case SUMO_TAG_ROUNDABOUT:
addRoundabout(attrs);
break;
default:
break;
}
}
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;
}
void
MSRouteHandler::openRoute(const SUMOSAXAttributes &attrs) {
// check whether the id is really necessary
if (myVehicleParameter!=0) {
// ok, a vehicle is wrapping the route,
// we may use this vehicle's id as default
myActiveRouteID = "!" + myVehicleParameter->id; // !!! document this
} else {
bool ok = true;
myActiveRouteID = attrs.getStringReporting(SUMO_ATTR_ID, "route", 0, ok, false);
if (!ok) {
return;
}
}
bool ok = true;
if (attrs.hasAttribute(SUMO_ATTR_EDGES)) {
MSEdge::parseEdgesList(attrs.getStringReporting(SUMO_ATTR_EDGES, "route", myActiveRouteID.c_str(), ok), myActiveRoute, myActiveRouteID);
}
myActiveRouteProbability = attrs.getOptSUMORealReporting(SUMO_ATTR_PROB, "route", myActiveRouteID.c_str(), ok, DEFAULT_VEH_PROB);
myActiveRouteColor = attrs.hasAttribute(SUMO_ATTR_COLOR) ? RGBColor::parseColorReporting(attrs.getString(SUMO_ATTR_COLOR), "route", myActiveRouteID.c_str(), true, ok) : RGBColor::getDefaultColor();
}
