Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2006-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 RODFDetectorFlow.cpp
15 : /// @author Daniel Krajzewicz
16 : /// @author Eric Nicolay
17 : /// @author Michael Behrisch
18 : /// @author Melanie Knocke
19 : /// @date Thu, 16.03.2006
20 : ///
21 : // Storage for flows within the DFROUTER
22 : /****************************************************************************/
23 : #include <config.h>
24 :
25 : #include <iostream>
26 : #include <cassert>
27 : #include "RODFDetectorFlow.h"
28 :
29 :
30 : // ===========================================================================
31 : // method definitions
32 : // ===========================================================================
33 178 : RODFDetectorFlows::RODFDetectorFlows(SUMOTime startTime, SUMOTime endTime,
34 178 : SUMOTime stepOffset)
35 178 : : myBeginTime(startTime), myEndTime(endTime), myStepOffset(stepOffset),
36 178 : myMaxDetectorFlow(-1) {}
37 :
38 :
39 178 : RODFDetectorFlows::~RODFDetectorFlows() {}
40 :
41 :
42 : void
43 8067 : RODFDetectorFlows::addFlow(const std::string& id, SUMOTime t, const FlowDef& fd) {
44 8067 : if (myFastAccessFlows.find(id) == myFastAccessFlows.end()) {
45 962 : int noItems = (int)((myEndTime - myBeginTime) / myStepOffset);
46 962 : myFastAccessFlows[id] = std::vector<FlowDef>(noItems);
47 962 : std::vector<FlowDef>& cflows = myFastAccessFlows[id];
48 : // initialise
49 493655 : for (std::vector<FlowDef>::iterator i = cflows.begin(); i < cflows.end(); ++i) {
50 492693 : (*i).qPKW = 0;
51 492693 : (*i).qLKW = 0;
52 492693 : (*i).vPKW = 0;
53 492693 : (*i).vLKW = 0;
54 492693 : (*i).fLKW = 0;
55 492693 : (*i).isLKW = 0;
56 492693 : (*i).firstSet = true;
57 : }
58 : }
59 8067 : const int index = (int)((t - myBeginTime) / myStepOffset);
60 : assert(index < (int) myFastAccessFlows[id].size());
61 8067 : FlowDef& ofd = myFastAccessFlows[id][index];
62 8067 : if (ofd.firstSet) {
63 8067 : ofd = fd;
64 8067 : ofd.firstSet = false;
65 : } else {
66 0 : ofd.qLKW = ofd.qLKW + fd.qLKW;
67 0 : ofd.qPKW = ofd.qPKW + fd.qPKW;
68 0 : ofd.vLKW = ofd.vLKW + fd.vLKW; //!!! mean value?
69 0 : ofd.vPKW = ofd.vPKW + fd.vPKW; //!!! mean value?
70 : }
71 8067 : if (ofd.qPKW != 0) {
72 6543 : ofd.fLKW = ofd.qLKW / (ofd.qLKW + ofd.qPKW);
73 : } else {
74 1524 : ofd.fLKW = 1;
75 1524 : ofd.isLKW = 1;
76 : }
77 8067 : }
78 :
79 :
80 : void
81 0 : RODFDetectorFlows::setFlows(const std::string& detector_id,
82 : std::vector<FlowDef>& flows) {
83 0 : for (std::vector<FlowDef>::iterator i = flows.begin(); i < flows.end(); ++i) {
84 : FlowDef& ofd = *i;
85 0 : if (ofd.qLKW != 0 && ofd.qPKW != 0) {
86 0 : ofd.fLKW = ofd.qLKW / ofd.qPKW;
87 : } else {
88 0 : ofd.fLKW = 0;
89 : }
90 : }
91 0 : myFastAccessFlows[detector_id] = flows;
92 0 : }
93 :
94 :
95 : void
96 7 : RODFDetectorFlows::removeFlow(const std::string& detector_id) {
97 : myFastAccessFlows.erase(detector_id);
98 7 : }
99 :
100 :
101 : bool
102 1587 : RODFDetectorFlows::knows(const std::string& det_id) const {
103 1587 : return myFastAccessFlows.find(det_id) != myFastAccessFlows.end();
104 : }
105 :
106 :
107 : const std::vector<FlowDef>&
108 1068 : RODFDetectorFlows::getFlowDefs(const std::string& id) const {
109 : assert(myFastAccessFlows.find(id) != myFastAccessFlows.end());
110 : assert(myFastAccessFlows.find(id)->second.size() != 0);
111 1068 : return myFastAccessFlows.find(id)->second;
112 : }
113 :
114 :
115 : double
116 0 : RODFDetectorFlows::getFlowSumSecure(const std::string& id) const {
117 : double ret = 0;
118 0 : if (knows(id)) {
119 : const std::vector<FlowDef>& flows = getFlowDefs(id);
120 0 : for (std::vector<FlowDef>::const_iterator i = flows.begin(); i != flows.end(); ++i) {
121 0 : ret += (*i).qPKW;
122 0 : ret += (*i).qLKW;
123 : }
124 : }
125 0 : return ret;
126 : }
127 :
128 :
129 : double
130 0 : RODFDetectorFlows::getMaxDetectorFlow() const {
131 0 : if (myMaxDetectorFlow < 0) {
132 : double max = 0;
133 : std::map<std::string, std::vector<FlowDef> >::const_iterator j;
134 0 : for (j = myFastAccessFlows.begin(); j != myFastAccessFlows.end(); ++j) {
135 : double curr = 0;
136 : const std::vector<FlowDef>& flows = (*j).second;
137 0 : for (std::vector<FlowDef>::const_iterator i = flows.begin(); i != flows.end(); ++i) {
138 0 : curr += (*i).qPKW;
139 0 : curr += (*i).qLKW;
140 : }
141 0 : if (max < curr) {
142 : max = curr;
143 : }
144 : }
145 0 : myMaxDetectorFlow = max;
146 : }
147 0 : return myMaxDetectorFlow;
148 : }
149 :
150 :
151 : void
152 0 : RODFDetectorFlows::mesoJoin(const std::string& nid,
153 : const std::vector<std::string>& oldids) {
154 0 : for (std::vector<std::string>::const_iterator i = oldids.begin(); i != oldids.end(); ++i) {
155 0 : if (!knows(*i)) {
156 0 : continue;
157 : }
158 0 : std::vector<FlowDef>& flows = myFastAccessFlows[*i];
159 : int index = 0;
160 0 : for (SUMOTime t = myBeginTime; t != myEndTime; t += myStepOffset) {
161 0 : addFlow(nid, t, flows[index++]); // !!!
162 : }
163 : myFastAccessFlows.erase(*i);
164 : }
165 0 : }
166 :
167 :
168 : void
169 0 : RODFDetectorFlows::printAbsolute() const {
170 0 : for (std::map<std::string, std::vector<FlowDef> >::const_iterator i = myFastAccessFlows.begin(); i != myFastAccessFlows.end(); ++i) {
171 0 : std::cout << (*i).first << ":";
172 : const std::vector<FlowDef>& flows = (*i).second;
173 : double qPKW = 0;
174 : double qLKW = 0;
175 0 : for (std::vector<FlowDef>::const_iterator j = flows.begin(); j != flows.end(); ++j) {
176 0 : qPKW += (*j).qPKW;
177 0 : qLKW += (*j).qLKW;
178 : }
179 : std::cout << qPKW << "/" << qLKW << std::endl;
180 : }
181 0 : }
182 :
183 :
184 : /****************************************************************************/
|
