Eclipse SUMO - Simulation of Urban MObility
MSDevice_DriverState.cpp
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3// Copyright (C) 2013-2023 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/****************************************************************************/
24/****************************************************************************/
25#include <config.h>
26
32#include <microsim/MSNet.h>
33#include <microsim/MSVehicle.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// ---------------------------------------------------------------------------
61void
63 oc.addOptionSubTopic("Driver State Device");
64 insertDefaultAssignmentOptions("driverstate", "Driver State Device", oc);
65 oc.doRegister("device.driverstate.initialAwareness", new Option_Float(DriverStateDefaults::initialAwareness));
66 oc.addDescription("device.driverstate.initialAwareness", "Driver State Device", TL("Initial value assigned to the driver's awareness."));
67 oc.doRegister("device.driverstate.errorTimeScaleCoefficient", new Option_Float(DriverStateDefaults::errorTimeScaleCoefficient));
68 oc.addDescription("device.driverstate.errorTimeScaleCoefficient", "Driver State Device", TL("Time scale for the error process."));
69 oc.doRegister("device.driverstate.errorNoiseIntensityCoefficient", new Option_Float(DriverStateDefaults::errorNoiseIntensityCoefficient));
70 oc.addDescription("device.driverstate.errorNoiseIntensityCoefficient", "Driver State Device", TL("Noise intensity driving the error process."));
71 oc.doRegister("device.driverstate.speedDifferenceErrorCoefficient", new Option_Float(DriverStateDefaults::speedDifferenceErrorCoefficient));
72 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 oc.doRegister("device.driverstate.headwayErrorCoefficient", new Option_Float(DriverStateDefaults::headwayErrorCoefficient));
74 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 oc.doRegister("device.driverstate.freeSpeedErrorCoefficient", new Option_Float(DriverStateDefaults::freeSpeedErrorCoefficient));
76 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 oc.doRegister("device.driverstate.speedDifferenceChangePerceptionThreshold", new Option_Float(DriverStateDefaults::speedDifferenceChangePerceptionThreshold));
78 oc.addDescription("device.driverstate.speedDifferenceChangePerceptionThreshold", "Driver State Device", TL("Base threshold for recognizing changes in the speed difference (threshold also scales with distance)."));
79 oc.doRegister("device.driverstate.headwayChangePerceptionThreshold", new Option_Float(DriverStateDefaults::headwayChangePerceptionThreshold));
80 oc.addDescription("device.driverstate.headwayChangePerceptionThreshold", "Driver State Device", TL("Base threshold for recognizing changes in the headway (threshold also scales with distance)."));
81 oc.doRegister("device.driverstate.minAwareness", new Option_Float(DriverStateDefaults::minAwareness));
82 oc.addDescription("device.driverstate.minAwareness", "Driver State Device", TL("Minimal admissible value for the driver's awareness."));
83 oc.doRegister("device.driverstate.maximalReactionTime", new Option_Float(-1.0));
84 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}
86
87
88void
89MSDevice_DriverState::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into) {
91 // ToC device implies driverstate
92 if (equippedByDefaultAssignmentOptions(oc, "driverstate", v, false) || equippedByDefaultAssignmentOptions(oc, "toc", v, false)) {
93 const double minAwareness = getMinAwareness(v, oc);
94 const double initialAwareness = getInitialAwareness(v, oc);
95 const double errorTimeScaleCoefficient = getErrorTimeScaleCoefficient(v, oc);
96 const double errorNoiseIntensityCoefficient = getErrorNoiseIntensityCoefficient(v, oc);
97 const double speedDifferenceErrorCoefficient = getSpeedDifferenceErrorCoefficient(v, oc);
98 const double speedDifferenceChangePerceptionThreshold = getSpeedDifferenceChangePerceptionThreshold(v, oc);
99 const double headwayChangePerceptionThreshold = getHeadwayChangePerceptionThreshold(v, oc);
100 const double headwayErrorCoefficient = getHeadwayErrorCoefficient(v, oc);
101 const double freeSpeedErrorCoefficient = getFreeSpeedErrorCoefficient(v, oc);
102 const double maximalReactionTime = getMaximalReactionTime(v, oc);
103 // build the device
104 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 maximalReactionTime);
115 into.push_back(device);
116 }
117}
118
119
120double
122 return getFloatParam(v, oc, "driverstate.minAwareness", DriverStateDefaults::minAwareness, false);
123}
124double
126 return getFloatParam(v, oc, "driverstate.initialAwareness", DriverStateDefaults::initialAwareness, false);
127}
128double
130 return getFloatParam(v, oc, "driverstate.errorTimeScaleCoefficient", DriverStateDefaults::errorTimeScaleCoefficient, false);
131}
132double
134 return getFloatParam(v, oc, "driverstate.errorNoiseIntensityCoefficient", DriverStateDefaults::errorNoiseIntensityCoefficient, false);
135}
136double
138 return getFloatParam(v, oc, "driverstate.speedDifferenceErrorCoefficient", DriverStateDefaults::speedDifferenceErrorCoefficient, false);
139}
140double
142 return getFloatParam(v, oc, "driverstate.speedDifferenceChangePerceptionThreshold", DriverStateDefaults::speedDifferenceChangePerceptionThreshold, false);
143}
144double
146 return getFloatParam(v, oc, "driverstate.headwayChangePerceptionThreshold", DriverStateDefaults::headwayChangePerceptionThreshold, false);
147}
148double
150 return getFloatParam(v, oc, "driverstate.headwayErrorCoefficient", DriverStateDefaults::headwayErrorCoefficient, false);
151}
152double
154 return getFloatParam(v, oc, "driverstate.freeSpeedErrorCoefficient", DriverStateDefaults::freeSpeedErrorCoefficient, false);
155}
156double
158 return getFloatParam(v, oc, "driverstate.maximalReactionTime", -1.0, false);
159}
160
161
162// ---------------------------------------------------------------------------
163// MSDevice_DriverState-methods
164// ---------------------------------------------------------------------------
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 double maximalReactionTime) :
176 MSVehicleDevice(holder, id),
177 myMinAwareness(minAwareness),
178 myInitialAwareness(initialAwareness),
179 myErrorTimeScaleCoefficient(errorTimeScaleCoefficient),
180 myErrorNoiseIntensityCoefficient(errorNoiseIntensityCoefficient),
181 mySpeedDifferenceErrorCoefficient(speedDifferenceErrorCoefficient),
182 mySpeedDifferenceChangePerceptionThreshold(speedDifferenceChangePerceptionThreshold),
183 myHeadwayChangePerceptionThreshold(headwayChangePerceptionThreshold),
184 myHeadwayErrorCoefficient(headwayErrorCoefficient),
185 myFreeSpeedErrorCoefficient(freeSpeedErrorCoefficient),
186 myMaximalReactionTime(maximalReactionTime) {
187 // Take care! Holder is currently being constructed. Cast occurs before completion.
188 myHolderMS = static_cast<MSVehicle*>(&holder);
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}
206
207void
209 myDriverState = std::make_shared<MSSimpleDriverState>(myHolderMS);
210 myDriverState->setMinAwareness(myMinAwareness);
211 myDriverState->setInitialAwareness(myInitialAwareness);
212 myDriverState->setErrorTimeScaleCoefficient(myErrorTimeScaleCoefficient);
213 myDriverState->setErrorNoiseIntensityCoefficient(myErrorNoiseIntensityCoefficient);
214 myDriverState->setSpeedDifferenceErrorCoefficient(mySpeedDifferenceErrorCoefficient);
215 myDriverState->setHeadwayErrorCoefficient(myHeadwayErrorCoefficient);
216 myDriverState->setFreeSpeedErrorCoefficient(myFreeSpeedErrorCoefficient);
217 myDriverState->setSpeedDifferenceChangePerceptionThreshold(mySpeedDifferenceChangePerceptionThreshold);
218 myDriverState->setHeadwayChangePerceptionThreshold(myHeadwayChangePerceptionThreshold);
219 myDriverState->setAwareness(myInitialAwareness);
220 if (myMaximalReactionTime > 0) {
221 myDriverState->setMaximalReactionTime(myMaximalReactionTime);
222 }
223}
224
225void
227 myDriverState->update();
228}
229
230std::string
231MSDevice_DriverState::getParameter(const std::string& key) const {
232#ifdef DEBUG_DSDEVICE
233 std::cout << "MSDevice_DriverState::getParameter(key=" << key << ")" << std::endl;
234#endif
235 if (key == "awareness") {
236 return toString(myDriverState->getAwareness());
237 } else if (key == "errorState") {
238 return toString(myDriverState->getErrorState());
239 } else if (key == "errorTimeScale") {
240 return toString(myDriverState->getErrorTimeScale());
241 } else if (key == "errorNoiseIntensity") {
242 return toString(myDriverState->getErrorNoiseIntensity());
243 } else if (key == "minAwareness") {
244 return toString(myDriverState->getMinAwareness());
245 } else if (key == "initialAwareness") {
246 return toString(myDriverState->getInitialAwareness());
247 } else if (key == "errorTimeScaleCoefficient") {
248 return toString(myDriverState->getErrorTimeScaleCoefficient());
249 } else if (key == "errorNoiseIntensityCoefficient") {
250 return toString(myDriverState->getErrorNoiseIntensityCoefficient());
251 } else if (key == "speedDifferenceErrorCoefficient") {
252 return toString(myDriverState->getSpeedDifferenceErrorCoefficient());
253 } else if (key == "headwayErrorCoefficient") {
254 return toString(myDriverState->getHeadwayErrorCoefficient());
255 } else if (key == "speedDifferenceChangePerceptionThreshold") {
256 return toString(myDriverState->getSpeedDifferenceChangePerceptionThreshold());
257 } else if (key == "headwayChangePerceptionThreshold") {
258 return toString(myDriverState->getHeadwayChangePerceptionThreshold());
259 } else if (key == "maximalReactionTime") {
260 return toString(myDriverState->getMaximalReactionTime());
261 } else if (key == "originalReactionTime") {
262 return toString(myDriverState->getOriginalReactionTime());
263 } else if (key == "actionStepLength") {
264 return toString(myDriverState->getActionStepLength());
265 }
266 throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
267}
268
269
270void
271MSDevice_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 if (key == "awareness") {
276 myDriverState->setAwareness(StringUtils::toDouble(value));
277 } else if (key == "errorState") {
278 myDriverState->setErrorState(StringUtils::toDouble(value));
279 } else if (key == "errorTimeScale") {
280 myDriverState->setErrorTimeScale(StringUtils::toDouble(value));
281 } else if (key == "errorNoiseIntensity") {
282 myDriverState->setErrorNoiseIntensity(StringUtils::toDouble(value));
283 } else if (key == "minAwareness") {
284 myDriverState->setMinAwareness(StringUtils::toDouble(value));
285 } else if (key == "initialAwareness") {
286 myDriverState->setInitialAwareness(StringUtils::toDouble(value));
287 } else if (key == "errorTimeScaleCoefficient") {
288 myDriverState->setErrorTimeScaleCoefficient(StringUtils::toDouble(value));
289 } else if (key == "errorNoiseIntensityCoefficient") {
290 myDriverState->setErrorNoiseIntensityCoefficient(StringUtils::toDouble(value));
291 } else if (key == "speedDifferenceErrorCoefficient") {
292 myDriverState->setSpeedDifferenceErrorCoefficient(StringUtils::toDouble(value));
293 } else if (key == "headwayErrorCoefficient") {
294 myDriverState->setHeadwayErrorCoefficient(StringUtils::toDouble(value));
295 } else if (key == "freeSpeedErrorCoefficient") {
296 myDriverState->setFreeSpeedErrorCoefficient(StringUtils::toDouble(value));
297 } else if (key == "speedDifferenceChangePerceptionThreshold") {
298 myDriverState->setSpeedDifferenceChangePerceptionThreshold(StringUtils::toDouble(value));
299 } else if (key == "headwayChangePerceptionThreshold") {
300 myDriverState->setHeadwayChangePerceptionThreshold(StringUtils::toDouble(value));
301 } else if (key == "maximalReactionTime") {
302 myDriverState->setMaximalReactionTime(StringUtils::toDouble(value));
303 } else if (key == "originalReactionTime") {
304 myDriverState->setOriginalReactionTime(StringUtils::toDouble(value));
305 } else {
306 throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
307 }
308}
309
310
311/****************************************************************************/
#define TL(string)
Definition: MsgHandler.h:284
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
The ToC Device controls transition of control between automated and manual driving.
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into)
Build devices for the given vehicle, if needed.
MSVehicle * myHolderMS
The holder vehicle casted to MSVehicle*.
static double getSpeedDifferenceChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_DriverState-options.
MSDevice_DriverState(SUMOVehicle &holder, const std::string &id, double minAwareness, double initialAwareness, double errorTimeScaleCoefficient, double errorNoiseIntensityCoefficient, double speedDifferenceErrorCoefficient, double speedDifferenceChangePerceptionThreshold, double headwayChangePerceptionThreshold, double headwayErrorCoefficient, double freeSpeedErrorCoefficient, double maximalReactionTime)
Constructor.
static double getErrorTimeScaleCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this device. Throw exception for unsupported key
static double getHeadwayErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
const std::string deviceName() const
return the name for this type of device
void initDriverState()
Initializeses the driver state parameters.
static double getSpeedDifferenceErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
static double getFreeSpeedErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
static double getMaximalReactionTime(const SUMOVehicle &v, const OptionsCont &oc)
double mySpeedDifferenceChangePerceptionThreshold
std::shared_ptr< MSSimpleDriverState > myDriverState
The driver state of the holder.
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key
static double getMinAwareness(const SUMOVehicle &v, const OptionsCont &oc)
void update()
update internal state
static double getHeadwayChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
static double getErrorNoiseIntensityCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
static double getInitialAwareness(const SUMOVehicle &v, const OptionsCont &oc)
static double getFloatParam(const SUMOVehicle &v, const OptionsCont &oc, std::string paramName, double deflt, bool required)
Definition: MSDevice.cpp:195
static void insertDefaultAssignmentOptions(const std::string &deviceName, const std::string &optionsTopic, OptionsCont &oc, const bool isPerson=false)
Adds common command options that allow to assign devices to vehicles.
Definition: MSDevice.cpp:144
static bool equippedByDefaultAssignmentOptions(const OptionsCont &oc, const std::string &deviceName, DEVICEHOLDER &v, bool outputOptionSet, const bool isPerson=false)
Determines whether a vehicle should get a certain device.
Definition: MSDevice.h:202
Abstract in-vehicle device.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
const std::string & getID() const
Returns the id.
Definition: Named.h:74
A storage for options typed value containers)
Definition: OptionsCont.h:89
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
void doRegister(const std::string &name, Option *o)
Adds an option under the given name.
Definition: OptionsCont.cpp:75
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:59
Representation of a vehicle.
Definition: SUMOVehicle.h:62
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
static double speedDifferenceChangePerceptionThreshold
static double headwayChangePerceptionThreshold
static double initialAwareness
static double minAwareness
static double freeSpeedErrorCoefficient
static double headwayErrorCoefficient
static double errorTimeScaleCoefficient
static double errorNoiseIntensityCoefficient
static double speedDifferenceErrorCoefficient