RandomDistributor<std::string>
GUISettingsHandler::getEventDistribution(const std::string& id) {
RandomDistributor<std::string> result = myEventDistributions[id];
if (result.getOverallProb() > 0 && result.getOverallProb() < 1) {
// unscaled probabilities are assumed, fill up with dummy event
result.add(1 - result.getOverallProb(), "");
}
return result;
}
ROJTREdge*
ROJTREdge::chooseNext(const ROVehicle* const veh, double time, const std::set<const ROEdge*>& avoid) const {
// if no usable follower exist, return 0
// their probabilities are not yet regarded
if (myFollowingEdges.size() == 0 || (veh != 0 && allFollowersProhibit(veh))) {
return 0;
}
// gather information about the probabilities at this time
RandomDistributor<ROJTREdge*> dist;
// use the loaded definitions, first
for (FollowerUsageCont::const_iterator i = myFollowingDefs.begin(); i != myFollowingDefs.end(); ++i) {
if (avoid.count(i->first) == 0) {
if ((veh == 0 || !(*i).first->prohibits(veh)) && (*i).second->describesTime(time)) {
dist.add((*i).first, (*i).second->getValue(time));
}
}
}
// if no loaded definitions are valid for this time, try to use the defaults
if (dist.getOverallProb() == 0) {
for (int i = 0; i < (int)myParsedTurnings.size(); ++i) {
if (avoid.count(myFollowingEdges[i]) == 0) {
if (veh == 0 || !myFollowingEdges[i]->prohibits(veh)) {
dist.add(static_cast<ROJTREdge*>(myFollowingEdges[i]), myParsedTurnings[i]);
}
}
}
}
// if still no valid follower exists, return null
if (dist.getOverallProb() == 0) {
return 0;
}
// return one of the possible followers
return dist.get();
}
bool
RODFDetector::writeEmitterDefinition(const std::string& file,
const std::map<size_t, RandomDistributor<size_t>* >& dists,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset,
bool includeUnusedRoutes,
SUMOReal scale,
bool insertionsOnly,
SUMOReal defaultSpeed) const {
OutputDevice& out = OutputDevice::getDevice(file);
if (getType() != SOURCE_DETECTOR) {
out.writeXMLHeader("calibrator");
}
// routes
if (myRoutes != 0 && myRoutes->get().size() != 0) {
const std::vector<RODFRouteDesc>& routes = myRoutes->get();
out.openTag(SUMO_TAG_ROUTE_DISTRIBUTION).writeAttr(SUMO_ATTR_ID, myID);
bool isEmptyDist = true;
for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i).overallProb > 0) {
isEmptyDist = false;
}
}
for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i).overallProb > 0 || includeUnusedRoutes) {
out.openTag(SUMO_TAG_ROUTE).writeAttr(SUMO_ATTR_REFID, (*i).routename).writeAttr(SUMO_ATTR_PROB, (*i).overallProb).closeTag();
}
if (isEmptyDist) {
out.openTag(SUMO_TAG_ROUTE).writeAttr(SUMO_ATTR_REFID, (*i).routename).writeAttr(SUMO_ATTR_PROB, SUMOReal(1)).closeTag();
}
}
out.closeTag(); // routeDistribution
} else {
WRITE_ERROR("Detector '" + getID() + "' has no routes!?");
return false;
}
// insertions
if (insertionsOnly || flows.knows(myID)) {
// get the flows for this detector
const std::vector<FlowDef>& mflows = flows.getFlowDefs(myID);
// go through the simulation seconds
unsigned int index = 0;
for (SUMOTime time = startTime; time < endTime; time += stepOffset, index++) {
// get own (departure flow)
assert(index < mflows.size());
const FlowDef& srcFD = mflows[index]; // !!! check stepOffset
// get flows at end
RandomDistributor<size_t>* destDist = dists.find(time) != dists.end() ? dists.find(time)->second : 0;
// go through the cars
size_t carNo = (size_t)((srcFD.qPKW + srcFD.qLKW) * scale);
for (size_t car = 0; car < carNo; ++car) {
// get the vehicle parameter
SUMOReal v = -1;
int destIndex = destDist != 0 && destDist->getOverallProb() > 0 ? (int) destDist->get() : -1;
if (srcFD.isLKW >= 1) {
srcFD.isLKW = srcFD.isLKW - (SUMOReal) 1.;
v = srcFD.vLKW;
} else {
v = srcFD.vPKW;
}
// compute insertion speed
if (v <= 0 || v > 250) {
v = defaultSpeed;
} else {
v = (SUMOReal)(v / 3.6);
}
// compute the departure time
SUMOTime ctime = (SUMOTime)(time + ((SUMOReal) stepOffset * (SUMOReal) car / (SUMOReal) carNo));
// write
out.openTag(SUMO_TAG_VEHICLE);
if (getType() == SOURCE_DETECTOR) {
out.writeAttr(SUMO_ATTR_ID, "emitter_" + myID + "_" + toString(ctime));
} else {
out.writeAttr(SUMO_ATTR_ID, "calibrator_" + myID + "_" + toString(ctime));
}
out.writeAttr(SUMO_ATTR_DEPART, time2string(ctime));
if (v > defaultSpeed) {
out.writeAttr(SUMO_ATTR_DEPARTSPEED, "max");
} else {
out.writeAttr(SUMO_ATTR_DEPARTSPEED, v);
}
out.writeAttr(SUMO_ATTR_DEPARTPOS, myPosition).writeAttr(SUMO_ATTR_DEPARTLANE, TplConvert::_2int(myLaneID.substr(myLaneID.rfind("_") + 1).c_str()));
if (destIndex >= 0) {
out.writeAttr(SUMO_ATTR_ROUTE, myRoutes->get()[destIndex].routename);
} else {
out.writeAttr(SUMO_ATTR_ROUTE, myID);
}
out.closeTag();
srcFD.isLKW += srcFD.fLKW;
}
}
}
if (getType() != SOURCE_DETECTOR) {
out.close();
}
return true;
}
bool
RODFDetector::writeEmitterDefinition(const std::string& file,
const std::map<size_t, RandomDistributor<size_t>* > &dists,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset,
bool includeUnusedRoutes,
SUMOReal scale,
bool insertionsOnly,
SUMOReal defaultSpeed) const {
OutputDevice& out = OutputDevice::getDevice(file);
if (getType() != SOURCE_DETECTOR) {
out.writeXMLHeader("calibrator");
}
// routes
if (myRoutes != 0 && myRoutes->get().size() != 0) {
const std::vector<RODFRouteDesc> &routes = myRoutes->get();
out.openTag("routeDistribution") << " id=\"" << myID << "\">\n";
bool isEmptyDist = true;
for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i).overallProb > 0) {
isEmptyDist = false;
}
}
for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i).overallProb > 0 || includeUnusedRoutes) {
out.openTag("route") << " refId=\"" << (*i).routename << "\" probability=\"" << (*i).overallProb << "\"";
out.closeTag(true);
}
if (isEmptyDist) {
out.openTag("route") << " refId=\"" << (*i).routename << "\" probability=\"1\"";
out.closeTag(true);
}
}
out.closeTag();
} else {
WRITE_ERROR("Detector '" + getID() + "' has no routes!?");
return false;
}
// emissions
if (insertionsOnly || flows.knows(myID)) {
// get the flows for this detector
const std::vector<FlowDef> &mflows = flows.getFlowDefs(myID);
// go through the simulation seconds
int index = 0;
for (SUMOTime time = startTime; time < endTime; time += stepOffset, index++) {
// get own (departure flow)
assert(index < mflows.size());
const FlowDef& srcFD = mflows[index]; // !!! check stepOffset
// get flows at end
RandomDistributor<size_t> *destDist = dists.find(time) != dists.end() ? dists.find(time)->second : 0;
// go through the cars
size_t carNo = (size_t)((srcFD.qPKW + srcFD.qLKW) * scale);
for (size_t car = 0; car < carNo; ++car) {
// get the vehicle parameter
std::string type = "test";
SUMOReal v = -1;
int destIndex = destDist != 0 && destDist->getOverallProb() > 0 ? (int) destDist->get() : -1;
if (srcFD.isLKW >= 1) {
srcFD.isLKW = srcFD.isLKW - (SUMOReal) 1.;
//!!! type = lkwTypes[vehSpeedDist.get()];
v = srcFD.vLKW;
} else {
//!!! type = pkwTypes[vehSpeedDist.get()];
v = srcFD.vPKW;
}
// compute emission speed
if (v < 0 || v > 250) {
v = defaultSpeed;
} else {
v = (SUMOReal)(v / 3.6);
}
// compute the departure time
SUMOTime ctime = (SUMOTime)(time + ((SUMOReal) stepOffset * (SUMOReal) car / (SUMOReal) carNo));
// write
out.openTag("vehicle") << " id=\"";
if (getType() == SOURCE_DETECTOR) {
out << "emitter_" << myID;
} else {
out << "calibrator_" << myID;
}
out << "_" << ctime << "\"" // !!! running
<< " depart=\"" << time2string(ctime) << "\""
<< " departSpeed=\"";
if (v > defaultSpeed) {
out << "max";
} else {
out << v;
}
out << "\" departPos=\"" << myPosition << "\""
<< " departLane=\"" << myLaneID.substr(myLaneID.rfind("_") + 1) << "\" route=\"";
if (destIndex >= 0) {
out << myRoutes->get()[destIndex].routename << "\"";
} else {
out << myID << "\"";
}
out.closeTag(true);
srcFD.isLKW += srcFD.fLKW;
}
}
}
if (getType() != SOURCE_DETECTOR) {
out.close();
}
return true;
}
bool
RODFDetector::writeEmitterDefinition(const std::string& file,
const std::map<SUMOTime, RandomDistributor<int>* >& dists,
const RODFDetectorFlows& flows,
SUMOTime startTime, SUMOTime endTime,
SUMOTime stepOffset,
bool includeUnusedRoutes,
SUMOReal scale,
bool insertionsOnly,
SUMOReal defaultSpeed) const {
OutputDevice& out = OutputDevice::getDevice(file);
OptionsCont& oc = OptionsCont::getOptions();
if (getType() != SOURCE_DETECTOR) {
out.writeXMLHeader("additional", "additional_file.xsd");
}
// routes
if (myRoutes != 0 && myRoutes->get().size() != 0) {
const std::vector<RODFRouteDesc>& routes = myRoutes->get();
out.openTag(SUMO_TAG_ROUTE_DISTRIBUTION).writeAttr(SUMO_ATTR_ID, myID);
bool isEmptyDist = true;
for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i).overallProb > 0) {
isEmptyDist = false;
}
}
for (std::vector<RODFRouteDesc>::const_iterator i = routes.begin(); i != routes.end(); ++i) {
if ((*i).overallProb > 0 || includeUnusedRoutes) {
out.openTag(SUMO_TAG_ROUTE).writeAttr(SUMO_ATTR_REFID, (*i).routename).writeAttr(SUMO_ATTR_PROB, (*i).overallProb).closeTag();
}
if (isEmptyDist) {
out.openTag(SUMO_TAG_ROUTE).writeAttr(SUMO_ATTR_REFID, (*i).routename).writeAttr(SUMO_ATTR_PROB, SUMOReal(1)).closeTag();
}
}
out.closeTag(); // routeDistribution
} else {
WRITE_ERROR("Detector '" + getID() + "' has no routes!?");
return false;
}
// insertions
if (insertionsOnly || flows.knows(myID)) {
// get the flows for this detector
const std::vector<FlowDef>& mflows = flows.getFlowDefs(myID);
// go through the simulation seconds
int index = 0;
for (SUMOTime time = startTime; time < endTime; time += stepOffset, index++) {
// get own (departure flow)
assert(index < (int)mflows.size());
const FlowDef& srcFD = mflows[index]; // !!! check stepOffset
// get flows at end
RandomDistributor<int>* destDist = dists.find(time) != dists.end() ? dists.find(time)->second : 0;
// go through the cars
int carNo = (int)((srcFD.qPKW + srcFD.qLKW) * scale);
for (int car = 0; car < carNo; ++car) {
// get the vehicle parameter
SUMOReal v = -1;
std::string vtype;
int destIndex = destDist != 0 && destDist->getOverallProb() > 0 ? (int) destDist->get() : -1;
if (srcFD.isLKW >= 1) {
srcFD.isLKW = srcFD.isLKW - (SUMOReal) 1.;
v = srcFD.vLKW;
vtype = "LKW";
} else {
v = srcFD.vPKW;
vtype = "PKW";
}
// compute insertion speed
if (v <= 0 || v > 250) {
v = defaultSpeed;
} else {
v = (SUMOReal)(v / 3.6);
}
// compute the departure time
SUMOTime ctime = (SUMOTime)(time + ((SUMOReal) stepOffset * (SUMOReal) car / (SUMOReal) carNo));
// write
out.openTag(SUMO_TAG_VEHICLE);
if (getType() == SOURCE_DETECTOR) {
out.writeAttr(SUMO_ATTR_ID, "emitter_" + myID + "_" + toString(ctime));
} else {
out.writeAttr(SUMO_ATTR_ID, "calibrator_" + myID + "_" + toString(ctime));
}
if (oc.getBool("vtype")) {
out.writeAttr(SUMO_ATTR_TYPE, vtype);
}
out.writeAttr(SUMO_ATTR_DEPART, time2string(ctime));
if (oc.isSet("departlane")) {
out.writeNonEmptyAttr(SUMO_ATTR_DEPARTLANE, oc.getString("departlane"));
} else {
out.writeAttr(SUMO_ATTR_DEPARTLANE, TplConvert::_2int(myLaneID.substr(myLaneID.rfind("_") + 1).c_str()));
}
if (oc.isSet("departpos")) {
std::string posDesc = oc.getString("departpos");
if (posDesc.substr(0, 8) == "detector") {
SUMOReal position = myPosition;
if (posDesc.length() > 8) {
if (posDesc[8] == '+') {
position += TplConvert::_2SUMOReal(posDesc.substr(9).c_str());
} else if (posDesc[8] == '-') {
position -= TplConvert::_2SUMOReal(posDesc.substr(9).c_str());
} else {
throw NumberFormatException();
}
}
out.writeAttr(SUMO_ATTR_DEPARTPOS, position);
} else {
out.writeNonEmptyAttr(SUMO_ATTR_DEPARTPOS, posDesc);
}
} else {
out.writeAttr(SUMO_ATTR_DEPARTPOS, myPosition);
}
if (oc.isSet("departspeed")) {
out.writeNonEmptyAttr(SUMO_ATTR_DEPARTSPEED, oc.getString("departspeed"));
} else {
out.writeAttr(SUMO_ATTR_DEPARTSPEED, v);
}
if (oc.isSet("arrivallane")) {
out.writeNonEmptyAttr(SUMO_ATTR_ARRIVALLANE, oc.getString("arrivallane"));
}
if (oc.isSet("arrivalpos")) {
out.writeNonEmptyAttr(SUMO_ATTR_ARRIVALPOS, oc.getString("arrivalpos"));
}
if (oc.isSet("arrivalspeed")) {
out.writeNonEmptyAttr(SUMO_ATTR_ARRIVALSPEED, oc.getString("arrivalspeed"));
}
if (destIndex >= 0) {
out.writeAttr(SUMO_ATTR_ROUTE, myRoutes->get()[destIndex].routename);
} else {
out.writeAttr(SUMO_ATTR_ROUTE, myID);
}
out.closeTag();
srcFD.isLKW += srcFD.fLKW;
}
}
}
if (getType() != SOURCE_DETECTOR) {
out.close();
}
return true;
}
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;
}
