Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2013-2024 German Aerospace Center (DLR) and others.
4 : // This program and the accompanying materials are made available under the
5 : // terms of the Eclipse Public License 2.0 which is available at
6 : // https://www.eclipse.org/legal/epl-2.0/
7 : // This Source Code may also be made available under the following Secondary
8 : // Licenses when the conditions for such availability set forth in the Eclipse
9 : // Public License 2.0 are satisfied: GNU General Public License, version 2
10 : // or later which is available at
11 : // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 : // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 : /****************************************************************************/
14 : /// @file MSDevice_DriverState.cpp
15 : /// @author Leonhard Luecken
16 : /// @author Daniel Krajzewicz
17 : /// @author Michael Behrisch
18 : /// @author Jakob Erdmann
19 : /// @date 15.06.2018
20 : ///
21 : /// The Driver State Device mainly provides a configuration and interaction interface for the vehicle's driver state.
22 : /// @see microsim/MSDriverState.h
23 : ///
24 : /****************************************************************************/
25 : #include <config.h>
26 :
27 : #include <utils/common/StringUtils.h>
28 : #include <utils/options/OptionsCont.h>
29 : #include <utils/vehicle/SUMOVehicle.h>
30 : #include <utils/common/WrappingCommand.h>
31 : #include <utils/common/RGBColor.h>
32 : #include <microsim/MSNet.h>
33 : #include <microsim/MSVehicle.h>
34 : #include <microsim/MSRouteHandler.h>
35 : #include <microsim/MSVehicleControl.h>
36 : #include <microsim/MSEventControl.h>
37 : #include <microsim/MSDriverState.h>
38 : #include "MSDevice_DriverState.h"
39 :
40 :
41 : // ===========================================================================
42 : // debug constants
43 : // ===========================================================================
44 : //#define DEBUG_DSDEVICE
45 : //#define DEBUG_COND (myHolder.isSelected())
46 :
47 :
48 : // ===========================================================================
49 : // parameter defaults
50 : // ===========================================================================
51 :
52 : // see DriverStateDefaults in MSDriverState
53 :
54 :
55 : // ===========================================================================
56 : // method definitions
57 : // ===========================================================================
58 : // ---------------------------------------------------------------------------
59 : // static initialisation methods
60 : // ---------------------------------------------------------------------------
61 : void
62 36320 : MSDevice_DriverState::insertOptions(OptionsCont& oc) {
63 36320 : oc.addOptionSubTopic("Driver State Device");
64 72640 : insertDefaultAssignmentOptions("driverstate", "Driver State Device", oc);
65 36320 : oc.doRegister("device.driverstate.initialAwareness", new Option_Float(DriverStateDefaults::initialAwareness));
66 108960 : oc.addDescription("device.driverstate.initialAwareness", "Driver State Device", TL("Initial value assigned to the driver's awareness."));
67 36320 : oc.doRegister("device.driverstate.errorTimeScaleCoefficient", new Option_Float(DriverStateDefaults::errorTimeScaleCoefficient));
68 108960 : oc.addDescription("device.driverstate.errorTimeScaleCoefficient", "Driver State Device", TL("Time scale for the error process."));
69 36320 : oc.doRegister("device.driverstate.errorNoiseIntensityCoefficient", new Option_Float(DriverStateDefaults::errorNoiseIntensityCoefficient));
70 108960 : oc.addDescription("device.driverstate.errorNoiseIntensityCoefficient", "Driver State Device", TL("Noise intensity driving the error process."));
71 36320 : oc.doRegister("device.driverstate.speedDifferenceErrorCoefficient", new Option_Float(DriverStateDefaults::speedDifferenceErrorCoefficient));
72 108960 : oc.addDescription("device.driverstate.speedDifferenceErrorCoefficient", "Driver State Device", TL("General scaling coefficient for applying the error to the perceived speed difference (error also scales with distance)."));
73 36320 : oc.doRegister("device.driverstate.headwayErrorCoefficient", new Option_Float(DriverStateDefaults::headwayErrorCoefficient));
74 108960 : oc.addDescription("device.driverstate.headwayErrorCoefficient", "Driver State Device", TL("General scaling coefficient for applying the error to the perceived distance (error also scales with distance)."));
75 36320 : oc.doRegister("device.driverstate.freeSpeedErrorCoefficient", new Option_Float(DriverStateDefaults::freeSpeedErrorCoefficient));
76 108960 : oc.addDescription("device.driverstate.freeSpeedErrorCoefficient", "Driver State Device", TL("General scaling coefficient for applying the error to the vehicle's own speed when driving without a leader (error also scales with own speed)."));
77 36320 : oc.doRegister("device.driverstate.speedDifferenceChangePerceptionThreshold", new Option_Float(DriverStateDefaults::speedDifferenceChangePerceptionThreshold));
78 108960 : oc.addDescription("device.driverstate.speedDifferenceChangePerceptionThreshold", "Driver State Device", TL("Base threshold for recognizing changes in the speed difference (threshold also scales with distance)."));
79 36320 : oc.doRegister("device.driverstate.headwayChangePerceptionThreshold", new Option_Float(DriverStateDefaults::headwayChangePerceptionThreshold));
80 108960 : oc.addDescription("device.driverstate.headwayChangePerceptionThreshold", "Driver State Device", TL("Base threshold for recognizing changes in the headway (threshold also scales with distance)."));
81 36320 : oc.doRegister("device.driverstate.minAwareness", new Option_Float(DriverStateDefaults::minAwareness));
82 108960 : oc.addDescription("device.driverstate.minAwareness", "Driver State Device", TL("Minimal admissible value for the driver's awareness."));
83 36320 : oc.doRegister("device.driverstate.maximalReactionTime", new Option_Float(-1.0));
84 108960 : oc.addDescription("device.driverstate.maximalReactionTime", "Driver State Device", TL("Maximal reaction time (~action step length) induced by decreased awareness level (reached for awareness=minAwareness)."));
85 36320 : }
86 :
87 :
88 : void
89 4658938 : MSDevice_DriverState::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into) {
90 4658938 : OptionsCont& oc = OptionsCont::getOptions();
91 : // ToC device implies driverstate
92 9317799 : if (equippedByDefaultAssignmentOptions(oc, "driverstate", v, false) || equippedByDefaultAssignmentOptions(oc, "toc", v, false)) {
93 237 : const double minAwareness = getMinAwareness(v, oc);
94 237 : const double initialAwareness = getInitialAwareness(v, oc);
95 237 : const double errorTimeScaleCoefficient = getErrorTimeScaleCoefficient(v, oc);
96 237 : const double errorNoiseIntensityCoefficient = getErrorNoiseIntensityCoefficient(v, oc);
97 237 : const double speedDifferenceErrorCoefficient = getSpeedDifferenceErrorCoefficient(v, oc);
98 237 : const double speedDifferenceChangePerceptionThreshold = getSpeedDifferenceChangePerceptionThreshold(v, oc);
99 237 : const double headwayChangePerceptionThreshold = getHeadwayChangePerceptionThreshold(v, oc);
100 237 : const double headwayErrorCoefficient = getHeadwayErrorCoefficient(v, oc);
101 237 : const double freeSpeedErrorCoefficient = getFreeSpeedErrorCoefficient(v, oc);
102 237 : const double maximalReactionTime = getMaximalReactionTime(v, oc);
103 : // build the device
104 237 : MSDevice_DriverState* device = new MSDevice_DriverState(v, "driverstate" + v.getID(),
105 : minAwareness,
106 : initialAwareness,
107 : errorTimeScaleCoefficient,
108 : errorNoiseIntensityCoefficient,
109 : speedDifferenceErrorCoefficient,
110 : speedDifferenceChangePerceptionThreshold,
111 : headwayChangePerceptionThreshold,
112 : headwayErrorCoefficient,
113 : freeSpeedErrorCoefficient,
114 237 : maximalReactionTime);
115 237 : into.push_back(device);
116 : }
117 4658938 : }
118 :
119 :
120 : double
121 237 : MSDevice_DriverState::getMinAwareness(const SUMOVehicle& v, const OptionsCont& oc) {
122 474 : return getFloatParam(v, oc, "driverstate.minAwareness", DriverStateDefaults::minAwareness, false);
123 : }
124 : double
125 237 : MSDevice_DriverState::getInitialAwareness(const SUMOVehicle& v, const OptionsCont& oc) {
126 474 : return getFloatParam(v, oc, "driverstate.initialAwareness", DriverStateDefaults::initialAwareness, false);
127 : }
128 : double
129 237 : MSDevice_DriverState::getErrorTimeScaleCoefficient(const SUMOVehicle& v, const OptionsCont& oc) {
130 474 : return getFloatParam(v, oc, "driverstate.errorTimeScaleCoefficient", DriverStateDefaults::errorTimeScaleCoefficient, false);
131 : }
132 : double
133 237 : MSDevice_DriverState::getErrorNoiseIntensityCoefficient(const SUMOVehicle& v, const OptionsCont& oc) {
134 474 : return getFloatParam(v, oc, "driverstate.errorNoiseIntensityCoefficient", DriverStateDefaults::errorNoiseIntensityCoefficient, false);
135 : }
136 : double
137 237 : MSDevice_DriverState::getSpeedDifferenceErrorCoefficient(const SUMOVehicle& v, const OptionsCont& oc) {
138 474 : return getFloatParam(v, oc, "driverstate.speedDifferenceErrorCoefficient", DriverStateDefaults::speedDifferenceErrorCoefficient, false);
139 : }
140 : double
141 237 : MSDevice_DriverState::getSpeedDifferenceChangePerceptionThreshold(const SUMOVehicle& v, const OptionsCont& oc) {
142 474 : return getFloatParam(v, oc, "driverstate.speedDifferenceChangePerceptionThreshold", DriverStateDefaults::speedDifferenceChangePerceptionThreshold, false);
143 : }
144 : double
145 237 : MSDevice_DriverState::getHeadwayChangePerceptionThreshold(const SUMOVehicle& v, const OptionsCont& oc) {
146 474 : return getFloatParam(v, oc, "driverstate.headwayChangePerceptionThreshold", DriverStateDefaults::headwayChangePerceptionThreshold, false);
147 : }
148 : double
149 237 : MSDevice_DriverState::getHeadwayErrorCoefficient(const SUMOVehicle& v, const OptionsCont& oc) {
150 474 : return getFloatParam(v, oc, "driverstate.headwayErrorCoefficient", DriverStateDefaults::headwayErrorCoefficient, false);
151 : }
152 : double
153 237 : MSDevice_DriverState::getFreeSpeedErrorCoefficient(const SUMOVehicle& v, const OptionsCont& oc) {
154 474 : return getFloatParam(v, oc, "driverstate.freeSpeedErrorCoefficient", DriverStateDefaults::freeSpeedErrorCoefficient, false);
155 : }
156 : double
157 237 : MSDevice_DriverState::getMaximalReactionTime(const SUMOVehicle& v, const OptionsCont& oc) {
158 474 : return getFloatParam(v, oc, "driverstate.maximalReactionTime", -1.0, false);
159 : }
160 :
161 :
162 : // ---------------------------------------------------------------------------
163 : // MSDevice_DriverState-methods
164 : // ---------------------------------------------------------------------------
165 237 : MSDevice_DriverState::MSDevice_DriverState(SUMOVehicle& holder, const std::string& id,
166 : double minAwareness,
167 : double initialAwareness,
168 : double errorTimeScaleCoefficient,
169 : double errorNoiseIntensityCoefficient,
170 : double speedDifferenceErrorCoefficient,
171 : double speedDifferenceChangePerceptionThreshold,
172 : double headwayChangePerceptionThreshold,
173 : double headwayErrorCoefficient,
174 : double freeSpeedErrorCoefficient,
175 237 : double maximalReactionTime) :
176 : MSVehicleDevice(holder, id),
177 237 : myMinAwareness(minAwareness),
178 237 : myInitialAwareness(initialAwareness),
179 237 : myErrorTimeScaleCoefficient(errorTimeScaleCoefficient),
180 237 : myErrorNoiseIntensityCoefficient(errorNoiseIntensityCoefficient),
181 237 : mySpeedDifferenceErrorCoefficient(speedDifferenceErrorCoefficient),
182 237 : mySpeedDifferenceChangePerceptionThreshold(speedDifferenceChangePerceptionThreshold),
183 237 : myHeadwayChangePerceptionThreshold(headwayChangePerceptionThreshold),
184 237 : myHeadwayErrorCoefficient(headwayErrorCoefficient),
185 237 : myFreeSpeedErrorCoefficient(freeSpeedErrorCoefficient),
186 237 : myMaximalReactionTime(maximalReactionTime) {
187 : // Take care! Holder is currently being constructed. Cast occurs before completion.
188 237 : myHolderMS = static_cast<MSVehicle*>(&holder);
189 237 : initDriverState();
190 :
191 :
192 : #ifdef DEBUG_DSDEVICE
193 : std::cout << "initialized device '" << id << "' with "
194 : << "myMinAwareness=" << myMinAwareness << ", "
195 : << "myInitialAwareness=" << myInitialAwareness << ", "
196 : << "myErrorTimeScaleCoefficient=" << myErrorTimeScaleCoefficient << ", "
197 : << "myErrorNoiseIntensityCoefficient=" << myErrorNoiseIntensityCoefficient << ", "
198 : << "mySpeedDifferenceErrorCoefficient=" << mySpeedDifferenceErrorCoefficient << ", "
199 : << "mySpeedDifferenceChangePerceptionThreshold=" << mySpeedDifferenceChangePerceptionThreshold << ", "
200 : << "myHeadwayChangePerceptionThreshold=" << myHeadwayChangePerceptionThreshold << ", "
201 : << "myHeadwayErrorCoefficient=" << myHeadwayErrorCoefficient << std::endl;
202 : << "myFreeSpeedErrorCoefficient=" << myFreeSpeedErrorCoefficient << std::endl;
203 : #endif
204 :
205 237 : }
206 :
207 : void
208 237 : MSDevice_DriverState::initDriverState() {
209 474 : myDriverState = std::make_shared<MSSimpleDriverState>(myHolderMS);
210 237 : myDriverState->setMinAwareness(myMinAwareness);
211 237 : myDriverState->setInitialAwareness(myInitialAwareness);
212 237 : myDriverState->setErrorTimeScaleCoefficient(myErrorTimeScaleCoefficient);
213 237 : myDriverState->setErrorNoiseIntensityCoefficient(myErrorNoiseIntensityCoefficient);
214 237 : myDriverState->setSpeedDifferenceErrorCoefficient(mySpeedDifferenceErrorCoefficient);
215 237 : myDriverState->setHeadwayErrorCoefficient(myHeadwayErrorCoefficient);
216 237 : myDriverState->setFreeSpeedErrorCoefficient(myFreeSpeedErrorCoefficient);
217 237 : myDriverState->setSpeedDifferenceChangePerceptionThreshold(mySpeedDifferenceChangePerceptionThreshold);
218 237 : myDriverState->setHeadwayChangePerceptionThreshold(myHeadwayChangePerceptionThreshold);
219 237 : myDriverState->setAwareness(myInitialAwareness);
220 237 : if (myMaximalReactionTime > 0) {
221 : myDriverState->setMaximalReactionTime(myMaximalReactionTime);
222 : }
223 237 : }
224 :
225 : void
226 272458 : MSDevice_DriverState::update() {
227 272458 : myDriverState->update();
228 272458 : }
229 :
230 : std::string
231 424 : MSDevice_DriverState::getParameter(const std::string& key) const {
232 : #ifdef DEBUG_DSDEVICE
233 : std::cout << "MSDevice_DriverState::getParameter(key=" << key << ")" << std::endl;
234 : #endif
235 424 : if (key == "awareness") {
236 162 : return toString(myDriverState->getAwareness());
237 262 : } else if (key == "errorState") {
238 162 : return toString(myDriverState->getErrorState());
239 100 : } else if (key == "errorTimeScale") {
240 8 : return toString(myDriverState->getErrorTimeScale());
241 92 : } else if (key == "errorNoiseIntensity") {
242 8 : return toString(myDriverState->getErrorNoiseIntensity());
243 84 : } else if (key == "minAwareness") {
244 8 : return toString(myDriverState->getMinAwareness());
245 76 : } else if (key == "initialAwareness") {
246 8 : return toString(myDriverState->getInitialAwareness());
247 68 : } else if (key == "errorTimeScaleCoefficient") {
248 8 : return toString(myDriverState->getErrorTimeScaleCoefficient());
249 60 : } else if (key == "errorNoiseIntensityCoefficient") {
250 8 : return toString(myDriverState->getErrorNoiseIntensityCoefficient());
251 52 : } else if (key == "speedDifferenceErrorCoefficient") {
252 8 : return toString(myDriverState->getSpeedDifferenceErrorCoefficient());
253 44 : } else if (key == "headwayErrorCoefficient") {
254 8 : return toString(myDriverState->getHeadwayErrorCoefficient());
255 36 : } else if (key == "speedDifferenceChangePerceptionThreshold") {
256 8 : return toString(myDriverState->getSpeedDifferenceChangePerceptionThreshold());
257 28 : } else if (key == "headwayChangePerceptionThreshold") {
258 8 : return toString(myDriverState->getHeadwayChangePerceptionThreshold());
259 20 : } else if (key == "maximalReactionTime") {
260 6 : return toString(myDriverState->getMaximalReactionTime());
261 14 : } else if (key == "originalReactionTime") {
262 6 : return toString(myDriverState->getOriginalReactionTime());
263 8 : } else if (key == "actionStepLength") {
264 8 : return toString(myDriverState->getActionStepLength());
265 : }
266 0 : throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
267 : }
268 :
269 :
270 : void
271 28 : MSDevice_DriverState::setParameter(const std::string& key, const std::string& value) {
272 : #ifdef DEBUG_DSDEVICE
273 : std::cout << "MSDevice_DriverState::setParameter(key=" << key << ", value=" << value << ")" << std::endl;
274 : #endif
275 28 : if (key == "awareness") {
276 2 : myDriverState->setAwareness(StringUtils::toDouble(value));
277 26 : } else if (key == "errorState") {
278 2 : myDriverState->setErrorState(StringUtils::toDouble(value));
279 24 : } else if (key == "errorTimeScale") {
280 2 : myDriverState->setErrorTimeScale(StringUtils::toDouble(value));
281 22 : } else if (key == "errorNoiseIntensity") {
282 2 : myDriverState->setErrorNoiseIntensity(StringUtils::toDouble(value));
283 20 : } else if (key == "minAwareness") {
284 2 : myDriverState->setMinAwareness(StringUtils::toDouble(value));
285 18 : } else if (key == "initialAwareness") {
286 2 : myDriverState->setInitialAwareness(StringUtils::toDouble(value));
287 16 : } else if (key == "errorTimeScaleCoefficient") {
288 2 : myDriverState->setErrorTimeScaleCoefficient(StringUtils::toDouble(value));
289 14 : } else if (key == "errorNoiseIntensityCoefficient") {
290 2 : myDriverState->setErrorNoiseIntensityCoefficient(StringUtils::toDouble(value));
291 12 : } else if (key == "speedDifferenceErrorCoefficient") {
292 2 : myDriverState->setSpeedDifferenceErrorCoefficient(StringUtils::toDouble(value));
293 10 : } else if (key == "headwayErrorCoefficient") {
294 2 : myDriverState->setHeadwayErrorCoefficient(StringUtils::toDouble(value));
295 8 : } else if (key == "freeSpeedErrorCoefficient") {
296 0 : myDriverState->setFreeSpeedErrorCoefficient(StringUtils::toDouble(value));
297 8 : } else if (key == "speedDifferenceChangePerceptionThreshold") {
298 2 : myDriverState->setSpeedDifferenceChangePerceptionThreshold(StringUtils::toDouble(value));
299 6 : } else if (key == "headwayChangePerceptionThreshold") {
300 2 : myDriverState->setHeadwayChangePerceptionThreshold(StringUtils::toDouble(value));
301 4 : } else if (key == "maximalReactionTime") {
302 2 : myDriverState->setMaximalReactionTime(StringUtils::toDouble(value));
303 2 : } else if (key == "originalReactionTime") {
304 2 : myDriverState->setOriginalReactionTime(StringUtils::toDouble(value));
305 : } else {
306 0 : throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
307 : }
308 28 : }
309 :
310 :
311 : /****************************************************************************/
|
