void
MELoop::buildSegmentsFor(const MSEdge& e, const OptionsCont& oc) {
const SUMOReal length = e.getLength();
int no = numSegmentsFor(length, oc.getFloat("meso-edgelength"));
const SUMOReal slength = length / (SUMOReal)no;
const SUMOReal lengthGeometryFactor = e.getLanes()[0]->getLengthGeometryFactor();
MESegment* newSegment = 0;
MESegment* nextSegment = 0;
bool multiQueue = oc.getBool("meso-multi-queue");
bool junctionControl = oc.getBool("meso-junction-control");
for (int s = no - 1; s >= 0; s--) {
std::string id = e.getID() + ":" + toString(s);
newSegment =
new MESegment(id, e, nextSegment, slength,
e.getLanes()[0]->getSpeedLimit(), s,
string2time(oc.getString("meso-tauff")), string2time(oc.getString("meso-taufj")),
string2time(oc.getString("meso-taujf")), string2time(oc.getString("meso-taujj")),
oc.getFloat("meso-jam-threshold"), multiQueue, junctionControl,
lengthGeometryFactor);
multiQueue = false;
junctionControl = false;
nextSegment = newSegment;
}
while (e.getNumericalID() >= static_cast<int>(myEdges2FirstSegments.size())) {
myEdges2FirstSegments.push_back(0);
}
myEdges2FirstSegments[e.getNumericalID()] = newSegment;
}
void
NLHandler::closeEdge() {
// omit internal edges if not wished and broken edges
if (myCurrentIsInternalToSkip || myCurrentIsBroken) {
return;
}
try {
MSEdge* e = myEdgeControlBuilder.closeEdge();
MSEdge::dictionary(e->getID(), e);
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
}
}
void
NLHandler::addConnection(const SUMOSAXAttributes& attrs) {
bool ok = true;
std::string fromID = attrs.get<std::string>(SUMO_ATTR_FROM, 0, ok);
if (!MSGlobals::gUsingInternalLanes && fromID[0] == ':') {
return;
}
try {
bool ok = true;
const std::string toID = attrs.get<std::string>(SUMO_ATTR_TO, 0, ok);
const int fromLaneIdx = attrs.get<int>(SUMO_ATTR_FROM_LANE, 0, ok);
const int toLaneIdx = attrs.get<int>(SUMO_ATTR_TO_LANE, 0, ok);
LinkDirection dir = parseLinkDir(attrs.get<std::string>(SUMO_ATTR_DIR, 0, ok));
LinkState state = parseLinkState(attrs.get<std::string>(SUMO_ATTR_STATE, 0, ok));
std::string tlID = attrs.getOpt<std::string>(SUMO_ATTR_TLID, 0, ok, "");
#ifdef HAVE_INTERNAL_LANES
std::string viaID = attrs.getOpt<std::string>(SUMO_ATTR_VIA, 0, ok, "");
#endif
MSEdge* from = MSEdge::dictionary(fromID);
if (from == 0) {
WRITE_ERROR("Unknown from-edge '" + fromID + "' in connection");
return;
}
MSEdge* to = MSEdge::dictionary(toID);
if (to == 0) {
WRITE_ERROR("Unknown to-edge '" + toID + "' in connection");
return;
}
if (fromLaneIdx < 0 || static_cast<unsigned int>(fromLaneIdx) >= from->getLanes().size() ||
toLaneIdx < 0 || static_cast<unsigned int>(toLaneIdx) >= to->getLanes().size()) {
WRITE_ERROR("Invalid lane index in connection from '" + from->getID() + "' to '" + to->getID() + "'.");
return;
}
MSLane* fromLane = from->getLanes()[fromLaneIdx];
MSLane* toLane = to->getLanes()[toLaneIdx];
assert(fromLane);
assert(toLane);
int tlLinkIdx = -1;
if (tlID != "") {
tlLinkIdx = attrs.get<int>(SUMO_ATTR_TLLINKINDEX, 0, ok);
// make sure that the index is in range
MSTrafficLightLogic* logic = myJunctionControlBuilder.getTLLogic(tlID).getActive();
if (tlLinkIdx < 0 || tlLinkIdx >= (int)logic->getCurrentPhaseDef().getState().size()) {
WRITE_ERROR("Invalid " + toString(SUMO_ATTR_TLLINKINDEX) + " '" + toString(tlLinkIdx) +
"' in connection controlled by '" + tlID + "'");
return;
}
if (!ok) {
return;
}
}
SUMOReal length = fromLane->getShape()[-1].distanceTo(toLane->getShape()[0]);
MSLink* link = 0;
// build the link
#ifdef HAVE_INTERNAL_LANES
MSLane* via = 0;
if (viaID != "" && MSGlobals::gUsingInternalLanes) {
via = MSLane::dictionary(viaID);
if (via == 0) {
WRITE_ERROR("An unknown lane ('" + viaID +
"') should be set as a via-lane for lane '" + toLane->getID() + "'.");
return;
}
length = via->getLength();
}
link = new MSLink(toLane, via, dir, state, length);
if (via != 0) {
via->addIncomingLane(fromLane, link);
} else {
toLane->addIncomingLane(fromLane, link);
}
#else
link = new MSLink(toLane, dir, state, length);
toLane->addIncomingLane(fromLane, link);
#endif
toLane->addApproachingLane(fromLane);
// if a traffic light is responsible for it, inform the traffic light
// check whether this link is controlled by a traffic light
if (tlID != "") {
myJunctionControlBuilder.getTLLogic(tlID).addLink(link, fromLane, tlLinkIdx);
}
// add the link
fromLane->addLink(link);
} catch (InvalidArgument& e) {
WRITE_ERROR(e.what());
}
}
/* -------------------------------------------------------------------------
* MSPerson::MSPersonStage_Waiting - methods
* ----------------------------------------------------------------------- */
MSPerson::MSPersonStage_Waiting::MSPersonStage_Waiting(const MSEdge& destination,
SUMOTime duration, SUMOTime until, SUMOReal pos, const std::string& actType) :
MSTransportable::Stage(destination, 0, SUMOVehicleParameter::interpretEdgePos(
pos, destination.getLength(), SUMO_ATTR_DEPARTPOS, "person stopping at " + destination.getID()), WAITING),
myWaitingDuration(duration),
myWaitingUntil(until),
myActType(actType) {
}
void
MSXMLRawOut::writeEdge(OutputDevice& of, const MSEdge& edge, SUMOTime timestep) {
//en
bool dump = !MSGlobals::gOmitEmptyEdgesOnDump;
if (!dump) {
#ifdef HAVE_INTERNAL
if (MSGlobals::gUseMesoSim) {
MESegment* seg = MSGlobals::gMesoNet->getSegmentForEdge(edge);
while (seg != 0) {
if (seg->getCarNumber() != 0) {
dump = true;
break;
}
seg = seg->getNextSegment();
}
} else {
#endif
const std::vector<MSLane*>& lanes = edge.getLanes();
for (std::vector<MSLane*>::const_iterator lane = lanes.begin(); lane != lanes.end(); ++lane) {
if (((**lane).getVehicleNumber() != 0)) {
dump = true;
break;
}
}
#ifdef HAVE_INTERNAL
}
#endif
}
//en
const std::vector<MSPerson*>& persons = edge.getSortedPersons(timestep);
if (dump || persons.size() > 0) {
of.openTag("edge") << " id=\"" << edge.getID() << "\"";
if (dump) {
#ifdef HAVE_INTERNAL
if (MSGlobals::gUseMesoSim) {
MESegment* seg = MSGlobals::gMesoNet->getSegmentForEdge(edge);
while (seg != 0) {
seg->writeVehicles(of);
seg = seg->getNextSegment();
}
} else {
#endif
const std::vector<MSLane*>& lanes = edge.getLanes();
for (std::vector<MSLane*>::const_iterator lane = lanes.begin(); lane != lanes.end(); ++lane) {
writeLane(of, **lane);
}
#ifdef HAVE_INTERNAL
}
#endif
}
// write persons
for (std::vector<MSPerson*>::const_iterator it_p = persons.begin(); it_p != persons.end(); ++it_p) {
of.openTag(SUMO_TAG_PERSON);
of.writeAttr(SUMO_ATTR_ID, (*it_p)->getID());
of.writeAttr(SUMO_ATTR_POSITION, (*it_p)->getEdgePos());
of.writeAttr(SUMO_ATTR_ANGLE, (*it_p)->getAngle());
of.writeAttr("stage", (*it_p)->getCurrentStageDescription());
of.closeTag();
}
of.closeTag();
}
}