16 | | L = 90; |
17 | | BaseTrafficAgent::validate(); |
18 | | |
19 | | rv_action = RV("Tc",1); |
20 | | rv_action.add( RV( stage_names, ones_i(stage_names.length()) ) ); |
21 | | |
22 | | for ( int i=0; i<lanehs.length(); i ++ ) { |
23 | | unsigned int index = find_index( green_names, name + "_" + lanehs(i)->getSG() ); |
24 | | lanehs(i)->green_time_ratio = green_times( index ); |
25 | | } |
26 | | |
27 | | Q = diag( ones( queues.length()) ); |
28 | | R = "1"; |
29 | | A = diag( ones( queues.length()) ); |
30 | | B = ones( queues.length(), 1); |
31 | | |
32 | | minimizer = new QuadraticMinimalizator(A,B,Q,R); |
| 17 | BaseTrafficAgentCt::validate(); |
46 | | void adapt (const vec &glob_dt) { |
47 | | for ( int i=0; i<lanehs.length(); i ++ ) { |
48 | | //lanehs(i)->inputs( 0 ) = inputs( 2*find_index(rv_inputs, lanehs(i)->rv_inputs.name(0) ) ); |
49 | | //lanehs(i)->inputs( 1 ) = inputs( 2*find_index(rv_inputs, lanehs(i)->rv_inputs.name(0) ) + 1 ); |
50 | | lanehs(i)->queue = queues( find_index( rv_queues, lanehs(i)->getQueueName() ) ); |
51 | | lanehs(i)->countAvgs(); |
52 | | } |
53 | | |
| 23 | void adapt (const vec &glob_dt) { |
| 24 | BaseTrafficAgentCt::adapt(glob_dt); |
| 25 | |
| 26 | Q = 100 * diag( ones( queues.length()) ) + diag(computedQueues); |
| 27 | R = "0.0000001"; |
| 28 | A = diag( ones( queues.length()) ); |
| 29 | B = zeros( queues.length(), 1); |
| 30 | |
| 61 | } |
| 62 | |
| 63 | double votingWeight() { |
| 64 | //vec computedQueues = getComputedQueues(); |
| 65 | double qsum = 0; |
| 66 | for ( int i = 0; i < computedQueues.length(); i++ ) { |
| 67 | qsum += computedQueues(i); |
| 68 | } |
| 69 | if ( qsum > 1 ) |
| 70 | return qsum; |
| 71 | else |
| 72 | return 1; |
| 73 | } |
| 74 | |
| 75 | void broadcastTc( Setting & set) { |
| 76 | // posli idealni tc |
| 77 | Tc_computed = computeTc(); |
| 78 | stringstream tcstr; |
| 79 | tcstr << "timecycle" << name; |
| 80 | |
| 81 | // posli vahu hlasu (suma front) |
| 82 | //vec computedQueues = getComputedQueues(); |
| 83 | |
| 84 | vec tc_vec = "0.0 0.0"; |
| 85 | tc_vec(0) = Tc_computed; |
| 86 | tc_vec(1) = votingWeight(); |
| 87 | // posilam vektor [tc, w] |
| 88 | sendToAll<vec>(set, tcstr.str(), tc_vec); |
95 | | void act (vec &glob_ut){ |
96 | | //cout <<"A act"<<endl<<A<<endl; |
97 | | B = B * T * L; |
98 | | minimizer = new QuadraticMinimalizator(A, B, Q, R); |
99 | | vec computedQueues = getComputedQueues(); |
100 | | vec res = minimizer->minimize(computedQueues, 100); |
101 | | //cout << "minimalization res " << name << endl << res << endl << endl; |
102 | | delete minimizer; |
103 | | int Tc = 80; |
104 | | vec action; |
105 | | action.set_size(rv_action._dsize()); |
106 | | action(find_index(rv_action, "Tc")) = Tc; |
107 | | int st; |
108 | | int stage_time_sum = 0; // soucet delky fazi |
109 | | action(find_index(rv_action, "Tc")) = Tc; |
110 | | for ( int i =0; i < stage_names.length(); i ++) { |
111 | | if ( (i+1) < stage_names.length() ) { |
112 | | st = round(((double)(stage_times(i)*Tc))/80.0); |
113 | | stage_time_sum += st; |
114 | | action(find_index(rv_action, stage_names(i))) = st; |
115 | | } |
116 | | else { // dopocitani posledni faze - oprava zaokrouhlovaci chyby |
117 | | action(find_index(rv_action, stage_names(i))) = Tc - stage_time_sum; |
118 | | } |
119 | | } |
120 | | action2ds.filldown(action,glob_ut); |
| 112 | void act (vec &glob_ut){ |
| 113 | //vec computedQueues = getComputedQueues(); |
| 114 | cout << endl << name << " ACT" << endl; |
| 115 | cout << "Tc computed = " << Tc_computed << endl; |
| 116 | cout << "queues = " << round( computedQueues )<< endl; |
| 117 | double w = votingWeight(); |
| 118 | Tc_sum += Tc_computed * w; |
| 119 | Tc_w_sum += w; |
| 120 | int Tc = (int)round( Tc_sum / Tc_w_sum ); |
| 121 | setCycleTime(Tc, glob_ut); |
| 122 | looper ++; |
| 123 | } |
| 124 | // VYPOCETNI FUNKCE |
| 125 | |
| 126 | // saturovany tok pruhu i |
| 127 | double s_flow(int i) { |
| 128 | double min_flow = 0.3; |
| 129 | double max_flow = 0.5; |
| 130 | double input = 0; |
| 131 | if ( 2*i < inputs.length() ) |
| 132 | input = inputs(2*i); |
| 133 | |
| 134 | vec q = getComputedQueues(); |
| 135 | double flow = q(i); |
| 136 | if ( input > 0 ) |
| 137 | flow += input; |
| 138 | flow = flow/T; |
| 139 | if ( flow > max_flow ) |
| 140 | return max_flow; |
| 141 | if ( flow < min_flow ) |
| 142 | return min_flow; |
| 143 | else |
| 144 | return flow; |
123 | | void setCycleTime( int Tc, vec &glob_ut ) { |
124 | | |
| 147 | double computeTc() { |
| 148 | B = B * T; |
| 149 | //vec computedQueues = getComputedQueues(); |
| 150 | minimizer = new QuadraticMinimalizator(A, B, Q, R); |
| 151 | mat L_mat = minimizer->L( 100); |
| 152 | vec u_vec = L_mat * computedQueues; |
| 153 | double u = u_vec(0); |
| 154 | double Tc_computed = L / (1 - u); |
| 155 | delete minimizer; |
| 156 | if ( u >= 1 || Tc_computed > Tc_max ) { |
| 157 | cout << endl << "Tc error : " << Tc_computed << " setting to max" << endl; |
| 158 | Tc_computed = Tc_max; |
| 159 | } |
| 160 | if ( Tc_computed < Tc_min ) { |
| 161 | cout << endl << "Tc error : " << Tc_computed << " setting to min" << endl; |
| 162 | Tc_computed = Tc_min; |
| 163 | } |
| 164 | return Tc_computed; |
138 | | template <class T> void sendToAll( Setting &set, string msgCode, T value) { |
139 | | for ( int i = 0; i < neighbours.length(); i ++ ) { |
140 | | Setting & msg = set.add(Setting::TypeGroup); |
141 | | UI::save( neighbours(i), msg, "to" ); |
142 | | UI::save (name,msg,"from"); |
143 | | UI::save( msgCode, msg, "what" ); |
144 | | UI::save( value, msg, "value" ); |
145 | | } |
146 | | } |
148 | | void printVector ( RV rv_vector, vec vector, string description ) { |
149 | | cout << endl << description << " " << name << endl; |
150 | | int k = 0; |
151 | | for ( int i = 0; i < rv_vector.length(); i ++ ) { |
152 | | cout << rv_vector.name(i) << " : "; |
153 | | for ( int j = 0; j < rv_vector.size(i); j ++ ) { |
154 | | cout << vector(k) << " "; |
155 | | k ++; |
156 | | } |
157 | | cout << endl; |
158 | | } |
159 | | cout << endl; |
160 | | } |
161 | | |
162 | | unsigned int find_index ( RV rv_vector, string index_string ) { |
163 | | for ( unsigned int i = 0; i < rv_vector.length(); i ++) { |
164 | | if ( rv_vector.name(i) == index_string ) |
165 | | return i; |
166 | | } |
167 | | return -1; |
168 | | } |
169 | | |
170 | | unsigned int find_index ( Array <string> arr, string index_string ) { |
171 | | for ( unsigned int i = 0; i < arr.length(); i ++) { |
172 | | if ( arr(i) == index_string ) |
173 | | return i; |
174 | | } |
175 | | return -1; |
| 174 | // KONEC |
| 175 | ~TrafficAgentLQ() { |
| 176 | |