source: proiecte/ptvs/src/vnsim/network/propagation/Ricean.java @ 31

/************************************************************************************
 * Copyright (C) 2008 by Politehnica University of Bucharest and Rutgers University
 * All rights reserved.
 * Refer to LICENSE for terms and conditions of use.
 ***********************************************************************************/
package vnsim.network.propagation;


import java.io.BufferedReader;
import java.io.FileReader;
import java.io.File;
import java.util.StringTokenizer;
import java.util.Scanner;
import java.io.IOException;

import vnsim.map.object.Globals;


public class Ricean
{
        //vectors containig the Gaussian components from the txt file
        double[] data1,data2;
        //number of Gaussian components
        int n;
        
        double K;
        //max velocity of nodes , used in calculating the fm Doppler frequency
        double maxVelocity;
        
        double fm0,fs,dt,fm;
        
        public Ricean(String fileName,boolean isUrban) throws IOException
        {
                this.K=Globals.RICEAN_K;
                
                if(isUrban)
                        this.maxVelocity=Globals.RICEAN_MAX_VELOCITY_URBAN;
                else
                        this.maxVelocity=Globals.RICEAN_MAX_VELOCITY_FREE;
                
                this.fm=this.maxVelocity/Globals.DSRC_LAMBDA;
                
                this.fm0=this.fs=this.dt=0;
                
                this.loadDataFile(fileName);
        }

        //reading gaussian components from file
        public void loadDataFile(String fileName) throws IOException
        {       
                //Scanner s=new Scanner(new File(fileName));
                
                BufferedReader br=new BufferedReader(new FileReader(fileName));
                
                this.n=Integer.parseInt(br.readLine());
                this.fm0=(double)Integer.parseInt(br.readLine());
                this.fs=(double)Integer.parseInt(br.readLine());;
                
                this.data1=new double[this.n];
                this.data2=new double[this.n];
                
                StringTokenizer st;
                
                for(int i=0;i<this.n;i++)
                {
                        st=new StringTokenizer(br.readLine());
                        
                        this.data1[i]=Double.parseDouble(st.nextToken());
                        this.data2[i]=Double.parseDouble(st.nextToken());
                }
        }
        
        //calculates the fading and adds it to the received power calculated by Two Ray Ground
        public double getPr(double Pt,double R,int currentTime)
        {
                double Pr, Pr_Rice=0.0, Pr_tot;

                Pr = TwoRay.getPr(Pt,R);

                double time_index;
                double envelope_fac, tmp_x1, tmp_x2, x1_interp, x2_interp;
                
                time_index=currentTime + 2*this.fs * this.fm/this.fm0;
                
                time_index-=(double)this.n * Math.floor(time_index/(double)this.n);
                
                double X0, X1, X2, X3;
                int ind0, ind1, ind2, ind3;
                
                ind1 = (int)Math.floor(time_index);
                ind0 = (ind1-1+this.n) % this.n;
                ind2 = (ind1+1) % this.n;
                ind3 = (ind1+2) % this.n;
                
                X1 = time_index - ind1;
                X0 = X1+1.0;
                X2 = X1-1.0;
                X3 = X1-2.0;

                x1_interp = this.data1[ind0]*X1*X2*X3/(-6.0) +this.data1[ind1]*X0*X2*X3*(0.5) +this.data1[ind2]*X0*X1*X3*(-0.5) +this.data1[ind3]*X0*X1*X2/6.0;
                        
                x2_interp = this.data2[ind0]*X1*X2*X3/(-6.0) +this.data2[ind1]*X0*X2*X3*(0.5) +this.data2[ind2]*X0*X1*X3*(-0.5) +this.data2[ind3]*X0*X1*X2/6.0;

                /* Find the envelope multiplicative factor */
                tmp_x1 = x1_interp + Math.sqrt(2.0 * this.K);
                tmp_x2 = x2_interp;

                envelope_fac = (tmp_x1*tmp_x1 + tmp_x2*tmp_x2) / 
                        (2.0 * (this.K+1)); 

                Pr_Rice = envelope_fac;

                Pr_tot = Pr * Pr_Rice;

                return Pr_tot;
        }
}