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 /****************************************************************************/
21 /****************************************************************************/
22 
23 // ===========================================================================
24 // included modules
25 // ===========================================================================
26 #include <config.h>
27 
32 #include <utils/common/RGBColor.h>
33 #include <microsim/MSNet.h>
34 #include <microsim/MSVehicle.h>
38 #include <microsim/MSDriverState.h>
39 #include "MSDevice_DriverState.h"
40 
41 
42 // ===========================================================================
43 // debug constants
44 // ===========================================================================
45 //#define DEBUG_DSDEVICE
46 //#define DEBUG_COND (myHolder.isSelected())
47 
48 
49 // ===========================================================================
50 // parameter defaults
51 // ===========================================================================
52 
53 // see DriverStateDefaults in MSDriverState
54 
55 
56 // ===========================================================================
57 // method definitions
58 // ===========================================================================
59 // ---------------------------------------------------------------------------
60 // static initialisation methods
61 // ---------------------------------------------------------------------------
62 void
64  oc.addOptionSubTopic("Driver State Device");
65  insertDefaultAssignmentOptions("driverstate", "Driver State Device", oc);
66  oc.doRegister("device.driverstate.initialAwareness", new Option_Float(DriverStateDefaults::initialAwareness));
67  oc.addDescription("device.driverstate.initialAwareness", "Driver State Device", "Initial value assigned to the driver's awareness.");
68  oc.doRegister("device.driverstate.errorTimeScaleCoefficient", new Option_Float(DriverStateDefaults::errorTimeScaleCoefficient));
69  oc.addDescription("device.driverstate.errorTimeScaleCoefficient", "Driver State Device", "Time scale for the error process.");
70  oc.doRegister("device.driverstate.errorNoiseIntensityCoefficient", new Option_Float(DriverStateDefaults::errorNoiseIntensityCoefficient));
71  oc.addDescription("device.driverstate.errorNoiseIntensityCoefficient", "Driver State Device", "Noise intensity driving the error process.");
72  oc.doRegister("device.driverstate.speedDifferenceErrorCoefficient", new Option_Float(DriverStateDefaults::speedDifferenceErrorCoefficient));
73  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).");
74  oc.doRegister("device.driverstate.headwayErrorCoefficient", new Option_Float(DriverStateDefaults::headwayErrorCoefficient));
75  oc.addDescription("device.driverstate.headwayErrorCoefficient", "Driver State Device", "General scaling coefficient for applying the error to the perceived distance (error also scales with distance).");
76  oc.doRegister("device.driverstate.speedDifferenceChangePerceptionThreshold", new Option_Float(DriverStateDefaults::speedDifferenceChangePerceptionThreshold));
77  oc.addDescription("device.driverstate.speedDifferenceChangePerceptionThreshold", "Driver State Device", "Base threshold for recognizing changes in the speed difference (threshold also scales with distance).");
78  oc.doRegister("device.driverstate.headwayChangePerceptionThreshold", new Option_Float(DriverStateDefaults::headwayChangePerceptionThreshold));
79  oc.addDescription("device.driverstate.headwayChangePerceptionThreshold", "Driver State Device", "Base threshold for recognizing changes in the headway (threshold also scales with distance).");
80  oc.doRegister("device.driverstate.minAwareness", new Option_Float(DriverStateDefaults::minAwareness));
81  oc.addDescription("device.driverstate.minAwareness", "Driver State Device", "Minimal admissible value for the driver's awareness.");
82  oc.doRegister("device.driverstate.maximalReactionTime", new Option_Float(-1.0));
83  oc.addDescription("device.driverstate.maximalReactionTime", "Driver State Device", "Maximal reaction time (~action step length) induced by decreased awareness level (reached for awareness=minAwareness).");
84 }
85 
86 
87 void
88 MSDevice_DriverState::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into) {
90  // ToC device implies driverstate
91  if (equippedByDefaultAssignmentOptions(oc, "driverstate", v, false) || equippedByDefaultAssignmentOptions(oc, "toc", v, false)) {
92  const double minAwareness = getMinAwareness(v, oc);
93  const double initialAwareness = getInitialAwareness(v, oc);
94  const double errorTimeScaleCoefficient = getErrorTimeScaleCoefficient(v, oc);
95  const double errorNoiseIntensityCoefficient = getErrorNoiseIntensityCoefficient(v, oc);
96  const double speedDifferenceErrorCoefficient = getSpeedDifferenceErrorCoefficient(v, oc);
97  const double speedDifferenceChangePerceptionThreshold = getSpeedDifferenceChangePerceptionThreshold(v, oc);
98  const double headwayChangePerceptionThreshold = getHeadwayChangePerceptionThreshold(v, oc);
99  const double headwayErrorCoefficient = getHeadwayErrorCoefficient(v, oc);
100  const double maximalReactionTime = getMaximalReactionTime(v, oc);
101  // build the device
102  MSDevice_DriverState* device = new MSDevice_DriverState(v, "driverstate" + v.getID(),
103  minAwareness,
104  initialAwareness,
105  errorTimeScaleCoefficient,
106  errorNoiseIntensityCoefficient,
107  speedDifferenceErrorCoefficient,
108  speedDifferenceChangePerceptionThreshold,
109  headwayChangePerceptionThreshold,
110  headwayErrorCoefficient,
111  maximalReactionTime);
112  into.push_back(device);
113  }
114 }
115 
116 
117 double
119  return getFloatParam(v, oc, "driverstate.minAwareness", DriverStateDefaults::minAwareness, false);
120 }
121 double
123  return getFloatParam(v, oc, "driverstate.initialAwareness", DriverStateDefaults::initialAwareness, false);
124 }
125 double
127  return getFloatParam(v, oc, "driverstate.errorTimeScaleCoefficient", DriverStateDefaults::errorTimeScaleCoefficient, false);
128 }
129 double
131  return getFloatParam(v, oc, "driverstate.errorNoiseIntensityCoefficient", DriverStateDefaults::errorNoiseIntensityCoefficient, false);
132 }
133 double
135  return getFloatParam(v, oc, "driverstate.speedDifferenceErrorCoefficient", DriverStateDefaults::speedDifferenceErrorCoefficient, false);
136 }
137 double
139  return getFloatParam(v, oc, "driverstate.speedDifferenceChangePerceptionThreshold", DriverStateDefaults::speedDifferenceChangePerceptionThreshold, false);
140 }
141 double
143  return getFloatParam(v, oc, "driverstate.headwayChangePerceptionThreshold", DriverStateDefaults::headwayChangePerceptionThreshold, false);
144 }
145 double
147  return getFloatParam(v, oc, "driverstate.headwayErrorCoefficient", DriverStateDefaults::headwayErrorCoefficient, false);
148 }
149 double
151  return getFloatParam(v, oc, "driverstate.maximalReactionTime", -1.0, false);
152 }
153 
154 
155 // ---------------------------------------------------------------------------
156 // MSDevice_DriverState-methods
157 // ---------------------------------------------------------------------------
159  double minAwareness,
160  double initialAwareness,
161  double errorTimeScaleCoefficient,
162  double errorNoiseIntensityCoefficient,
163  double speedDifferenceErrorCoefficient,
164  double speedDifferenceChangePerceptionThreshold,
165  double headwayChangePerceptionThreshold,
166  double headwayErrorCoefficient,
167  double maximalReactionTime) :
168  MSVehicleDevice(holder, id),
169  myMinAwareness(minAwareness),
170  myInitialAwareness(initialAwareness),
171  myErrorTimeScaleCoefficient(errorTimeScaleCoefficient),
172  myErrorNoiseIntensityCoefficient(errorNoiseIntensityCoefficient),
173  mySpeedDifferenceErrorCoefficient(speedDifferenceErrorCoefficient),
174  mySpeedDifferenceChangePerceptionThreshold(speedDifferenceChangePerceptionThreshold),
175  myHeadwayChangePerceptionThreshold(headwayChangePerceptionThreshold),
176  myHeadwayErrorCoefficient(headwayErrorCoefficient),
177  myMaximalReactionTime(maximalReactionTime) {
178  // Take care! Holder is currently being constructed. Cast occurs before completion.
179  myHolderMS = static_cast<MSVehicle*>(&holder);
180  initDriverState();
181 
182 
183 #ifdef DEBUG_DSDEVICE
184  std::cout << "initialized device '" << id << "' with "
185  << "myMinAwareness=" << myMinAwareness << ", "
186  << "myInitialAwareness=" << myInitialAwareness << ", "
187  << "myErrorTimeScaleCoefficient=" << myErrorTimeScaleCoefficient << ", "
188  << "myErrorNoiseIntensityCoefficient=" << myErrorNoiseIntensityCoefficient << ", "
189  << "mySpeedDifferenceErrorCoefficient=" << mySpeedDifferenceErrorCoefficient << ", "
190  << "mySpeedDifferenceChangePerceptionThreshold=" << mySpeedDifferenceChangePerceptionThreshold << ", "
191  << "myHeadwayChangePerceptionThreshold=" << myHeadwayChangePerceptionThreshold << ", "
192  << "myHeadwayErrorCoefficient=" << myHeadwayErrorCoefficient << std::endl;
193 #endif
194 
195 }
196 
197 void
199  myDriverState = std::make_shared<MSSimpleDriverState>(myHolderMS);
200  myDriverState->setMinAwareness(myMinAwareness);
201  myDriverState->setInitialAwareness(myInitialAwareness);
202  myDriverState->setErrorTimeScaleCoefficient(myErrorTimeScaleCoefficient);
203  myDriverState->setErrorNoiseIntensityCoefficient(myErrorNoiseIntensityCoefficient);
204  myDriverState->setSpeedDifferenceErrorCoefficient(mySpeedDifferenceErrorCoefficient);
205  myDriverState->setHeadwayErrorCoefficient(myHeadwayErrorCoefficient);
206  myDriverState->setSpeedDifferenceChangePerceptionThreshold(mySpeedDifferenceChangePerceptionThreshold);
207  myDriverState->setHeadwayChangePerceptionThreshold(myHeadwayChangePerceptionThreshold);
208  myDriverState->setAwareness(myInitialAwareness);
209  if (myMaximalReactionTime > 0) {
210  myDriverState->setMaximalReactionTime(myMaximalReactionTime);
211  }
212 }
213 
214 void
216  myDriverState->update();
217 }
218 
219 std::string
220 MSDevice_DriverState::getParameter(const std::string& key) const {
221 #ifdef DEBUG_DSDEVICE
222  std::cout << "MSDevice_DriverState::getParameter(key=" << key << ")" << std::endl;
223 #endif
224  if (key == "awareness") {
225  return toString(myDriverState->getAwareness());
226  } else if (key == "errorState") {
227  return toString(myDriverState->getErrorState());
228  } else if (key == "errorTimeScale") {
229  return toString(myDriverState->getErrorTimeScale());
230  } else if (key == "errorNoiseIntensity") {
231  return toString(myDriverState->getErrorNoiseIntensity());
232  } else if (key == "errorNoiseIntensity") {
233  return toString(myDriverState->getErrorNoiseIntensity());
234  } else if (key == "minAwareness") {
235  return toString(myDriverState->getMinAwareness());
236  } else if (key == "initialAwareness") {
237  return toString(myDriverState->getInitialAwareness());
238  } else if (key == "errorTimeScaleCoefficient") {
239  return toString(myDriverState->getErrorTimeScaleCoefficient());
240  } else if (key == "errorNoiseIntensityCoefficient") {
241  return toString(myDriverState->getErrorNoiseIntensityCoefficient());
242  } else if (key == "speedDifferenceErrorCoefficient") {
243  return toString(myDriverState->getSpeedDifferenceErrorCoefficient());
244  } else if (key == "headwayErrorCoefficient") {
245  return toString(myDriverState->getHeadwayErrorCoefficient());
246  } else if (key == "speedDifferenceChangePerceptionThreshold") {
247  return toString(myDriverState->getSpeedDifferenceChangePerceptionThreshold());
248  } else if (key == "headwayChangePerceptionThreshold") {
249  return toString(myDriverState->getHeadwayChangePerceptionThreshold());
250  } else if (key == "maximalReactionTime") {
251  return toString(myDriverState->getMaximalReactionTime());
252  } else if (key == "originalReactionTime") {
253  return toString(myDriverState->getOriginalReactionTime());
254  } else if (key == "actionStepLength") {
255  return toString(myDriverState->getActionStepLength());
256  }
257  throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
258 }
259 
260 
261 void
262 MSDevice_DriverState::setParameter(const std::string& key, const std::string& value) {
263 #ifdef DEBUG_DSDEVICE
264  std::cout << "MSDevice_DriverState::setParameter(key=" << key << ", value=" << value << ")" << std::endl;
265 #endif
266  if (key == "awareness") {
267  myDriverState->setAwareness(StringUtils::toDouble(value));
268  } else if (key == "errorState") {
269  myDriverState->setErrorState(StringUtils::toDouble(value));
270  } else if (key == "errorTimeScale") {
271  myDriverState->setErrorTimeScale(StringUtils::toDouble(value));
272  } else if (key == "errorNoiseIntensity") {
273  myDriverState->setErrorNoiseIntensity(StringUtils::toDouble(value));
274  } else if (key == "minAwareness") {
275  myDriverState->setMinAwareness(StringUtils::toDouble(value));
276  } else if (key == "initialAwareness") {
277  myDriverState->setInitialAwareness(StringUtils::toDouble(value));
278  } else if (key == "errorTimeScaleCoefficient") {
279  myDriverState->setErrorTimeScaleCoefficient(StringUtils::toDouble(value));
280  } else if (key == "errorNoiseIntensityCoefficient") {
281  myDriverState->setErrorNoiseIntensityCoefficient(StringUtils::toDouble(value));
282  } else if (key == "speedDifferenceErrorCoefficient") {
283  myDriverState->setSpeedDifferenceErrorCoefficient(StringUtils::toDouble(value));
284  } else if (key == "headwayErrorCoefficient") {
285  myDriverState->setHeadwayErrorCoefficient(StringUtils::toDouble(value));
286  } else if (key == "speedDifferenceChangePerceptionThreshold") {
287  myDriverState->setSpeedDifferenceChangePerceptionThreshold(StringUtils::toDouble(value));
288  } else if (key == "headwayChangePerceptionThreshold") {
289  myDriverState->setHeadwayChangePerceptionThreshold(StringUtils::toDouble(value));
290  } else if (key == "maximalReactionTime") {
291  myDriverState->setMaximalReactionTime(StringUtils::toDouble(value));
292  } else if (key == "originalReactionTime") {
293  myDriverState->setOriginalReactionTime(StringUtils::toDouble(value));
294  } else {
295  throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
296  }
297 }
298 
299 
300 /****************************************************************************/
301 
MSDevice_DriverState.h
MSDevice_DriverState::getHeadwayErrorCoefficient
static double getHeadwayErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:146
MSNet.h
MSDevice_DriverState::myHeadwayChangePerceptionThreshold
double myHeadwayChangePerceptionThreshold
Definition: MSDevice_DriverState.h:147
OptionsCont.h
MSDevice_DriverState::myErrorTimeScaleCoefficient
double myErrorTimeScaleCoefficient
Definition: MSDevice_DriverState.h:143
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:313
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:142
SUMOVehicle
Representation of a vehicle.
Definition: SUMOVehicle.h:61
OptionsCont::getOptions
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
MSDevice_DriverState::mySpeedDifferenceErrorCoefficient
double mySpeedDifferenceErrorCoefficient
Definition: MSDevice_DriverState.h:145
MSDevice_DriverState::deviceName
const std::string deviceName() const
return the name for this type of device
Definition: MSDevice_DriverState.h:103
MSDevice_DriverState::getErrorTimeScaleCoefficient
static double getErrorTimeScaleCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:126
MSDevice_DriverState
The ToC Device controls transition of control between automated and manual driving.
Definition: MSDevice_DriverState.h:55
RGBColor.h
MSDevice_DriverState::insertOptions
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_DriverState-options.
Definition: MSDevice_DriverState.cpp:63
MSVehicle.h
MSDevice_DriverState::mySpeedDifferenceChangePerceptionThreshold
double mySpeedDifferenceChangePerceptionThreshold
Definition: MSDevice_DriverState.h:146
MSDevice_DriverState::getMinAwareness
static double getMinAwareness(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:118
MSDevice_DriverState::myMinAwareness
double myMinAwareness
Definition: MSDevice_DriverState.h:141
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:473
MSDevice_DriverState::myMaximalReactionTime
double myMaximalReactionTime
Definition: MSDevice_DriverState.h:149
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:142
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:262
MSDevice_DriverState::myErrorNoiseIntensityCoefficient
double myErrorNoiseIntensityCoefficient
Definition: MSDevice_DriverState.h:144
OptionsCont::doRegister
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:75
MSDevice_DriverState::getMaximalReactionTime
static double getMaximalReactionTime(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:150
MSDevice_DriverState::buildVehicleDevices
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into)
Build devices for the given vehicle, if needed.
Definition: MSDevice_DriverState.cpp:88
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:90
MSDevice_DriverState::update
void update()
update internal state
Definition: MSDevice_DriverState.cpp:215
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:523
MSDevice_DriverState::myHolderMS
MSVehicle * myHolderMS
The holder vehicle casted to MSVehicle*.
Definition: MSDevice_DriverState.h:136
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:48
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:204
MSDevice_DriverState::getSpeedDifferenceErrorCoefficient
static double getSpeedDifferenceErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:134
MSDevice_DriverState::getInitialAwareness
static double getInitialAwareness(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:122
InvalidArgument
Definition: UtilExceptions.h:57
Option_Float
Definition: Option.h:472
MSDevice_DriverState::myDriverState
std::shared_ptr< MSSimpleDriverState > myDriverState
The driver state of the holder.
Definition: MSDevice_DriverState.h:153
MSDevice_DriverState::getErrorNoiseIntensityCoefficient
static double getErrorNoiseIntensityCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:130
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:158
MSDevice_DriverState::initDriverState
void initDriverState()
Initializeses the driver state parameters.
Definition: MSDevice_DriverState.cpp:198
MSRouteHandler.h
MSVehicleControl.h
MSDevice_DriverState::myHeadwayErrorCoefficient
double myHeadwayErrorCoefficient
Definition: MSDevice_DriverState.h:148
MSDevice_DriverState::getSpeedDifferenceChangePerceptionThreshold
static double getSpeedDifferenceChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
Definition: MSDevice_DriverState.cpp:138
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:220
MSVehicleDevice
Abstract in-vehicle device.
Definition: MSVehicleDevice.h:55