bool MSCFModel_KraussOrig1::hasSafeGap(SUMOReal speed, SUMOReal gap, SUMOReal predSpeed, SUMOReal laneMaxSpeed) const throw() { if (gap<0) { return false; } SUMOReal vSafe = MIN2(_vsafe(gap, predSpeed), maxNextSpeed(speed)); SUMOReal vNext = MIN3(maxNextSpeed(speed), laneMaxSpeed, vSafe); return (vNext>=getSpeedAfterMaxDecel(speed) && gap>= SPEED2DIST(speed)); }
SUMOReal MSCFModel_SmartSK::moveHelper(MSVehicle* const veh, SUMOReal vPos) const { const SUMOReal oldV = veh->getSpeed(); // save old v for optional acceleration computation const SUMOReal vSafe = MIN2(vPos, veh->processNextStop(vPos)); // process stops // we need the acceleration for emission computation; // in this case, we neglect dawdling, nonetheless, using // vSafe does not incorporate speed reduction due to interaction // on lane changing const SUMOReal vMin = getSpeedAfterMaxDecel(oldV); const SUMOReal vMax = MIN3(veh->getLane()->getVehicleMaxSpeed(veh), maxNextSpeed(oldV, veh), vSafe); #ifdef _DEBUG if (vMin > vMax) { WRITE_WARNING("Vehicle's '" + veh->getID() + "' maximum speed is lower than the minimum speed (min: " + toString(vMin) + ", max: " + toString(vMax) + ")."); } #endif updateMyHeadway(veh); SSKVehicleVariables* vars = (SSKVehicleVariables*)veh->getCarFollowVariables(); #ifdef _DEBUG if (vars->ggOld.size() > 1) { std::cout << "# more than one entry in ggOld list. Speed is " << vPos << ", corresponding dist is " << vars->ggOld[(int) vPos] << "\n"; for (std::map<int, SUMOReal>::iterator I = vars->ggOld.begin(); I != vars->ggOld.end(); I++) { std::cout << "# " << (*I).first << ' ' << (*I).second << std::endl; } } #endif vars->gOld = vars->ggOld[(int) vPos]; vars->ggOld.clear(); return veh->getLaneChangeModel().patchSpeed(vMin, MAX2(vMin, dawdle(vMax)), vMax, *this); }
double MSCFModel::finalizeSpeed(MSVehicle* const veh, double vPos) const { // save old v for optional acceleration computation const double oldV = veh->getSpeed(); // process stops (includes update of stopping state) const double vStop = MIN2(vPos, veh->processNextStop(vPos)); // apply deceleration bounds const double vMinEmergency = minNextSpeedEmergency(oldV, veh); // vPos contains the uppper bound on safe speed. allow emergency braking here const double vMin = MIN2(minNextSpeed(oldV, veh), MAX2(vPos, vMinEmergency)); // aMax: Maximal admissible acceleration until the next action step, such that the vehicle's maximal // desired speed on the current lane will not be exceeded when the // acceleration is maintained until the next action step. double aMax = (veh->getLane()->getVehicleMaxSpeed(veh) - oldV) / veh->getActionStepLengthSecs(); // apply planned speed constraints and acceleration constraints double vMax = MIN3(oldV + ACCEL2SPEED(aMax), maxNextSpeed(oldV, veh), vStop); // do not exceed max decel even if it is unsafe #ifdef _DEBUG //if (vMin > vMax) { // WRITE_WARNING("Maximum speed of vehicle '" + veh->getID() + "' is lower than the minimum speed (min: " + toString(vMin) + ", max: " + toString(vMax) + ")."); //} #endif #ifdef DEBUG_FINALIZE_SPEED if DEBUG_COND { std::cout << "\n" << SIMTIME << " FINALIZE_SPEED\n"; } #endif vMax = MAX2(vMin, vMax); // apply further speed adaptations double vNext = patchSpeedBeforeLC(veh, vMin, vMax); #ifdef DEBUG_FINALIZE_SPEED double vDawdle = vNext; #endif assert(vNext >= vMin); assert(vNext <= vMax); // apply lane-changing related speed adaptations vNext = veh->getLaneChangeModel().patchSpeed(vMin, vNext, vMax, *this); assert(vNext >= vMin); assert(vNext <= vMax); #ifdef DEBUG_FINALIZE_SPEED if DEBUG_COND { std::cout << std::setprecision(gPrecision) << "veh '" << veh->getID() << "' oldV=" << oldV << " vPos" << vPos << " vMin=" << vMin << " vMax=" << vMax << " vStop=" << vStop << " vDawdle=" << vDawdle << " vNext=" << vNext << "\n"; } #endif return vNext; }
SUMOReal MSCFModel_KraussOrig1::moveHelper(MSVehicle * const veh, const MSLane * const lane, SUMOReal vPos) const throw() { SUMOReal oldV = veh->getSpeed(); // save old v for optional acceleration computation SUMOReal vSafe = MIN2(vPos, veh->processNextStop(vPos)); // process stops // we need the acceleration for emission computation; // in this case, we neglect dawdling, nonetheless, using // vSafe does not incorporate speed reduction due to interaction // on lane changing veh->setPreDawdleAcceleration(SPEED2ACCEL(vSafe-oldV)); // SUMOReal vNext = dawdle(MIN3(lane->getMaxSpeed(), maxNextSpeed(oldV), vSafe)); vNext = veh->getLaneChangeModel().patchSpeed( MAX2((SUMOReal) 0, oldV-(SUMOReal)ACCEL2SPEED(myDecel)), //!!! reverify vNext, MIN3(vSafe, veh->getLane().getMaxSpeed(), maxNextSpeed(oldV)),//vaccel(myState.mySpeed, myLane->maxSpeed())), vSafe); return MIN4(vNext, vSafe, veh->getLane().getMaxSpeed(), maxNextSpeed(oldV)); }
SUMOReal MSCFModel_Wiedemann::stopSpeed(const MSVehicle* const veh, const SUMOReal speed, SUMOReal gap) const { /* Wiedemann does not handle approaching junctions or stops very well: * regime approaching() fails when dv = 0 (i.e. a vehicle inserted with speed 0 does not accelerate to reach a stop) * for dv ~ 0 the standard decision tree will switch to following() which * does a lousy job of closing in on a stop / junction * hence we borrow from Krauss here */ return MAX2(getSpeedAfterMaxDecel(speed), MIN2(krauss_vsafe(gap, 0), maxNextSpeed(speed, veh))); }
double MSCFModel::interactionGap(const MSVehicle* const veh, double vL) const { // Resolve the vsafe equation to gap. Assume predecessor has // speed != 0 and that vsafe will be the current speed plus acceleration, // i.e that with this gap there will be no interaction. const double vNext = MIN2(maxNextSpeed(veh->getSpeed(), veh), veh->getLane()->getVehicleMaxSpeed(veh)); const double gap = (vNext - vL) * ((veh->getSpeed() + vL) / (2.*myDecel) + myHeadwayTime) + vL * myHeadwayTime; // Don't allow timeHeadWay < deltaT situations. return MAX2(gap, SPEED2DIST(vNext)); }
SUMOReal MSCFModel_KraussOrig1::interactionGap(const MSVehicle * const veh, SUMOReal vL) const throw() { // Resolve the vsafe equation to gap. Assume predecessor has // speed != 0 and that vsafe will be the current speed plus acceleration, // i.e that with this gap there will be no interaction. SUMOReal vNext = MIN2(maxNextSpeed(veh->getSpeed()), veh->getLane().getMaxSpeed()); SUMOReal gap = (vNext - vL) * ((veh->getSpeed() + vL) * myInverseTwoDecel + myTau) + vL * myTau; // Don't allow timeHeadWay < deltaT situations. return MAX2(gap, SPEED2DIST(vNext)); }
SUMOReal MSCFModel_SmartSK::stopSpeed(const MSVehicle* const veh, const SUMOReal speed, SUMOReal gap) const { SSKVehicleVariables* vars = (SSKVehicleVariables*)veh->getCarFollowVariables(); // if (((gap - vars->gOld) < maxDeltaGap) && (speed>=5.0) && gap>=5.0) { if ((gap - vars->gOld) < maxDeltaGap) { SUMOReal tTauTest = gap / speed; // allow headway only to decrease only, never to increase. Increase is handled automatically by the headway dynamics in moveHelper()!!! if ((tTauTest < vars->myHeadway) && (tTauTest > TS)) { vars->myHeadway = tTauTest; } } return MAX2(getSpeedAfterMaxDecel(speed), MIN2(_vsafe(veh, gap, 0), maxNextSpeed(speed, veh))); }
SUMOReal MSCFModel_Daniel1::moveHelper(MSVehicle* const veh, SUMOReal vPos) const { const SUMOReal oldV = veh->getSpeed(); // save old v for optional acceleration computation const SUMOReal vSafe = MIN2(vPos, veh->processNextStop(vPos)); // process stops // we need the acceleration for emission computation; // in this case, we neglect dawdling, nonetheless, using // vSafe does not incorporate speed reduction due to interaction // on lane changing const SUMOReal vMin = getSpeedAfterMaxDecel(oldV); const SUMOReal vMax = MIN3(veh->getLane()->getVehicleMaxSpeed(veh), maxNextSpeed(oldV, veh), vSafe); #ifdef _DEBUG if (vMin > vMax) { WRITE_WARNING("Vehicle's '" + veh->getID() + "' maximum speed is lower than the minimum speed (min: " + toString(vMin) + ", max: " + toString(vMax) + ")."); } #endif return veh->getLaneChangeModel().patchSpeed(vMin, MAX2(vMin, dawdle(vMax)), vMax, *this); }
double MSCFModel_ACC::finalizeSpeed(MSVehicle* const veh, double vPos) const { const double oldV = veh->getSpeed(); // save old v for optional acceleration computation const double vSafe = MIN2(vPos, veh->processNextStop(vPos)); // process stops // we need the acceleration for emission computation; // in this case, we neglect dawdling, nonetheless, using // vSafe does not incorporate speed reduction due to interaction // on lane changing // const double vMin = getSpeedAfterMaxDecel(oldV); const double vMin = minNextSpeed(oldV); const double vMax = MAX2(vMin, MIN3(veh->getLane()->getVehicleMaxSpeed(veh), maxNextSpeed(oldV, veh), vSafe)); #ifdef _DEBUG //if (vMin > vMax) { // WRITE_WARNING("Maximum speed of vehicle '" + veh->getID() + "' is lower than the minimum speed (min: " + toString(vMin) + ", max: " + toString(vMax) + ")."); //} #endif return veh->getLaneChangeModel().patchSpeed(vMin, MAX2(vMin, vMax), vMax, *this); }
SUMOReal MSCFModel_SmartSK::followSpeed(const MSVehicle* const veh, SUMOReal speed, SUMOReal gap, SUMOReal predSpeed, SUMOReal /*predMaxDecel*/) const { SSKVehicleVariables* vars = (SSKVehicleVariables*)veh->getCarFollowVariables(); // if (((gap - vars->gOld) < maxDeltaGap) && (speed>=5.0) && gap>=5.0) { if ((gap - vars->gOld) < maxDeltaGap) { SUMOReal tTauTest = gap / speed; // allow headway only to decrease only, never to increase. Increase is handled automatically by the headway dynamics in moveHelper()!!! if ((tTauTest < vars->myHeadway) && (tTauTest > TS)) { vars->myHeadway = tTauTest; } } SUMOReal vsafe = _vsafe(veh, gap, predSpeed); if ((speed <= 0.0) && (vsafe < myS2Sspeed)) { vsafe = 0; } SUMOReal vNew = MAX2(getSpeedAfterMaxDecel(speed), MIN2(vsafe, maxNextSpeed(speed, veh))); // there must be a better place to do the following assignment!!! vars->gOld = gap; vars->ggOld[(int)vNew] = gap; return vNew; }
SUMOReal MSCFModel_Daniel1::stopSpeed(const MSVehicle* const veh, SUMOReal gap) const { return MIN2(_vsafe(gap, 0), maxNextSpeed(veh->getSpeed(), veh)); }
SUMOReal MSCFModel_Daniel1::followSpeed(const MSVehicle* const veh, SUMOReal speed, SUMOReal gap, SUMOReal predSpeed, SUMOReal /*predMaxDecel*/) const { return MIN2(_vsafe(gap, predSpeed), maxNextSpeed(speed, veh)); }
SUMOReal MSCFModel_Krauss::stopSpeed(const MSVehicle* const veh, const SUMOReal speed, SUMOReal gap) const { return MIN2(_vsafe(gap, 0, 0), maxNextSpeed(speed, veh)); }
SUMOReal MSCFModel_Krauss::followSpeed(const MSVehicle* const veh, const SUMOReal speed, SUMOReal gap, SUMOReal predSpeed, SUMOReal predMaxDecel) const { return MIN2(_vsafe(gap, predSpeed, predMaxDecel), maxNextSpeed(speed, veh)); }
double MSCFModel_ACC::stopSpeed(const MSVehicle* const veh, const double speed, double gap) const { // NOTE: This allows return of smaller values than minNextSpeed(). // Only relevant for the ballistic update: We give the argument headway=TS, to assure that // the stopping position is approached with a uniform deceleration also for tau!=TS. return MIN2(maximumSafeStopSpeed(gap, speed, false, veh->getActionStepLengthSecs()), maxNextSpeed(speed, veh)); }
SUMOReal MSCFModel_Kerner::followSpeed(const MSVehicle* const veh, SUMOReal speed, SUMOReal gap, SUMOReal predSpeed, SUMOReal /*predMaxDecel*/) const { return MIN2(_v(veh, speed, maxNextSpeed(speed, veh), gap, predSpeed), maxNextSpeed(speed, veh)); }
SUMOReal MSCFModel_KraussOrig1::stopSpeed(const MSVehicle* const veh, SUMOReal gap) const { return MIN2(_vsafe(gap, 0), maxNextSpeed(veh->getSpeed())); }
SUMOReal MSCFModel_KraussOrig1::followSpeed(const MSVehicle* const /*veh*/, SUMOReal speed, SUMOReal gap, SUMOReal predSpeed, SUMOReal /*predMaxDecel*/) const { return MIN2(_vsafe(gap, predSpeed), maxNextSpeed(speed)); }
SUMOReal MSCFModel_Kerner::stopSpeed(const MSVehicle* const veh, const SUMOReal speed, SUMOReal gap) const { return MIN2(_v(veh, speed, maxNextSpeed(speed, veh), gap, 0), maxNextSpeed(speed, veh)); }
SUMOReal MSCFModel_KraussOrig1::ffeV(const MSVehicle * const veh, SUMOReal speed, SUMOReal gap, SUMOReal predSpeed) const throw() { return MIN2(_vsafe(gap, predSpeed), maxNextSpeed(speed)); }
double MSCFModel_Kerner::stopSpeed(const MSVehicle* const veh, const double speed, double gap) const { return MIN2(_v(veh, speed, maxNextSpeed(speed, veh), gap, 0), maxNextSpeed(speed, veh)); }
double MSCFModel_Kerner::followSpeed(const MSVehicle* const veh, double speed, double gap, double predSpeed, double /*predMaxDecel*/, const MSVehicle* const /*pred*/) const { return MIN2(_v(veh, speed, maxNextSpeed(speed, veh), gap, predSpeed), maxNextSpeed(speed, veh)); }
SUMOReal MSCFModel_KraussOrig1::ffeV(const MSVehicle * const veh, const MSVehicle *pred) const throw() { return MIN2(_vsafe(veh->gap2pred(*pred), pred->getSpeed()), maxNextSpeed(veh->getSpeed())); }