generic_dist_radio.h

博弈论自适应功率控制中的实现

#ifndef _generic_dist_radio_h_
#define _generic__dist_radio_h_

#include <math.h>
#include <stdlib.h> // for calloc
//********************************************
//********************************************
//         Generalized Functions
//********************************************
//********************************************
double channel_exponent;
double channel_d0;

double channel(double p, double dist)
{
	double dist_div;
	
	dist_div = pow(channel_d0/dist,channel_exponent);
	
	if(dist_div > 1)
		dist_div = 1;

	return p*dist_div;
};

double lin2dB(double d1)
{
	return 10*log10(d1);
};

double dB2lin(double d1)
{
	return pow(10.0,d1/10.0);
};

//********************************************
//********************************************
//         Generic Radio Class Definition
//********************************************
//********************************************
class generic_radio
{
protected:
	double transmit_power; //transmit power
	double obj;
	double incident_power;

	double x,y; //distance from base station	
	double dist;
	double noise;

	int obj_index;
	int power_index;
	
	double *obj_store;
	double *power_store;

	int node_id;
	int node_of_interest_id;
	generic_radio *node_of_interest;
	
	
public:

	generic_radio()
	{
		obj_index = 0;
		power_index = 0;
		noise = 0.0000000003; //-95 dBm
	};

	double get_x(void)
	{
		return x;		
	};

	double get_y(void)
	{
		return y;		
	};

	int get_node_of_interest_id(void)
	{
		return node_of_interest_id;
	};

	double * get_power_store(void)
	{
		return power_store;
	};

	double * get_obj_store(void)
	{
		return obj_store;
	};

	double distance(generic_radio *r)
	{
		double d;
		double dx,dy;
		dx = x - (*r).x;
		dy = y - (*r).y;
		d = sqrt(dx*dx + dy*dy);
		dist = d;
		return d;
	};

	double get_obj(void)
	{
		return obj;
	};

	int get_node_id(void)
	{
		return node_id;
	};

	double get_incident_power(void)
	{
		return incident_power;
	};

	virtual double get_noise(void)
	{
		return noise;
	};
	
	//virtual functions, must be refined in children
	virtual void update_stats(void)
	{
		obj_store[obj_index] = obj;
		power_store[obj_index] = 10*log10(transmit_power);
		obj_index++;
	};

	virtual void update_decision()
	{
	
	};
	
	virtual int allocate_space(int N)
	{
		obj_store = (double *) calloc(sizeof(double),N);
		power_store = (double *) calloc(sizeof(double),N);
		obj_index = 0;
		power_index = 0;
		return 0;
	};

	virtual void set_pos(double d1, double d2)
	{
		x = d1;
		y = d2;
	};

	virtual void set_power(double power)
	{
		transmit_power = power;
	};
	
	virtual double get_power(void)
	{
		return transmit_power;
	};

	virtual void set_node_of_interest(generic_radio *gr)
	{
		node_of_interest = gr;
	};

	virtual generic_radio * get_node_of_interest(void)
	{
		return node_of_interest;
	};

	virtual void set_noise(double d)
	{
		noise = d;
	};
};

class generic_radio_list : public generic_radio
{
	struct node
	{	
		generic_radio *current;
		struct node *next;
	};

private:
	node *front;
	node *rear;

public:
	generic_radio_list()
	{
		front = NULL;
		rear = NULL;
	};

	~generic_radio_list()
	{
		node *temp;
		while(front != NULL)
		{
			temp = front;
			front = (*front).next;
			delete temp;
		};		
	};

	generic_radio * get_radio(int N)
	{
		node *temp;
		int k;
		temp = front;
		k = 0;
		
		while((temp!=NULL)&(k<(N)))
		{
			temp = (*temp).next;
			k++;
		}

		return (*temp).current;
	};

	int allocate_space(int N)
	{
		node *temp;
		temp = front;
		// run process on clocked
		while(temp!=NULL)
		{
			(*(*temp).current).allocate_space(N);			
			temp = (*temp).next;
		}		
		return 1;
	};

	void add_radio(generic_radio *new_core)
	{
		node *add = new node;
		(*add).current = new_core;
		(*add).next = NULL;
		if(front == NULL)
		{
			front = add;
		}
		else
		{
			(*rear).next = add;
		}
		rear = add;	
	};

	double calc_rcv_power(generic_radio r)
	{		
		return transmit_power; // default no channel
	};

	void update_decision(double rcv, double interference, double noise)
	{
	
	};
};


#endif