root/applications/doprava/traffic_agent.h

/*!
\file
\brief Traffic Light Agents 
\author Vaclav Smidl.
*/

#ifndef TRAGE_H
#define TRAGE_H


#include <base/participants.h>

using namespace bdm;

class BaseTrafficAgent;

//! detector of traffic variables
class Lane{
public:
        Array<string> inputs;
        Array<string> outputs;
        vec input_distances;
        vec output_distances;
        vec alpha; //size of outputs
        //! percent of queue lenght (for "multiline queues")
        double beta;
        string queue;
        string sg;

        //! function loading info from Setting
        void from_setting(const Setting &set){
                UI::get(inputs,set,"inputs",UI::compulsory);
                UI::get(outputs,set,"outputs",UI::compulsory);
                UI::get(input_distances,set,"input_distances",UI::compulsory);
                UI::get(output_distances,set,"output_distances",UI::compulsory);
                UI::get(alpha,set,"alpha",UI::compulsory);
                UI::get(queue,set,"queue",UI::compulsory);
                UI::get(sg,set,"sg",UI::compulsory);
                UI::get(beta, set, "beta");
        }
};

//! class that operates on a signal group
class LaneHandler {
protected:
        //! pointer to physical lane
        const Lane &lane;
        //! agent pointer
        BaseTrafficAgent *agent;

public:
        //! actual data from the relevant signal group
        vec inputs;
        //! queue length
        double queue; 
        //! description of det_data
        RV rv_inputs;
        //! description of det_data
        RV rv_outputs;
        //! description of det_data
        RV rv_queue;
        //! link from global measured data 
        datalink agentin2input;
        //!
        datalink output2agentout;
        //!
        int queue_index;

public:
        LaneHandler(const Lane &lane0): lane(lane0){
                for (int i=0;i<lane0.inputs.length();i++){
                        rv_inputs.add(RV(lane.inputs(i), 2));
                }
                for (int i=0;i<lane0.outputs.length();i++){
                        rv_outputs.add(RV(lane.outputs(i), 2)); 
                }
                rv_queue.add(RV(lane.queue, 1)); 
                inputs.set_size(rv_inputs._dsize());
                // KOD PRO TrafficAgentCycleTime
                init();
        }


        void connect_data(BaseTrafficAgent &agent0);

        //! computes expected density in cars/s
        double expected_density();

        //! arbitrary function that computes the need of the signal group for green light in common units (number of waiting cars?)
        double expected_output(double green_time);

        

/********************************
* KOD PRO TrafficAgentCycleTime *
*********************************/
        double queue_last;      
        double queue_avg_last;
        double green_time_ratio;
        double Tc;
        double last_Tc;
        double saturated_stream;
        double delta; // ztratovy cas pri prechodu na zelenou
        double delta_w;
        // udaje opro filtr
        double queue_avg; //  pruner
        double queue_w;   //  vaha

        double Ro_avg;  //  prumer
        double Ro_w;    //  vaha K

        double cars_in_avg;
        double cars_in_w;
        

        double last_queue_avg;

// pomocne funkce

        

        void init () {
                last_Tc = 0;
                saturated_stream = 0.5;
                queue = 0;
                queue_last = 0;
                // filtr
                delta = 0;
                delta_w = 0.2;
                
                queue_avg = 0;  //  prumer
                queue_w = 0.4;  //  vaha                

                Ro_avg = 0;     //  prumer
                Ro_w = 0.1;     //  vaha

                cars_in_avg = 0;
                cars_in_w = 0.4;
                
                last_queue_avg = 0;
        }

        /*double abs ( double x ) {
                if ( x > 0 ) return x;
                else return -x;
        }*/

        void echo () {
                
                cout << getQueueName();
                
                cout << "\tgtr: " << green_time_ratio;
                cout << "\tRo: " << getRo();
                cout << "\tC: " << green_time_ratio*Tc*saturated_stream - getRo()*Tc << endl; 
                //cout << "\tWT:";
                for ( int i = -2; i <= 2; i++ ) {
                        double tc = Tc + i*8;
                        cout << tc << "\t";
                }
                cout << endl;
                for ( int i = -2; i <= 2; i++ ) {
                        double tc = Tc + i*8;
                        cout << (int)(100*getWT(tc)) << "\t";
                }
                
                cout << endl << endl;
        }
        

        Lane getLane () {
                return lane;
        }

        string getSG () {
                return lane.sg;
        }

        string getQueueName () {
                return lane.queue;
        }

        double getQueue() {
                return queue_avg;
        }

        void addQueueLength ( int ql ) {
                // pricita pouze namerene udaje
                if ( ql >= 0 ) {
                        queue_last = queue;
                        queue = ql;
                        queue_avg_last = queue_avg;
                        
                        // KALMAN                       
                        //cout << endl << "pridani fronty\t" << queue_avg << "\t" << ql << endl;
                        queue_avg += queue_w*( ql - queue_avg );                        
                        /*cout << getQueueName() << " inputs";
                        int k = 0;
                        for ( int i = 0; i < rv_inputs.length(); i ++ ) {
                        cout <<"\t"<< rv_inputs.name(i) << ": ";
                        for ( int j = 0; j < rv_inputs.size(i); j ++ ) {                                
                                cout << inputs(k) << " ";
                                k ++;
                        }
                        cout << endl;*/
                }
                if ( inputs(0) >= 0 ) {
                        cars_in_avg += cars_in_w*( inputs(0) - cars_in_avg );
                
                }
                if ( cars_in_avg > 0 && queue_avg_last > saturated_stream*last_Tc*green_time_ratio ) {
                        //double delta_d = queue_avg - queue_avg_last + last_Tc * saturated_stream - cars_in_avg*(double)last_Tc/90;                    
                        double delta_d = ( last_Tc/(90*saturated_stream)) * (cars_in_avg - queue_avg + queue_avg_last) - green_time_ratio;
                        delta += delta_w * ( delta_d - delta );
                        if ( delta < 0 )
                                delta = 0;
                }

                cout << getQueueName() << " cars in: " << inputs(0) << " " << cars_in_avg <<
                        " q_avd: " << queue_avg <<
                        " delta: " << delta <<
                        endl;
        }


        

        double getAverageQueueLength () {
                // kalmam
                return queue_avg;
        }

        double getLastAverageQueueLength () {
                return queue_avg_last;
        }

        /*double getAverageQueueGrow () {
                return queue_diff_sum / n_of_queues_in_length;
        }*/
        
        /*double getQueueVariance () {
                return queue_variance_sum / n_of_queues_in_length;
        }*/

        double getGreenTime ( double tc ) { return green_time_ratio * tc - delta; }     
        double getGreenTime () { return getGreenTime( Tc ); }   
        
        double getRedTime ( double tc ) { return (1-green_time_ratio) * tc;     }
        double getRedTime () { return getRedTime( Tc ); }       

        

        // hodnotici funkce - suma cekaciho casu aut za 10h
        //double getWT_old ( double  Tc ) {
        //  double T = 36000; // celkovy cas 10h
        //  double Ro = getRo();
        //  double Gr = green_time_ratio;
        //  double ss = saturated_stream;
        //  double WT = 0;
        //  double q = 0;  // zacina s nulovou frontou ?
        //  double ti = 0;
        //  double sumq = q;
        //  while ( ti < T ) {
        //      // ve fronte stoji vic aut nez je schopno odjet za zelenou
        //      if ( q > 0.5*ss*Tc ) {
        //        WT += 0.5*ss*(Tc*Gr - delta)*(Tc*Gr - delta);
        //      }
        //      else {

        //        WT += 0.5*q*(Tc*Gr - delta);
        //      }

        //      if ( (Tc*Gr - delta)*ss < q )
        //        q -= (Tc*Gr - delta)*ss;
        //      else
        //        q = 0;

        //      WT += q * Tc; // zbytek fronty ceka cely cyklus
        //      // cekani vozidel, ktera prijela za pocitany cyklus
        //      if ( q > 0 ) {
        //        //pokud je fronta > 0, auta cekaji prumerne polovinu delky cyklu
        //        WT += Ro*Tc*0.5*Tc;
        //      }
        //      else {
        //        // pokud je fronta = 0 cekaji pouze auta, ktera prijela na cervenou (p=(1-Gr)) 0.5Tc(1-Gr)
        //        WT += Ro*(1-Gr)*Tc*0.5*(1-Gr)*Tc;
        //      }
        //      // fronta se zvetsi o Ro*Tc
        //      q += Ro*Tc;
        //      sumq += Ro*Tc;
        //      ti += Tc;
        //  }

        //  //return WT;
        //  if ( sumq > 0 )
        //      return 100*(WT/(0.5*T*sumq));
        //  else
        //  return 0;
        //}
        // stredni doba prujezdu n-teho auta ve fronte
        double getEcarWT ( const double tc, const int n ) {
                double cpg = (tc * green_time_ratio - delta) * saturated_stream; // cars per green time
                double wc = floor( n / cpg ); // number of waiting cycles               
                double ET_last_cycle = ( 1/ (2*tc) ) * ( tc*(1-green_time_ratio) + (n-wc*cpg)/saturated_stream )*( tc*(1-green_time_ratio) + (n-wc*cpg)/saturated_stream );
                double ET = wc*tc + ET_last_cycle;
                return ET;
        }

        // suma strednich hodnot cekacich casu pres auta ve fronte
        double getWT ( const double tc ) {
                double sumEWT = 0;
                //int n = round(getAverageQueueLength());
                int n = round(cars_in_avg + getAverageQueueLength());
                for ( int i = 0; i <= n; i ++ ) {
                        sumEWT += getEcarWT( tc, i );
                }
                return sumEWT;
        }


        //double getWT ( double  tc ) {
        //      double T = ;
        //      double WT = 0;
        //      double cWT = 0;
        //      double q = 0;
        //      double cq = 0;
        //      double sum_t;
        //      double car_part = 0.1;
        //      double Ro = getRo();
        //      double dt = car_part/Ro;
        //      while ( sum_t < T ) {
        //              if ( q < 0 )
        //                      q = 0;
        //              WT += q * dt;
        //              // prirustek fronty za dt
        //              q += car_part;
        //              // zelena - auta projedou
        //              if ( (sum_t - tc*(int)(sum_t/tc)) > delta && )
        //                      q -= saturated_stream*dt;
        //              sum_t += dt;
        //      }
        //}
        // Odhad hustoty ( auto/sec )
        double getActualRo () {
                // pokud delka fronty mensi nez pocet aut ktere odjedou za zelenou
                if ( saturated_stream*getGreenTime() >= getAverageQueueLength() ) {
                        // pocet aut, ktera prijela pri cervene
                        return getAverageQueueLength()/getRedTime();
                }
                else {
                        //fronta se nevynuluje
                        // pocet aut = to co stihlo projet na zelenou + o co narostla fronta
                        // doba pocet_cyklu*90
                        //double T = n_of_queues_in_length*90;
                        //double cars_per_green = T*(getGreenTime()/Tc)*saturated_stream;
                        //return (cars_per_green + queue_diff_sum)/T;
                        double T = 90;
                        double cars_per_green = T*(getGreenTime()/Tc)*saturated_stream;
                        return (cars_per_green + (getLastAverageQueueLength()-getAverageQueueLength()))/T;
                }
        }

        double getRo() {
                return Ro_avg;
        }
        
        

        /***************************************
        * KONEC KODU PRO TrafficAgentCycleTime *
        ****************************************/
};

/*!
\brief  Basic Traffic Agent

*/
class BaseTrafficAgent : public Participant {

LOG_LEVEL(BaseTrafficAgent,logdata);
public:
        //! Signal Groups
        Array<Lane> lanes;

        Array<LaneHandler*> lanehs;

        //!data from messages
        vec inputs;

        //! decription of msg_data
        RV rv_inputs;

        //! data to broadcast
        vec outputs;

        //! description of broadcast dataind
        RV rv_outputs;

        vec queues;

        //! description of queues
        RV rv_queues;

        //! 
        vec green_starts;

        //!
        vec green_times;

        //!
        Array<string> green_names;

        //!
        Array<string> stage_names;

        //!
        vec stage_times;





        //! datalink from DS to input variables
        datalink ds2inputs;

        //! datalink from DS to output variables
        datalink ds2queues;

        //! action description
        RV rv_action;

        datalink_part action2ds;

        Array<string> neighbours;

        Array<RV> rv_neighbours_out;

        Array<datalink> output2neighbour;

        //! simulator's step length in seconds
        static const int step_length=90;

        //! lenght of cycle in seconds
        static const int cycle_length=80;



public:
        void validate(){

                lanehs.set_length(lanes.length());
                for (int l=0; l<lanes.length(); l++){
                        lanehs(l) = new LaneHandler(lanes(l));

                        rv_inputs.add(lanehs(l)->rv_inputs);
                        rv_outputs.add(lanehs(l)->rv_outputs);
                        rv_queues.add(lanehs(l)->rv_queue);
                }
                inputs.set_size(rv_inputs._dsize());
                outputs.set_size(rv_outputs._dsize());
                queues.set_size(rv_queues._dsize());

                for (int l=0; l<lanes.length(); l++){
                        lanehs(l)->connect_data(*this);
                }

                //for -- rv_outputs -- 
                // TODO vybrat rv pro sousedy 
                rv_neighbours_out.set_length(neighbours.length());
                output2neighbour.set_length(neighbours.length());

                for (int i=0; i<neighbours.length(); i++){
                        for (int r=0; r<rv_outputs.length(); r++){
                                int str_pos = rv_outputs.name(r).compare(neighbours(i));
                                if (str_pos>(int)neighbours(i).length()){
                                        rv_neighbours_out(i).add(rv_outputs.subselect(vec_1(r)));
                                }
                        }
                        // connect datasource
                        output2neighbour(i).set_connection(rv_neighbours_out(i), rv_outputs);
                }

                // lanehs knows RVS
                // write internal checks if all was loaded OK

        }
        void receive(const Setting &msg){
                string what;
                UI::get(what, msg, "what", UI::compulsory);

                if (what=="new_stable_state"){ // 
                        // field data 
                        // extract decription of teh received datavector
                        shared_ptr<RV> rv=UI::build<RV>(msg,"rv",UI::compulsory);
                        // find if it is needed
                        ivec ind=rv->dataind(rv_inputs); // position of rv in in_rv;
                        if (ind.length()>0){ //data are interesting
                                vec dt;
                                UI::get(dt, msg, "value",UI::compulsory); // get data
                                set_subvector(inputs, ind,  dt); //check size?
                        }                               
                } else {
                        Participant::receive(msg);
                }
        }
        void log_register(logger &L, const string &prefix){
                root::log_register ( L, prefix );
                if ( log_level[logdata]){
                        L.add_vector ( log_level, logdata, RV ( 1 ), prefix );  
                }
        }
        void log_write() const {
                if (log_level[logdata]){
                        log_level.store(logdata, inputs);
                }
        }

        void broadcast(Setting& set){
                // broadcast data to all neighbours
                for (int i=0; i<neighbours.length(); i++){
                        Setting &msg =set.add(Setting::TypeGroup);

                        // if...
                        // copy from create message
                        // create msg with fields {to=..., what=data, rv=..., value = ...}
                        UI::save ( neighbours(i), msg, "to");
                        UI::save ( (string)"new_stable_state", msg, "what");
                        UI::save ( &(rv_neighbours_out(i)), msg, "rv");
                        UI::save( output2neighbour(i).pushdown(outputs), msg, "value");
                }

        }
        void adapt(const vec &glob_dt){
                // copy data from global vector to sSGHandlers
                ds2inputs.filldown(glob_dt, inputs);
                //copy data from neighbours
                ds2queues.filldown(glob_dt, queues);
                // copy sg_length ... and others...
        }
        void act(vec &glob_ut){
                vec action; // trivial stuff
                action2ds.filldown(action,glob_ut);
        }

        void ds_register(const DS &ds){
                //register ds2output
                ds2inputs.set_connection(rv_inputs, ds._drv());
                ds2queues.set_connection(rv_queues, ds._drv());

                inputs.set_size(rv_inputs._dsize());
                action2ds.set_connection( ds._urv(), rv_action);

        }

        void from_setting(const Setting &set);
};
UIREGISTER(BaseTrafficAgent);

#endif //TRAGE_H