Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2010-2024 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 MSSOTLE2Sensors.h
15 : /// @author Gianfilippo Slager
16 : /// @author Federico Caselli
17 : /// @date Feb 2010
18 : ///
19 : // The class for SOTL sensors of "E2" type
20 : // XXX: Not tested with MSMultiLaneE2Collector (Generalization of MSE2Collector). If this is to be used in the future and you run into problems,
21 : // start taking a look at the getEstimateQueueLength() method of the collector.
22 : /****************************************************************************/
23 : #pragma once
24 : #include <config.h>
25 :
26 :
27 : #include <cmath>
28 : #include <map>
29 : #include <utility>
30 : #include <microsim/output/MSE2Collector.h>
31 : #include "MSSOTLSensors.h"
32 : #include "MSSOTLDefinitions.h"
33 :
34 : class MSSOTLE2Sensors : public MSSOTLSensors {
35 : protected :
36 : void buildSensorForLane(MSLane* lane, NLDetectorBuilder& nb);
37 : void buildSensorForLane(MSLane* lane, NLDetectorBuilder& nb, double sensorLength);
38 : void buildContinueSensior(MSLane* lane, NLDetectorBuilder& nb, double sensorLength, MSLane* continueOnLane, double usedLength);
39 : void buildSensorForOutLane(MSLane* lane, NLDetectorBuilder& nb);
40 : void buildSensorForOutLane(MSLane* lane, NLDetectorBuilder& nb, double sensorLength);
41 :
42 : void buildCountSensorForLane(MSLane* lane, NLDetectorBuilder& nb);
43 : void buildCountSensorForOutLane(MSLane* lane, NLDetectorBuilder& nb);
44 :
45 : public:
46 : /*
47 : * @brief This sensor logic contructor
48 : */
49 : MSSOTLE2Sensors(std::string tlLogicID, const MSTrafficLightLogic::Phases* phases);
50 :
51 : /*
52 : * @brief This sensor logic destructor
53 : */
54 : ~MSSOTLE2Sensors(void);
55 :
56 : void buildSensors(MSTrafficLightLogic::LaneVectorVector controlledLanes, NLDetectorBuilder& nb);
57 : void buildSensors(MSTrafficLightLogic::LaneVectorVector controlledLanes, NLDetectorBuilder& nb, double sensorLength);
58 : void buildOutSensors(MSTrafficLightLogic::LaneVectorVector controlledLanes, NLDetectorBuilder& nb);
59 : void buildOutSensors(MSTrafficLightLogic::LaneVectorVector controlledLanes, NLDetectorBuilder& nb, double sensorLength);
60 : void buildCountSensors(MSTrafficLightLogic::LaneVectorVector controlledLanes, NLDetectorBuilder& nb);
61 : void buildCountOutSensors(MSTrafficLightLogic::LaneVectorVector controlledLanes, NLDetectorBuilder& nb);
62 :
63 : /*
64 : * Returns the number of vehicles that have passed the sensor.
65 : * Vehicles are effectively counted or guessed in the space from the sensor to the junction.
66 : * @param[in] laneId The ID of the lane of which you want to count vehicles.
67 : * @param[in] out boolean that indicate if the lane is an incoming or an outgoing one (@todo review)
68 : */
69 : int getPassedVeh(std::string laneId, bool out);
70 :
71 : /*
72 : * Sets the number of vehicles that have passed the sensor.
73 : * @param[in] laneId The ID of the lane of which you want to set vehicles.
74 : * @param[in] passed int indicating the number of vehicles to subtract.
75 : */
76 : void subtractPassedVeh(std::string laneId, int passed);
77 :
78 : void setSpeedThresholdParam(double newThreshold) {
79 96 : speedThresholdParam = newThreshold;
80 : }
81 :
82 : /*
83 : * Returns the number of vehicles currently approaching the
84 : * junction for the given lane.
85 : * Vehicles are effectively counted or guessed in the space from the sensor to the junction.
86 : * @param[in] lane The lane to count vehicles
87 : */
88 : int countVehicles(MSLane* lane);
89 :
90 : /*
91 : * Returns the number of vehicles currently approaching the
92 : * junction for the given lane.
93 : * Vehicles are effectively counted or guessed in the space from the sensor to the junction.
94 : * @param[in] lane The lane to count vehicles given by ID
95 : */
96 : int countVehicles(std::string laneId);
97 :
98 : int estimateVehicles(std::string laneId);
99 :
100 : double getEstimateQueueLength(std::string laneId);
101 : /*
102 : * @param[in] The lane given by Id
103 : * @return The maximum speed allowed for the given laneId
104 : */
105 : virtual double getMaxSpeed(std::string laneId);
106 :
107 : /*
108 : * Returns the average speed of vehicles currently approaching or leaving the
109 : * junction for the given lane.
110 : * Vehicles speed is effectively sensed or guessed in the space from the sensor.
111 : * @param[in] lane The lane to count vehicles
112 : */
113 : virtual double meanVehiclesSpeed(MSLane* lane);
114 :
115 : /*
116 : * Returns the average speed of vehicles currently approaching or leaving the
117 : * junction for the given lane.
118 : * Vehicles speed is effectively sensed or guessed in the space from the sensor.
119 : * @param[in] laneID The lane to count vehicles by ID
120 : */
121 : virtual double meanVehiclesSpeed(std::string laneId);
122 :
123 : /*
124 : * Set the weight of the vehicle types to be used by countVehicles
125 : * @param[in] the value of the param VEHICLE_TYPES_WEIGHTS. Format type1=value1; type2=value2 etc..
126 : */
127 : virtual void setVehicleWeigths(const std::string& weightString);
128 :
129 : protected:
130 : int count(MSE2Collector* sensor);
131 : template<typename Method, typename ValueType>
132 0 : bool getVelueFromSensor(std::string laneId, Method function, ValueType& value) {
133 0 : if (m_sensorMap.find(laneId) != m_sensorMap.end()) {
134 0 : value = (m_sensorMap[laneId]->*function)();
135 0 : return true;
136 : }
137 : return false;
138 : }
139 :
140 : // MSLane_MSE2CollectorMap m_sensorMap;
141 : MSLaneID_MSE2CollectorMap m_sensorMap;
142 : MSLaneID_MaxSpeedMap m_maxSpeedMap;
143 :
144 : // MSLane_MSE2CollectorMap mySensorsMap_OutLanes;
145 : // MSLaneID_MSE2CollectorMap mySensorsIDMap_OutLanes;
146 : // MSLaneID_MaxSpeedMap myMaxSpeedMap_OutLanes;
147 :
148 : double speedThresholdParam;
149 : std::map<std::string, std::vector<std::string> > m_continueSensorOnLanes;
150 : std::map<const std::string, int> m_typeWeightMap;
151 :
152 : };
|
