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-2018 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::minAwareness));
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 }
83 
84 
85 void
86 MSDevice_DriverState::buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into) {
88  if (equippedByDefaultAssignmentOptions(oc, "driverstate", v, false)) {
89  const double minAwareness = getMinAwareness(v, oc);
90  const double initialAwareness = getInitialAwareness(v, oc);
91  const double errorTimeScaleCoefficient = getErrorTimeScaleCoefficient(v, oc);
92  const double errorNoiseIntensityCoefficient = getErrorNoiseIntensityCoefficient(v, oc);
93  const double speedDifferenceErrorCoefficient = getSpeedDifferenceErrorCoefficient(v, oc);
94  const double speedDifferenceChangePerceptionThreshold = getSpeedDifferenceChangePerceptionThreshold(v, oc);
95  const double headwayChangePerceptionThreshold = getHeadwayChangePerceptionThreshold(v, oc);
96  const double headwayErrorCoefficient = getHeadwayErrorCoefficient(v, oc);
97  // build the device
98  MSDevice_DriverState* device = new MSDevice_DriverState(v, "driverstate" + v.getID(),
99  minAwareness,
100  initialAwareness,
101  errorTimeScaleCoefficient,
102  errorNoiseIntensityCoefficient,
103  speedDifferenceErrorCoefficient,
104  speedDifferenceChangePerceptionThreshold,
105  headwayChangePerceptionThreshold,
106  headwayErrorCoefficient);
107  into.push_back(device);
108  }
109 }
110 
111 
112 double
114  return getFloatParam(v, oc, "driverstate.minAwareness", DriverStateDefaults::minAwareness, false);
115 }
116 double
118  return getFloatParam(v, oc, "driverstate.initialAwareness", DriverStateDefaults::initialAwareness, false);
119 }
120 double
122  return getFloatParam(v, oc, "driverstate.errorTimeScaleCoefficient", DriverStateDefaults::errorTimeScaleCoefficient, false);
123 }
124 double
126  return getFloatParam(v, oc, "driverstate.errorNoiseIntensityCoefficient", DriverStateDefaults::errorNoiseIntensityCoefficient, false);
127 }
128 double
130  return getFloatParam(v, oc, "driverstate.speedDifferenceErrorCoefficient", DriverStateDefaults::speedDifferenceErrorCoefficient, false);
131 }
132 double
134  return getFloatParam(v, oc, "driverstate.speedDifferenceChangePerceptionThreshold", DriverStateDefaults::speedDifferenceChangePerceptionThreshold, false);
135 }
136 double
138  return getFloatParam(v, oc, "driverstate.headwayChangePerceptionThreshold", DriverStateDefaults::headwayChangePerceptionThreshold, false);
139 }
140 double
142  return getFloatParam(v, oc, "driverstate.headwayErrorCoefficient", DriverStateDefaults::headwayErrorCoefficient, false);
143 }
144 
145 
146 // ---------------------------------------------------------------------------
147 // MSDevice_DriverState-methods
148 // ---------------------------------------------------------------------------
150  double minAwareness,
151  double initialAwareness,
152  double errorTimeScaleCoefficient,
153  double errorNoiseIntensityCoefficient,
154  double speedDifferenceErrorCoefficient,
155  double speedDifferenceChangePerceptionThreshold,
156  double headwayChangePerceptionThreshold,
157  double headwayErrorCoefficient) :
158  MSVehicleDevice(holder, id),
159  myMinAwareness(minAwareness),
160  myInitialAwareness(initialAwareness),
161  myErrorTimeScaleCoefficient(errorTimeScaleCoefficient),
162  myErrorNoiseIntensityCoefficient(errorNoiseIntensityCoefficient),
163  mySpeedDifferenceErrorCoefficient(speedDifferenceErrorCoefficient),
164  mySpeedDifferenceChangePerceptionThreshold(speedDifferenceChangePerceptionThreshold),
165  myHeadwayChangePerceptionThreshold(headwayChangePerceptionThreshold),
166  myHeadwayErrorCoefficient(headwayErrorCoefficient),
167  myDriverState(nullptr) {
168  // Take care! Holder is currently being constructed. Cast occurs before completion.
169  myHolderMS = static_cast<MSVehicle*>(&holder);
170  // Ensure that the holder receives a driver state as soon as it is created (can't be done here, since myHolderMS is incomplete)
172 
173 #ifdef DEBUG_DSDEVICE
174  std::cout << "initialized device '" << id << "' with "
175  << "myMinAwareness=" << myMinAwareness << ", "
176  << "myInitialAwareness=" << myInitialAwareness << ", "
177  << "myErrorTimeScaleCoefficient=" << myErrorTimeScaleCoefficient << ", "
178  << "myErrorNoiseIntensityCoefficient=" << myErrorNoiseIntensityCoefficient << ", "
179  << "mySpeedDifferenceErrorCoefficient=" << mySpeedDifferenceErrorCoefficient << ", "
180  << "mySpeedDifferenceChangePerceptionThreshold=" << mySpeedDifferenceChangePerceptionThreshold << ", "
181  << "myHeadwayChangePerceptionThreshold=" << myHeadwayChangePerceptionThreshold << ", "
182  << "myHeadwayErrorCoefficient=" << myHeadwayErrorCoefficient << std::endl;
183 #endif
184 
185 }
186 
187 //MSDevice_DriverState::~MSDevice_DriverState() {}
188 
189 SUMOTime
191 #ifdef DEBUG_DSDEVICE
192  std::cout << SIMTIME << " MSDevice_DriverState::createDriverState() for vehicle '" << myHolder.getID() << "'" << std::endl;
193 #endif
194  assert(myDriverState == nullptr);
195  assert(myHolderMS->getDriverState() == nullptr);
198  initDriverState();
199  return 0;
200 }
201 
202 void
204  myDriverState->setMinAwareness(myMinAwareness);
205  myDriverState->setInitialAwareness(myInitialAwareness);
206  myDriverState->setErrorTimeScaleCoefficient(myErrorTimeScaleCoefficient);
207  myDriverState->setErrorNoiseIntensityCoefficient(myErrorNoiseIntensityCoefficient);
208  myDriverState->setSpeedDifferenceErrorCoefficient(mySpeedDifferenceErrorCoefficient);
209  myDriverState->setHeadwayErrorCoefficient(myHeadwayErrorCoefficient);
210  myDriverState->setSpeedDifferenceChangePerceptionThreshold(mySpeedDifferenceChangePerceptionThreshold);
211  myDriverState->setHeadwayChangePerceptionThreshold(myHeadwayChangePerceptionThreshold);
212  myDriverState->setAwareness(myInitialAwareness);
213 }
214 
215 std::string
216 MSDevice_DriverState::getParameter(const std::string& key) const {
217 #ifdef DEBUG_DSDEVICE
218  std::cout << "MSDevice_DriverState::getParameter(key=" << key << ")" << std::endl;
219 #endif
220  if (key == "awareness") {
221  return toString(myDriverState->getAwareness());
222  } else if (key == "errorState") {
223  return toString(myDriverState->getErrorState());
224  } else if (key == "errorTimeScale") {
225  return toString(myDriverState->getErrorTimeScale());
226  } else if (key == "errorNoiseIntensity") {
227  return toString(myDriverState->getErrorNoiseIntensity());
228  } else if (key == "errorNoiseIntensity") {
229  return toString(myDriverState->getErrorNoiseIntensity());
230  } else if (key == "minAwareness") {
231  return toString(myDriverState->getMinAwareness());
232  } else if (key == "initialAwareness") {
233  return toString(myDriverState->getInitialAwareness());
234  } else if (key == "errorTimeScaleCoefficient") {
235  return toString(myDriverState->getErrorTimeScaleCoefficient());
236  } else if (key == "errorNoiseIntensityCoefficient") {
237  return toString(myDriverState->getErrorNoiseIntensityCoefficient());
238  } else if (key == "speedDifferenceErrorCoefficient") {
239  return toString(myDriverState->getSpeedDifferenceErrorCoefficient());
240  } else if (key == "headwayErrorCoefficient") {
241  return toString(myDriverState->getHeadwayErrorCoefficient());
242  } else if (key == "speedDifferenceChangePerceptionThreshold") {
243  return toString(myDriverState->getSpeedDifferenceChangePerceptionThreshold());
244  } else if (key == "headwayChangePerceptionThreshold") {
245  return toString(myDriverState->getHeadwayChangePerceptionThreshold());
246  }
247  throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
248 }
249 
250 
251 void
252 MSDevice_DriverState::setParameter(const std::string& key, const std::string& value) {
253 #ifdef DEBUG_DSDEVICE
254  std::cout << "MSDevice_DriverState::setParameter(key=" << key << ", value=" << value << ")" << std::endl;
255 #endif
256  if (key == "awareness") {
257  myDriverState->setAwareness(StringUtils::toDouble(value));
258  } else if (key == "errorState") {
259  myDriverState->setErrorState(StringUtils::toDouble(value));
260  } else if (key == "errorTimeScale") {
261  myDriverState->setErrorTimeScale(StringUtils::toDouble(value));
262  } else if (key == "errorNoiseIntensity") {
263  myDriverState->setErrorNoiseIntensity(StringUtils::toDouble(value));
264  } else if (key == "minAwareness") {
265  myDriverState->setMinAwareness(StringUtils::toDouble(value));
266  } else if (key == "initialAwareness") {
267  myDriverState->setInitialAwareness(StringUtils::toDouble(value));
268  } else if (key == "errorTimeScaleCoefficient") {
269  myDriverState->setErrorTimeScaleCoefficient(StringUtils::toDouble(value));
270  } else if (key == "errorNoiseIntensityCoefficient") {
271  myDriverState->setErrorNoiseIntensityCoefficient(StringUtils::toDouble(value));
272  } else if (key == "speedDifferenceErrorCoefficient") {
273  myDriverState->setSpeedDifferenceErrorCoefficient(StringUtils::toDouble(value));
274  } else if (key == "headwayErrorCoefficient") {
275  myDriverState->setHeadwayErrorCoefficient(StringUtils::toDouble(value));
276  } else if (key == "speedDifferenceChangePerceptionThreshold") {
277  myDriverState->setSpeedDifferenceChangePerceptionThreshold(StringUtils::toDouble(value));
278  } else if (key == "headwayChangePerceptionThreshold") {
279  myDriverState->setHeadwayChangePerceptionThreshold(StringUtils::toDouble(value));
280  } else {
281  throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
282  }
283 }
284 
285 
286 /****************************************************************************/
287 
void doRegister(const std::string &name, Option *v)
Adds an option under the given name.
Definition: OptionsCont.cpp:75
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:79
long long int SUMOTime
Definition: SUMOTime.h:36
double mySpeedDifferenceChangePerceptionThreshold
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_DriverState-options.
static double headwayChangePerceptionThreshold
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key ...
SUMOVehicle & myHolder
The vehicle that stores the device.
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:165
void createDriverState()
Create a DriverState for the vehicle.
Definition: MSVehicle.cpp:5735
static double minAwareness
static double getErrorNoiseIntensityCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
static double initialAwareness
static double getInitialAwareness(const SUMOVehicle &v, const OptionsCont &oc)
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:58
#define SIMTIME
Definition: SUMOTime.h:65
static double headwayErrorCoefficient
static double errorTimeScaleCoefficient
static double getSpeedDifferenceErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:49
static double getHeadwayErrorCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
Representation of a vehicle.
Definition: SUMOVehicle.h:60
std::shared_ptr< MSSimpleDriverState > myDriverState
The driver state of the holder.
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 toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter ...
static double speedDifferenceErrorCoefficient
#define SIMSTEP
Definition: SUMOTime.h:64
MSEventControl * getBeginOfTimestepEvents()
Returns the event control for events executed at the begin of a time step.
Definition: MSNet.h:409
static double getMinAwareness(const SUMOVehicle &v, const OptionsCont &oc)
A wrapper for a Command function.
SUMOTime createDriverState(SUMOTime)
Creates a DriverState for the equipped vehicle.
virtual void addEvent(Command *operation, SUMOTime execTimeStep=-1)
Adds an Event.
static double speedDifferenceChangePerceptionThreshold
static double getFloatParam(const SUMOVehicle &v, const OptionsCont &oc, std::string paramName, double deflt, bool required)
Definition: MSDevice.cpp:193
void addOptionSubTopic(const std::string &topic)
Adds an option subtopic.
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:121
static double getErrorTimeScaleCoefficient(const SUMOVehicle &v, const OptionsCont &oc)
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 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:208
A storage for options typed value containers)
Definition: OptionsCont.h:92
void initDriverState()
Initializeses the driver state parameters.
Abstract in-vehicle device.
static double getHeadwayChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
std::shared_ptr< MSSimpleDriverState > getDriverState() const
Returns the vehicle driver&#39;s state.
Definition: MSVehicle.h:900
The ToC Device controls transition of control between automated and manual driving.
void addDescription(const std::string &name, const std::string &subtopic, const std::string &description)
Adds a description for an option.
static double errorNoiseIntensityCoefficient
static double getSpeedDifferenceChangePerceptionThreshold(const SUMOVehicle &v, const OptionsCont &oc)
virtual const std::string & getID() const =0
Get the vehicle&#39;s ID.
const std::string deviceName() const
return the name for this type of device
MSDevice_DriverState(SUMOVehicle &holder, const std::string &id, double minAwareness, double initialAwareness, double errorTimeScaleCoefficient, double errorNoiseIntensityCoefficient, double speedDifferenceErrorCoefficient, double speedDifferenceChangePerceptionThreshold, double headwayChangePerceptionThreshold, double headwayErrorCoefficient)
Constructor.