bool
MSInductLoop::notifyMove(SUMOVehicle& veh, SUMOReal oldPos,
SUMOReal newPos, SUMOReal newSpeed) {
if (newPos < myPosition) {
// detector not reached yet
return true;
}
if (newPos >= myPosition && oldPos < myPosition) {
// entered the detector by move
SUMOReal entryTime = STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep());
if (newSpeed != 0) {
if (myPosition > oldPos) {
entryTime += (myPosition - oldPos) / newSpeed;
}
}
enterDetectorByMove(veh, entryTime);
}
if (newPos - veh.getVehicleType().getLength() > myPosition) {
// vehicle passed the detector
SUMOReal leaveTime = STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep());
leaveTime += (myPosition - oldPos + veh.getVehicleType().getLength()) / newSpeed;
leaveDetectorByMove(veh, leaveTime);
return false;
}
// vehicle stays on the detector
return true;
}
GUIParameterTableWindow*
GUICalibrator::getParameterWindow(GUIMainWindow& app,
GUISUMOAbstractView&) {
GUIParameterTableWindow* ret;
if (isActive()) {
ret = new GUIParameterTableWindow(app, *this, 10);
// add items
ret->mkItem("interval start", false, STEPS2TIME(myCurrentStateInterval->begin));
ret->mkItem("interval end", false, STEPS2TIME(myCurrentStateInterval->end));
ret->mkItem("aspired flow [veh/h]", false, myCurrentStateInterval->q);
ret->mkItem("aspired speed", false, myCurrentStateInterval->v);
ret->mkItem("default speed", false, myDefaultSpeed);
ret->mkItem("required vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::totalWished));
ret->mkItem("passed vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::passed));
ret->mkItem("inserted vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::inserted));
ret->mkItem("removed vehicles", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::removed));
ret->mkItem("cleared in jam", true, new FunctionBinding<GUICalibrator, int>(this, &GUICalibrator::clearedInJam));
} else {
ret = new GUIParameterTableWindow(app, *this, 1);
const std::string nextStart =
(myCurrentStateInterval != myIntervals.end() ?
time2string(myCurrentStateInterval->begin) :
"simulation end");
ret->mkItem("inactive until", false, nextStart);
}
// close building
ret->closeBuilding();
return ret;
}
void
MSTLLogicControl::WAUTSwitchProcedure_Stretch::stretchLogic(SUMOTime step, SUMOTime startPos, SUMOTime allStretchTime) {
unsigned int currStep = myTo->getIndexFromOffset(startPos);
SUMOTime durOfPhase = myTo->getPhase(currStep).duration;
SUMOTime remainingStretchTime = allStretchTime;
SUMOTime StretchTimeOfPhase = 0;
unsigned int stretchUmlaufAnz = (unsigned int) TplConvert::_2SUMOReal(myTo->getParameterValue("StretchUmlaufAnz").c_str());
SUMOReal facSum = 0;
int areasNo = getStretchAreaNo(myTo);
for (int x = 0; x < areasNo; x++) {
StretchBereichDef def = getStretchBereichDef(myTo, x + 1);
facSum += def.fac;
}
facSum *= stretchUmlaufAnz;
//switch to startPos and stretch this phase, if there is a end of "bereich" between startpos and end of phase
SUMOTime diffToStart = getDiffToStartOfPhase(*myTo, startPos);
for (int x = 0; x < areasNo; x++) {
StretchBereichDef def = getStretchBereichDef(myTo, x + 1);
SUMOTime end = TIME2STEPS(def.end);
SUMOTime endOfPhase = (startPos + durOfPhase - diffToStart);
if (end <= endOfPhase && end >= startPos) {
SUMOReal fac = def.fac;
SUMOReal actualfac = fac / facSum;
facSum = facSum - fac;
StretchTimeOfPhase = TIME2STEPS(int(STEPS2TIME(remainingStretchTime) * actualfac + 0.5));
remainingStretchTime = allStretchTime - StretchTimeOfPhase;
}
}
if (facSum == 0) {
WRITE_WARNING("The computed factor sum in WAUT '" + myWAUT.id + "' at time '" + toString(STEPS2TIME(step)) + "' equals zero;\n assuming an error in WAUT definition.");
return;
}
durOfPhase = durOfPhase - diffToStart + StretchTimeOfPhase;
myTo->changeStepAndDuration(myControl, step, currStep, durOfPhase);
currStep = (currStep + 1) % (int)myTo->getPhases().size();
// stretch all other phases, if there is a "bereich"
while (remainingStretchTime > 0) {
for (unsigned int i = currStep; i < myTo->getPhases().size() && remainingStretchTime > 0; i++) {
durOfPhase = myTo->getPhase(i).duration;
SUMOTime beginOfPhase = myTo->getOffsetFromIndex(i);
SUMOTime endOfPhase = beginOfPhase + durOfPhase;
for (int j = 0; j < areasNo && remainingStretchTime > 0; j++) {
StretchBereichDef def = getStretchBereichDef(myTo, j + 1);
SUMOTime end = TIME2STEPS(def.end);
SUMOReal fac = def.fac;
if ((beginOfPhase <= end) && (endOfPhase >= end)) {
SUMOReal actualfac = fac / facSum;
StretchTimeOfPhase = TIME2STEPS(int(STEPS2TIME(remainingStretchTime) * actualfac + 0.5));
facSum -= fac;
durOfPhase += StretchTimeOfPhase;
remainingStretchTime -= StretchTimeOfPhase;
}
}
myTo->addOverridingDuration(durOfPhase);
}
currStep = 0;
}
}
void MSInductLoop::writeXMLOutput(OutputDevice &dev,
SUMOTime startTime, SUMOTime stopTime) throw(IOError) {
SUMOReal t(STEPS2TIME(stopTime-startTime));
unsigned nVehCrossed ;
SUMOReal flow ;
SUMOReal occupancy = 0;
SUMOReal meanLength, meanSpeed;
dev.openTag("interval");
dev <<" begin=\""<<time2string(startTime)<<"\" end=\""<<
time2string(stopTime)<<"\" \n";
unsigned totVeh = 0;
for(unsigned stripIndex=0;stripIndex<myStripCount;stripIndex++){
int no_vehicles = myVehicleDataCont[stripIndex].size();
nVehCrossed = (unsigned) no_vehicles;
flow = ((SUMOReal) no_vehicles / (SUMOReal) t) * (SUMOReal) 3600.0;
for (std::deque< VehicleData >::const_iterator i=myVehicleDataCont[stripIndex].begin(); i!=myVehicleDataCont[stripIndex].end(); ++i) {
SUMOReal timeOnDetDuringInterval = (*i).leaveTimeM - MAX2(STEPS2TIME(startTime), (*i).entryTimeM);
timeOnDetDuringInterval = MIN2(timeOnDetDuringInterval, t);
occupancy += timeOnDetDuringInterval;
}
for (std::map< MSVehicle*, SUMOReal >::const_iterator i=myVehiclesOnDet[stripIndex].begin(); i!=myVehiclesOnDet[stripIndex].end(); ++i) {
SUMOReal timeOnDetDuringInterval = STEPS2TIME(stopTime) - MAX2(STEPS2TIME(startTime), (*i).second);
occupancy += timeOnDetDuringInterval;
}
occupancy = no_vehicles!=0 ? occupancy / t * (SUMOReal) 100.0 : 0;
meanSpeed = no_vehicles!=0
? accumulate(myVehicleDataCont[stripIndex].begin(), myVehicleDataCont[stripIndex].end(), (SUMOReal) 0.0, speedSum) / (SUMOReal) myVehicleDataCont[stripIndex].size()
: -1;
meanLength = no_vehicles!=0
? accumulate(myVehicleDataCont[stripIndex].begin(), myVehicleDataCont[stripIndex].end(), (SUMOReal) 0.0, lengthSum) / (SUMOReal) myVehicleDataCont[stripIndex].size()
: -1;
if(no_vehicles >= 1){
dev <<"\tstripNum=\""<<stripIndex<<" \"vehicle_id=\""<< (myVehicleDataCont[stripIndex].begin())->idM
<<"\" flow=\""<<flow<<
"\" occupancy=\""<<occupancy<<"\" speed=\""<<meanSpeed<<
"\" length=\""<<meanLength<<
"\" nVehEntered=\""<<no_vehicles<<"\" \n";
totVeh += no_vehicles;
}
else {
dev << "\tstripNum=\""<<stripIndex
<<"\" flow=\""<<flow<<
"\" occupancy=\""<<occupancy<<"\" speed=\""<<meanSpeed<<
"\" length=\""<<meanLength<<
"\" nVehEntered=\""<<no_vehicles<<"\" \n";
totVeh += no_vehicles;
}
}
dev << "total_Vehicles=\" "<<totVeh + myDismissedVehicleNumber <<"\"";
dev.closeTag(true);
reset();
}
void
MSMeanData_Net::MSLaneMeanDataValues::write(OutputDevice& dev, const SUMOTime period,
const SUMOReal numLanes, const SUMOReal defaultTravelTime, const int numVehicles) const {
if (myParent == 0) {
if (sampleSeconds > 0) {
dev << "\" density=\"" << sampleSeconds / STEPS2TIME(period) *(SUMOReal) 1000 / myLaneLength <<
"\" occupancy=\"" << vehLengthSum / STEPS2TIME(period) / myLaneLength / numLanes *(SUMOReal) 100 <<
"\" waitingTime=\"" << waitSeconds <<
"\" speed=\"" << travelledDistance / sampleSeconds;
}
dev << "\" departed=\"" << nVehDeparted <<
"\" arrived=\"" << nVehArrived <<
"\" entered=\"" << nVehEntered <<
"\" left=\"" << nVehLeft << "\"";
if (nVehVaporized > 0) {
dev << " vaporized=\"" << nVehVaporized << "\"";
}
dev.closeTag();
return;
}
if (sampleSeconds > myParent->myMinSamples) {
SUMOReal traveltime = myParent->myMaxTravelTime;
if (travelledDistance > 0.f) {
traveltime = MIN2(traveltime, myLaneLength * sampleSeconds / travelledDistance);
}
if (numVehicles > 0) {
dev << "\" traveltime=\"" << sampleSeconds / numVehicles <<
"\" waitingTime=\"" << waitSeconds <<
"\" speed=\"" << travelledDistance / sampleSeconds;
} else {
dev << "\" traveltime=\"" << traveltime <<
"\" density=\"" << sampleSeconds / STEPS2TIME(period) *(SUMOReal) 1000 / myLaneLength <<
"\" occupancy=\"" << vehLengthSum / STEPS2TIME(period) / myLaneLength / numLanes *(SUMOReal) 100 <<
"\" waitingTime=\"" << waitSeconds <<
"\" speed=\"" << travelledDistance / sampleSeconds;
}
} else if (defaultTravelTime >= 0.) {
dev << "\" traveltime=\"" << defaultTravelTime <<
"\" speed=\"" << myLaneLength / defaultTravelTime;
}
dev << "\" departed=\"" << nVehDeparted <<
"\" arrived=\"" << nVehArrived <<
"\" entered=\"" << nVehEntered <<
"\" left=\"" << nVehLeft <<
"\" laneChangedFrom=\"" << nVehLaneChangeFrom <<
"\" laneChangedTo=\"" << nVehLaneChangeTo << "\"";
if (nVehVaporized > 0) {
dev << " vaporized=\"" << nVehVaporized << "\"";
}
dev.closeTag();
}
bool
MSInductLoop::isStillActive(MSVehicle& veh, SUMOReal oldPos,
SUMOReal newPos, SUMOReal newSpeed) throw() {
if (newPos < myPosition) {
// detector not reached yet
return true;
}
int mainStripNum = 0;int flag =0;
for( MSLane::StripContIter it = myLane->myStrips.begin(); it!=myLane->myStrips.end();
it ++){
if(veh.isMainStrip(**it)){
flag=1;
break;
}
mainStripNum++;
}
if (flag == 1 && myVehiclesOnDet[mainStripNum].find(&veh) == myVehiclesOnDet[mainStripNum].end()) {
// entered the detector by move
SUMOReal entryTime = STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep());
if (newSpeed!=0) {
entryTime += (myPosition - oldPos) / newSpeed;
}
if (newPos - veh.getVehicleType().getLength() > myPosition) {
// entered and passed detector in a single timestep
SUMOReal leaveTime = STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep());
leaveTime += (myPosition - oldPos + veh.getVehicleType().getLength()) / newSpeed;
enterDetectorByMove(veh, entryTime);
leaveDetectorByMove(veh, leaveTime);
return false;
}
// entered detector, but not passed
enterDetectorByMove(veh, entryTime);
return true;
}
else if(flag==1){
// vehicle has been on the detector the previous timestep
if (newPos - veh.getVehicleType().getLength() >= myPosition) {
// vehicle passed the detector
SUMOReal leaveTime = STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep());
leaveTime += (myPosition - oldPos + veh.getVehicleType().getLength()) / newSpeed;
leaveDetectorByMove(veh, leaveTime);
return false;
}
// vehicle stays on the detector
return true;
}
else {std::cerr<<"Main strip not found\n";}
}
GUIParameterTableWindow*
GUIVehicle::getTypeParameterWindow(GUIMainWindow& app,
GUISUMOAbstractView&) {
GUIParameterTableWindow* ret =
new GUIParameterTableWindow(app, *this, 26
+ (int)myType->getParameter().getParametersMap().size()
+ (int)myType->getParameter().lcParameter.size()
+ (int)myType->getParameter().jmParameter.size());
// add items
ret->mkItem("Type Information:", false, "");
ret->mkItem("type [id]", false, myType->getID());
ret->mkItem("length", false, myType->getLength());
ret->mkItem("width", false, myType->getWidth());
ret->mkItem("height", false, myType->getHeight());
ret->mkItem("minGap", false, myType->getMinGap());
ret->mkItem("vehicle class", false, SumoVehicleClassStrings.getString(myType->getVehicleClass()));
ret->mkItem("emission class", false, PollutantsInterface::getName(myType->getEmissionClass()));
ret->mkItem("carFollowModel", false, SUMOXMLDefinitions::CarFollowModels.getString((SumoXMLTag)getCarFollowModel().getModelID()));
ret->mkItem("LaneChangeModel", false, SUMOXMLDefinitions::LaneChangeModels.getString(getLaneChangeModel().getModelID()));
ret->mkItem("guiShape", false, getVehicleShapeName(myType->getGuiShape()));
ret->mkItem("maximum speed [m/s]", false, getMaxSpeed());
ret->mkItem("maximum acceleration [m/s^2]", false, getCarFollowModel().getMaxAccel());
ret->mkItem("maximum deceleration [m/s^2]", false, getCarFollowModel().getMaxDecel());
ret->mkItem("emergency deceleration [m/s^2]", false, getCarFollowModel().getEmergencyDecel());
ret->mkItem("apparent deceleration [m/s^2]", false, getCarFollowModel().getApparentDecel());
ret->mkItem("imperfection (sigma)", false, getCarFollowModel().getImperfection());
ret->mkItem("desired headway (tau)", false, getCarFollowModel().getHeadwayTime());
ret->mkItem("person capacity", false, myType->getPersonCapacity());
ret->mkItem("boarding time", false, STEPS2TIME(myType->getBoardingDuration()));
ret->mkItem("container capacity", false, myType->getContainerCapacity());
ret->mkItem("loading time", false, STEPS2TIME(myType->getLoadingDuration()));
if (MSGlobals::gLateralResolution > 0) {
ret->mkItem("minGapLat", false, myType->getMinGapLat());
ret->mkItem("maxSpeedLat", false, myType->getMaxSpeedLat());
ret->mkItem("latAlignment", false, toString(myType->getPreferredLateralAlignment()));
} else if (MSGlobals::gLaneChangeDuration > 0) {
ret->mkItem("maxSpeedLat", false, myType->getMaxSpeedLat());
}
for (auto item : myType->getParameter().lcParameter) {
ret->mkItem(toString(item.first).c_str(), false, toString(item.second));
}
for (auto item : myType->getParameter().jmParameter) {
ret->mkItem(toString(item.first).c_str(), false, toString(item.second));
}
// close building
ret->closeBuilding(&(myType->getParameter()));
return ret;
}
void
GNETLSEditorFrame::initPhaseTable(unsigned int index) {
myPhaseTable->setVisibleRows(1);
myPhaseTable->setVisibleColumns(2);
myPhaseTable->hide();
if (myDefinitions.size() > 0) {
const std::vector<NBTrafficLightLogic::PhaseDefinition>& phases = getPhases();
myPhaseTable->setTableSize((int)phases.size(), 2);
myPhaseTable->setVisibleRows((int)phases.size());
myPhaseTable->setVisibleColumns(2);
for (unsigned int row = 0; row < phases.size(); row++) {
myPhaseTable->setItemText(row, 0, toString(STEPS2TIME(phases[row].duration)).c_str());
myPhaseTable->setItemText(row, 1, phases[row].state.c_str());
myPhaseTable->getItem(row, 1)->setJustify(FXTableItem::LEFT);
}
myPhaseTable->fitColumnsToContents(0, 2);
const int maxWidth = 140 - 4;
int desiredWidth = myPhaseTable->getColumnWidth(0) +
myPhaseTable->getColumnWidth(1) + 3;
int spaceForScrollBar = desiredWidth > maxWidth ? 15 : 0;
myPhaseTable->setHeight((int)phases.size() * 21 + spaceForScrollBar); // experimental
myPhaseTable->setWidth(MIN2(desiredWidth, maxWidth));
myPhaseTable->setCurrentItem(index, 0);
myPhaseTable->selectRow(index, true);
myPhaseTable->show();
myPhaseTable->setFocus();
}
update();
}
void
ODMatrix::writeFlows(const SUMOTime begin, const SUMOTime end,
OutputDevice& dev, bool noVtype,
const std::string& prefix,
bool asProbability) {
if (myContainer.size() == 0) {
return;
}
int flowName = 0;
sortByBeginTime();
// recheck begin time
for (std::vector<ODCell*>::const_iterator i = myContainer.begin(); i != myContainer.end(); ++i) {
const ODCell* const c = *i;
if (c->end > begin && c->begin < end) {
dev.openTag(SUMO_TAG_FLOW).writeAttr(SUMO_ATTR_ID, prefix + toString(flowName++));
dev.writeAttr(SUMO_ATTR_BEGIN, time2string(c->begin));
dev.writeAttr(SUMO_ATTR_END, time2string(c->end));
if (!asProbability) {
dev.writeAttr(SUMO_ATTR_NUMBER, int(c->vehicleNumber));
} else {
const double probability = float(c->vehicleNumber) / STEPS2TIME(c->end - c->begin);
if (probability > 1) {
WRITE_WARNING("Flow density of " + toString(probability) + " vehicles per second, cannot be represented with a simple probability. Falling back to even spacing.");
dev.writeAttr(SUMO_ATTR_NUMBER, int(c->vehicleNumber));
} else {
dev.setPrecision(6);
dev.writeAttr(SUMO_ATTR_PROB, probability);
dev.setPrecision();
}
}
writeDefaultAttrs(dev, noVtype, *i);
dev.closeTag();
}
}
}
SUMOTime
MESegment::newArrival(const MEVehicle* const v, SUMOReal newSpeed, SUMOTime currentTime) {
// since speed is only an upper bound pos may be to optimistic
const SUMOReal pos = MIN2(myLength, STEPS2TIME(currentTime - v->getLastEntryTime()) * v->getSpeed());
// traveltime may not be 0
return currentTime + MAX2(TIME2STEPS((myLength - pos) / newSpeed), SUMOTime(1));
}
long
GNETLSEditorFrame::onCmdPhaseEdit(FXObject*, FXSelector, void* ptr) {
/* @note: there is a bug when copying/pasting rows: when this handler is
* called the value of the cell is not yet updated. This means you have to
* click inside the cell and hit enter to actually update the value */
FXTablePos* tp = (FXTablePos*)ptr;
FXString value = myPhaseTable->getItemText(tp->row, tp->col);
if (tp->col == 0) {
// duration edited
if (GNEAttributeCarrier::canParse<SUMOReal>(value.text())) {
SUMOTime duration = getSUMOTime(value);
if (duration > 0) {
myEditedDef->getLogic()->setPhaseDuration(tp->row, duration);
myHaveModifications = true;
updateCycleDuration();
return 1;
}
}
// input error, reset value
myPhaseTable->setItemText(tp->row, 0, toString(STEPS2TIME(getPhases()[tp->row].duration)).c_str());
} else {
// state edited
try {
// insert phase with new step and delete the old phase
myEditedDef->getLogic()->addStep(getPhases()[tp->row].duration, value.text(), tp->row);
myEditedDef->getLogic()->deletePhase(tp->row + 1);
myHaveModifications = true;
onCmdPhaseSwitch(0, 0, 0);
} catch (ProcessError) {
// input error, reset value
myPhaseTable->setItemText(tp->row, 1, getPhases()[tp->row].state.c_str());
}
}
return 1;
}
long
GNETLSEditorFrame::onCmdDefSwitch(FXObject*, FXSelector, void*) {
assert(myCurrentJunction != 0);
assert((int)myDefinitions.size() == myProgramComboBox->getNumItems());
NBTrafficLightDefinition* tlDef = myDefinitions[myProgramComboBox->getCurrentItem()];
// logic may not have been recomputed yet. recompute to be sure
NBTrafficLightLogicCont& tllCont = myViewNet->getNet()->getTLLogicCont();
myViewNet->getNet()->computeJunction(myCurrentJunction);
NBTrafficLightLogic* tllogic = tllCont.getLogic(tlDef->getID(), tlDef->getProgramID());
if (tllogic != 0) {
// now we can be sure that the tlDef is up to date (i.e. re-guessed)
buildIinternalLanes(tlDef);
// create working copy from original def
delete myEditedDef;
myEditedDef = new NBLoadedSUMOTLDef(tlDef, tllogic);
myOffset->setText(toString(STEPS2TIME(myEditedDef->getLogic()->getOffset())).c_str());
initPhaseTable();
updateCycleDuration();
} else {
// tlDef has no valid logic (probably because id does not control any links
onCmdCancel(0, 0, 0);
myViewNet->setStatusBarText("Traffic light does not control any links");
}
return 1;
}
void
MSCalibrator::writeXMLOutput() {
if (myOutput != nullptr) {
updateMeanData();
const int p = passed();
// meandata will be off if vehicles are removed on the next edge instead of this one
const int discrepancy = myEdgeMeanData.nVehEntered + myEdgeMeanData.nVehDeparted - myEdgeMeanData.nVehVaporized - passed();
assert(discrepancy >= 0);
const std::string ds = (discrepancy > 0 ? "\" vaporizedOnNextEdge=\"" + toString(discrepancy) : "");
const double durationSeconds = STEPS2TIME(myCurrentStateInterval->end - myCurrentStateInterval->begin);
(*myOutput) << " <interval begin=\"" << time2string(myCurrentStateInterval->begin) <<
"\" end=\"" << time2string(myCurrentStateInterval->end) <<
"\" id=\"" << myID <<
"\" nVehContrib=\"" << p <<
"\" removed=\"" << myRemoved <<
"\" inserted=\"" << myInserted <<
"\" cleared=\"" << myClearedInJam <<
"\" flow=\"" << p * 3600.0 / durationSeconds <<
"\" aspiredFlow=\"" << myCurrentStateInterval->q <<
"\" speed=\"" << myEdgeMeanData.getTravelledDistance() / myEdgeMeanData.getSamples() <<
"\" aspiredSpeed=\"" << myCurrentStateInterval->v <<
ds << //optional
"\"/>\n";
}
myDidSpeedAdaption = false;
myInserted = 0;
myRemoved = 0;
myClearedInJam = 0;
myHaveWarnedAboutClearingJam = false;
reset();
}
void MSNet::closeSimulation(SUMOTime start)
{
if (myLogExecutionTime) {
long duration = SysUtils::getCurrentMillis() - mySimBeginMillis;
std::ostringstream msg;
msg << "Performance: " << "\n" << " Duration: " << duration << " ms" << "\n";
if (duration != 0) {
msg << " Real time factor: " << (STEPS2TIME(myStep - start) * 1000. / (SUMOReal)duration) << "\n";
msg.setf(std::ios::fixed , std::ios::floatfield); // use decimal format
msg.setf(std::ios::showpoint); // print decimal point
msg << " UPS: " << ((SUMOReal) myVehiclesMoved * 1000. / (SUMOReal) duration) << "\n";
}
const std::string scaleNotice = ((myVehicleControl->getLoadedVehicleNo() != myVehicleControl->getDepartedVehicleNo()) ?
" (Loaded: " + toString(myVehicleControl->getLoadedVehicleNo()) + ")" : "");
msg << "Vehicles: " << "\n"
<< " Emitted: " << myVehicleControl->getDepartedVehicleNo() << scaleNotice << "\n"
<< " Running: " << myVehicleControl->getRunningVehicleNo() << "\n"
<< " Waiting: " << myInserter->getWaitingVehicleNo() << "\n";
WRITE_MESSAGE(msg.str());
}
myDetectorControl->close(myStep);
#ifndef NO_TRACI
traci::TraCIServer::close();
#endif
}
void MSEdge::recalcCache() {
if (myLanes->empty()) {
return;
}
myLength = myLanes->front()->getLength();
myEmptyTraveltime = myLength / MAX2(getSpeedLimit(), NUMERICAL_EPS);
if (MSGlobals::gMesoTLSPenalty > 0 || MSGlobals::gMesoMinorPenalty > 0) {
// add tls penalties to the minimum travel time
SUMOTime minPenalty = -1;
for (std::vector<MSLane*>::const_iterator i = myLanes->begin(); i != myLanes->end(); ++i) {
MSLane* l = *i;
const MSLinkCont& lc = l->getLinkCont();
for (MSLinkCont::const_iterator j = lc.begin(); j != lc.end(); ++j) {
MSLink* link = *j;
SUMOTime linkPenalty = link->getMesoTLSPenalty() + (link->havePriority() ? 0 : MSGlobals::gMesoMinorPenalty);
if (minPenalty == -1) {
minPenalty = linkPenalty;
} else {
minPenalty = MIN2(minPenalty, linkPenalty);
}
}
}
if (minPenalty > 0) {
myEmptyTraveltime += STEPS2TIME(minPenalty);
}
}
}
bool
MSE3Collector::MSE3EntryReminder::notifyMove(SUMOVehicle& veh, double oldPos,
double newPos, double newSpeed) {
if (myCollector.myEnteredContainer.find(&veh) == myCollector.myEnteredContainer.end() && newPos > myPosition) {
if (oldPos > myPosition) {
// was behind the detector already in the last step
return false;
} else {
// entered in this step
const double oldSpeed = veh.getPreviousSpeed();
const double entryTime = STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep());
assert(!MSGlobals::gSemiImplicitEulerUpdate || newSpeed != 0); // how could it move across the detector otherwise
const double timeBeforeEnter = MSCFModel::passingTime(oldPos, myPosition, newPos, oldSpeed, newSpeed);
const double fractionTimeOnDet = TS - timeBeforeEnter;
myCollector.enter(veh, entryTime - fractionTimeOnDet, fractionTimeOnDet);
#ifdef DEBUG_E3_NOTIFY_MOVE
if (DEBUG_COND(myCollector) && DEBUG_COND_VEH(veh)) {
std::cout << "\n" << SIMTIME
<< " MSE3EntryReminder::notifyMove() (" << getDescription() << "on lane '" << myLane->getID() << "')"
<< " vehicle '" << veh.getID() << "'"
<< " entered. oldPos=" << oldPos << " newPos=" << newPos << " newSpeed=" << newSpeed << "\n";
}
#endif
}
}
return true;
}
void
MSE3Collector::enter(const SUMOVehicle& veh, const double entryTimestep, const double fractionTimeOnDet) {
if (!vehicleApplies(veh)) {
return;
}
if (myEnteredContainer.find(&veh) != myEnteredContainer.end()) {
WRITE_WARNING("Vehicle '" + veh.getID() + "' reentered " + toString(SUMO_TAG_E3DETECTOR) + " '" + getID() + "'.");
return;
}
const double speedFraction = veh.getSpeed() * fractionTimeOnDet;
E3Values v;
v.entryTime = entryTimestep;
v.frontLeaveTime = 0;
v.backLeaveTime = 0;
v.speedSum = speedFraction;
v.haltingBegin = veh.getSpeed() < myHaltingSpeedThreshold ? entryTimestep : -1;
v.intervalSpeedSum = entryTimestep >= STEPS2TIME(myLastResetTime) ? speedFraction : 0;
v.haltings = 0;
v.intervalHaltings = 0;
if (veh.getSpeed() < myHaltingSpeedThreshold) {
if (fractionTimeOnDet > myHaltingTimeThreshold) {
v.haltings++;
v.intervalHaltings++;
}
}
v.hadUpdate = false;
if (!MSGlobals::gUseMesoSim) {
v.timeLoss = static_cast<const MSVehicle&>(veh).getTimeLoss();
v.intervalTimeLoss = v.timeLoss;
}
myEnteredContainer[&veh] = v;
}
std::string
MSDevice_Tripinfo::printStatistics() {
std::ostringstream msg;
msg.setf(msg.fixed);
msg.precision(gPrecision);
msg << "Statistics (avg):\n"
<< " RouteLength: " << getAvgRouteLength() << "\n"
<< " Duration: " << getAvgDuration() << "\n"
<< " WaitingTime: " << getAvgWaitingTime() << "\n"
<< " TimeLoss: " << getAvgTimeLoss() << "\n"
<< " DepartDelay: " << getAvgDepartDelay() << "\n";
if (myWaitingDepartDelay >= 0) {
msg << " DepartDelayWaiting: " << STEPS2TIME(myWaitingDepartDelay) << "\n";
}
if (myWalkCount > 0) {
msg << "Pedestrian Statistics (avg of " << myWalkCount << " walks):\n"
<< " RouteLength: " << getAvgWalkRouteLength() << "\n"
<< " Duration: " << getAvgWalkDuration() << "\n"
<< " TimeLoss: " << getAvgWalkTimeLoss() << "\n";
}
if (myRideCount > 0) {
msg << "Ride Statistics (avg of " << myRideCount << " rides):\n"
<< " WaitingTime: " << getAvgRideWaitingTime() << "\n"
<< " RouteLength: " << getAvgRideRouteLength() << "\n"
<< " Duration: " << getAvgRideDuration() << "\n"
<< " Bus: " << myRideBusCount << "\n"
<< " Train: " << myRideRailCount << "\n"
<< " Bike: " << myRideBikeCount << "\n"
<< " Aborted: " << myRideAbortCount << "\n";
}
return msg.str();
}
void
MSE3Collector::detectorUpdate(const SUMOTime step) {
myCurrentMeanSpeed = 0;
myCurrentHaltingsNumber = 0;
for (std::map<const SUMOVehicle*, E3Values>::iterator pair = myEnteredContainer.begin(); pair != myEnteredContainer.end(); ++pair) {
const SUMOVehicle* veh = pair->first;
E3Values& values = pair->second;
myCurrentMeanSpeed += veh->getSpeed();
values.hadUpdate = true;
values.speedSum += veh->getSpeed() * TS;
values.intervalSpeedSum += veh->getSpeed() * TS;
if (veh->getSpeed() < myHaltingSpeedThreshold) {
if (values.haltingBegin == -1) {
values.haltingBegin = STEPS2TIME(step);
}
if (step - values.haltingBegin > myHaltingTimeThreshold) {
values.haltings++;
values.intervalHaltings++;
myCurrentHaltingsNumber++;
}
} else {
values.haltingBegin = -1;
}
}
if (myEnteredContainer.size() == 0) {
myCurrentMeanSpeed = -1;
} else {
myCurrentMeanSpeed /= myEnteredContainer.size();
}
}
std::vector<MSInductLoop::VehicleData>
MSInductLoop::collectVehiclesOnDet(SUMOTime tMS) const throw() {
SUMOReal t = STEPS2TIME(tMS);
std::vector<VehicleData> ret;
for(unsigned stripIndex = 0;stripIndex!=myStripCount; stripIndex ++){
for (VehicleDataCont::const_iterator i=myVehicleDataCont[stripIndex].begin(); i!=myVehicleDataCont[stripIndex].end(); ++i) {
if ((*i).leaveTimeM>=t) {
ret.push_back(*i);
}
}
for (VehicleDataCont::const_iterator i=myLastVehicleDataCont[stripIndex].begin(); i!=myLastVehicleDataCont[stripIndex].end(); ++i) {
if ((*i).leaveTimeM>=t) {
ret.push_back(*i);
}
}
/*SUMOTime ct = MSNet::getInstance()->getCurrentTimeStep();
for (VehicleMap::const_iterator i=myVehiclesOnDet[stripIndex].begin(); i!=myVehiclesOnDet[stripIndex].end(); ++i) {
MSVehicle *v = (*i).first;
VehicleData d(v->getID(), v->getVehicleType().getLength(), (*i).second, STEPS2TIME(ct));
d.speedM = v->getSpeed();
ret.push_back(d);
}*/
}
return ret;
}
OutputDevice&
RORoute::writeXMLDefinition(OutputDevice& dev, const ROVehicle* const veh,
const bool withCosts,
const bool withExitTimes) const {
dev.openTag(SUMO_TAG_ROUTE);
if (withCosts) {
dev.writeAttr(SUMO_ATTR_COST, myCosts);
dev.setPrecision(8);
dev.writeAttr(SUMO_ATTR_PROB, myProbability);
dev.setPrecision();
}
if (myColor != 0) {
dev.writeAttr(SUMO_ATTR_COLOR, *myColor);
}
dev.writeAttr(SUMO_ATTR_EDGES, myRoute);
if (withExitTimes) {
std::string exitTimes;
SUMOReal time = STEPS2TIME(veh->getDepartureTime());
for (std::vector<const ROEdge*>::const_iterator i = myRoute.begin(); i != myRoute.end(); ++i) {
if (i != myRoute.begin()) {
exitTimes += " ";
}
time += (*i)->getTravelTime(veh, time);
exitTimes += toString(time);
}
dev.writeAttr("exitTimes", exitTimes);
}
dev.closeTag(true);
return dev;
}
void
MSVehicleControl::removePending() {
#ifdef HAVE_FOX
std::vector<SUMOVehicle*>& vehs = myPendingRemovals.getContainer();
#else
std::vector<SUMOVehicle*>& vehs = myPendingRemovals;
#endif
std::sort(vehs.begin(), vehs.end(), ComparatorNumericalIdLess());
for (SUMOVehicle* const veh : vehs) {
myTotalTravelTime += STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep() - veh->getDeparture());
myRunningVehNo--;
MSNet::getInstance()->informVehicleStateListener(veh, MSNet::VEHICLE_STATE_ARRIVED);
for (MSVehicleDevice* const dev : veh->getDevices()) {
dev->generateOutput();
}
if (OptionsCont::getOptions().isSet("tripinfo-output")) {
// close tag after tripinfo (possibly including emissions from another device) have been written
OutputDevice::getDeviceByOption("tripinfo-output").closeTag();
}
deleteVehicle(veh);
}
vehs.clear();
#ifdef HAVE_FOX
myPendingRemovals.unlock();
#endif
}
bool
ROJTRRouter::compute(const ROEdge* from, const ROEdge* to,
const ROVehicle* const vehicle,
SUMOTime time, ConstROEdgeVector& into) {
const ROJTREdge* current = static_cast<const ROJTREdge*>(from);
SUMOReal timeS = STEPS2TIME(time);
std::set<const ROEdge*> avoidEdges;
// route until a sinks has been found
while (current != 0 && current != to &&
current->getFunc() != ROEdge::ET_SINK &&
(int)into.size() < myMaxEdges) {
into.push_back(current);
if (!myAllowLoops) {
avoidEdges.insert(current);
}
timeS += current->getTravelTime(vehicle, timeS);
current = current->chooseNext(myIgnoreClasses ? 0 : vehicle, timeS, avoidEdges);
assert(myIgnoreClasses || current == 0 || !current->prohibits(vehicle));
}
// check whether no valid ending edge was found
if (current == 0 || (int) into.size() >= myMaxEdges) {
if (myAcceptAllDestination) {
return true;
} else {
MsgHandler* mh = myUnbuildIsWarningOnly ? MsgHandler::getWarningInstance() : MsgHandler::getErrorInstance();
mh->inform("The route starting at edge '" + from->getID() + "' could not be closed.");
return false;
}
}
// append the sink
if (current != 0) {
into.push_back(current);
}
return true;
}
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;
}
}
double
MSDevice_Tripinfo::getAvgDepartDelay() {
if (myVehicleCount > 0) {
return STEPS2TIME(myTotalDepartDelay / myVehicleCount);
} else {
return 0;
}
}
SUMOReal
MSInductLoop::getTimestepsSinceLastDetection() const {
if (myVehiclesOnDet.size() != 0) {
// detector is occupied
return 0;
}
return STEPS2TIME(MSNet::getInstance()->getCurrentTimeStep()) - myLastLeaveTime;
}
double
MSDevice_Tripinfo::getAvgRideWaitingTime() {
if (myRideCount > 0) {
return STEPS2TIME(myTotalRideWaitingTime / myRideCount);
} else {
return 0;
}
}
double
MSDevice_Tripinfo::getAvgRideDuration() {
if (myRideCount > 0) {
return STEPS2TIME(myTotalRideDuration / myRideCount);
} else {
return 0;
}
}
double
MSDevice_Tripinfo::getAvgWalkTimeLoss() {
if (myWalkCount > 0) {
return STEPS2TIME(myTotalWalkTimeLoss / myWalkCount);
} else {
return 0;
}
}
double
MSDevice_Tripinfo::getAvgWalkDuration() {
if (myWalkCount > 0) {
return STEPS2TIME(myTotalWalkDuration / myWalkCount);
} else {
return 0;
}
}
