void
NIXMLTypesHandler::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
if (element!=SUMO_TAG_TYPE) {
return;
}
// get the id, report a warning if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("type", id), false) {
WRITE_WARNING("No type id given... Skipping.");
return;
}
// check deprecated (unused) attributes
if (!myHaveReportedAboutFunctionDeprecation&&attrs.hasAttribute(SUMO_ATTR_FUNCTION)) {
MsgHandler::getWarningInstance()->inform("While parsing type '" + id + "': 'function' is deprecated.\n All occurences are ignored.");
myHaveReportedAboutFunctionDeprecation = true;
}
bool ok = true;
int priority = attrs.getOptIntReporting(SUMO_ATTR_PRIORITY, "type", id.c_str(), ok, myTypeCont.getDefaultPriority());
int noLanes = attrs.getOptIntReporting(SUMO_ATTR_NOLANES, "type", id.c_str(), ok, myTypeCont.getDefaultNoLanes());
SUMOReal speed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, "type", id.c_str(), ok, (SUMOReal) myTypeCont.getDefaultSpeed());
bool discard = attrs.getOptBoolReporting(SUMO_ATTR_DISCARD, 0, 0, ok, false);
if (!ok) {
return;
}
// build the type
if (!myTypeCont.insert(id, noLanes, speed, priority)) {
MsgHandler::getErrorInstance()->inform("Duplicate type occured. ID='" + id + "'");
} else {
if (discard) {
myTypeCont.markAsToDiscard(id);
}
}
}
void
NIImporter_SUMO::addJunction(const SUMOSAXAttributes &attrs) {
// get the id, report an error if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("junction", id)) {
return;
}
if (id[0]==':') {
return;
}
bool ok = true;
SUMOReal x = attrs.getOptSUMORealReporting(SUMO_ATTR_X, "junction", id.c_str(), ok, -1);
SUMOReal y = attrs.getOptSUMORealReporting(SUMO_ATTR_Y, "junction", id.c_str(), ok, -1);
// !!! this is too simplified! A proper error check should be done
if (x==-1||y==-1) {
MsgHandler::getErrorInstance()->inform("Junction '" + id + "' has an invalid position.");
return;
}
Position2D pos(x, y);
if (!GeoConvHelper::x2cartesian(pos)) {
MsgHandler::getErrorInstance()->inform("Unable to project coordinates for junction " + id + ".");
return;
}
NBNode *node = new NBNode(id, pos);
if (!myNodeCont.insert(node)) {
MsgHandler::getErrorInstance()->inform("Problems on adding junction '" + id + "'.");
delete node;
return;
}
}
void
MSRouteHandler::openRouteDistribution(const SUMOSAXAttributes &attrs) {
if (attrs.setIDFromAttributes("routeDistribution", myCurrentRouteDistributionID)) {
myCurrentRouteDistribution = new RandomDistributor<const MSRoute*>();
if (attrs.hasAttribute(SUMO_ATTR_ROUTES)) {
bool ok = true;
StringTokenizer st(attrs.getStringReporting(SUMO_ATTR_ROUTES, "routeDistribution", myCurrentRouteDistributionID.c_str(), ok));
while (st.hasNext()) {
std::string routeID = st.next();
const MSRoute *route = MSRoute::dictionary(routeID);
if (route==0) {
throw ProcessError("Unknown route '" + routeID + "' in distribution '" + myCurrentRouteDistributionID + "'.");
}
myCurrentRouteDistribution->add(1., route, false);
}
}
}
}
void
MSRouteHandler::openVehicleTypeDistribution(const SUMOSAXAttributes &attrs) {
if (attrs.setIDFromAttributes("vtypeDistribution", myCurrentVTypeDistributionID)) {
myCurrentVTypeDistribution = new RandomDistributor<MSVehicleType*>();
if (attrs.hasAttribute(SUMO_ATTR_VTYPES)) {
bool ok = true;
StringTokenizer st(attrs.getStringReporting(SUMO_ATTR_VTYPES, "vtypeDistribution", myCurrentVTypeDistributionID.c_str(), ok));
while (st.hasNext()) {
std::string vtypeID = st.next();
MSVehicleType *type = MSNet::getInstance()->getVehicleControl().getVType(vtypeID);
if (type==0) {
throw ProcessError("Unknown vtype '" + vtypeID + "' in distribution '" + myCurrentVTypeDistributionID + "'.");
}
myCurrentVTypeDistribution->add(type->getDefaultProbability(), type);
}
}
}
}
void
NIImporter_SUMO::addEdge(const SUMOSAXAttributes &attrs) {
// get the id, report an error if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("edge", id)) {
return;
}
bool ok = true;
myCurrentEdge = new EdgeAttrs;
myCurrentEdge->id = id;
// get the type
myCurrentEdge->type = attrs.getOptStringReporting(SUMO_ATTR_TYPE, "edge", id.c_str(), ok, "");
// get the origin and the destination node
myCurrentEdge->fromNode = attrs.getOptStringReporting(SUMO_ATTR_FROM, "edge", id.c_str(), ok, "");
myCurrentEdge->toNode = attrs.getOptStringReporting(SUMO_ATTR_TO, "edge", id.c_str(), ok, "");
myCurrentEdge->priority = attrs.getOptIntReporting(SUMO_ATTR_PRIORITY, "edge", id.c_str(), ok, -1);
myCurrentEdge->maxSpeed = 0;
myCurrentEdge->builtEdge = 0;
}
void
NIXMLEdgesHandler::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
if (element==SUMO_TAG_EDGE) {
myIsUpdate = false;
bool ok = true;
// initialise the edge
myCurrentEdge = 0;
mySplits.clear();
// get the id, report an error if not given or empty...
if (!attrs.setIDFromAttributes("edge", myCurrentID)) {
return;
}
myCurrentEdge = myEdgeCont.retrieve(myCurrentID);
// check deprecated (unused) attributes
if (!myHaveReportedAboutFunctionDeprecation&&attrs.hasAttribute(SUMO_ATTR_FUNCTION)) {
MsgHandler::getWarningInstance()->inform("While parsing edge '" + myCurrentID + "': 'function' is deprecated.\n All occurences are ignored.");
myHaveReportedAboutFunctionDeprecation = true;
}
// use default values, first
myCurrentSpeed = myTypeCont.getDefaultSpeed();
myCurrentPriority = myTypeCont.getDefaultPriority();
myCurrentLaneNo = myTypeCont.getDefaultNoLanes();
// use values from the edge to overwrite if existing, then
if (myCurrentEdge!=0) {
myIsUpdate = true;
if (!myHaveReportedAboutOverwriting) {
MsgHandler::getMessageInstance()->inform("Duplicate edge id occured ('" + myCurrentID + "'); assuming overwriting is wished.");
myHaveReportedAboutOverwriting = true;
}
myCurrentSpeed = myCurrentEdge->getSpeed();
myCurrentPriority = myCurrentEdge->getPriority();
myCurrentLaneNo = myCurrentEdge->getNoLanes();
myCurrentType = myCurrentEdge->getTypeID();
}
// check whether a type's values shall be used
myCurrentType = "";
if (attrs.hasAttribute(SUMO_ATTR_TYPE)) {
myCurrentType = attrs.getStringReporting(SUMO_ATTR_TYPE, "edge", myCurrentID.c_str(), ok);
if (!ok) {
return;
}
if (!myTypeCont.knows(myCurrentType)) {
MsgHandler::getErrorInstance()->inform("Type '" + myCurrentType + "' used by edge '" + myCurrentID + "' was not defined.");
return;
}
myCurrentSpeed = myTypeCont.getSpeed(myCurrentType);
myCurrentPriority = myTypeCont.getPriority(myCurrentType);
myCurrentLaneNo = myTypeCont.getNoLanes(myCurrentType);
}
// speed, priority and the number of lanes have now default values;
// try to read the real values from the file
if (attrs.hasAttribute(SUMO_ATTR_SPEED)) {
myCurrentSpeed = attrs.getSUMORealReporting(SUMO_ATTR_SPEED, "edge", myCurrentID.c_str(), ok);
}
if (myOptions.getBool("speed-in-kmh")) {
myCurrentSpeed = myCurrentSpeed / (SUMOReal) 3.6;
}
// try to get the number of lanes
if (attrs.hasAttribute(SUMO_ATTR_NOLANES)) {
myCurrentLaneNo = attrs.getIntReporting(SUMO_ATTR_NOLANES, "edge", myCurrentID.c_str(), ok);
}
// try to get the priority
if (attrs.hasAttribute(SUMO_ATTR_PRIORITY)) {
myCurrentPriority = attrs.getIntReporting(SUMO_ATTR_PRIORITY, "edge", myCurrentID.c_str(), ok);
}
// try to get the shape
myShape = tryGetShape(attrs);
// and how to spread the lanes
if (attrs.getOptStringReporting(SUMO_ATTR_SPREADFUNC, "edge", myCurrentID.c_str(), ok, "")=="center") {
myLanesSpread = NBEdge::LANESPREAD_CENTER;
} else {
myLanesSpread = NBEdge::LANESPREAD_RIGHT;
}
// try to set the nodes
if (!setNodes(attrs)) {
// return if this failed
return;
}
// get the length or compute it
if (attrs.hasAttribute(SUMO_ATTR_LENGTH)) {
myLength = attrs.getSUMORealReporting(SUMO_ATTR_LENGTH, "edge", myCurrentID.c_str(), ok);
} else {
myLength = 0;
}
/// insert the parsed edge into the edges map
if (!ok) {
return;
}
// check whether a previously defined edge shall be overwritten
if (myCurrentEdge!=0) {
myCurrentEdge->reinit(myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myShape,
myLanesSpread);
} else {
// the edge must be allocated in dependence to whether a shape is given
if (myShape.size()==0) {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myLanesSpread);
} else {
myCurrentEdge = new NBEdge(myCurrentID, myFromNode, myToNode, myCurrentType, myCurrentSpeed,
myCurrentLaneNo, myCurrentPriority, myShape,
myLanesSpread, OptionsCont::getOptions().getBool("xml.keep-shape"));
}
myCurrentEdge->setLoadedLength(myLength);
}
}
if (element==SUMO_TAG_LANE) {
if (myCurrentEdge==0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges", myCurrentID)) {
MsgHandler::getErrorInstance()->inform("Additional lane information could not been set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
bool ok = true;
int lane = attrs.getIntReporting(SUMO_ATTR_ID, "lane", 0, ok);
std::vector<std::string> disallowed, allowed, preferred;
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_DISALLOW, "lane", 0, ok, ""), disallowed);
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_ALLOW, "lane", 0, ok, ""), allowed);
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_PREFER, "lane", 0, ok, ""), preferred);
if (!ok) {
return;
}
if (lane<0) {
MsgHandler::getErrorInstance()->inform("Missing lane-id in lane definition (edge '" + myCurrentID + "').");
return;
}
// check whether this lane exists
if (lane>=(int) myCurrentEdge->getNoLanes()) {
MsgHandler::getErrorInstance()->inform("Lane-id is larger than number of lanes (edge '" + myCurrentID + "').");
return;
}
// set information about allowed / disallowed vehicle classes
for (std::vector<std::string>::iterator i=disallowed.begin(); i!=disallowed.end(); ++i) {
myCurrentEdge->disallowVehicleClass(lane, getVehicleClassID(*i));
}
for (std::vector<std::string>::iterator i=allowed.begin(); i!=allowed.end(); ++i) {
myCurrentEdge->allowVehicleClass(lane, getVehicleClassID(*i));
}
for (std::vector<std::string>::iterator i=preferred.begin(); i!=preferred.end(); ++i) {
myCurrentEdge->preferVehicleClass(lane, getVehicleClassID(*i));
}
// set information about later beginning lanes
if (attrs.hasAttribute(SUMO_ATTR_FORCE_LENGTH)) {
bool ok = true;
int forcedLength = attrs.getIntReporting(SUMO_ATTR_FORCE_LENGTH, "lane", myCurrentID.c_str(), ok); // !!! edge id
if (ok) {
int nameid = forcedLength;
forcedLength = (int)(myCurrentEdge->getGeometry().length() - forcedLength);
std::vector<Split>::iterator i;
i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder((SUMOReal) forcedLength));
if (i==mySplits.end()) {
Split e;
e.pos = (SUMOReal) forcedLength;
e.nameid = nameid;
for (unsigned int j=0; j<myCurrentEdge->getNoLanes(); j++) {
e.lanes.push_back(j);
}
mySplits.push_back(e);
}
i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder((SUMOReal) forcedLength));
std::vector<int>::iterator k = find((*i).lanes.begin(), (*i).lanes.end(), lane);
if (k!=(*i).lanes.end()) {
(*i).lanes.erase(k);
}
}
}
}
if (element==SUMO_TAG_SPLIT) {
bool ok = true;
Split e;
e.pos = attrs.getSUMORealReporting(SUMO_ATTR_POSITION, "split", 0, ok);
std::vector<Split>::iterator i = find_if(mySplits.begin(), mySplits.end(), split_by_pos_finder(e.pos));
if (i!=mySplits.end()) {
MsgHandler::getErrorInstance()->inform("Edge '" + myCurrentID + "' has already a split at position " + toString(e.pos) + ".");
return;
}
if (e.pos<0) {
e.pos = myCurrentEdge->getGeometry().length() - e.pos;
}
e.nameid = (int)e.pos;
if (ok) {
if (myCurrentEdge==0) {
if (!OptionsCont::getOptions().isInStringVector("remove-edges", myCurrentID)) {
MsgHandler::getErrorInstance()->inform("Additional lane information could not been set - the edge with id '" + myCurrentID + "' is not known.");
}
return;
}
if (e.pos<0) {
e.pos = myCurrentEdge->getGeometry().length() + e.pos;
}
std::vector<std::string> lanes;
SUMOSAXAttributes::parseStringVector(attrs.getOptStringReporting(SUMO_ATTR_LANES, "split", 0, ok, ""), lanes);
for (std::vector<std::string>::iterator i=lanes.begin(); i!=lanes.end(); ++i) {
try {
int lane = TplConvert<char>::_2int((*i).c_str());
e.lanes.push_back(lane);
} catch (NumberFormatException &) {
MsgHandler::getErrorInstance()->inform("Error on parsing a split (edge '" + myCurrentID + "').");
} catch (EmptyData &) {
MsgHandler::getErrorInstance()->inform("Error on parsing a split (edge '" + myCurrentID + "').");
}
}
if (e.lanes.size()==0) {
MsgHandler::getErrorInstance()->inform("Missing lane information in split of edge '" + myCurrentID + "'.");
} else {
mySplits.push_back(e);
}
}
}
}
void
MSCalibrator::MSCalibrator_FileTriggeredChild::myStartElement(SumoXMLTag element,
const SUMOSAXAttributes &attrs) throw(ProcessError) {
if (element==SUMO_TAG_ROUTEDISTELEM) {
bool ok = true;
SUMOReal freq = attrs.getSUMORealReporting(SUMO_ATTR_PROB, "calibrator/routedistelem", myParent.getID().c_str(), ok);
std::string routeStr = attrs.getStringReporting(SUMO_ATTR_ID, "calibrator/routedistelem", myParent.getID().c_str(), ok);
if (ok) {
const MSRoute* route = MSRoute::dictionary(routeStr);
if (route == 0) {
throw ProcessError("MSTriggeredSource " + myParent.getID() + ": Route '" + routeStr + "' does not exist.");
}
if (freq<0) {
throw ProcessError("MSTriggeredSource " + myParent.getID() + ": Attribute \"probability\" is negative (must not).");
}
// Attributes ok, add to routeDist
myRouteDist.add(freq, route);
}
return;
}
// vehicle-type distributions
if (element==SUMO_TAG_VTYPEDISTELEM) {
// get the id, report an error if not given or empty...
std::string id;
if (!attrs.setIDFromAttributes("vtypedistelem", id)) {
return;
}
bool ok = true;
SUMOReal prob = attrs.getSUMORealReporting(SUMO_ATTR_PROB, "vtypedistelem", id.c_str(), ok);
if (ok) {
if (prob<=0) {
MsgHandler::getErrorInstance()->inform("False probability while parsing calibrator '" + myParent.getID() + "' (" + toString(prob) + ").");
return;
}
MSVehicleType *vtype = MSNet::getInstance()->getVehicleControl().getVType(id);
if (vtype==0) {
MsgHandler::getErrorInstance()->inform("Unknown vtype-object '" + id + "'.");
return;
}
myVTypeDist.add(prob, vtype);
}
}
if (element==SUMO_TAG_FLOW) {
bool ok = true;
SUMOReal no = attrs.getSUMORealReporting(SUMO_ATTR_NO, "flow", myParent.getID().c_str(), ok);
if (no<0) {
MsgHandler::getErrorInstance()->inform("Negative flow in calibrator '" + myParent.getID() + "'.");
return;
}
SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, "flow", myParent.getID().c_str(), ok, -1);
if (!ok) {
return;
}
myFlow = (SUMOReal) no;
if (end==-1||end>=MSNet::getInstance()->getCurrentTimeStep()) {
if (myFlow>0) {
buildAndScheduleFlowVehicle();
MSNet::getInstance()->getEmissionEvents().addEvent(
new WrappingCommand<MSCalibrator::MSCalibrator_FileTriggeredChild>(this, &MSCalibrator::MSCalibrator_FileTriggeredChild::execute),
(SUMOTime)(1. / (myFlow / 3600.))+MSNet::getInstance()->getCurrentTimeStep(),
MSEventControl::ADAPT_AFTER_EXECUTION);
myHaveInitialisedFlow = true;
}
}
}
// check whethe the correct tag is read
if (element==SUMO_TAG_EMIT) {
bool ok = true;
SUMOTime depart = attrs.getSUMOTimeReporting(SUMO_ATTR_TIME, "emit", 0, ok);
SUMOReal departSpeed = attrs.getOptSUMORealReporting(SUMO_ATTR_SPEED, "emit", myParent.getID().c_str(), ok, -1);
if (!ok) {
return;
}
if (depart<myBeginTime) {
// do not process the vehicle if the emission time is before the simulation begin
return;
}
SUMOVehicleParameter* pars = new SUMOVehicleParameter();
pars->repetitionNumber = -1;
pars->repetitionOffset = -1;
pars->depart = depart;
pars->departSpeed = departSpeed;
// check and assign id
pars->id = attrs.getStringSecure(SUMO_ATTR_ID, "");
if (myVehicleControl.getVehicle(pars->id)!=0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": Vehicle " + pars->id + " already exists.\n Generating a default id.");
pars->id = "";
}
if (pars->id=="") {
pars->id = myParent.getID() + "_" + toString(pars->depart) + "_" + toString(myRunningID++);
if (myVehicleControl.getVehicle(pars->id)!=0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": Vehicle " + pars->id + " already exists.\n Continuing with next element.");
return;
}
}
// check and assign vehicle type
pars->vtypeid = attrs.getStringReporting(SUMO_ATTR_TYPE, "calibrator/routedistelem", myParent.getID().c_str(), ok, "");
MSVehicleType* aVehType = MSNet::getInstance()->getVehicleControl().getVType(pars->vtypeid);
if (aVehType == 0) {
if (myVTypeDist.getOverallProb()!=0) {
aVehType = myVTypeDist.get();
}
if (aVehType==0) {
aVehType = MSNet::getInstance()->getVehicleControl().getVType();
if (aVehType==0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": no valid vehicle type exists.\n Continuing with next element.");
return;
}
}
}
// check and assign vehicle type
pars->routeid = attrs.getStringReporting(SUMO_ATTR_ROUTE, "calibrator/routedistelem", myParent.getID().c_str(), ok, "");
const MSRoute *aEmitRoute = MSRoute::dictionary(pars->routeid);
if (aEmitRoute==0) {
if (myRouteDist.getOverallProb()!=0) {
aEmitRoute = myRouteDist.get();
}
if (aEmitRoute==0) {
WRITE_WARNING("MSTriggeredSource " + myParent.getID()+ ": no valid route exsists.");
WRITE_WARNING("Continuing with next element.");
return;
}
}
// build vehicle
MSVehicle *veh = MSNet::getInstance()->getVehicleControl().buildVehicle(pars, aEmitRoute, aVehType);
myParent.schedule(this, veh, pars->departSpeed);
myHaveNext = true;
myOffset = SUMOTime(pars->depart);
}
// check whethe the correct tag is read
if (element==SUMO_TAG_RESET) {
myVTypeDist.clear();
myRouteDist.clear();
}
#if 0
#ifdef TM_CALIB
if (element==SUMO_TAG_CALIB) {
WRITE_WARNING("FOUND calib Tag!!!");
/*
MSNet::getInstance()->getEmissionEvents().addEvent(
new WrappingCommand<MSCalibrator::MSCalibrator_FileTriggeredChild>(this, &MSCalibrator::MSCalibrator_FileTriggeredChild::execute2),
//MSNet::getInstance()->getCurrentTimeStep() + 5,
10,
MSEventControl::ADAPT_AFTER_EXECUTION);
*/
}
#endif //TM_CALIB
#endif //0
}