/home/ltracy/workspace/NSUAN/uan/uan-prop-bhp.h

#ifndef UANPROPBHP_H_
#define UANPROPBHP_H_

#define UAN_PROPBHP_IPL  1000000.00             //Infinite path loss

#undef NDEBUG

#include <cassert>
#include <complex>
#include <set>
#include <map>
#include <cstdlib>


#include "uan-prop.h"
#include "uan-phy.h"


#define UAN_BHP_BHEXPATH "/home/ltracy/workspace/bellhop/Bellhop/bellhop.exe"

using namespace std;

/* \class ArrResults
 * 
 * \brief Keeps information obtained from a Bellhop run
 * 
 * This class keeps information about the transmitter and receiver
 * configured in the Bellhop run as well as all of the arrivals.
 * 
 * The entire class is public and is only designed to be used inside
 * UanPropagationBhp and possible some Phy layers that require it.
 * 
 * \author Leonard Tracy
 * \date 9-28-2007
 * 
 * Contact: lentracy@u.washington.edu
 * Created on:  June 2007
 */
struct ArrResults {
public:
        ArrResults();
        ArrResults(int nume);
        ~ArrResults();
        void printe(int e);
        
        void doInit(int nume);
        void freeVars(void);
        double compPLoss(double tsym);
        double compISI(double tsym, double tclear);
        
        double sumArrivals(double min, double max);
        
        int numarr;
        double freq;
        double srcDepth;
        double recDepth;
        double range;
        double propdelay;
        
        complex<double> *amp;
        double *delay;
        double *srcAngle;
        double *recAngle;
        double *topBounce;
        double *botBounce;
        private:
        bool init;
        
};

class BhRun {
public:
        BhRun() : valid(false), srcDepth(-1), freq(-1) { }
        
        BhRun(double src, double f, set<double> d, set<double> r, char *path) :
                valid(true), srcDepth(src), freq(f), depths(d), ranges(r) { 
                res = new ArrResults[depths.size()*ranges.size()];
                
                runBH(path);
        }
        BhRun(const BhRun &other) {
                srcDepth = other.srcDepth;
                freq = other.freq;
                depths = other.depths;
                ranges = other.ranges;
                valid = other.valid;

                res = new ArrResults[depths.size()*ranges.size()];
                memcpy(res, other.res, sizeof(struct ArrResults)*depths.size()*ranges.size());
        }
        ~BhRun() { delete [] res; }
        
        //TODO:  Verify that shallowest depth is d=0!
        ArrResults &getRes(int d, int r) { assert(valid); return *(res + d*depths.size() + r); }
        const set<double> &getDepths() {return depths;}
        const set<double> &getRanges() {return ranges;}
        double getSD() {return srcDepth;}
        double getF() {return freq;}
        
        
private:
        bool valid;
        double srcDepth;
        double freq;
        ArrResults *res;
        set<double> depths;
        set<double> ranges;
        
        void runBH(char *path);

};


class UanPropagationBhp : public UanPropagation {
public:
        UanPropagationBhp();
        
        virtual double getPr(UanPhy *txif, UanPhy *rxif);
        //virtual void getPlMat(ArrResults res[], set<double> depths, set<double> ranges, double srcDepth);
        
        void updateResults(int addr, double srcDepth, double freq, set<double> depths, set<double> ranges);
        
        double getPLossRes(int addr, double depth, double range, double tsym);

        double getISIRes(int addr, double depth, double range, double tsym, double tclear);

        ArrResults &getDat(int addr, double depth, double range);
        
protected:
        double recDepthTol;
        double srcDepthTol;
        double rangeTol;
        double freqTol;
        double maxDepth;                //TODO:  Implement these in env file
        
        double maxRange;                //TODO:  Do we want this??? Probably not = REMOVE THIS
        
        char *bhExPath;
        
        void getResults(ArrResults &res, char *fileName);
        
        map<int, BhRun> bhData;
        
};



#endif /*UANPROPBHP_H_*/

---