Spaces:
Sleeping
Sleeping
File size: 5,579 Bytes
92cc220 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 | #ifndef CITYFLOW_ENGINE_H
#define CITYFLOW_ENGINE_H
#include "flow/flow.h"
#include "roadnet/roadnet.h"
#include "engine/archive.h"
#include "utility/barrier.h"
#include <mutex>
#include <thread>
#include <set>
#include <random>
#include <fstream>
namespace CityFlow {
class Engine {
friend class Archive;
private:
static bool vehicleCmp(const std::pair<Vehicle *, double> &a, const std::pair<Vehicle *, double> &b) {
return a.second > b.second;
}
std::map<int, std::pair<Vehicle *, int>> vehiclePool;
std::map<std::string, Vehicle *> vehicleMap;
std::vector<std::set<Vehicle *>> threadVehiclePool;
std::vector<std::vector<Road *>> threadRoadPool;
std::vector<std::vector<Intersection *>> threadIntersectionPool;
std::vector<std::vector<Drivable *>> threadDrivablePool;
std::vector<Flow> flows;
RoadNet roadnet;
int threadNum;
double interval;
bool saveReplay;
bool saveReplayInConfig; // saveReplay option in config json
bool warnings;
std::vector<std::pair<Vehicle *, double>> pushBuffer;
std::vector<Vehicle *> laneChangeNotifyBuffer;
std::set<Vehicle *> vehicleRemoveBuffer;
rapidjson::Document jsonRoot;
std::string stepLog;
size_t step = 0;
size_t activeVehicleCount = 0;
int seed;
std::mutex lock;
Barrier startBarrier, endBarrier;
std::vector<std::thread> threadPool;
bool finished = false;
std::string dir;
std::ofstream logOut;
bool rlTrafficLight;
bool laneChange;
int manuallyPushCnt = 0;
int finishedVehicleCnt = 0;
double cumulativeTravelTime = 0;
private:
void vehicleControl(Vehicle &vehicle, std::vector<std::pair<Vehicle *, double>> &buffer);
void planRoute();
void getAction();
void updateAction();
void updateLocation();
void updateLeaderAndGap();
void planLaneChange();
void threadController(std::set<Vehicle *> &vehicles,
std::vector<Road *> &roads,
std::vector<Intersection *> &intersections,
std::vector<Drivable *> &drivables);
void threadPlanRoute(const std::vector<Road *> &roads);
void threadGetAction(std::set<Vehicle *> &vehicles);
void threadUpdateAction(std::set<Vehicle *> &vehicles);
void threadUpdateLeaderAndGap(const std::vector<Drivable *> &drivables);
void threadUpdateLocation(const std::vector<Drivable *> &drivables);
void threadNotifyCross(const std::vector<Intersection *> &intersections);
void threadInitSegments(const std::vector<Road *> &roads);
void threadPlanLaneChange(const std::set<Vehicle *> &vehicles);
void handleWaiting();
void updateLog();
bool checkWarning();
bool loadRoadNet(const std::string &jsonFile);
bool loadFlow(const std::string &jsonFilename);
std::vector<const Vehicle *> getRunningVehicles(bool includeWaiting=false) const;
void scheduleLaneChange();
void insertShadow(Vehicle *vehicle);
public:
std::mt19937 rnd;
Engine(const std::string &configFile, int threadNum);
double getInterval() const { return interval; }
bool hasLaneChange() const { return laneChange; }
bool loadConfig(const std::string &configFile);
void notifyCross();
void nextStep();
bool checkPriority(int priority);
void pushVehicle(Vehicle *const vehicle, bool pushToDrivable = true);
void setLogFile(const std::string &jsonFile, const std::string &logFile);
void initSegments();
~Engine();
// RL related api
void pushVehicle(const std::map<std::string, double> &info, const std::vector<std::string> &roads);
size_t getVehicleCount() const;
std::vector<std::string> getVehicles(bool includeWaiting = false) const;
std::map<std::string, int> getLaneVehicleCount() const;
std::map<std::string, int> getLaneWaitingVehicleCount() const;
std::map<std::string, std::vector<std::string>> getLaneVehicles();
std::map<std::string, double> getVehicleSpeed() const;
std::map<std::string, double> getVehicleDistance() const;
std::string getLeader(const std::string &vehicleId) const;
double getCurrentTime() const;
double getAverageTravelTime() const;
void setTrafficLightPhase(const std::string &id, int phaseIndex);
void setReplayLogFile(const std::string &logFile);
void setSaveReplay(bool open);
void setVehicleSpeed(const std::string &id, double speed);
void setRandomSeed(int seed) { rnd.seed(seed); }
void reset(bool resetRnd = false);
// archive
void load(const Archive &archive) { archive.resume(*this); }
Archive snapshot() { return Archive(*this); }
void loadFromFile(const char *fileName);
bool setRoute(const std::string &vehicle_id, const std::vector<std::string> &anchor_id);
std::map<std::string, std::string> getVehicleInfo(const std::string &id) const;
};
}
#endif //CITYFLOW_ENGINE_H
|