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 
31 #include <utils/common/RGBColor.h>
32 #include <microsim/MSNet.h>
33 #include <microsim/MSVehicle.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
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 
86 void
87 MSDevice_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 
116 double
118  return getFloatParam(v, oc, "driverstate.minAwareness", DriverStateDefaults::minAwareness, false);
119 }
120 double
122  return getFloatParam(v, oc, "driverstate.initialAwareness", DriverStateDefaults::initialAwareness, false);
123 }
124 double
126  return getFloatParam(v, oc, "driverstate.errorTimeScaleCoefficient", DriverStateDefaults::errorTimeScaleCoefficient, false);
127 }
128 double
130  return getFloatParam(v, oc, "driverstate.errorNoiseIntensityCoefficient", DriverStateDefaults::errorNoiseIntensityCoefficient, false);
131 }
132 double
134  return getFloatParam(v, oc, "driverstate.speedDifferenceErrorCoefficient", DriverStateDefaults::speedDifferenceErrorCoefficient, false);
135 }
136 double
138  return getFloatParam(v, oc, "driverstate.speedDifferenceChangePerceptionThreshold", DriverStateDefaults::speedDifferenceChangePerceptionThreshold, false);
139 }
140 double
142  return getFloatParam(v, oc, "driverstate.headwayChangePerceptionThreshold", DriverStateDefaults::headwayChangePerceptionThreshold, false);
143 }
144 double
146  return getFloatParam(v, oc, "driverstate.headwayErrorCoefficient", DriverStateDefaults::headwayErrorCoefficient, false);
147 }
148 double
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);
179  initDriverState();
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 
196 void
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 
213 void
215  myDriverState->update();
216 }
217 
218 std::string
219 MSDevice_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 
258 void
259 MSDevice_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:188
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:137
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:205
Abstract in-vehicle device.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:75
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:75
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
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