wiselib.testing/algorithms/cluster/modules/chd/leach_chd.h

Go to the documentation of this file.

/*
 * File:   leach_chd.h
 * Author: Amaxilatis
 */

#ifndef _PROBABILISTIC_CHD_H
#define  _PROBABILISTIC_CHD_H

namespace wiselib {

    template< typename OsModel_P>
    class LeachClusterHeadDecision {
    public:

        //TYPEDEFS
        typedef OsModel_P OsModel;
        typedef typename OsModel::Radio Radio;
        typedef typename OsModel::Debug Debug;
        typedef typename OsModel::Rand Rand;

        // data types
        typedef int cluster_id_t;
        typedef int cluster_level_t; //quite useless within current scheme, supported for compatibility issues
        typedef typename Radio::node_id_t node_id_t;
        typedef typename Radio::size_t size_t;
        typedef typename Radio::block_data_t block_data_t;

        // delegate
        typedef delegate1<int, int*> chd_delegate_t;

        /*
         * Constructor
         * */
        LeachClusterHeadDecision() :
        cluster_head_(false),
        probability_(10),
        id_(-1),
        clustering_round_(0),
        rounds_since_head_(-1) {
        };

        /*
         * Destructor
         * */
        ~LeachClusterHeadDecision() {
        };

        /*
         * INIT
         * initializes the values of radio and debug
         */
        void init(Radio& radio, Debug& debug) {
            radio_ = &radio;
            debug_ = &debug;
        };

        /* SET functions */

        // Set my id

        void set_id(node_id_t id) {
            id_ = id;
        };

        // get an integer [0-100]
        // this the probability in % to
        // become a cluster_head

        void set_probability(int prob) {
            if (prob > 100) {
                probability_ = 100;
            } else if (prob < 0) {
                probability_ = 0;
            } else {
                probability_ = prob;
            }

        }

        /* GET functions */

        // Returns if Cluster Head

        bool is_cluster_head(void) {
            return cluster_head_;
        };

        /*
         * ENABLE
         * enables the module
         * initializes values
         * */
        void enable() {
            cluster_head_ = false;
        };

        /*
         * Disable
         * disables the bfsclustering module
         * unregisters callbacks
         * */
        void disable() {
        };

        /*
         * CALCULATE_HEAD
         * defines if the node is a cluster head or not
         * if a cluster head return true
         * */
        bool calculate_head() {
            int random_num = (Random() % 100);

            int rmod = 100 / probability_;

            int election_probability = (probability_ * 100) / (100 - probability_ * (clustering_round_ % rmod));

            if (rounds_since_head_ != -1) {

                if (rounds_since_head_ < (100 / probability_)) {
                    election_probability = 0;

                }
                debug().debug("Rounds since head %d, %d %d%%\n", radio().id(), rounds_since_head_, election_probability);
            }


            // check condition to be a cluster head
            if (random_num < election_probability) {
                cluster_head_ = true;
                rounds_since_head_ = 0;
            } else {
                cluster_head_ = false;
            }
            if (rounds_since_head_ != -1) {
                rounds_since_head_++;
            }
            clustering_round_++;
            return cluster_head_;
        };
    private:

        bool cluster_head_; // if a cluster head
        int probability_; // clustering parameter
        node_id_t id_; // contains the nodes id
        int clustering_round_; //counts the times clusterheads were elected
        int rounds_since_head_;
        // delegate for callbacks
        chd_delegate_t winner_callback_;
        chd_delegate_t sender_callback_;

        Radio * radio_;
        Debug * debug_;
        Rand * rand_;

        Radio& radio() {
            return *radio_;
        }

        Debug& debug() {
            return *debug_;
        }

        Rand& rand() {
            return *rand_;
        }

    };

}

#endif