Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2025 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 : /****************************************************************************/
14 : /// @file TraCIServerAPI_VehicleType.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Jakob Erdmann
17 : /// @author Michael Behrisch
18 : /// @author Laura Bieker
19 : /// @author Robert Hilbrich
20 : /// @author Gregor Laemmel
21 : /// @date 07.05.2009
22 : ///
23 : // APIs for getting/setting vehicle type values via TraCI
24 : /****************************************************************************/
25 : #include <config.h>
26 :
27 : #include <limits>
28 : #include <utils/emissions/PollutantsInterface.h>
29 : #include <microsim/MSNet.h>
30 : #include <microsim/MSVehicleType.h>
31 : #include <libsumo/StorageHelper.h>
32 : #include <libsumo/TraCIConstants.h>
33 : #include <libsumo/VehicleType.h>
34 : #include "TraCIServerAPI_VehicleType.h"
35 :
36 :
37 : // ===========================================================================
38 : // method definitions
39 : // ===========================================================================
40 : bool
41 214 : TraCIServerAPI_VehicleType::processSet(TraCIServer& server, tcpip::Storage& inputStorage,
42 : tcpip::Storage& outputStorage) {
43 214 : std::string warning = ""; // additional description for response
44 : // variable
45 214 : int variable = inputStorage.readUnsignedByte();
46 214 : if (variable != libsumo::VAR_LENGTH && variable != libsumo::VAR_MAXSPEED && variable != libsumo::VAR_VEHICLECLASS
47 199 : && variable != libsumo::VAR_SPEED_FACTOR && variable != libsumo::VAR_SPEED_DEVIATION && variable != libsumo::VAR_EMISSIONCLASS
48 184 : && variable != libsumo::VAR_WIDTH && variable != libsumo::VAR_MINGAP && variable != libsumo::VAR_SHAPECLASS
49 171 : && variable != libsumo::VAR_ACCEL && variable != libsumo::VAR_IMPERFECTION
50 158 : && variable != libsumo::VAR_DECEL && variable != libsumo::VAR_EMERGENCY_DECEL && variable != libsumo::VAR_APPARENT_DECEL
51 129 : && variable != libsumo::VAR_TAU && variable != libsumo::VAR_COLOR && variable != libsumo::VAR_ACTIONSTEPLENGTH
52 120 : && variable != libsumo::VAR_SCALE
53 108 : && variable != libsumo::VAR_HEIGHT
54 108 : && variable != libsumo::VAR_MASS
55 : && variable != libsumo::VAR_MINGAP_LAT
56 98 : && variable != libsumo::VAR_MAXSPEED_LAT
57 90 : && variable != libsumo::VAR_LATALIGNMENT
58 90 : && variable != libsumo::VAR_BOARDING_DURATION
59 83 : && variable != libsumo::VAR_IMPATIENCE
60 83 : && variable != libsumo::VAR_PARAMETER
61 4 : && variable != libsumo::COPY
62 : ) {
63 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE,
64 0 : "Change Vehicle Type State: unsupported variable " + toHex(variable, 2)
65 0 : + " specified", outputStorage);
66 : }
67 : // id
68 214 : std::string id = inputStorage.readString();
69 : // MSVehicleType* v = libsumo::VehicleType::getVType(id);
70 : // if (v == 0) {
71 : // return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, "Vehicle type '" + id + "' is not known",
72 : // outputStorage);
73 : // }
74 : // process
75 : try {
76 214 : if (setVariable(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, variable, id, server, inputStorage, outputStorage)) {
77 205 : server.writeStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, libsumo::RTYPE_OK, warning, outputStorage);
78 : return true;
79 : }
80 9 : } catch (ProcessError& e) {
81 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
82 9 : } catch (libsumo::TraCIException& e) {
83 9 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLETYPE_VARIABLE, e.what(), outputStorage);
84 9 : }
85 : return false;
86 : }
87 :
88 :
89 : bool
90 459 : TraCIServerAPI_VehicleType::setVariable(const int cmd, const int variable,
91 : const std::string& id, TraCIServer& server,
92 : tcpip::Storage& inputStorage, tcpip::Storage& outputStorage) {
93 459 : switch (variable) {
94 : case libsumo::VAR_LENGTH: {
95 77 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting length requires a double.");
96 77 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
97 0 : return server.writeErrorStatusCmd(cmd, "Invalid length.", outputStorage);
98 : }
99 77 : libsumo::VehicleType::setLength(id, value);
100 77 : break;
101 : }
102 : case libsumo::VAR_HEIGHT: {
103 13 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting height requires a double.");
104 13 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
105 0 : return server.writeErrorStatusCmd(cmd, "Invalid height.", outputStorage);
106 : }
107 13 : libsumo::VehicleType::setHeight(id, value);
108 13 : break;
109 : }
110 : case libsumo::VAR_MASS: {
111 11 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting mass requires a double.");
112 11 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
113 0 : return server.writeErrorStatusCmd(cmd, "Invalid mass.", outputStorage);
114 : }
115 11 : libsumo::VehicleType::setMass(id, value);
116 11 : break;
117 : }
118 : case libsumo::VAR_MAXSPEED: {
119 36 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting maximum speed requires a double.");
120 36 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
121 2 : return server.writeErrorStatusCmd(cmd, "Invalid maximum speed.", outputStorage);
122 : }
123 35 : libsumo::VehicleType::setMaxSpeed(id, value);
124 35 : break;
125 : }
126 : case libsumo::VAR_VEHICLECLASS: {
127 12 : libsumo::VehicleType::setVehicleClass(id, StoHelp::readTypedString(inputStorage, "Setting vehicle class requires a string."));
128 12 : break;
129 : }
130 : case libsumo::VAR_SPEED_FACTOR: {
131 6 : double value = StoHelp::readTypedDouble(inputStorage, "Setting speed factor requires a double.");
132 6 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
133 0 : return server.writeErrorStatusCmd(cmd, "Invalid speed factor.", outputStorage);
134 : }
135 6 : libsumo::VehicleType::setSpeedFactor(id, value);
136 6 : break;
137 : }
138 : case libsumo::VAR_SPEED_DEVIATION: {
139 3 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting speed deviation requires a double.");
140 3 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
141 0 : return server.writeErrorStatusCmd(cmd, "Invalid speed deviation.", outputStorage);
142 : }
143 3 : libsumo::VehicleType::setSpeedDeviation(id, value);
144 3 : break;
145 : }
146 : case libsumo::VAR_EMISSIONCLASS: {
147 19 : libsumo::VehicleType::setEmissionClass(id, StoHelp::readTypedString(inputStorage, "Setting emission class requires a string."));
148 19 : break;
149 : }
150 : case libsumo::VAR_WIDTH: {
151 20 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting width requires a double.");
152 20 : if (value <= 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
153 0 : return server.writeErrorStatusCmd(cmd, "Invalid width.", outputStorage);
154 : }
155 20 : libsumo::VehicleType::setWidth(id, value);
156 20 : break;
157 : }
158 : case libsumo::VAR_MINGAP: {
159 10 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting minimum gap requires a double.");
160 10 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
161 0 : return server.writeErrorStatusCmd(cmd, "Invalid minimum gap.", outputStorage);
162 : }
163 10 : libsumo::VehicleType::setMinGap(id, value);
164 10 : break;
165 : }
166 : case libsumo::VAR_MINGAP_LAT: {
167 4 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting minimum lateral gap requires a double.");
168 4 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
169 0 : return server.writeErrorStatusCmd(cmd, "Invalid minimum lateral gap.", outputStorage);
170 : }
171 4 : libsumo::VehicleType::setMinGapLat(id, value);
172 4 : break;
173 : }
174 : case libsumo::VAR_MAXSPEED_LAT: {
175 9 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting maximum lateral speed requires a double.");
176 9 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
177 0 : return server.writeErrorStatusCmd(cmd, "Invalid maximum lateral speed.", outputStorage);
178 : }
179 9 : libsumo::VehicleType::setMaxSpeedLat(id, value);
180 9 : break;
181 : }
182 : case libsumo::VAR_LATALIGNMENT: {
183 9 : libsumo::VehicleType::setLateralAlignment(id, StoHelp::readTypedString(inputStorage, "Setting preferred lateral alignment requires a string."));
184 9 : break;
185 : }
186 : case libsumo::VAR_SHAPECLASS: {
187 10 : libsumo::VehicleType::setShapeClass(id, StoHelp::readTypedString(inputStorage, "Setting vehicle shape requires a string."));
188 10 : break;
189 : }
190 : case libsumo::VAR_ACCEL: {
191 25 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting acceleration requires a double.");
192 25 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
193 0 : return server.writeErrorStatusCmd(cmd, "Invalid acceleration.", outputStorage);
194 : }
195 25 : libsumo::VehicleType::setAccel(id, value);
196 25 : break;
197 : }
198 : case libsumo::VAR_DECEL: {
199 15 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting deceleration requires a double.");
200 15 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
201 0 : return server.writeErrorStatusCmd(cmd, "Invalid deceleration.", outputStorage);
202 : }
203 15 : libsumo::VehicleType::setDecel(id, value);
204 15 : break;
205 : }
206 : case libsumo::VAR_EMERGENCY_DECEL: {
207 20 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting emergency deceleration requires a double.");
208 20 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
209 0 : return server.writeErrorStatusCmd(cmd, "Invalid emergency deceleration.", outputStorage);
210 : }
211 20 : libsumo::VehicleType::setEmergencyDecel(id, value);
212 20 : break;
213 : }
214 : case libsumo::VAR_APPARENT_DECEL: {
215 15 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting apparent deceleration requires a double.");
216 15 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
217 0 : return server.writeErrorStatusCmd(cmd, "Invalid apparent deceleration.", outputStorage);
218 : }
219 15 : libsumo::VehicleType::setApparentDecel(id, value);
220 15 : break;
221 : }
222 : case libsumo::VAR_SCALE: {
223 3 : const double value = StoHelp::readTypedDouble(inputStorage, "Traffic scale requires a double.");
224 3 : if (value < 0.0) {
225 0 : return server.writeErrorStatusCmd(cmd, "Invalid traffic scale.", outputStorage);
226 : }
227 3 : libsumo::VehicleType::setScale(id, value);
228 3 : break;
229 : }
230 : case libsumo::VAR_ACTIONSTEPLENGTH: {
231 9 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting action step length requires a double.");
232 9 : if (fabs(value) == std::numeric_limits<double>::infinity()) {
233 0 : return server.writeErrorStatusCmd(libsumo::CMD_SET_VEHICLE_VARIABLE, "Invalid action step length.", outputStorage);
234 : }
235 9 : bool resetActionOffset = value >= 0.0;
236 9 : libsumo::VehicleType::setActionStepLength(id, fabs(value), resetActionOffset);
237 9 : break;
238 : }
239 : case libsumo::VAR_IMPERFECTION: {
240 24 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting driver imperfection requires a double.");
241 24 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
242 0 : return server.writeErrorStatusCmd(cmd, "Invalid driver imperfection.", outputStorage);
243 : }
244 24 : libsumo::VehicleType::setImperfection(id, value);
245 24 : break;
246 : }
247 : case libsumo::VAR_TAU: {
248 15 : const double value = StoHelp::readTypedDouble(inputStorage, "Setting headway time requires a double.");
249 15 : if (value < 0.0 || fabs(value) == std::numeric_limits<double>::infinity()) {
250 0 : return server.writeErrorStatusCmd(cmd, "Invalid headway time.", outputStorage);
251 : }
252 15 : libsumo::VehicleType::setTau(id, value);
253 15 : break;
254 : }
255 : case libsumo::VAR_IMPATIENCE: {
256 3 : libsumo::VehicleType::setImpatience(id, StoHelp::readTypedDouble(inputStorage, "Setting impatience requires a double."));
257 3 : break;
258 : }
259 : case libsumo::VAR_BOARDING_DURATION: {
260 8 : libsumo::VehicleType::setBoardingDuration(id, StoHelp::readTypedDouble(inputStorage, "Setting boarding duration requires a double."));
261 8 : break;
262 : }
263 : case libsumo::VAR_COLOR: {
264 3 : libsumo::VehicleType::setColor(id, StoHelp::readTypedColor(inputStorage, "The color must be given using the according type."));
265 3 : break;
266 : }
267 : case libsumo::COPY: {
268 4 : libsumo::VehicleType::copy(id, StoHelp::readTypedString(inputStorage, "Copying a vehicle type requires a string."));
269 4 : break;
270 : }
271 : case libsumo::VAR_PARAMETER: {
272 76 : StoHelp::readCompound(inputStorage, 2, "A compound object of size 2 is needed for setting a parameter.");
273 76 : const std::string name = StoHelp::readTypedString(inputStorage, "The name of the parameter must be given as a string.");
274 85 : const std::string value = StoHelp::readTypedString(inputStorage, "The value of the parameter must be given as a string.");
275 76 : libsumo::VehicleType::setParameter(id, name, value);
276 : break;
277 : }
278 : default:
279 : break;
280 : }
281 : return true;
282 : }
283 :
284 :
285 : /****************************************************************************/
|
