Changeset 1071 for applications/doprava

Timestamp:

06/10/10 00:41:54 (15 years ago)

Author:

ondrak

Message:

compatibility with new config file, many other changes, but yet untested

Location:

applications/doprava

Files:

• . (modified) (1 prop)
• Zlicingw.cfg (modified) (3 diffs)
• main_loop.cpp (modified) (1 diff)
• traffic_agent_offset.h (modified) (23 diffs)

applications/doprava/Zlicingw.cfg

@@ -13 +13 @@
         neighbours = ("601");
         offset = 60; //s
-        sgs=("VA","VB","VC","VD","VE","VF");
-        green_starts=[72,4,5,35,36,71];
-        moje_special=14;
-},
+  green_names = ("495_VA","495_VB","495_VC","495_VD","495_VE","495_VF");
+  green_starts=[72,4,5,35,36,71];
+  green_times = [0.2,0.2,0.1,0.1,0.2,0.2];// ratios of green of 80s
+  stage_names = ("495_F1","495_F2","495_F3");
+  stage_times = [30,30,20];},
 { //agent 2
         class = "GreenWaveTrafficAgent";
@@ -32 +33 @@
         neighbours = ("495");
         offset = 40;
-        sgs=("VA","VB","VC","VD","VE","SE");
-        green_starts=[54,9,26,25,9,9];
+        green_names = ("601_VA","601_VB","601_VC","601_VD","601_VE","601_SE");
+        green_starts=[54,9,26,25,9,9];
+        green_times = [0.2,0.2,0.1,0.1,0.2,0.2];// ratios of green of 80s
+        stage_names = ("601_F1","601_F2","601_F3");
+        stage_times = [30,30,20];
 }
-
 );
 
 logger = {class="memlog"; filename = "mujzlicin"; maxlen = 1000;};
-
-
-
 
 system = {
@@ -54 +54 @@
         // simulation in our case starts always at 00:00:00. Default simulation
         // length is 24 hours (24:00:00).
-        stop_time = "01:00:00";
+        stop_time = "00:05:00";
         
 };

applications/doprava/main_loop.cpp

@@ -59 +59 @@
         // INITIALISATION OF UT
         glob_ut[ 0] = 80; // cycle time
-        glob_ut[ 1] = 40; // offset 495
+        glob_ut[ 1] = 60; // offset 495
         glob_ut[ 2] = 30; // ut[2]+ut[3]+ut[4] has to sum up to ut[0]
         glob_ut[ 3] = 30;
         glob_ut[ 4] = 20;
-    glob_ut[ 8] = 20; // offset 601
+    glob_ut[ 8] = 40; // offset 601
         glob_ut[ 9] = 30; // ut[9]+ut[10]+ut[11] has to sum up to ut[0]
         glob_ut[10] = 30;

applications/doprava/traffic_agent_offset.h

@@ -1 +1 @@
 #include "traffic_agent.h"
 #include <list>
+#include <fstream>
 
 class GreenWaveTrafficAgent : public BaseTrafficAgent {
@@ -7 +8 @@
         int negot_offset;
 
+        int actual_time;
+
+        RV rv_outputs;
+        vec outputs;
+
         RV rv_change_request;
         vec change_request;
@@ -12 +18 @@
         RV rv_recieved_exps;
         vec recieved_exps;
+
+        RV rv_next_exps;
+        vec next_exps;
 
         RV rv_recieved_changes;
@@ -30 +39 @@
 
         //! counts all expected cars going from each lane, saves to outputs and rv_outputs
-        void expected_cars(/*const string dest*/) {
+        void expected_cars() {
                 double start_time;
+                ivec ind;
+                RV rv_exp;
+                datalink exp2outputs;
+                vec exp;
 
                 for (int i=0;i<lanes.length();i++) {
                         for (int j=0;j<lanes(i).outputs.length();j++) {
-                                string group = name+"_"+lanes(i).sg;            //e.g. 495_VA
-                                ivec index=rv_inputs.dataind(RV(group,1));
-                                vec green_time=inputs(index);
-
-                                rv_outputs.add(RV(lanes(i).outputs(j)+"-"+group,3));
-                                outputs.set_size(rv_outputs._dsize());
-
-                                ivec ind = rv_outputs.dataind(RV(lanes(i).outputs(j)+"-"+group,3));
-
-                                //Number of cars
-                                outputs(ind(0))=lanehs(i)->expected_output(green_time(0));      
-
-                                start_time = green_starts(sg_index(lanes(i).sg)) + lanes(i).output_distances(j)/VP + planned_offset;
-                                //first car arrive time
-                                outputs(ind(1))=start_time;                                                                     
-                                //last car arrive time
-                                outputs(ind(2))= start_time + green_time(0);
+                                if (lanes(i).outputs(j)!="DUMMY_DET") {
+                                        string group = name+"_"+lanes(i).sg;            //e.g. 495_VA
+                                        
+                                        int index=group_index(group);
+                                        
+                                        double green_time=green_times(index)*cycle_length;
+
+                                        //ivec green_index=rv_inputs.dataind(RV(group,1));
+                                        //vec green_time=inputs(green_index);
+
+                                        //cout << "Green time "<<green_time<<endl;
+
+                                        rv_exp=RV(lanes(i).outputs(j)+"-"+name+"_"+to_string(i),3);
+
+                                        exp.set_size(rv_exp._dsize());
+                                        exp2outputs.set_connection(rv_exp,rv_outputs);
+
+                                        //Number of cars
+                                        exp(0)=lanehs(i)->expected_output(green_time)*lanes(i).alpha(j);        
+
+                                        start_time = green_starts(group_index(name+"_"+lanes(i).sg)) + lanes(i).output_distances(j)/VP + planned_offset;
+                                        //first car arrive time
+                                        exp(1)=start_time;
+                                        //last car arrive time
+                                        exp(2)=start_time + green_time;
+                                        //TODO pushup az na konec
+                                        exp2outputs.pushup(outputs,exp);
+
+                                }                       
                         }
                 }
@@ -59 +84 @@
         double count_rating(const int offset) {
                 double virtual_queue;
-                double t_emptiyng;
                 double t_green_begin;
                 double t_green_end;
-                double t_cars_begin;
-                double t_cars_end;
-//              vec t_cars_begin;
-//              vec t_cars_end;
-                double t_mixing;
+                vec cars_count;
+                vec t_cars_begin;
+                vec t_cars_end;
                 bool found;
 
                 double rating=0.0;
+
+                RV rv_vector;
+                vec vector;
+                datalink exps2vector;
 
                 for (int i=0;i<lanes.length();i++) {
@@ -75 +101 @@
                         //Finding, if we have some expectations
                         found=false;
+                        
                         for (int k=0;k<lanes(i).inputs.length();k++) { 
-//                              t_cars_begin.set_size(lanes(i).inputs.length());
-//                              t_cars_end.set_size(lanes(i).inputs.length());
-
+                                int l=0;                
                                 for (int j=0;j<rv_recieved_exps.length();j++) {
+                                        t_cars_begin.set_size(l+1,true);
+                                        t_cars_end.set_size(l+1,true);
+                                        cars_count.set_size(l+1,true);
+                                
                                         int result=rv_recieved_exps.name(j).find(lanes(i).inputs(k)+"-");
                                         if (result>=0) {
-                                                ivec ind = rv_recieved_exps.dataind(RV(rv_recieved_exps.name(j),3));
-
-                                                t_cars_begin=recieved_exps(ind(1));             //TODO now using only last found exp.
-                                                t_cars_end=recieved_exps(ind(2));
+
+                                                rv_vector = RV(rv_recieved_exps.name(j),3);
+                                                ivec ind = rv_vector.dataind(rv_recieved_exps);
+
+                                                cars_count(l)=recieved_exps(ind(0));
+                                                t_cars_begin(l)=recieved_exps(ind(1));
+                                                t_cars_end(l)=recieved_exps(ind(2));
+                                                l++;
+
                                                 found=true;
                                         }
                                 }
-                        }
-
-                        if (!found) {
-                                t_cars_begin=0;
-                                t_cars_end=cycle_length;
-                        }
-                        //counting rating
-                        t_green_begin=green_starts(sg_index(lanes(i).sg)) + offset;
-                        ivec ind = rv_inputs.dataind(RV(name+"_"+lanes(i).sg,1));
-                        t_green_end=t_green_begin+inputs(ind(0));
-
-                        //TODO use real queues lenghts
-                        if (t_green_begin<t_cars_begin) {
-                                //virtual_queue=lanehs(i)->queue-(t_cars_begin-t_green_begin)/car_leaving;
-                                //virtual_queue=(rand()%8)-(t_cars_begin-t_green_begin)/car_leaving;
-                                virtual_queue=5-(t_cars_begin-t_green_begin)/car_leaving;
-                        } 
-                        else if (t_green_begin>t_cars_begin) {
-                                //virtual_queue=lanehs(i)->queue+(t_green_begin-t_cars_begin)*lanehs(i)->expected_density();
-                                //virtual_queue=(rand()%9)+(t_green_begin-t_cars_begin)*lanehs(i)->expected_density();
-                                virtual_queue=4+(t_green_begin-t_cars_begin)*lanehs(i)->expected_density();
-                        }
-
-                        t_emptiyng=virtual_queue/(1/car_leaving - lanehs(i)->expected_density());
-                        t_mixing=min(t_green_end,t_cars_end)-max(t_green_begin,t_cars_begin);
-
-                        rating+=max((t_mixing-t_emptiyng)*lanehs(i)->expected_density(),0.0);  
+                                if (found) {                    
+                                        //counting rating
+                                        string group = name+"_"+lanes(i).sg;            //e.g. 495_VA
+                                        int index=group_index(group);
+
+                                        t_green_begin=green_starts(index) + offset;
+                                        double green_time=green_times(index)*cycle_length;
+                                        t_green_end=t_green_begin+green_time;
+
+                                        /************** counting with all exps ****************/
+
+                                        int k;
+                                        double t_act=t_green_begin;
+                                        virtual_queue=lanehs(i)->queue;
+
+                                        //cycle goes through all stopping points and counts queue lenght at these points
+                                        do {
+                                                k=min_i(t_cars_begin);
+
+                                                if (k!=-1) {                                            
+                                                        double a=cars_count(k);
+                                                        double b=t_cars_begin(k);
+                                                        double c=t_cars_end(k);
+
+                                                        //in case there are cars comming before t_green begin
+                                                        if (t_cars_begin(k)<t_act) {
+                                                                if (t_cars_end(k)<=t_act) {
+                                                                        virtual_queue+=cars_count(k);
+                                                                        //jen prodlouzime, t_act zustava, odstranime k-ty predpoklad (mozna hned, mozna az na konci
+                                                                        cars_count.del(k);
+                                                                        t_cars_begin.del(k);
+                                                                        t_cars_end.del(k);
+
+                                                                }
+                                                                else {
+                                                                        //prodlouzujeme do casu t_green_begin, 
+                                                                        //pak bud green_begin posuneme do t_act
+                                                                        double pomer=(t_cars_begin(k)-t_act)/(t_cars_end(k)-t_cars_begin(k));
+                                                                        virtual_queue+=cars_count(k)*pomer;
+                                                                        t_cars_begin(k)=t_act;
+                                                                }
+                                                        }
+                                                        else if (t_cars_begin(k)==t_act) {
+                                                                //mixujeme az do t_cars_end nebo t_green_end
+                                                                //posuneme t_act na jeden z tech casu
+                                                                if (t_cars_end(k)<t_green_end) {
+                                                                        virtual_queue+=cars_count(k)-(t_cars_end(k)-t_act)/car_leaving;
+                                                                        t_act=t_cars_end(k);
+
+                                                                        cars_count.del(k);
+                                                                        t_cars_begin.del(k);
+                                                                        t_cars_end.del(k);
+                                                                }
+                                                                //t_cars_end>=t_green_end
+                                                                else {
+                                                                        virtual_queue+=cars_count(k)-(t_green_end-t_act)/car_leaving;
+                                                                        t_act=t_green_end;
+
+                                                                        cars_count.del(k);
+                                                                        t_cars_begin.del(k);
+                                                                        t_cars_end.del(k);                                                      
+                                                                }
+
+
+                                                        }
+                                                        //t_cars_begin(k)>=t_act
+                                                        else {
+                                                                //zkracujeme frontu az do t_cars_end(k) nebo t_green_end a posuneme t_act
+                                                                if (t_cars_end(k)<t_green_end) {
+                                                                        virtual_queue-=(t_cars_end(k)-t_act)/car_leaving;
+                                                                        t_act=t_cars_end(k);
+                                                                }
+                                                                else {
+                                                                        virtual_queue-=(t_green_end-t_act)/car_leaving;
+                                                                        t_act=t_green_end;
+                                                                }
+                                                        }
+                                                }
+                                                else {
+                                                        virtual_queue-=(t_green_end-t_act)/car_leaving;
+                                                        t_act=t_green_end;
+                                                }
+                                                if (virtual_queue<0) {
+                                                        rating-=virtual_queue;
+                                                        virtual_queue=0;
+                                                }
+
+                                        } while (t_act<t_green_end);
+                                }
+                        }
                 }
                 return rating;
@@ -179 +276 @@
                         int res = rv_recieved_exps.name(j).find("-"+neighbour);
                         if (res>0) {
-                                ivec ind = rv_recieved_exps.dataind(RV(rv_recieved_exps.name(j),3));
+                                ivec ind = RV(rv_recieved_exps.name(j),3).dataind(rv_recieved_exps);
+
                                 rating_n=count_rating(planned_offset);
 
@@ -219 +317 @@
         }
 
-        //! returns index of signal group sg
-        int sg_index(const string sg) {
-                for (int i=0;i<sgs.length();i++) {
-                        if (sgs(i)==sg) {
+        // pravdepodobne s chybou, momentalne se nepouziva
+        void split_exps() {
+                ivec ind;
+                RV rv_exp;
+                datalink recieved2next;
+
+                rv_next_exps=RV();
+                for (int i=0;i<rv_recieved_exps.length();i++) {
+                        if (rv_recieved_exps.size(i)==3) {              
+                                rv_exp=RV(rv_recieved_exps.name(i),3);
+                                ind = rv_exp.dataind(rv_recieved_exps);
+                                //cout << "ind " << ind << endl;
+
+                                int next_cycle_end=2 * cycle_length - (actual_time % cycle_length);
+                                if (recieved_exps(ind(1))>next_cycle_end) {
+                                        rv_next_exps.add(rv_exp);
+                                        next_exps.set_size(rv_next_exps._dsize());
+                                        
+                                        if (actual_time==630) {
+                                                cout << "rv_next_exps " << rv_next_exps.to_string() << endl;
+                                                cout << "rv_recived_exps " << rv_recieved_exps.to_string() << endl;
+                                        }
+
+                                        recieved2next.set_connection(rv_next_exps,rv_recieved_exps);
+                                        recieved2next.filldown(recieved_exps,next_exps);
+                                        rv_recieved_exps=rv_recieved_exps.subt(rv_exp);
+                                }
+                                else if (recieved_exps(ind(2))>next_cycle_end) {
+                                        rv_next_exps.add(rv_exp);
+                                        next_exps.set_size(rv_next_exps._dsize());
+
+                                        ivec ind2=rv_exp.dataind(rv_next_exps);
+                                        next_exps(ind2(0))=recieved_exps(ind(0)); //TODO to neni spravne
+                                        next_exps(ind2(1))=next_cycle_end; 
+                                        next_exps(ind2(2))=recieved_exps(ind(2));
+                                        recieved_exps(ind(2))=next_cycle_end;
+                                }
+                        }
+                }
+        }
+
+        //! returns index of signal group group
+        int group_index(const string group) {
+                for (int i=0;i<green_names.length();i++) {
+                        if (green_names(i)==group) {
                                 return i;
                         }
@@ -231 +370 @@
         //! returns offset value shifted to fit interval <0;cycle_length>
         int normalize_offset(int offset) {
-                while (offset<0 && offset<cycle_length) {
+                while (offset<0 || offset>cycle_length) {
                         if (offset<0) {
                                 offset+=cycle_length;
@@ -241 +380 @@
                 return offset;
         }
-
+        
+        //! returns value shifted to fit interval <0;cycle_length>
+        template<class T> T normalize(T time) {
+                while (time<0 && time<cycle_length) {
+                        if (time<0) {
+                                time+=cycle_length;
+                        }
+                        else {
+                                time-=cycle_length;
+                        }
+                }
+                return time;
+        }
+
+        template <class T> inline string to_string (const T& t)
+        {
+                std::stringstream ss;
+                ss << t;
+                return ss.str();
+        }
 
         //! returns index of maximum of entered values
@@ -256 +414 @@
         }
 
+        //! returns index of smallest element in vectorsx
+        int min_i(vec vector) {
+                if (vector.length()>0) {
+                        double min=vector(0);
+                        int index=0;
+                        for (int i=1;i<vector.length();i++) {
+                                if (vector(i)<min) {
+                                        min=vector(i);
+                                        index=i;
+                                }
+                        }
+                        return index;
+                }
+                return -1;
+        }
+
 public:
         //! offset set in last simulation step
@@ -261 +435 @@
         //! actual planned offset to set for next simulation step
         int planned_offset;
+        //! planned offset for cycle after next cycle
+        int planned_next_offset;
         //! rating of actual planned offset
         double planned_rating;
+        //! rating of planned next offset
+        double planned_next_rating;
         
-        //! array of existing signal groups
-        Array<string> sgs;
-        //! relative starts of green for signal groups
-        ivec green_starts;
-
         //! avarage speed of cars
         int VP;
@@ -275 +448 @@
                 rv_action = RV(name+"_offset", 1); // <======= example
 
-                for (int i=0; i<sgs.length();i++) {
-                        rv_inputs.add(RV(name+"_"+sgs(i),1));
+                for (int i=0; i<green_names.length();i++) {
+                        rv_inputs.add(RV(green_names(i),1));
                 }
                 inputs.set_size(rv_inputs._dsize());
@@ -283 +456 @@
 
                 for (int i=0;i<lanehs.length();i++) {
-                        ivec index = rv_queues.dataind(RV(lanes(i).queue,1));
+                        ivec index = RV(lanes(i).queue,1).dataind(rv_queues);
                         lanehs(i)->queue_index=index(0);
                 }
-
-
         }
 
@@ -323 +494 @@
                 // broadcast expected cars
                 if (!seznam.empty()) {
+                        double a;
                         expected_cars();
                         do {
@@ -332 +504 @@
                                 UI::save ( outputs, msg, "value");
                                 seznam.pop_back();
+                                a=outputs (10);
+                                
                         } while (!seznam.empty());                      
                 }
@@ -375 +549 @@
                 // reached final offset. Log value?
                 if (final_state) {
-                        
-                        //cout << "Jmenuji se "<<name<< " a skoncil jsem na offsetu " << planned_offset << " s hodnocenim " << planned_rating <<endl;
+                        cout << "Jmenuji se "<<name<< " a skoncil jsem na offsetu " << planned_offset << " s hodnocenim " << planned_rating <<endl;
                         final_state=false;
                 }
@@ -401 +574 @@
                         rv_recieved_exps=*rv;
                         recieved_exps=value;
+                        //split_exps();
                         
                         last_offset=planned_offset;
@@ -411 +585 @@
                                 reset_negot_offset=true;
                         }*/
+
                         planned_rating=count_rating(planned_offset);
                         // we have new stable state to broadcast
@@ -418 +593 @@
                         rv_recieved_exps=*rv;
                         recieved_exps=value;
+                        //split_exps();
                         planned_rating=count_rating(planned_offset);
 
@@ -423 +599 @@
                                 rv_change_request.add(RV(neighbours(i)+"_change",2));
                                 change_request.set_size(rv_change_request._dsize()); 
-                                ivec ind=rv_change_request.dataind(RV(neighbours(i)+"_change",2));
+                                ivec ind=RV(neighbours(i)+"_change",2).dataind(rv_change_request);
                                 // offset change
                                 change_request(ind(0))=find_best_exps(negot_offset,neighbours(i),rating_change);
@@ -446 +622 @@
                         for (int i=0;i<rv_recieved_changes.length();i++) {
 
-                                ivec ind=rv_recieved_changes.dataind(RV(rv_recieved_changes.name(i),2));
-
-                                final_rating_diff=-planned_rating+count_rating(planned_offset+(int)recieved_changes(ind(0)))-recieved_changes(ind(0));
-                                if (final_rating_diff>0) {
+                                ivec ind=RV(rv_recieved_changes.name(i),2).dataind(rv_recieved_changes);
+
+                                final_rating_diff=-planned_rating+count_rating(planned_offset+(int)recieved_changes(ind(0)))+recieved_changes(ind(1));
+                                if (final_rating_diff>=0) {
                                         planned_offset+=(int)recieved_changes(ind(0));
+                                        planned_offset=normalize_offset(planned_offset);
                                         planned_rating+=final_rating_diff;
                                         accepted_from=from;
@@ -473 +650 @@
         void from_setting(const Setting &set) {
                 BaseTrafficAgent::from_setting(set);
-                
-                srand(time(NULL));
+
+                RV rv_exp;
+
+                std::ofstream ofile;
+                ofile.open("greentimes.txt");
+                ofile.close();
 
                 car_leaving=2;
                 VP=45;
+                actual_time=0;
 
                 negot_offset=8;
                 
                 // load from file
-                UI::get(sgs, set, "sgs", UI::compulsory);       
-                UI::get(green_starts, set, "green_starts", UI::compulsory);
+                //UI::get(sgs, set, "sgs", UI::compulsory);     
+
+                //UI::get(green_starts, set, "green_starts", UI::compulsory);
                 UI::get(last_offset, set, "offset", UI::compulsory);
-        
-        }
+
+                for (int i=0;i<lanes.length();i++) {
+                        for (int j=0;j<lanes(i).outputs.length();j++) {
+                                if (lanes(i).outputs(j)!="DUMMY_DET") {
+                                        rv_exp=RV(lanes(i).outputs(j)+"-"+name+"_"+to_string(i),3);
+                                        rv_outputs.add(rv_exp);
+                                }
+                        }
+                }
+                outputs.set_size(rv_outputs._dsize());  
+        }
+
         void act(vec &glob_ut){
                 vec action;
                 action.set_size(rv_action._dsize());
-
+                
                 ivec index = rv_action.dataind(RV(name+"_offset",1));
+
                 action(index(0))=planned_offset;
                 last_offset=planned_offset;
-
                 action2ds.filldown(action,glob_ut);
+
+                actual_time+=step_length;
         }