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-2022 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", "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", "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", "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", "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", "General scaling coefficient for applying the error to the perceived distance (error also scales with distance).");
75 oc.doRegister("device.driverstate.speedDifferenceChangePerceptionThreshold", new Option_Float(DriverStateDefaults::speedDifferenceChangePerceptionThreshold));
76 oc.addDescription("device.driverstate.speedDifferenceChangePerceptionThreshold", "Driver State Device", "Base threshold for recognizing changes in the speed difference (threshold also scales with distance).");
77 oc.doRegister("device.driverstate.headwayChangePerceptionThreshold", new Option_Float(DriverStateDefaults::headwayChangePerceptionThreshold));
78 oc.addDescription("device.driverstate.headwayChangePerceptionThreshold", "Driver State Device", "Base threshold for recognizing changes in the headway (threshold also scales with distance).");
79 oc.doRegister("device.driverstate.minAwareness", new Option_Float(DriverStateDefaults::minAwareness));
80 oc.addDescription("device.driverstate.minAwareness", "Driver State Device", "Minimal admissible value for the driver's awareness.");
81 oc.doRegister("device.driverstate.maximalReactionTime", new Option_Float(-1.0));
82 oc.addDescription("device.driverstate.maximalReactionTime", "Driver State Device", "Maximal reaction time (~action step length) induced by decreased awareness level (reached for awareness=minAwareness).");
83}
84
85
86void
87MSDevice_DriverState::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into) {
89 // ToC device implies driverstate
90 if (equippedByDefaultAssignmentOptions(oc, "driverstate", v, false) || equippedByDefaultAssignmentOptions(oc, "toc", v, false)) {
91 const double minAwareness = getMinAwareness(v, oc);
92 const double initialAwareness = getInitialAwareness(v, oc);
93 const double errorTimeScaleCoefficient = getErrorTimeScaleCoefficient(v, oc);
94 const double errorNoiseIntensityCoefficient = getErrorNoiseIntensityCoefficient(v, oc);
95 const double speedDifferenceErrorCoefficient = getSpeedDifferenceErrorCoefficient(v, oc);
96 const double speedDifferenceChangePerceptionThreshold = getSpeedDifferenceChangePerceptionThreshold(v, oc);
97 const double headwayChangePerceptionThreshold = getHeadwayChangePerceptionThreshold(v, oc);
98 const double headwayErrorCoefficient = getHeadwayErrorCoefficient(v, oc);
99 const double maximalReactionTime = getMaximalReactionTime(v, oc);
100 // build the device
101 MSDevice_DriverState* device = new MSDevice_DriverState(v, "driverstate" + v.getID(),
102 minAwareness,
103 initialAwareness,
104 errorTimeScaleCoefficient,
105 errorNoiseIntensityCoefficient,
106 speedDifferenceErrorCoefficient,
107 speedDifferenceChangePerceptionThreshold,
108 headwayChangePerceptionThreshold,
109 headwayErrorCoefficient,
110 maximalReactionTime);
111 into.push_back(device);
112 }
113}
114
115
116double
118 return getFloatParam(v, oc, "driverstate.minAwareness", DriverStateDefaults::minAwareness, false);
119}
120double
122 return getFloatParam(v, oc, "driverstate.initialAwareness", DriverStateDefaults::initialAwareness, false);
123}
124double
126 return getFloatParam(v, oc, "driverstate.errorTimeScaleCoefficient", DriverStateDefaults::errorTimeScaleCoefficient, false);
127}
128double
130 return getFloatParam(v, oc, "driverstate.errorNoiseIntensityCoefficient", DriverStateDefaults::errorNoiseIntensityCoefficient, false);
131}
132double
134 return getFloatParam(v, oc, "driverstate.speedDifferenceErrorCoefficient", DriverStateDefaults::speedDifferenceErrorCoefficient, false);
135}
136double
138 return getFloatParam(v, oc, "driverstate.speedDifferenceChangePerceptionThreshold", DriverStateDefaults::speedDifferenceChangePerceptionThreshold, false);
139}
140double
142 return getFloatParam(v, oc, "driverstate.headwayChangePerceptionThreshold", DriverStateDefaults::headwayChangePerceptionThreshold, false);
143}
144double
146 return getFloatParam(v, oc, "driverstate.headwayErrorCoefficient", DriverStateDefaults::headwayErrorCoefficient, false);
147}
148double
150 return getFloatParam(v, oc, "driverstate.maximalReactionTime", -1.0, false);
151}
152
153
154// ---------------------------------------------------------------------------
155// MSDevice_DriverState-methods
156// ---------------------------------------------------------------------------
158 double minAwareness,
159 double initialAwareness,
160 double errorTimeScaleCoefficient,
161 double errorNoiseIntensityCoefficient,
162 double speedDifferenceErrorCoefficient,
163 double speedDifferenceChangePerceptionThreshold,
164 double headwayChangePerceptionThreshold,
165 double headwayErrorCoefficient,
166 double maximalReactionTime) :
167 MSVehicleDevice(holder, id),
168 myMinAwareness(minAwareness),
169 myInitialAwareness(initialAwareness),
170 myErrorTimeScaleCoefficient(errorTimeScaleCoefficient),
171 myErrorNoiseIntensityCoefficient(errorNoiseIntensityCoefficient),
172 mySpeedDifferenceErrorCoefficient(speedDifferenceErrorCoefficient),
173 mySpeedDifferenceChangePerceptionThreshold(speedDifferenceChangePerceptionThreshold),
174 myHeadwayChangePerceptionThreshold(headwayChangePerceptionThreshold),
175 myHeadwayErrorCoefficient(headwayErrorCoefficient),
176 myMaximalReactionTime(maximalReactionTime) {
177 // Take care! Holder is currently being constructed. Cast occurs before completion.
178 myHolderMS = static_cast<MSVehicle*>(&holder);
180
181
182#ifdef DEBUG_DSDEVICE
183 std::cout << "initialized device '" << id << "' with "
184 << "myMinAwareness=" << myMinAwareness << ", "
185 << "myInitialAwareness=" << myInitialAwareness << ", "
186 << "myErrorTimeScaleCoefficient=" << myErrorTimeScaleCoefficient << ", "
187 << "myErrorNoiseIntensityCoefficient=" << myErrorNoiseIntensityCoefficient << ", "
188 << "mySpeedDifferenceErrorCoefficient=" << mySpeedDifferenceErrorCoefficient << ", "
189 << "mySpeedDifferenceChangePerceptionThreshold=" << mySpeedDifferenceChangePerceptionThreshold << ", "
190 << "myHeadwayChangePerceptionThreshold=" << myHeadwayChangePerceptionThreshold << ", "
191 << "myHeadwayErrorCoefficient=" << myHeadwayErrorCoefficient << std::endl;
192#endif
193
194}
195
196void
198 myDriverState = std::make_shared<MSSimpleDriverState>(myHolderMS);
199 myDriverState->setMinAwareness(myMinAwareness);
200 myDriverState->setInitialAwareness(myInitialAwareness);
201 myDriverState->setErrorTimeScaleCoefficient(myErrorTimeScaleCoefficient);
202 myDriverState->setErrorNoiseIntensityCoefficient(myErrorNoiseIntensityCoefficient);
203 myDriverState->setSpeedDifferenceErrorCoefficient(mySpeedDifferenceErrorCoefficient);
204 myDriverState->setHeadwayErrorCoefficient(myHeadwayErrorCoefficient);
205 myDriverState->setSpeedDifferenceChangePerceptionThreshold(mySpeedDifferenceChangePerceptionThreshold);
206 myDriverState->setHeadwayChangePerceptionThreshold(myHeadwayChangePerceptionThreshold);
207 myDriverState->setAwareness(myInitialAwareness);
208 if (myMaximalReactionTime > 0) {
209 myDriverState->setMaximalReactionTime(myMaximalReactionTime);
210 }
211}
212
213void
215 myDriverState->update();
216}
217
218std::string
219MSDevice_DriverState::getParameter(const std::string& key) const {
220#ifdef DEBUG_DSDEVICE
221 std::cout << "MSDevice_DriverState::getParameter(key=" << key << ")" << std::endl;
222#endif
223 if (key == "awareness") {
224 return toString(myDriverState->getAwareness());
225 } else if (key == "errorState") {
226 return toString(myDriverState->getErrorState());
227 } else if (key == "errorTimeScale") {
228 return toString(myDriverState->getErrorTimeScale());
229 } else if (key == "errorNoiseIntensity") {
230 return toString(myDriverState->getErrorNoiseIntensity());
231 } else if (key == "minAwareness") {
232 return toString(myDriverState->getMinAwareness());
233 } else if (key == "initialAwareness") {
234 return toString(myDriverState->getInitialAwareness());
235 } else if (key == "errorTimeScaleCoefficient") {
236 return toString(myDriverState->getErrorTimeScaleCoefficient());
237 } else if (key == "errorNoiseIntensityCoefficient") {
238 return toString(myDriverState->getErrorNoiseIntensityCoefficient());
239 } else if (key == "speedDifferenceErrorCoefficient") {
240 return toString(myDriverState->getSpeedDifferenceErrorCoefficient());
241 } else if (key == "headwayErrorCoefficient") {
242 return toString(myDriverState->getHeadwayErrorCoefficient());
243 } else if (key == "speedDifferenceChangePerceptionThreshold") {
244 return toString(myDriverState->getSpeedDifferenceChangePerceptionThreshold());
245 } else if (key == "headwayChangePerceptionThreshold") {
246 return toString(myDriverState->getHeadwayChangePerceptionThreshold());
247 } else if (key == "maximalReactionTime") {
248 return toString(myDriverState->getMaximalReactionTime());
249 } else if (key == "originalReactionTime") {
250 return toString(myDriverState->getOriginalReactionTime());
251 } else if (key == "actionStepLength") {
252 return toString(myDriverState->getActionStepLength());
253 }
254 throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
255}
256
257
258void
259MSDevice_DriverState::setParameter(const std::string& key, const std::string& value) {
260#ifdef DEBUG_DSDEVICE
261 std::cout << "MSDevice_DriverState::setParameter(key=" << key << ", value=" << value << ")" << std::endl;
262#endif
263 if (key == "awareness") {
264 myDriverState->setAwareness(StringUtils::toDouble(value));
265 } else if (key == "errorState") {
266 myDriverState->setErrorState(StringUtils::toDouble(value));
267 } else if (key == "errorTimeScale") {
268 myDriverState->setErrorTimeScale(StringUtils::toDouble(value));
269 } else if (key == "errorNoiseIntensity") {
270 myDriverState->setErrorNoiseIntensity(StringUtils::toDouble(value));
271 } else if (key == "minAwareness") {
272 myDriverState->setMinAwareness(StringUtils::toDouble(value));
273 } else if (key == "initialAwareness") {
274 myDriverState->setInitialAwareness(StringUtils::toDouble(value));
275 } else if (key == "errorTimeScaleCoefficient") {
276 myDriverState->setErrorTimeScaleCoefficient(StringUtils::toDouble(value));
277 } else if (key == "errorNoiseIntensityCoefficient") {
278 myDriverState->setErrorNoiseIntensityCoefficient(StringUtils::toDouble(value));
279 } else if (key == "speedDifferenceErrorCoefficient") {
280 myDriverState->setSpeedDifferenceErrorCoefficient(StringUtils::toDouble(value));
281 } else if (key == "headwayErrorCoefficient") {
282 myDriverState->setHeadwayErrorCoefficient(StringUtils::toDouble(value));
283 } else if (key == "speedDifferenceChangePerceptionThreshold") {
284 myDriverState->setSpeedDifferenceChangePerceptionThreshold(StringUtils::toDouble(value));
285 } else if (key == "headwayChangePerceptionThreshold") {
286 myDriverState->setHeadwayChangePerceptionThreshold(StringUtils::toDouble(value));
287 } else if (key == "maximalReactionTime") {
288 myDriverState->setMaximalReactionTime(StringUtils::toDouble(value));
289 } else if (key == "originalReactionTime") {
290 myDriverState->setOriginalReactionTime(StringUtils::toDouble(value));
291 } else {
292 throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
293 }
294}
295
296
297/****************************************************************************/
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.
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 maximalReactionTime)
Constructor.
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.
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 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 *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:76
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:60
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 headwayErrorCoefficient
static double errorTimeScaleCoefficient
static double errorNoiseIntensityCoefficient
static double speedDifferenceErrorCoefficient