dsss_radio.h

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

#ifndef _DSSS_radio_h_
#define _DSSS_radio_h_

#include "generic_dist_radio.h"
#include "obj_funcs.h"

double Infdneg;

double target_ber;
class DSSS_transmit : public generic_radio
{
protected:
	double spreading_gain;
	double step_size;

	double min_power; //dB
	double max_power; //dB
	
	int obj_func_num;
	double objective_param;

public:
	
	DSSS_transmit()
	{
		max_power = 20;
		min_power = -85;
		step_size = 0.1; 
		spreading_gain = 63;
		obj_func_num = 0;
		objective_param = 0.001;
	};

	void set_min_power(double d)
	{
		min_power = d;
	};
	
	void set_max_power(double d)
	{
		max_power = d;
	};

	void set_spreading_gain(double N)
	{
		spreading_gain = N;
	};
	
	double get_spreading_gain(void)
	{
		return spreading_gain;
	};

	double my_obj_function(double rcv, double interf, double d_noise)
	{
		double val;
		val = 0;

		switch(obj_func_num)
		{
		case 0:
			val = target_standard_ber(rcv, interf, d_noise, objective_param);
			break;
		case 1:
			val = target_standard_snr(rcv, interf, d_noise, objective_param);
			break;
		case 2:
			val = ber(rcv, interf, d_noise);
			break;
		case 3:
			val = log_snr(rcv, interf, d_noise);
			break;
		case 4:
			val = bit_watt(rcv, interf, d_noise, transmit_power);
			val = val*objective_param;
			break;
		};
		return val;
	};

	void set_power(double power)
	{
		transmit_power = power;
	};

	virtual void update_decision()
	{
		double dist;
		double rcv_pow;
		double interf;
		double temp_power_plus;
		double temp_power_minus;
		double v_noise;

		double temp_receive_power;

		double temp_obj_plus;
		double temp_obj_minus;
		
		// Perform base objective function calculation
		//get distance for received power estimate
		dist = (*node_of_interest).distance(this);
		rcv_pow = channel(transmit_power,dist);
		interf = (*node_of_interest).get_incident_power() - rcv_pow;
		interf = interf/3/spreading_gain; // asynchronous

		v_noise = (*node_of_interest).get_noise();
		obj = (*this).my_obj_function(rcv_pow, interf, v_noise);

		//dither up to see if change improves performance
		temp_power_plus = lin2dB(transmit_power) + step_size;
		temp_receive_power = channel(dB2lin(temp_power_plus),dist);
		temp_obj_plus = (*this).my_obj_function(temp_receive_power, interf, v_noise);

		//get total power
		//dither up to see if change improves performance
		temp_power_minus = lin2dB(transmit_power) - step_size;
		temp_receive_power = channel(dB2lin(temp_power_minus),dist);
		temp_obj_minus = (*this).my_obj_function(temp_receive_power, interf, v_noise);

		if(temp_obj_plus > obj)
			transmit_power = dB2lin(temp_power_plus);
		else if (temp_obj_minus > obj)
			transmit_power = dB2lin(temp_power_minus);
		
		if((obj == Infdneg)||(temp_obj_plus ==Infdneg)||(temp_obj_minus ==Infdneg)) //result of 0 BER
		{
			transmit_power = dB2lin(temp_power_minus-0.1);
			obj = -20;
		}

		// limit output power
		if(lin2dB(transmit_power) > max_power)
		{
			transmit_power = dB2lin(max_power);
		}
		if(lin2dB(transmit_power) <min_power)
		{
			transmit_power = dB2lin(min_power);
		}
	};

	friend ofstream& operator<< (ofstream &fout, DSSS_transmit &d)
	{
		int k;
		for(k=0; k <d.obj_index;k++)
		{
			fout << d.obj_store[k] << "\n";
		}

		fout << endl;
		for(k=0; k <d.obj_index;k++)
		{
			fout << d.power_store[k] << "\n";
		}
		fout << endl;
		return fout;
	};

	friend ifstream& operator>> (ifstream &fin, DSSS_transmit &d)
	{
		double garbage;
		fin >> d.spreading_gain;
		fin >> garbage;
		d.transmit_power = dB2lin(garbage);
		fin >> d.min_power;		
		fin >> d.max_power;
		fin >> garbage;
		d.obj_func_num = (int) garbage - 1;
		fin >> d.objective_param;

		return fin;
	};
};

class DSSS_receive : public generic_radio
{
protected:
	generic_radio_list mobile_list;
	int num_radios;	

public:
	
	DSSS_receive()
	{
		num_radios = 0;
	};
	
	void add_radio(generic_radio *radio)
	{
		mobile_list.add_radio(radio);
		num_radios++;
	};

	void set_power(double power)
	{
		transmit_power = power;
	};

	void update_incident_power()
	{	
		int k;
		double dist;
		generic_radio *gr;
		double xmt;
		double rcv;

		incident_power = 0;
		for(k=0;k<num_radios;k++)
		{
			gr = mobile_list.get_radio(k);
			dist = (*gr).distance(this);
			xmt = (*gr).get_power();
			rcv = channel(xmt, dist);
			incident_power += rcv;
		}
	};
};

#endif