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-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
20 /****************************************************************************/
21 
22 // ===========================================================================
23 // included modules
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 == "errorNoiseIntensity") {
232  return toString(myDriverState->getErrorNoiseIntensity());
233  } else if (key == "minAwareness") {
234  return toString(myDriverState->getMinAwareness());
235  } else if (key == "initialAwareness") {
236  return toString(myDriverState->getInitialAwareness());
237  } else if (key == "errorTimeScaleCoefficient") {
238  return toString(myDriverState->getErrorTimeScaleCoefficient());
239  } else if (key == "errorNoiseIntensityCoefficient") {
240  return toString(myDriverState->getErrorNoiseIntensityCoefficient());
241  } else if (key == "speedDifferenceErrorCoefficient") {
242  return toString(myDriverState->getSpeedDifferenceErrorCoefficient());
243  } else if (key == "headwayErrorCoefficient") {
244  return toString(myDriverState->getHeadwayErrorCoefficient());
245  } else if (key == "speedDifferenceChangePerceptionThreshold") {
246  return toString(myDriverState->getSpeedDifferenceChangePerceptionThreshold());
247  } else if (key == "headwayChangePerceptionThreshold") {
248  return toString(myDriverState->getHeadwayChangePerceptionThreshold());
249  } else if (key == "maximalReactionTime") {
250  return toString(myDriverState->getMaximalReactionTime());
251  } else if (key == "originalReactionTime") {
252  return toString(myDriverState->getOriginalReactionTime());
253  } else if (key == "actionStepLength") {
254  return toString(myDriverState->getActionStepLength());
255  }
256  throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
257 }
258 
259 
260 void
261 MSDevice_DriverState::setParameter(const std::string& key, const std::string& value) {
262 #ifdef DEBUG_DSDEVICE
263  std::cout << "MSDevice_DriverState::setParameter(key=" << key << ", value=" << value << ")" << std::endl;
264 #endif
265  if (key == "awareness") {
266  myDriverState->setAwareness(StringUtils::toDouble(value));
267  } else if (key == "errorState") {
268  myDriverState->setErrorState(StringUtils::toDouble(value));
269  } else if (key == "errorTimeScale") {
270  myDriverState->setErrorTimeScale(StringUtils::toDouble(value));
271  } else if (key == "errorNoiseIntensity") {
272  myDriverState->setErrorNoiseIntensity(StringUtils::toDouble(value));
273  } else if (key == "minAwareness") {
274  myDriverState->setMinAwareness(StringUtils::toDouble(value));
275  } else if (key == "initialAwareness") {
276  myDriverState->setInitialAwareness(StringUtils::toDouble(value));
277  } else if (key == "errorTimeScaleCoefficient") {
278  myDriverState->setErrorTimeScaleCoefficient(StringUtils::toDouble(value));
279  } else if (key == "errorNoiseIntensityCoefficient") {
280  myDriverState->setErrorNoiseIntensityCoefficient(StringUtils::toDouble(value));
281  } else if (key == "speedDifferenceErrorCoefficient") {
282  myDriverState->setSpeedDifferenceErrorCoefficient(StringUtils::toDouble(value));
283  } else if (key == "headwayErrorCoefficient") {
284  myDriverState->setHeadwayErrorCoefficient(StringUtils::toDouble(value));
285  } else if (key == "speedDifferenceChangePerceptionThreshold") {
286  myDriverState->setSpeedDifferenceChangePerceptionThreshold(StringUtils::toDouble(value));
287  } else if (key == "headwayChangePerceptionThreshold") {
288  myDriverState->setHeadwayChangePerceptionThreshold(StringUtils::toDouble(value));
289  } else if (key == "maximalReactionTime") {
290  myDriverState->setMaximalReactionTime(StringUtils::toDouble(value));
291  } else if (key == "originalReactionTime") {
292  myDriverState->setOriginalReactionTime(StringUtils::toDouble(value));
293  } else {
294  throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
295  }
296 }
297 
298 
299 /****************************************************************************/
300 
MSDevice_DriverState.h
MSDevice_DriverState::getHeadwayErrorCoefficient
static double getHeadwayErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:145
MSNet.h
MSDevice_DriverState::myHeadwayChangePerceptionThreshold
double myHeadwayChangePerceptionThreshold
Definition: MSDevice_DriverState.h:146
OptionsCont.h
MSDevice_DriverState::myErrorTimeScaleCoefficient
double myErrorTimeScaleCoefficient
Definition: MSDevice_DriverState.h:142
StringUtils::toDouble
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
Definition: StringUtils.cpp:345
SUMOTrafficObject::getID
virtual const std::string & getID() const =0
Get the vehicle's ID.
WrappingCommand.h
MSDevice_DriverState::myInitialAwareness
double myInitialAwareness
Definition: MSDevice_DriverState.h:141
SUMOVehicle
Representation of a vehicle.
Definition: SUMOVehicle.h:60
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:57
MSDevice_DriverState::mySpeedDifferenceErrorCoefficient
double mySpeedDifferenceErrorCoefficient
Definition: MSDevice_DriverState.h:144
MSDevice_DriverState::deviceName
const std::string deviceName() const
return the name for this type of device
Definition: MSDevice_DriverState.h:102
MSDevice_DriverState::getErrorTimeScaleCoefficient
static double getErrorTimeScaleCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:125
MSDevice_DriverState
The ToC Device controls transition of control between automated and manual driving.
Definition: MSDevice_DriverState.h:54
RGBColor.h
MSDevice_DriverState::insertOptions
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_DriverState-options.
Definition: MSDevice_DriverState.cpp:62
MSVehicle.h
MSDevice_DriverState::mySpeedDifferenceChangePerceptionThreshold
double mySpeedDifferenceChangePerceptionThreshold
Definition: MSDevice_DriverState.h:145
MSDevice_DriverState::getMinAwareness
static double getMinAwareness(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:117
MSDevice_DriverState::myMinAwareness
double myMinAwareness
Definition: MSDevice_DriverState.h:140
SUMOVehicle.h
OptionsCont::addDescription
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
Definition: OptionsCont.cpp:469
MSDevice_DriverState::myMaximalReactionTime
double myMaximalReactionTime
Definition: MSDevice_DriverState.h:148
MSDevice::insertDefaultAssignmentOptions
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:126
MSDevice_DriverState::getHeadwayChangePerceptionThreshold
static double getHeadwayChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:141
MSDevice_DriverState::setParameter
void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this device. Throw exception for unsupported key
Definition: MSDevice_DriverState.cpp:261
MSDevice_DriverState::myErrorNoiseIntensityCoefficient
double myErrorNoiseIntensityCoefficient
Definition: MSDevice_DriverState.h:143
OptionsCont::doRegister
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:74
MSDevice_DriverState::getMaximalReactionTime
static double getMaximalReactionTime(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:149
MSDevice_DriverState::buildVehicleDevices
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into)
Build devices for the given vehicle, if needed.
Definition: MSDevice_DriverState.cpp:87
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
MSDevice_DriverState::update
void update()
update internal state
Definition: MSDevice_DriverState.cpp:214
MSDevice::getFloatParam
static double getFloatParam(const SUMOVehicle &v, const OptionsCont &oc, std::string paramName, double deflt, bool required)
Definition: MSDevice.cpp:186
OptionsCont::addOptionSubTopic
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
Definition: OptionsCont.cpp:519
MSDevice_DriverState::myHolderMS
MSVehicle * myHolderMS
The holder vehicle casted to MSVehicle*.
Definition: MSDevice_DriverState.h:135
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
StringUtils.h
MSDriverState.h
MSDevice::equippedByDefaultAssignmentOptions
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:203
MSDevice_DriverState::getSpeedDifferenceErrorCoefficient
static double getSpeedDifferenceErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:133
MSDevice_DriverState::getInitialAwareness
static double getInitialAwareness(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:121
InvalidArgument
Definition: UtilExceptions.h:56
Option_Float
Definition: Option.h:470
MSDevice_DriverState::myDriverState
std::shared_ptr< MSSimpleDriverState > myDriverState
The driver state of the holder.
Definition: MSDevice_DriverState.h:152
MSDevice_DriverState::getErrorNoiseIntensityCoefficient
static double getErrorNoiseIntensityCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:129
config.h
MSEventControl.h
MSDevice_DriverState::MSDevice_DriverState
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.
Definition: MSDevice_DriverState.cpp:157
MSDevice_DriverState::initDriverState
void initDriverState()
Initializeses the driver state parameters.
Definition: MSDevice_DriverState.cpp:197
MSRouteHandler.h
MSVehicleControl.h
MSDevice_DriverState::myHeadwayErrorCoefficient
double myHeadwayErrorCoefficient
Definition: MSDevice_DriverState.h:147
MSDevice_DriverState::getSpeedDifferenceChangePerceptionThreshold
static double getSpeedDifferenceChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:137
MSDevice_DriverState::getParameter
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key
Definition: MSDevice_DriverState.cpp:219
MSVehicleDevice
Abstract in-vehicle device.
Definition: MSVehicleDevice.h:54