Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
eclipse
GitHub Repository: eclipse/sumo
 Path: blob/main/src/utils/handlers/MeanDataHandler.cpp
193863 views
1
/****************************************************************************/

2
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo

3
// Copyright (C) 2001-2026 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    MeanDataHandler.cpp

15
/// @author  Pablo Alvarez Lopez

16
/// @date    Nov 2022

17
///

18
// The XML-Handler for meanMeanData elements loading

19
/****************************************************************************/

20
#include <config.h>

21


22
#include <utils/common/MsgHandler.h>

23
#include <utils/common/StringUtils.h>

24
#include <utils/xml/XMLSubSys.h>

25


26
#include "MeanDataHandler.h"

27


28


29
// ===========================================================================

30
// method definitions

31
// ===========================================================================

32


33
MeanDataHandler::MeanDataHandler(FileBucket* fileBucket) :

34
    CommonHandler(fileBucket) {

35
}

36


37


38
MeanDataHandler::~MeanDataHandler() {}

39


40


41
bool

42
MeanDataHandler::beginParseAttributes(SumoXMLTag tag, const SUMOSAXAttributes& attrs) {

43
    // open SUMOBaseOBject

44
    myCommonXMLStructure.openSUMOBaseOBject();

45
    // check tag

46
    try {

47
        switch (tag) {

48
            case SUMO_TAG_MEANDATA_EDGE:

49
                parseEdgeMeanData(attrs);

50
                break;

51
            case SUMO_TAG_MEANDATA_LANE:

52
                parseLaneMeanData(attrs);

53
                break;

54
            case SUMO_TAG_PARAM:

55
                WRITE_WARNING(TL("MeanData elements cannot load attributes as params"));

56
                break;

57
            default:

58
                // tag cannot be parsed in MeanDataHandler

59
                myCommonXMLStructure.abortSUMOBaseOBject();

60
                return false;

61
        }

62
    } catch (InvalidArgument& e) {

63
        writeError(e.what());

64
    }

65
    return true;

66
}

67


68


69
void

70
MeanDataHandler::endParseAttributes() {

71
    // get last inserted object

72
    CommonXMLStructure::SumoBaseObject* obj = myCommonXMLStructure.getCurrentSumoBaseObject();

73
    // close SUMOBaseOBject

74
    if (obj) {

75
        myCommonXMLStructure.closeSUMOBaseOBject();

76
        // check tag

77
        switch (obj->getTag()) {

78
            case SUMO_TAG_MEANDATA_EDGE:

79
            case SUMO_TAG_MEANDATA_LANE:

80
                parseSumoBaseObject(obj);

81
                // delete object

82
                delete obj;

83
                break;

84
            default:

85
                break;

86
        }

87
    }

88
}

89


90


91
void

92
MeanDataHandler::parseSumoBaseObject(CommonXMLStructure::SumoBaseObject* obj) {

93
    // check if loading was aborted

94
    if (!myAbortLoading) {

95
        // switch tag

96
        switch (obj->getTag()) {

97
            case SUMO_TAG_MEANDATA_EDGE:

98
                if (buildEdgeMeanData(obj,

99
                                      obj->getStringAttribute(SUMO_ATTR_ID),

100
                                      obj->getStringAttribute(SUMO_ATTR_FILE),

101
                                      obj->getStringAttribute(SUMO_ATTR_TYPE),

102
                                      obj->getTimeAttribute(SUMO_ATTR_PERIOD),

103
                                      obj->getTimeAttribute(SUMO_ATTR_BEGIN),

104
                                      obj->getTimeAttribute(SUMO_ATTR_END),

105
                                      obj->getBoolAttribute(SUMO_ATTR_TRACK_VEHICLES),

106
                                      obj->getStringListAttribute(SUMO_ATTR_WRITE_ATTRIBUTES),

107
                                      obj->getBoolAttribute(SUMO_ATTR_AGGREGATE),

108
                                      obj->getStringListAttribute(SUMO_ATTR_EDGES),

109
                                      obj->getStringAttribute(SUMO_ATTR_EDGESFILE),

110
                                      obj->getStringAttribute(SUMO_ATTR_EXCLUDE_EMPTY),

111
                                      obj->getBoolAttribute(SUMO_ATTR_WITH_INTERNAL),

112
                                      obj->getStringListAttribute(SUMO_ATTR_DETECT_PERSONS),

113
                                      obj->getDoubleAttribute(SUMO_ATTR_MIN_SAMPLES),

114
                                      obj->getDoubleAttribute(SUMO_ATTR_MAX_TRAVELTIME),

115
                                      obj->getStringListAttribute(SUMO_ATTR_VTYPES),

116
                                      obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD))) {

117
                    obj->markAsCreated();

118
                };

119
                break;

120
            case SUMO_TAG_MEANDATA_LANE:

121
                if (buildLaneMeanData(obj,

122
                                      obj->getStringAttribute(SUMO_ATTR_ID),

123
                                      obj->getStringAttribute(SUMO_ATTR_FILE),

124
                                      obj->getStringAttribute(SUMO_ATTR_TYPE),

125
                                      obj->getTimeAttribute(SUMO_ATTR_PERIOD),

126
                                      obj->getTimeAttribute(SUMO_ATTR_BEGIN),

127
                                      obj->getTimeAttribute(SUMO_ATTR_END),

128
                                      obj->getBoolAttribute(SUMO_ATTR_TRACK_VEHICLES),

129
                                      obj->getStringListAttribute(SUMO_ATTR_WRITE_ATTRIBUTES),

130
                                      obj->getBoolAttribute(SUMO_ATTR_AGGREGATE),

131
                                      obj->getStringListAttribute(SUMO_ATTR_EDGES),

132
                                      obj->getStringAttribute(SUMO_ATTR_EDGESFILE),

133
                                      obj->getStringAttribute(SUMO_ATTR_EXCLUDE_EMPTY),

134
                                      obj->getBoolAttribute(SUMO_ATTR_WITH_INTERNAL),

135
                                      obj->getStringListAttribute(SUMO_ATTR_DETECT_PERSONS),

136
                                      obj->getDoubleAttribute(SUMO_ATTR_MIN_SAMPLES),

137
                                      obj->getDoubleAttribute(SUMO_ATTR_MAX_TRAVELTIME),

138
                                      obj->getStringListAttribute(SUMO_ATTR_VTYPES),

139
                                      obj->getDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD))) {

140
                    obj->markAsCreated();

141
                }

142
                break;

143
            default:

144
                break;

145
        }

146
        // now iterate over childrens

147
        for (const auto& child : obj->getSumoBaseObjectChildren()) {

148
            // call this function recursively

149
            parseSumoBaseObject(child);

150
        }

151
    }

152
}

153


154


155
void

156
MeanDataHandler::parseEdgeMeanData(const SUMOSAXAttributes& attrs) {

157
    // declare Ok Flag

158
    bool parsedOk = true;

159
    // needed attributes

160
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);

161
    const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);

162
    // optional attributes

163
    std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), parsedOk, "");

164
    const SUMOTime period = attrs.getOptSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), parsedOk, TIME2STEPS(-1));

165
    const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), parsedOk, TIME2STEPS(-1));

166
    const SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), parsedOk, TIME2STEPS(-1));

167
    const bool trackVehicles = attrs.getOpt<bool>(SUMO_ATTR_TRACK_VEHICLES, id.c_str(), parsedOk, false);

168
    const std::vector<std::string> writeAttributes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_WRITE_ATTRIBUTES, id.c_str(), parsedOk, {});

169
    const bool aggregate = attrs.getOpt<bool>(SUMO_ATTR_AGGREGATE, id.c_str(), parsedOk, false);

170
    const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk, {});

171
    const std::string edgeFile = attrs.getOpt<std::string>(SUMO_ATTR_EDGESFILE, id.c_str(), parsedOk, "");

172
    const std::string excludeEmpty = attrs.getOpt<std::string>(SUMO_ATTR_EXCLUDE_EMPTY, id.c_str(), parsedOk, SUMOXMLDefinitions::ExcludeEmptys.getString(ExcludeEmpty::FALSES));

173
    const bool withInternal = attrs.getOpt<bool>(SUMO_ATTR_WITH_INTERNAL, id.c_str(), parsedOk, false);

174
    const std::vector<std::string> detectPersons = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_DETECT_PERSONS, id.c_str(), parsedOk, {});

175
    const double minSamples = attrs.getOpt<double>(SUMO_ATTR_MIN_SAMPLES, id.c_str(), parsedOk, 0);

176
    const double maxTravel = attrs.getOpt<double>(SUMO_ATTR_MAX_TRAVELTIME, id.c_str(), parsedOk, 100000);

177
    const std::vector<std::string> vTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, {});

178
    const double speedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 0.1);

179
    // adjust type

180
    if (type == "performance") {

181
        type = "";

182
    } else if (type == "hbefa") {

183
        WRITE_WARNING(TL("The netstate type 'hbefa' is deprecated. Using 'emissions' instead."));

184
        type = "emissions";

185
    }

186
    // continue if flag is ok

187
    if (parsedOk && checkType(SUMO_TAG_MEANDATA_EDGE, id, type)) {

188
        // set tag

189
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_MEANDATA_EDGE);

190
        // add all attributes

191
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);

192
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);

193
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);

194
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);

195
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);

196
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);

197
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_TRACK_VEHICLES, trackVehicles);

198
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_WRITE_ATTRIBUTES, writeAttributes);

199
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_AGGREGATE, aggregate);

200
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);

201
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGESFILE, edgeFile);

202
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EXCLUDE_EMPTY, excludeEmpty);

203
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_WITH_INTERNAL, withInternal);

204
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);

205
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_MIN_SAMPLES, minSamples);

206
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_MAX_TRAVELTIME, maxTravel);

207
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vTypes);

208
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, speedThreshold);

209
    } else {

210
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);

211
    }

212
}

213


214


215
void

216
MeanDataHandler::parseLaneMeanData(const SUMOSAXAttributes& attrs) {

217
    // declare Ok Flag

218
    bool parsedOk = true;

219
    // needed attributes

220
    const std::string id = attrs.get<std::string>(SUMO_ATTR_ID, "", parsedOk);

221
    const std::string file = attrs.get<std::string>(SUMO_ATTR_FILE, id.c_str(), parsedOk);

222
    // optional attributes

223
    const std::string type = attrs.getOpt<std::string>(SUMO_ATTR_TYPE, id.c_str(), parsedOk, "");

224
    const SUMOTime period = attrs.getOptSUMOTimeReporting(SUMO_ATTR_PERIOD, id.c_str(), parsedOk, TIME2STEPS(-1));

225
    const SUMOTime begin = attrs.getOptSUMOTimeReporting(SUMO_ATTR_BEGIN, id.c_str(), parsedOk, TIME2STEPS(-1));

226
    const SUMOTime end = attrs.getOptSUMOTimeReporting(SUMO_ATTR_END, id.c_str(), parsedOk, TIME2STEPS(-1));

227
    const bool trackVehicles = attrs.getOpt<bool>(SUMO_ATTR_TRACK_VEHICLES, id.c_str(), parsedOk, false);

228
    const std::vector<std::string> writeAttributes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_WRITE_ATTRIBUTES, id.c_str(), parsedOk, {});

229
    const bool aggregate = attrs.getOpt<bool>(SUMO_ATTR_AGGREGATE, id.c_str(), parsedOk, false);

230
    const std::vector<std::string> edges = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_EDGES, id.c_str(), parsedOk, {});

231
    const std::string edgeFile = attrs.getOpt<std::string>(SUMO_ATTR_EDGESFILE, id.c_str(), parsedOk, "");

232
    const std::string excludeEmpty = attrs.getOpt<std::string>(SUMO_ATTR_EXCLUDE_EMPTY, id.c_str(), parsedOk, SUMOXMLDefinitions::ExcludeEmptys.getString(ExcludeEmpty::FALSES));

233
    const bool withInternal = attrs.getOpt<bool>(SUMO_ATTR_WITH_INTERNAL, id.c_str(), parsedOk, false);

234
    const std::vector<std::string> detectPersons = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_DETECT_PERSONS, id.c_str(), parsedOk, {});

235
    const double minSamples = attrs.getOpt<double>(SUMO_ATTR_MIN_SAMPLES, id.c_str(), parsedOk, 0);

236
    const double maxTravel = attrs.getOpt<double>(SUMO_ATTR_MAX_TRAVELTIME, id.c_str(), parsedOk, 100000);

237
    const std::vector<std::string> vTypes = attrs.getOpt<std::vector<std::string> >(SUMO_ATTR_VTYPES, id.c_str(), parsedOk, {});

238
    const double speedThreshold = attrs.getOpt<double>(SUMO_ATTR_HALTING_SPEED_THRESHOLD, id.c_str(), parsedOk, 0.1);

239
    // continue if flag is ok

240
    if (parsedOk && checkType(SUMO_TAG_MEANDATA_LANE, id, type)) {

241
        // set tag

242
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_MEANDATA_LANE);

243
        // add all attributes

244
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_ID, id);

245
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_FILE, file);

246
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_TYPE, type);

247
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_PERIOD, period);

248
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_BEGIN, begin);

249
        myCommonXMLStructure.getCurrentSumoBaseObject()->addTimeAttribute(SUMO_ATTR_END, end);

250
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_TRACK_VEHICLES, trackVehicles);

251
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_WRITE_ATTRIBUTES, writeAttributes);

252
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_AGGREGATE, aggregate);

253
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_EDGES, edges);

254
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EDGESFILE, edgeFile);

255
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringAttribute(SUMO_ATTR_EXCLUDE_EMPTY, excludeEmpty);

256
        myCommonXMLStructure.getCurrentSumoBaseObject()->addBoolAttribute(SUMO_ATTR_WITH_INTERNAL, withInternal);

257
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_DETECT_PERSONS, detectPersons);

258
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_MIN_SAMPLES, minSamples);

259
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_MAX_TRAVELTIME, maxTravel);

260
        myCommonXMLStructure.getCurrentSumoBaseObject()->addStringListAttribute(SUMO_ATTR_VTYPES, vTypes);

261
        myCommonXMLStructure.getCurrentSumoBaseObject()->addDoubleAttribute(SUMO_ATTR_HALTING_SPEED_THRESHOLD, speedThreshold);

262
    } else {

263
        myCommonXMLStructure.getCurrentSumoBaseObject()->setTag(SUMO_TAG_ERROR);

264
    }

265
}

266


267


268
bool

269
MeanDataHandler::checkType(const SumoXMLTag currentTag, const std::string& id, const std::string& type) {

270
    if (SUMOXMLDefinitions::MeanDataTypes.hasString(type)) {

271
        return true;

272
    } else {

273
        writeError(TLF("Attribute '%' defined in % with id '%' doesn't have a valid value (given '%').", toString(SUMO_ATTR_TYPE), toString(currentTag), id, type));

274
        return false;

275
    }

276
}

277


278
/****************************************************************************/

279


280