01_RFsimulation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# default_exp RFsimulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#hide\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "from nbdev.showdoc import *\n",
    "# default_cls_lvl 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RFsimulation\n",
    "> Submodule of `rfml_localization` that provides the ability to simulate an indoor RF propagation environment for the purpose of generating classical measurements (e.ge., ToA/TDoA, RSS/DRSS, and AoA/DAoA) to test optimization methods for localization purposes.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.special import comb\n",
    "from itertools import combinations\n",
    "from sklearn.utils import check_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#export\n",
    "class RFchannel:\n",
    "    \"\"\"\n",
    "    The class enables the creation of a parameterized RF channel \n",
    "    environment.  The default channel parameters are based on academic\n",
    "    literature that represent, in average, a typical office building\n",
    "    with an exponential distribution of multipath clusters, a path loss\n",
    "    characterized by a log-Gaussian distribution around a distant \n",
    "    dependent mean, and a Laplacian distribution with respect to angle\n",
    "    of arrival.  Using these parameters plus user input, there are a\n",
    "    number of functions within the class enabling simulation of \n",
    "    measurements. \n",
    "    \n",
    "    The methods within this class can be used as stand-alone functions\n",
    "    if pulled out of the class.  Parameters that are set by the class\n",
    "    instantiation are noted as such.\n",
    "    \n",
    "    __Parameters__\n",
    "    \n",
    "    Multipath parameters for temporal measurements (e.g. ToA/TDoA) as \n",
    "    described by ([^1]) are:\n",
    "    \n",
    "    >__maxSpreadT__ : float, default = 100\n",
    "    >- Max delay spread to check (ns)\n",
    "    >\n",
    "    >__PoissonInvLambda__ : float, default = 50 \n",
    "    >- Poisson Cluster Arrival Parameter (ns)\n",
    "    >\n",
    "    >__Poissoninvlambda__ : float, default = 10 \n",
    "    >- Poisson Multipath Arrival Parameter (ns)\n",
    "    \n",
    "    >__PoissonGamma__ : float, default = 50\n",
    "    >- Amplitude Decay of Cluster\n",
    "    \n",
    "    >__Poissongamma__ : float, default = 29\n",
    "    >-Amplitude Decay of Multipath\n",
    "        \n",
    "    Channel gain parameters for power/amplitude measurements (e.g. \n",
    "    RSS/DRSS) as described by ([^2]) are:\n",
    "    \n",
    "    >__PathLossN__ : float, default = 3.0\n",
    "    >- Path Loss Exponent (dB)\n",
    "    >\n",
    "    >__Xsigma__ : float, default =  7\n",
    "    >- Std deviation of Gaussian RV (log-normal)\n",
    "    >\n",
    "    >__Wavelength__ : float, default = 3.0e8 / 205.267e6 \n",
    "    >- Frequency dependent (Hz), units of meter\n",
    "        \n",
    "    Multipath parameters for spatial measurements (e.g. AoA/DAoA) as\n",
    "    described by ([^3]) are:\n",
    "    \n",
    "    >__AoAsigma__ : float, default = 26*np.pi/180\n",
    "    >- Std deviation of Laplacian RV (rad)\n",
    "    \n",
    "    __Notes__\n",
    "    \n",
    "    [^1]: A. A. M. Saleh and R. Valenzuela, \"A Statistical Model for\n",
    "        Indoor Multipath Propagation,\" in IEEE Journal on Selected \n",
    "        Areas in Communications, vol. 5, no. 2, pp. 128-137, February\n",
    "        1987, doi: 10.1109/JSAC.1987.1146527.\n",
    "    [^2]: Theodore S. Rappaport's Wireless Communications: Principles\n",
    "        and Practice by IEEE Press, Inc. Prentic Hall ISBN: \n",
    "        0-7803-1167-1. Chapters 3 and 4\n",
    "    [^3]: Q. H. Spencer, B. D. Jeffs, M. A. Jensen and A. L. \n",
    "        Swindlehurst, \"Modeling the statistical time and angle of \n",
    "        arrival characteristics of an indoor multipath channel,\" in\n",
    "        IEEE Journal on Selected Areas in Communications, vol. 18, no. \n",
    "        3, pp. 347-360, March 2000, doi: 10.1109/49.840194.    \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, maxSpreadT = 100, PoissonInvLambda = 50, Poissoninvlambda = 10,\n",
    "                 PoissonGamma = 50, Poissongamma = 29, PathLossN = 3.0, Xsigma = 7, \n",
    "                 Wavelength = 3.0e8 / 205.267e6, AoAsigma = 26*np.pi/180):\n",
    "        self.maxSpreadT=maxSpreadT \n",
    "        self.PoissonInvLambda=PoissonInvLambda\n",
    "        self.Poissoninvlambda=Poissoninvlambda\n",
    "        self.PoissonGamma=PoissonGamma\n",
    "        self.Poissongamma=Poissongamma\n",
    "        self.PathLossN=PathLossN\n",
    "        self.Xsigma=Xsigma\n",
    "        self.Wavelength=Wavelength\n",
    "        self.AoAsigma=AoAsigma \n",
    "\n",
    "    def generate_RxTxlocations(self, n_rx=6, areaWL=np.array([20,60]), n_runs=1000,\n",
    "                               sensor_locs= np.array([[[6.3], [14.1], [7.2], [14.5], [7.5], [13.5]],[[15.3], [15.1], [30.1], [30.5], [44.9], [44.5]]]),\n",
    "                               rxtx_flag=3, grid_flag=0, seed=None):\n",
    "        \"\"\"\n",
    "        Generate a three dimensional array (cartesian coordinates -- each \n",
    "        row a dim) x (sensors -- each col a specific sensor) x (num_runs --\n",
    "        3rd dimension is number of observations) that provides locations of\n",
    "        a Tx source and a set of RF sensors across multiple \n",
    "        observations/runs. Each column is a sensor (except first col \n",
    "        is Tx) location, next col is sensor 1 location, then sensor 2, etc.\n",
    "        3rd dimension marks either a new or same Rx sensor arrangement \n",
    "        (depending on flag) at next observation.  Values are in meters.\n",
    "\n",
    "        __Parameters__\n",
    "\n",
    "        >__n_rx__ : integer, default=6  \n",
    "        >- Number of receivers/sensors\n",
    "        >\n",
    "        >__areaWL__ : ndarray of shape (2,), default= np.array([20,60])\n",
    "        >- Bounding size of area of interest, square/rectangle\n",
    "        >\n",
    "        >__n_runs__ : integer, default=1000  \n",
    "        >- Number of observations/samples/runs to generate\n",
    "        >\n",
    "        >__sensor_locs__ : ndarray of shape (2,n_rx,1), default= np.array([[[6.3], [14.1], [7.2], [14.5], [7.5], [13.5]],[[15.3], [15.1], [30.1], [30.5], [44.9], [44.5]]])\n",
    "        >- Location of sensors, only used if `rxtx_flag`=3\n",
    "        >    \n",
    "        >__rxtx_flag__ : integer, default=3\n",
    "        >- Flag on how Tx and/or Rx location are randomly chosen. Values are as follows,\n",
    "        >    - 0 -same Tx location, random Rx locations\n",
    "        >    - 1 -random Tx location, same Rx locations\n",
    "        >    - 2 -random Tx locations, random Rx locations\n",
    "        >    - 3 -random Tx, fixed Rx locations based on rx_layout\n",
    "        >\n",
    "        >__grid_flag__ : boolean, default=0\n",
    "        >    - Flag on generating random Tx location on evenly spaced\n",
    "        >    grid (1m x 1m spacing).  Default is random, non-grid. \n",
    "        >\n",
    "        >__seed__ : integer, default=None\n",
    "        >- set for reprodducible results\n",
    "\n",
    "        __Returns__\n",
    "        \n",
    "        >Self, sets self.rxtx_locs\n",
    "\n",
    "        \"\"\"\n",
    "        #get basic parameters from class, set required variables        \n",
    "        grid_dim = len(areaWL)#.size\n",
    "        if grid_dim != 2:\n",
    "            raise ValueError('{areaWL} not supported, not handling anything other than 2'.format(grid_dim=repr(grid_dim)))\n",
    "\n",
    "        #generate locations on grid\n",
    "        if (grid_flag):\n",
    "            #needs to be fixed if higher than 3 dimensions\n",
    "            dict_size=areaWL[0]*areaWL[1]\n",
    "            #generate matrix with Tx locations at all grid points\n",
    "            rxtxlocations = np.mgrid[1:areaWL[0]+1,1:areaWL[1]+1].reshape((2,1,dict_size),order='C')\n",
    "            if n_runs != dict_size:\n",
    "                raise ValueError('num_runs is not {dict_size} for dictionary making'.format(dict_size=repr(dict_size)))\n",
    "            if rxtx_flag != 3:\n",
    "                raise ValueError('RxTx_flag not matching Dict_flag for dictionary making')\n",
    "            #concatenate random rx points which will be overwritten based on flag\n",
    "            rxtxlocations = np.concatenate((rxtxlocations,np.random.default_rng(seed).uniform(0,1,(grid_dim, n_rx, n_runs))),axis=1)\n",
    "            \n",
    "        #generate locations randomly\n",
    "        else:\n",
    "            rxtxlocations = np.random.default_rng(seed).uniform(0,1,size=(grid_dim, n_rx+1, n_runs))\n",
    "            #scale locations to given rectangular volume\n",
    "            for i in np.arange(grid_dim):\n",
    "                rxtxlocations[i,:,:] = rxtxlocations[i,:,:]*areaWL[i]\n",
    "\n",
    "        #fix locations based on flag sent\n",
    "        #set all Tx locations the same, keep random rx\n",
    "        if rxtx_flag == 0:\n",
    "            rxtxlocations[:,0,:]=np.expand_dims(rxtxlocations[:,0,0],axis=1)\n",
    "        #random Tx, same Rx\n",
    "        elif rxtx_flag == 1:\n",
    "            rxtxlocations[:,1:,:]=np.expand_dims(rxtxlocations[:,1:,0],axis=2)\n",
    "        #random Tx, random Rx (already there)\n",
    "        elif rxtx_flag == 2:\n",
    "            pass\n",
    "        #use provided layout for rx\n",
    "        elif rxtx_flag == 3:\n",
    "            try:\n",
    "                rxtxlocations[:,1:,:]=sensor_locs\n",
    "            except ValueError:\n",
    "                print(\"ValueError: check rx_layout parameter.  Passed numpy array of right shape?\")\n",
    "        else:\n",
    "            raise ValueError('{rxtx_flag} wrong rxtx_flag, check value'.format(rxtx_flag=repr(rxtx_flag)))\n",
    "        \n",
    "        #save passed parameters and location information to instance\n",
    "        self.n_runs=n_runs\n",
    "        self.n_rx=n_rx\n",
    "        self.areaWL=areaWL\n",
    "        self.sensor_locs=sensor_locs\n",
    "        self.rxtx_flag=rxtx_flag\n",
    "        self.grid_flag=grid_flag\n",
    "        self.seed_loc = seed\n",
    "        self.rxtx_locs=rxtxlocations\n",
    "        \n",
    "        return self        \n",
    "        \n",
    "    def calculate_Rxxdelay(self, ch_delay_flag = 1, tdoa_flag = 1, seed=None):\n",
    "        \"\"\"\n",
    "        Calculates relative delay of wireless signals from a\n",
    "        transmitter (Tx) to different receivers (Rx) based on given Rx\n",
    "        and Tx locations for each run/observation. Assumes structure of\n",
    "        first column is Tx, rest of columns are Rx. Third dimension is\n",
    "        multiple runs of data (see `generate_RxTxlocations`). These \n",
    "        relative delays are time delay estimates (TDE's).\n",
    "\n",
    "        Time related variables are assumed to be nanoseconds in\n",
    "        PoissonArray, time intervals are normalized to same.  Note that\n",
    "        rxtx_locations is given in meters.  Perturbs the ideal TDE \n",
    "        based on given statistical distribution(s) parameterized by\n",
    "        values in PoissonArray.  In other words, describes impairments\n",
    "        caused by multipath in a statistical sense ([^4]).\n",
    "\n",
    "        __Parameters__\n",
    "\n",
    "        >__ch_delay_flag__ : Integer/boolean, default=1\n",
    "        >- Channel flag whether to add multipath (random) based on \n",
    "        >PoissonArray parameters. \n",
    "        >    - 0 - return ideal delays (absolute\n",
    "        >or differential) \n",
    "        >    - 1 (default) - return random offsets \n",
    "        >characterized by poissonarray parameters\n",
    "        >\n",
    "        >__tdoa_flag__ : Integer/boolean, default=1 \n",
    "        >- Type of measurement to return,\n",
    "        >    - 0 - rtn abs time of flight (i.e. ToF) between Tx and Rx.\n",
    "        >    - 1-(default)- returns differential time (i.e., TDOA) between\n",
    "        >        pairs of sensors of format (rx1-rx2, rx1-rx3,... rx1-rxn, \n",
    "        >        rx2-rx3,..., rx(n-1) - rxn\n",
    "        >\n",
    "        >__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
    "        >- *set by class instantiation*\n",
    "        >- Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
    "        >\n",
    "        >__poissonarray__ : list,[maxSpreadT, PoissonInvLambda, Poissoninvlambda, PoissonGamma, Poissongamma] \n",
    "        >- *set by class instantiation*\n",
    "        >- List of time-related propagation parameters in integers\n",
    "        >    (nanosecond units)\n",
    "        >\n",
    "        >__seed__ : integer, default=None\n",
    "        >- set for reprodducible results\n",
    "        \n",
    "        __Returns__\n",
    "        \n",
    "        >Self, sets self.rxx_delay\n",
    "        >- Format is [num_runs] x [abs (num_rx)/diff delay measurements \n",
    "        >(num_rx choose 2)] - units of nanoseconds\n",
    "\n",
    "        __Notes__\n",
    "    \n",
    "        [^4]: A. A. M. Saleh and R. Valenzuela, \"A Statistical Model for\n",
    "            Indoor Multipath Propagation,\" in IEEE Journal on Selected \n",
    "            Areas in Communications, vol. 5, no. 2, pp. 128-137, February\n",
    "            1987, doi: 10.1109/JSAC.1987.1146527.\n",
    "\n",
    "        \"\"\"\n",
    "        #get basic parameters inherent in rxtx_locations\n",
    "        rxtx_locations = self.rxtx_locs\n",
    "        poissonarray = [self.maxSpreadT, self.PoissonInvLambda, \n",
    "                        self.Poissoninvlambda, self.PoissonGamma, \n",
    "                        self.Poissongamma]\n",
    "        _, num_rx, num_runs = rxtx_locations.shape\n",
    "        num_rx -= 1 #2nd dimension has one Tx and rest Rx\n",
    "\n",
    "        #get Tx positions\n",
    "        tx_vec=np.expand_dims(rxtx_locations[:,0,:],axis=1)\n",
    "        #get Rx positions\n",
    "        rx_array=rxtx_locations[:,1:,:]\n",
    "        #note that we (currently) assume that first entry is transmitter\n",
    "        #calculate absolute delays from Tx to each Rx (convert from meters to ns)\n",
    "        abs_delay = np.linalg.norm(tx_vec-rx_array, axis=0)*10/3\n",
    "        offsets=np.zeros(abs_delay.shape)\n",
    "\n",
    "        if (ch_delay_flag):\n",
    "            #add in Poisson delays and scale using Rayleigh values\n",
    "            maxspreadt,pIL, pil, pG, pg = poissonarray\n",
    "            #set up typical cluster, ray numbers based on provide values\n",
    "            num_clstrs = maxspreadt // pIL\n",
    "            if num_clstrs == 0: num_clstrs=1\n",
    "            num_rays = (2*pIL) // pil\n",
    "            clstr_idx = np.arange(0, num_clstrs)\n",
    "            ray_idx = np.arange(0, num_rays)\n",
    "            #generate cluster and ray timing\n",
    "            clstr_times = np.expand_dims(np.random.default_rng(seed).gamma(clstr_idx,pIL*np.ones((num_rx,num_runs,1))),axis=3)\n",
    "            ray_times = np.random.default_rng(seed).gamma(ray_idx,pil*np.ones((num_rx,num_runs,num_clstrs, num_rays)))\n",
    "\n",
    "            #get path gains for cluster/ray combos\n",
    "            clstr_ray_gains = np.random.default_rng(seed).rayleigh(np.multiply(np.exp(-clstr_times/pG),np.exp(-ray_times/pg))/2)\n",
    "\n",
    "            #reshape to make easier to index, find largest path gain\n",
    "            clstr_ray_gains = clstr_ray_gains.reshape(num_rx, num_runs, num_rays*num_clstrs)\n",
    "            times_matrix_idx = np.expand_dims(np.argmax(clstr_ray_gains, axis=2), axis=2)\n",
    "            #make it easy to find associated cluster, ray times for biggest path gain\n",
    "            clstr_times1 = np.matmul(clstr_times,np.ones((1,num_rays)))\n",
    "            #ray_times1 = np.matmul(np.ones((num_clstrs,1)),ray_times)\n",
    "            times_matrix = (clstr_times1 + ray_times).reshape(clstr_ray_gains.shape)\n",
    "            #get offset\n",
    "            offsets = np.take_along_axis(times_matrix,times_matrix_idx,axis=2).squeeze(axis=2)\n",
    "\n",
    "        if (tdoa_flag):\n",
    "            #from absolute delays+offsets, get relative delays\n",
    "            # so create array to hold values, set abs+offsets, then iterate to get diff\n",
    "            rxx_delay = np.zeros((num_runs,comb(num_rx,2,exact=True)))\n",
    "            temp = abs_delay+offsets\n",
    "            for i,j in zip(range(rxx_delay.shape[1]),combinations(range(num_rx),2)):\n",
    "                rxx_delay[:,i]=temp[j[0],:]-temp[j[1],:]\n",
    "        else:\n",
    "            #return absolute values of time of flight\n",
    "            rxx_delay = np.transpose(abs_delay + offsets)\n",
    "\n",
    "        #save parameters to self\n",
    "        self.ch_delay_flag = ch_delay_flag\n",
    "        self.tdoa_flag = tdoa_flag\n",
    "        self.seed_tdoa = seed\n",
    "        self.rxx_delay = rxx_delay\n",
    "        \n",
    "        return self\n",
    "        \n",
    "    def calculate_RxxRssi(self, ch_gain_flag=1, drss_flag=0, seed=None):\n",
    "        \"\"\"\n",
    "        Calculates absolute or relative received power at each sensor\n",
    "        (or pair of sensors) based on given Rx and Tx locations. Assumes\n",
    "        structure of first column is Tx, rest of columns are Rx. Third \n",
    "        dimension is multiple runs of data (see \n",
    "        `generate_RxTxlocations`).  Returns absolute received signal \n",
    "        strength (RSS) or relative power (RSSI).\n",
    "\n",
    "        Received power is a log-normal Gaussian/Normal RV around a \n",
    "        distance dependent mean ([^5]).\n",
    "\n",
    "        __Parameters__\n",
    "\n",
    "        >__ch_gain_flag__ : integer/boolean, default =1\n",
    "        >- Whether to add shadowing based on LogNormalArray parameters\n",
    "        >    - 0 - ideal free space loss\n",
    "        >    - 1 - (default) - shadowing path loss\n",
    "        >\n",
    "        >__drss_flag__ : integer/boolean, default=0\n",
    "        >- Type of measurement to return,\n",
    "        >    - 0 - (default) return RSS\n",
    "        >    - 1 - rtn differential RSS (n choose 2) between pairs of \n",
    "        >    sensors of format (rx1-rx2, rx1-rx3,... rx1-rxn, \n",
    "        >    rx2-rx3,..., rx(n-1) - rxn\n",
    "        >\n",
    "        >__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
    "        >- *set by class instantiation*\n",
    "        >-Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
    "        >\n",
    "        >__LogNormalArray__ : list, \n",
    "        >- *set by class instantiation*\n",
    "        >- List of RF channel parameters in relevant units:\n",
    "        >    [PathLossN, Xsigma, Wavelength] where PathLossN is path loss\n",
    "        >    exponent (ideal is 2) in dB, Xsigma is Std deviation of\n",
    "        >    received power in dB (log-normal Gaussian RV), Wavelength \n",
    "        >    is of RF signal emanating from Tx source in Hz\n",
    "        >\n",
    "        >__seed__ : integer, default=None\n",
    "        >- set for reprodducible results\n",
    "        \n",
    "        __Returns__\n",
    "        \n",
    "        >Self, sets self.rxx_rssi\n",
    "        >- Format is [num_runs] x [abs (num_rx)/diff delay measurements \n",
    "        >    (num_rx choose 2)] - units of dB\n",
    "\n",
    "        __Notes__\n",
    "        \n",
    "        [^5]: Theodore S. Rappaport's Wireless Communications: Principles\n",
    "            and Practice by IEEE Press, Inc. Prentic Hall ISBN: \n",
    "            0-7803-1167-1. Chapters 3 and 4\n",
    "        \"\"\"\n",
    "        #get basic parameters inherent in rxtx_locations\n",
    "        rxtx_locations = self.rxtx_locs\n",
    "        lognormalarray = [self.PathLossN, self.Xsigma, \n",
    "                          self.Wavelength]\n",
    "        _, num_rx, num_runs = rxtx_locations.shape\n",
    "        num_rx -= 1 #2nd dimension has one Tx and rest Rx\n",
    "        #\n",
    "        tx_vec=np.expand_dims(rxtx_locations[:,0,:],axis=1)\n",
    "        rx_array=rxtx_locations[:,1:,:]\n",
    "        #note that we (currently) assume that num_tx == 1\n",
    "        #calculate absolute distances from Tx to each Rx\n",
    "        #measurements stay in meters\n",
    "        abs_dist = np.linalg.norm(tx_vec-rx_array, axis=0)\n",
    "        #get reference loss in db, normalize d0 to lambda\n",
    "        pln, xsigma, wavelength=lognormalarray\n",
    "        PLd0=-10*np.log10(wavelength*wavelength/(16*np.pi*np.pi))*np.ones((num_rx,num_runs))\n",
    "        offsets=np.zeros(abs_dist.shape)\n",
    "\n",
    "        # if shadowing flag (or ch_gain_flag)\n",
    "        if (ch_gain_flag):\n",
    "            #calculate loss based on PL exponent and shadowing factors\n",
    "            rssi_vals = PLd0 + 10*pln*np.log10(abs_dist) + np.random.default_rng(seed).normal(scale=xsigma,size=abs_dist.shape)\n",
    "        else:\n",
    "            #calculate loss based on ideal path loss (free space)\n",
    "            rssi_vals = PLd0 + 10*2*np.log10(abs_dist)\n",
    "\n",
    "        #return either differential or absolute received signal strength\n",
    "        if (drss_flag):\n",
    "            #from absolute rssi_vals, get relative rss\n",
    "            # so create array to hold values, then iterate to get diff\n",
    "            rxx_rssi = np.zeros((num_runs,comb(num_rx,2,exact=True)))\n",
    "            for i,j in zip(range(rxx_rssi.shape[1]),combinations(range(num_rx),2)):\n",
    "                rxx_rssi[:,i]=rssi_vals[j[0],:]-rssi_vals[j[1],:]\n",
    "        else:\n",
    "            rxx_rssi = np.transpose(rssi_vals)\n",
    "\n",
    "        #save parameters to self\n",
    "        self.ch_gain_flag = ch_gain_flag\n",
    "        self.drss_flag = drss_flag\n",
    "        self.seed_rss = seed\n",
    "        self.rxx_rssi = rxx_rssi\n",
    "\n",
    "        return self\n",
    "\n",
    "    def calculate_AoA(self, ch_angle_flag= 1, daoa_flag= 0, seed=None):\n",
    "\n",
    "        \"\"\" Calculates AoA based on given Rx and Tx locations. Assumes\n",
    "        structure of first column is Tx, rest of columns are Rx. Third\n",
    "        dimension is multiple runs of data.  For noisy case, ([^7]) \n",
    "        assumes uniform distribution [0,2pi) of clusters, each cluster\n",
    "        has Laplacian distribution around a specific AoA with width \n",
    "        just under 30 degrees.  Assumption is specular component (or \n",
    "        strongest) mean value is correct value.\n",
    "\n",
    "        __Parameters__\n",
    "\n",
    "        >__ch_angle_flag__ : Integer/boolean, default=1\n",
    "        >- Flag whether to add multipath affect based on AoAsigma\n",
    "        >    parameters.  \n",
    "        >    - 0 - return ideal AoA (absolute or differential)\n",
    "        >    - 1 (default) - return random offsets characterized by\n",
    "        >    AoAsigma parameters  \n",
    "        >    \n",
    "        >__daoa_flag__ : integer/boolean, default=0\n",
    "        >- Type of measurement to return,\n",
    "        >    - 0 - (default) return AoA\n",
    "        >    - 1 - rtn differential AoA (n choose 2) between pairs of\n",
    "        >    sensors of format (rx1-rx2, rx1-rx3,... rx1-rxn, \n",
    "        >    rx2-rx3,..., rx(n-1) - rxn\n",
    "        >\n",
    "        >__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
    "        >- *set by class instantiation*\n",
    "        >- Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
    "        >\n",
    "        >__AoAArray__ : list, self.AoAsigma\n",
    "        >- *set by class instantiation*\n",
    "        >- List of RF channel parameters in relevant units: [AoAsigma]\n",
    "        >    which is Laplacian standard deviation of angle of arrival \n",
    "        >    error in radians of RF signal emanating from Tx source \n",
    "        >\n",
    "        >__seed__ : integer, default=None\n",
    "        >- set for reprodducible results\n",
    "        \n",
    "        __Returns__\n",
    "        \n",
    "        >Self, sets self.rxx_rssi\n",
    "        >- Format is [num_runs] x [abs (num_rx)/diff angle measurements \n",
    "        >    (num_rx choose 2)] - units of radians\n",
    "        \n",
    "        __Notes__\n",
    "        \n",
    "        [^7]: Q. H. Spencer, B. D. Jeffs, M. A. Jensen and A. L. \n",
    "            Swindlehurst, \"Modeling the statistical time and angle of \n",
    "            arrival characteristics of an indoor multipath channel,\" in\n",
    "            IEEE Journal on Selected Areas in Communications, vol. 18, no. \n",
    "            3, pp. 347-360, March 2000, doi: 10.1109/49.840194.   \n",
    "        \"\"\"\n",
    "        #get basic parameters inherent in rxtx_locations\n",
    "        rxtx_locations = self.rxtx_locs\n",
    "        aoasigma = self.AoAsigma\n",
    "        _, num_rx, num_runs = rxtx_locations.shape\n",
    "        num_rx -= 1 #2nd dimension has one Tx and rest Rx\n",
    "        #\n",
    "        tx_vec=np.expand_dims(rxtx_locations[:,0,:],axis=1)\n",
    "        rx_array=rxtx_locations[:,1:,:]\n",
    "        #note that we (currently) assume that num_tx == 1\n",
    "        #calculate angle from Rx to each Tx in radians\n",
    "        diff_vec = tx_vec - rx_array\n",
    "        abs_aoa = np.arctan2(diff_vec[1,:,:],diff_vec[0,:,:])\n",
    "        #\n",
    "        if (ch_angle_flag):\n",
    "            #calculate angle based on Laplacian\n",
    "            abs_aoa = abs_aoa+ np.random.default_rng(seed).laplace(scale=aoasigma,size=abs_aoa.shape)\n",
    "\n",
    "        if (daoa_flag):\n",
    "            #from absolute aoa vals, get relative aoa\n",
    "            # so create array to hold values, then iterate to get diff\n",
    "            rel_aoa = np.zeros((num_runs,comb(num_rx,2,exact=True)))\n",
    "            for i,j in zip(range(rel_aoa.shape[1]),combinations(range(num_rx),2)):\n",
    "                    rel_aoa[:,i]=abs_aoa[j[0],:]-abs_aoa[j[1],:]\n",
    "        else:\n",
    "            rel_aoa = np.transpose(abs_aoa)\n",
    "            \n",
    "        #save parameters to self\n",
    "        self.ch_angle_flag = ch_angle_flag\n",
    "        self.daoa_flag = daoa_flag\n",
    "        self.seed_aoa = seed\n",
    "        self.rxx_aoa = rel_aoa\n",
    "        \n",
    "        return self\n",
    "    \n",
    "    def generate_Xmodel(self, ch_delay_flag=1, ch_gain_flag=1, ch_angle_flag=1, \n",
    "                        meas_flag=6, diff_array= [1,0,0], seed=None):\n",
    "\n",
    "        \"\"\" Generates a set of measurements based on passed parameters \n",
    "        that can be used for a dictionary or training/testing of \n",
    "        different optimization algorithms.\n",
    "\n",
    "        ___Parameters___\n",
    "\n",
    "        >__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
    "        >- *set by class instantiation*\n",
    "        >- Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
    "        >\n",
    "        >__poissonarray__ : list, default=[maxSpreadT, PoissonInvLambda, Poissoninvlambda, PoissonGamma, Poissongamma] \n",
    "        >- *set by class instantiation*\n",
    "        >- List of time-related propagation parameters in integers\n",
    "        >    (nanosecond units)\n",
    "        >\n",
    "        >__ch_delay_flag__ : Integer/boolean, default=1\n",
    "        >- Channel flag whether to add multipath (random) based on \n",
    "        >    PoissonArray parameters.\n",
    "        >    - 0 - return ideal delays (absolute\n",
    "        >    - or differential) 1 (default) - return random offsets \n",
    "        >    characterized by poissonarray parameters\n",
    "        >\n",
    "        >__LogNormalArray__ : list, default=[PathLossN, Xsigma, Wavelength]\n",
    "        >- *set by class instantiation*\n",
    "        >- List of RF channel parameters in relevant units:\n",
    "        >     where PathLossN is path loss\n",
    "        >    exponent (ideal is 2) in dB, Xsigma is Std deviation of\n",
    "        >    received power in dB (log-normal Gaussian RV), Wavelength \n",
    "        >    is of RF signal emanating from Tx source in Hz\n",
    "        >\n",
    "        >__ch_gain_flag__ : integer/boolean, default =1\n",
    "        >- Whether to add shadowing based on LogNormalArray parameters\n",
    "        >    - 0 - ideal free space loss\n",
    "        >    - 1 - (default) - shadowing path loss\n",
    "        > \n",
    "        >__AoAArray__ : list, self.AoAsigma\n",
    "        >- *set by class instantiation*\n",
    "        >- List of RF channel parameters in relevant units: [AoAsigma]\n",
    "        >    which is Laplacian standard deviation of angle of arrival \n",
    "        >    error in radians of RF signal emanating from Tx source\n",
    "        >    \n",
    "        >__ch_angle_flag__ : Integer/boolean, default=1\n",
    "        >- Flag whether to add multipath affect based on AoAsigma\n",
    "        >    parameters.  \n",
    "        >    - 0 - return ideal AoA (absolute or differential)\n",
    "        >    - 1 (default) - return random offsets characterized by\n",
    "        >    AoAsigma parameters  \n",
    "        >\n",
    "        >__meas_flag__ : Integer, default=6\n",
    "        >    - Determines which measurement types are generated for\n",
    "        >    a given channel.  Options are: \n",
    "        >        - 0-tdoa, \n",
    "        >        - 1-drss, \n",
    "        >        - 2-aoa,\n",
    "        >        - 3-tdoa/drss, \n",
    "        >        - 4-tdoa/aoa, \n",
    "        >        - 5-drss/aoa, \n",
    "        >        - 6-tdoa/drss/aoa\n",
    "        >            \n",
    "        >__diff_array__ : Boolean list, default = [1,0,0] \n",
    "        >- List sets whether measurement types are differential or \n",
    "        >    absolute measurements for TDOA, RSS, and AoA, e.g.,\n",
    "        >    - [1,0,0] - TDOA, RSS, and AoA\n",
    "        >    - [1,1,0] - TDOA, DRSS, and AoA\n",
    "        >    - [1,1,1] - TDOA, DRSS, and DAoA\n",
    "        >    - [tdoa_flag, drss_flag, daoa_flag]\n",
    "        >\n",
    "        >__seed__ : integer, default=None\n",
    "        >- set for reprodducible results        \n",
    "        \n",
    "        ___Returns___\n",
    "\n",
    "        >Self, sets self.X_model\n",
    "        >- Format is [n_runs]x[measurements] (sized set by meas_flag,\n",
    "        >    diff_array parameters) \n",
    "        \n",
    "        \"\"\"\n",
    "        #get basic parameters inherent in rxtx_locations\n",
    "        rxtx_locs=self.rxtx_locs       \n",
    "        tdoa_flag, drss_flag, daoa_flag = diff_array\n",
    "\n",
    "        # generate delay based on Tx and Rx locations\n",
    "        self.calculate_Rxxdelay(ch_delay_flag = ch_delay_flag, tdoa_flag = tdoa_flag, seed=seed)\n",
    "        tde_len=self.rxx_delay.shape[1]\n",
    "        Rxx_delay=self.rxx_delay\n",
    "\n",
    "        #generate power measurements based on Tx and Rx locations\n",
    "        self.calculate_RxxRssi(ch_gain_flag=ch_gain_flag, drss_flag=drss_flag, seed=seed)\n",
    "        rss_len = self.rxx_rssi.shape[1]\n",
    "        Rxx_rssi= self.rxx_rssi\n",
    "\n",
    "        #generate aoa measurements based on Tx and Rx locations\n",
    "        self.calculate_AoA(ch_angle_flag= ch_angle_flag, daoa_flag= daoa_flag, seed=seed)\n",
    "        aoa_len=self.rxx_aoa.shape[1]\n",
    "        Abs_aoa=self.rxx_aoa\n",
    "\n",
    "        if (meas_flag == 0): X_model = Rxx_delay\n",
    "        elif (meas_flag==1): X_model = Rxx_rssi\n",
    "        elif (meas_flag==2): X_model = Abs_aoa\n",
    "        elif (meas_flag==3): X_model = np.concatenate((Rxx_delay, Rxx_rssi),axis=1)\n",
    "        elif (meas_flag==4): X_model = np.concatenate((Rxx_delay, Abs_aoa),axis=1)\n",
    "        elif (meas_flag==5): X_model = np.concatenate((Rxx_rssi, Abs_aoa), axis=1)\n",
    "        elif (meas_flag==6): X_model = np.concatenate((Rxx_delay, Rxx_rssi, Abs_aoa), axis=1)\n",
    "        else: raise ValueError('bad meas_flag')\n",
    "\n",
    "        #save parameters to self\n",
    "        self.ch_delay_flag = ch_delay_flag\n",
    "        self.ch_gain_flag = ch_gain_flag\n",
    "        self.ch_angle_flag = ch_angle_flag\n",
    "        self.tdoa_flag = tdoa_flag\n",
    "        self.drss_flag = drss_flag\n",
    "        self.daoa_flag = daoa_flag\n",
    "        self.seed_Xmodel = seed\n",
    "        self.X_model = X_model\n",
    "\n",
    "        return self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### RFchannel Examples\n",
    "\n",
    "An example of creating the default RFchannel object to simulate measurements of an indoor environment.  The associated variables are:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'maxSpreadT': 100, 'PoissonInvLambda': 50, 'Poissoninvlambda': 10, 'PoissonGamma': 50, 'Poissongamma': 29, 'PathLossN': 3.0, 'Xsigma': 7, 'Wavelength': 1.4615111050485465, 'AoAsigma': 0.4537856055185257}\n"
     ]
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#print out object variables\n",
    "print(vars(RFchannel_scenario1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"RFchannel.generate_RxTxlocations\" class=\"doc_header\"><code>RFchannel.generate_RxTxlocations</code><a href=\"__main__.py#L85\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>RFchannel.generate_RxTxlocations</code>()\n",
       "\n",
       "Generate a three dimensional array (cartesian coordinates -- each \n",
       "row a dim) x (sensors -- each col a specific sensor) x (num_runs --\n",
       "3rd dimension is number of observations) that provides locations of\n",
       "a Tx source and a set of RF sensors across multiple \n",
       "observations/runs. Each column is a sensor (except first col \n",
       "is Tx) location, next col is sensor 1 location, then sensor 2, etc.\n",
       "3rd dimension marks either a new or same Rx sensor arrangement \n",
       "(depending on flag) at next observation.  Values are in meters.\n",
       "\n",
       "__Parameters__\n",
       "\n",
       ">__n_rx__ : integer, default=6  \n",
       ">- Number of receivers/sensors\n",
       ">\n",
       ">__areaWL__ : ndarray of shape (2,), default= np.array([20,60])\n",
       ">- Bounding size of area of interest, square/rectangle\n",
       ">\n",
       ">__n_runs__ : integer, default=1000  \n",
       ">- Number of observations/samples/runs to generate\n",
       ">\n",
       ">__sensor_locs__ : ndarray of shape (2,n_rx,1), default= np.array([[[6.3], [14.1], [7.2], [14.5], [7.5], [13.5]],[[15.3], [15.1], [30.1], [30.5], [44.9], [44.5]]])\n",
       ">- Location of sensors, only used if `rxtx_flag`=3\n",
       ">    \n",
       ">__rxtx_flag__ : integer, default=3\n",
       ">- Flag on how Tx and/or Rx location are randomly chosen. Values are as follows,\n",
       ">    - 0 -same Tx location, random Rx locations\n",
       ">    - 1 -random Tx location, same Rx locations\n",
       ">    - 2 -random Tx locations, random Rx locations\n",
       ">    - 3 -random Tx, fixed Rx locations based on rx_layout\n",
       ">\n",
       ">__grid_flag__ : boolean, default=0\n",
       ">    - Flag on generating random Tx location on evenly spaced\n",
       ">    grid (1m x 1m spacing).  Default is random, non-grid. \n",
       ">\n",
       ">__seed__ : integer, default=None\n",
       ">- set for reprodducible results\n",
       "\n",
       "__Returns__\n",
       "\n",
       ">Self, sets self.rxtx_locs"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(RFchannel.generate_RxTxlocations)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### generate_RxTxlocations Example\n",
    "\n",
    "One observation or run in matrix/table form:\n",
    "\n",
    "|    | Tx Source | Rx_1  | ... | Rx_n  |\n",
    "| :---------:   | :-------: | :---: | :---: | :---:  |\n",
    "| x_coord       | x_tx      | x_rx1 | ...   | x_rxn  |\n",
    "| y_coord       | y_tx      | y_rx1 | ...   | y_rxn  |\n",
    "\n",
    "\n",
    "An example generating ten observations of two receivers at random locations within a 20x60m area is shown below.  The transmitter is randomly placed at every location as well.  A plot of the first observation is shown.  Practical uses either have receivers (Rx) fixed with unknown/random Tx placement or vice versa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of output: (2, 3, 10)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEICAYAAABGaK+TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy86wFpkAAAACXBIWXMAAAsTAAALEwEAmpwYAAAfkUlEQVR4nO3de5xVdb3/8dcbBhkR1ICJBJQx7zrgYGikoQjSD4WEc9LK0FBRsjoe66codjTRPB49eoAjmeVRGSoveMnLMesRmXgpUwcYwQs/DEUdQRggFFTI0c/vj7UGh2GG2XPdLHg/H4/9mL3un7XX7Pde+7vWXksRgZmZZU+HfBdgZmbN4wA3M8soB7iZWUY5wM3MMsoBbmaWUQ5wM7OMcoBbs0n6kaRb87Dcf5L0lqQNkgbWM/wYSa+mw8dK+p2k8Xmos1hSSCpo72W3hKRxkv6Q7zqscfJ54NklaRlwTkT8sR2WNRT4dUT0betlNUbSUuD/RsRDDQx/DHg4Iv67FZYVwAER8bdmTFsMvA50iojqltbSFrJQozXMe+CWRf2Al1owfLOs7R3XpYTfxzspb/gdkKTOkqZLWp4+pkvqXGv4GEkVkt6TtFTSyLT/WZJekbRe0muSvpP23w34HdA7bZbYIKm3pCmSfl1rvidLeknSOklzJR1Sa9gySRdJWijpXUmzJRU2UH8HSZdJekPSKkm/lLRHul4bgI7AC+meeN1plwKfB/43rbNzWss56fAzJf1Z0jRJa4ApkvaX9ERa12pJs9Nxn0xn+0I6r2/kWmud0c5Ot8MKSRfVmvYoSeXpdlgpaWqtYYMl/SV9LV9IvwHVDJsr6d8l/Rn4AJgkqbxOXT+U9HD6fJSkBely3pI0pdaoNeu4Ll3HL6Wv0dO15nW0pOfT1+d5SUfXqeUn6Wu6XtIfJPWs+zpZG4kIPzL6AJYBJ9TT/yrgr8BngSLgL8BP0mFHAe8CI0g+wPsAB6fDRgH7AQKOIwmHI9JhQ4HKOsuZQtKsAnAg8H46307AxcDfgF1q1foc0BvoDrwCnNfAep2dTvt5oCvwG+BXtYYHsH+urwswl6SpCeBMoBo4HygAdgXuAv4tfT0KgS83YVkN1goUp9PfBewG9AeqamoDngHOSJ93BQanz/sAa4CT0ppGpN1FtdbnTeCwdB32ANaTNPXU1PU88M1a265/Oq8BwEpgbJ0aC2pNeybwdPq8O/B34Ix0Wael3T1q1bI03f67pt3X5vu9sbM8vAe+YxoHXBURqyKiCriS5A0IMAG4PSLmRMQnEfF2RCwGiIjfRsTSSDwB/AEYkuMyvwH8Np3vR8ANJG/oo2uNc2NELI+ItcD/AqXbqH9qRLwWERuAS4FvtmJzx/KImBER1RHxIfARSbNL74jYGBFPNzJ9U2u9MiLej4hFwEySECRd7v6SekbEhoj4a9r/dODRiHg03UZzgHKSQK9RFhEvpevwLvBQzXwlHQAcDDwMEBFzI2JROq+FJB8ox+W4fqOAVyPiV+my7gIWA1+tNc7MiFiSvpb30PB2tVbmAN8x9QbeqNX9RtoPYG+SPaatSDpR0l8lrZW0jiQwcv06vMUyI+IT4C2Svcka79R6/gHJXmeu9RcAvXKspTFv1em+mORbx3NpE9DZTZhXLrW+VWd4zbaYQLLnujhtmhid9u8HnJo2n6xLt8WXgb22sQ538ukHw7eAByPiAwBJX5T0uKQqSe8C59HM7VprHZqzXa2VOcB3TMtJQqDGPmk/SN74+9WdQEkb+f0ke869ImJP4FGSYIPka3bOy5Qkkg+Lt5tefr31V5N89W8NW6xLRLwTEedGRG/gO8DPJO2f47xyqXXvOsOXp8t9NSJOI2nqug64Lz3e8BZJM8yetR67RcS1Da0DMAcoklRKEuR31hp2J8ne+N4RsQfwc5q5XWutQ3O2q7UyB3j2dZJUWOtRQPIV+TJJRekBpR8DNQcbbwPOkjQ8PQDXR9LBwC5AZ5I22mpJJwJfqbWclUCPeg7Q1bgHGJXOtxNwIbCJpP29qe4CfihpX0ldgWuA2dFGp7lJOlVSzemRfycJtU/S7pUk7dstqfVySV0kHQacBdQcJD1dUlH6bWVdOu4nJNvqq5L+j6SO6XYdWqvGraTNVvcC15O0W8+pNbgbsDYiNko6imQPvUZVusyG1vFR4EBJ35JUkB7IPRR4ZBuvibUTB3j2PQp8WOsxBbiapM10IbAImJ/2IyKeIwmRaSQHM58A+kXEeuBfSYL47yRv8odrFpK2k98FvJZ+ra9pBqgZ/v9I2m5nAKtJ2ki/GhH/aMY63Q78iuQMideBjSQHHdvKkcCzSs5weRi4ICJeS4dNAWal6/z1Ztb6BMmBzseAGyKi5kcyI4GX0uX+N8lBxw8j4i1gDPAjkoB9C5hE4+/XO4ETgHvrfIB8D7hK0nqSD/N7agakzSz/Dvw5XcfBtWcYEWuA0SQfyGtImptGR8TqRmqxduAf8piZZZT3wM3MMsoBbmaWUQ5wM7OMcoCbmWVUu17Ip2fPnlFcXNyeizQzy7x58+atjoiiuv3bNcCLi4spLy9vfEQzM9tMUt1fwwJuQjEzyywHuJlZRjnAzcwyKtN3IzHbGXz00UdUVlaycePGfJdibaywsJC+ffvSqVOnnMZ3gJtt5yorK+nWrRvFxcUkF3m0HVFEsGbNGiorK9l3331zmibnAJfUkeQCSW9HxGhJ+wJ3Az2AeSR3FmnOhYvM2tygq+ewesPW/549u+5C+WUj8lBR7jZu3Ojw3glIokePHlRVVeU8TVPawC8guQ1WjeuAaRGxP8nV6yY0YV5m7aq+8N5W/+2Nw3vn0NTtnFOAp9chHgXcmnYLGAbcl44yCxjbpCWbmVmL5LoHPp3kOsA1F7nvAayrdc3hSra8xZKZ7cSWLVtGSUlJuy5z06ZNnHDCCZSWljJ79uwthi1evJjS0lIGDhzI0qVLOfrooxuYS/2mT5/OBx980JrltopG28DT+/Stioh5koY2dQGSJgITAfbZZ5+mTm5mTdDWbf2b74beYfs7A3nBggUAVFRUbDXswQcf5JRTTuGyyy4D4C9/2fpGUdXV1RQU1B+J06dP5/TTT6dLly7brOHjjz+mY8eOTay8+XLZCscAJ0taRnLQchjJ3UP2rHXn7b40cI+8iLglIgZFxKCioq1+ym9mragt2vqXLVvGQQcdxLe//W1KSkr41a9+xfDhw4kIVqxYwYEHHsg777zT4PQbN27krLPOon///gwcOJDHH38cSMLuoosuoqSkhAEDBjBjxgwAJk+ezKGHHsqAAQO46KKLtprf2rVrGTt2LAMGDGDw4MEsXLiQVatWcfrpp/P8889TWlrK0qWf3rf70UcfZfr06dx8880cf/zxAHTtmtx3ee7cuQwZMoSTTz6ZQw89lPfff59Ro0Zx+OGHU1JSwuzZs7nxxhtZvnw5xx9//ObpaysuLuaSSy7hiCOO4N5772Xo0KGbLxmyevVqaq7/VFZWxj//8z8zcuRIDjjgAC6++OJmbI0tNboHHhGXApcCpHvgF0XEOEn3AqeQhPp44KEWV2PWRnp23aXBPVNr3KuvvsqsWbMYPDi549qcOXO46aab+P3vf8+VV17J5z73uQanvemmm5DEokWLWLx4MV/5yldYsmQJM2fOZNmyZVRUVFBQUMDatWtZs2YNDzzwAIsXL0YS69at22p+V1xxBQMHDuTBBx/kT3/6E9/+9repqKjg1ltv5YYbbuCRR7a8XedJJ53EeeedR9euXev9QJg/fz4vvvgi++67L/fffz+9e/fmt7/9LQDvvvsue+yxB1OnTuXxxx+nZ8+e9a5jjx49mD9/PgA///nPG3wtKioqWLBgAZ07d+aggw7i/PPPZ++9925w/Ma05DzwS4C7JV0NLCC5Wa7Zdml7P1Vwe9evX7/N4Q0wY8YMSkpKGDx4MKeddto2p3366ac5//zkNqEHH3ww/fr1Y8mSJfzxj3/kvPPO29xs0b17d6qrqyksLGTChAmMHj2a0aNH1zu/+++/H4Bhw4axZs0a3nvvvWav21FHHbX5vOv+/ftz4YUXcskllzB69GiGDBmS0zy+8Y1v5DTe8OHD2WOP5L7ghx56KG+88UaLArxJDVkRMTciRqfPX4uIoyJi/4g4NSI2NbsKM9uu7bbbblt0V1ZW0qFDB1auXMknn3zSwFRNV1BQwHPPPccpp5zCI488wsiRI1tt3g2pvW4HHngg8+fPp3///lx22WVcddVVTZ5HQUHB5tek7q9nO3fuvPl5x44dqa6upiW2vyMRZrZdq66u5uyzz+auu+7ikEMOYerUqdscf8iQIdxxxx0ALFmyhDfffJODDjqIESNG8Itf/GJziK1du5YNGzbw7rvvctJJJzFt2jReeOGFbc5v7ty59OzZk913371V1m358uV06dKF008/nUmTJm1uFunWrRvr16/PaR7FxcXMmzcPgPvuu6+RsVvGP6U324G0R1v/Nddcw5AhQ/jyl7/M4YcfzpFHHsmoUaM45JBD6h3/e9/7Ht/97nfp378/BQUFlJWV0blzZ8455xyWLFnCgAED6NSpE+eeey5f+9rXGDNmDBs3biQi6v1wmDJlCmeffTYDBgygS5cuzJo1q9XWbdGiRUyaNIkOHTrQqVMnbr75ZgAmTpzIyJEj6d279+aDsA256KKL+PrXv84tt9zCqFGjWq22+igi2nQBtQ0aNCh8QwezpnnllVcaDEfb8dS3vSXNi4hBdcd1E4qZWUY5wM3MMsoBbmaWUQ5wM7OMcoCbmWWUA9zMLKMc4Ga2TevWreNnP/tZq82vrKyM5cuXt2geVVVVfPGLX2TgwIE89dRTWwx76qmnOOywwygtLeXtt9/mlFNOadK8r7nmmhbV1p4c4GY7ovXvwMwTYf3KFs+qPQP8448/zmkejz32GP3792fBggVbXa/kjjvu4NJLL6WiooI+ffrU+2vIbf2EPdcAz7XWtuQAN9sRPfGf8OZf4YnrWjyryZMns3TpUkpLS5k0aRIPPPBAvZeTLSsrY+zYsYwYMYLi4mJ++tOfMnXqVAYOHMjgwYNZu3Yt9913H+Xl5YwbN47S0lI+/PDDrS7HWtuyZcsYNmwYAwYMYPjw4bz55ptUVFRw8cUX89BDD22eR41bb72Ve+65h8svv5xx48ZtcWOJsrIyTj75ZIYNG8bw4cNZsWIFxx57LKWlpZSUlPDUU08xefJkPvzwQ0pLSxk3btxWr0XXrl258MILOfzww3nmmWcoLi5m9erVAJSXlzN06FDg01+LDh06lM9//vPceOONLd4O9aq5QHt7PL7whS+EmTXNyy+/nPvIPymKuGL3rR8/KWr28l9//fU47LDDtug3bty4mDFjRowaNSruvPPOiIiYOXNm7LfffvHee+/FqlWrYvfdd4+bb745IiJ+8IMfxLRp0yIi4rjjjovnn39+87z69esX1113Xb3LHj16dJSVlUVExG233RZjxozZvKzvf//79U4zfvz4uPfee7eqfebMmdGnT59Ys2ZNRETccMMNcfXVV0dERHV1dbz33nsREbHbbrs1+FoAMXv27C1qr6qqioiI559/Po477riIiLjiiiviS1/6UmzcuDGqqqqie/fu8Y9//KPB+dZW3/YGyqOeTPUeuNmO5IKFUHIqFOyadBfsCv1PhQsWtepiZsyYwX/8x3/QuXPnLS4ne/zxx9OtWzeKiorYY489+OpXvwokl2ldtmxZg/Nr6HKszzzzDN/61rcAOOOMM3j66adbVPeIESPo3r07AEceeSQzZ85kypQpLFq0iG7dujU6fceOHfna176W07JGjRpF586d6dmzJ5/97GdZubLlzVl1OcDNdiTdPgedu8HHm6CgMPnbeXfo1qtVF9PQ5WRrXy61Q4cOm7s7dOiwzXbnuperbSu1l3Psscfy5JNP0qdPH84880x++ctfNjp9YWHhFrdMa89Lx9bHAW62o3l/FXzhLDjnj8nfDS3b86t7KdWmXk62sflty9FHH83dd98NJAcnc73BQi7eeOMNevXqxbnnnss555yz+dKxnTp14qOPPsppHrUvHVtzk4n25MvJmu1ovnnHp89HNy1c69OjRw+OOeYYSkpKOPHEE+nWrVu9l5PN1Zlnnsl5553HrrvuyjPPPLPNcWfMmMFZZ53F9ddfT1FRETNnzmzp6mw2d+5crr/+ejp16kTXrl0374FPnDiRAQMGcMQRR2y+7nhDrrjiCiZMmMDll1+++QBme/LlZM22c76c7M7Fl5M1M9sJNBrgkgolPSfpBUkvSboy7V8m6XVJFemjtM2rNTOzzXJpA98EDIuIDZI6AU9L+l06bFJEtO1N38yMiEBSvsuwNtbUJu1G98DT88g3pJ2d0kf7NZyb7eQKCwtZs2ZNk9/cli0RwZo1aygsLMx5mpzOQpHUEZgH7A/cFBHPSvou8O+Sfgw8BkyOiE31TDsRmAiwzz775FyYmSX69u1LZWUlVVVV+S7F2lhhYSF9+/bNefwmnYUiaU/gAeB8YA3wDrALcAuwNCKu2tb0PgvFzKzpWuUslIhYBzwOjIyIFWnzyiZgJnBUq1RqZmY5yeUslKJ0zxtJuwIjgMWS9kr7CRgLvNh2ZZqZWV25tIHvBcxK28E7APdExCOS/iSpCBBQAZzXdmWamVldjQZ4RCwEBtbTf1ibVGRmZjnxLzHNzDLKAW5mllEOcDOzjHKAm5lllAPczCyjHOBmZhnlADczyygHuJlZRjnAzcwyygFuZpZRDnAzs4xygJuZZZQD3MwsoxzgZmYZ5QA3M8soB7iZWUY5wM3MMsoBbmaWUbnc1LhQ0nOSXpD0kqQr0/77SnpW0t8kzZa0S9uXa2ZmNXLZA98EDIuIw4FSYKSkwcB1wLSI2B/4OzChzao0M7OtNBrgkdiQdnZKHwEMA+5L+88CxrZFgWZmVr+c2sAldZRUAawC5gBLgXURUZ2OUgn0aZMKzcysXjkFeER8HBGlQF/gKODgXBcgaaKkcknlVVVVzavSzMy20qSzUCJiHfA48CVgT0kF6aC+wNsNTHNLRAyKiEFFRUUtqdXMzGrJ5SyUIkl7ps93BUYAr5AE+SnpaOOBh9qoRjMzq0dB46OwFzBLUkeSwL8nIh6R9DJwt6SrgQXAbW1Yp5mZ1dFogEfEQmBgPf1fI2kPNzOzPPAvMc3MMsoBbmaWUQ5wM7OMcoCbmWWUA9zMLKMc4GZmGeUANzPLKAe4mVlGOcDNzDLKAW5mllEOcDOzjHKAm5lllAPczCyjHOBmZhnlADczyygHuJlZRjnAzcwyygFuZpZRDnAzs4zK5a70e0t6XNLLkl6SdEHaf4qktyVVpI+T2r5cMzOrkctd6auBCyNivqRuwDxJc9Jh0yLihrYrz8zMGpLLXelXACvS5+slvQL0aevCzMxs25rUBi6pGBgIPJv2+hdJCyXdLukzDUwzUVK5pPKqqqqWVWtmZpvlHOCSugL3Az+IiPeAm4H9gFKSPfT/qm+6iLglIgZFxKCioqKWV2xmZkCOAS6pE0l43xERvwGIiJUR8XFEfAL8D3BU25VpZmZ15XIWioDbgFciYmqt/nvVGu2fgBdbvzwzM2tILmehHAOcASySVJH2+xFwmqRSIIBlwHfaoD4zM2tALmehPA2onkGPtn45ZmaWK/8S08wsoxzgZmYZ5QA3M8soB7iZWUY5wM3MMsoBbmaWUQ5wM7OMcoCbmWWUA9zMLKMc4GZmGeUANzPLKAe4mVlGOcDNzDLKAW5mllEOcDOzjHKAm5lllAPczCyjHOBmZhmVy02N95b0uKSXJb0k6YK0f3dJcyS9mv79TNuXa2ZmNXLZA68GLoyIQ4HBwPclHQpMBh6LiAOAx9JuMzNrJ40GeESsiIj56fP1wCtAH2AMMCsdbRYwto1qNDOzejSpDVxSMTAQeBboFREr0kHvAL0amGaipHJJ5VVVVS2p1czMask5wCV1Be4HfhAR79UeFhEBRH3TRcQtETEoIgYVFRW1qFgzM/tUTgEuqRNJeN8REb9Je6+UtFc6fC9gVduUaGZm9cnlLBQBtwGvRMTUWoMeBsanz8cDD7V+eWZm1pCCHMY5BjgDWCSpIu33I+Ba4B5JE4A3gK+3SYVmZlavRgM8Ip4G1MDg4a1bjpmZ5cq/xDQzyygHuJlZRjnAzcwyygFuZpZRDnAzs4xygJuZZZQD3MwsoxzgZmYZ5QA3M8soB7iZWUY5wM3MMsoBbmaWUQ5wM7OMykaAr38HZp4I61fmuxIzs+1GNgL8if+EN/8KT1yX70rMzLYbudzQIX+u/ixUb/q0u/y25FHQGS7zHdzMbOe2fe+BX7AQSk6Fgl2T7oJdof+pcMGi/NZlZrYd2L4DvNvnoHM3+HgTFBQmfzvvDt165bsyM7O8276bUADeXwVfOAsGnQXlM2GDD2SamUEOAS7pdmA0sCoiStJ+U4Bzgap0tB9FxKNtUuE37/j0+eipbbIIM7MsyqUJpQwYWU//aRFRmj7aJrzNzKxBjQZ4RDwJrG2HWszMrAlachDzXyQtlHS7pM80NJKkiZLKJZVXVVU1NJqZmTVRcwP8ZmA/oBRYAfxXQyNGxC0RMSgiBhUVFTVzcWZmVlezAjwiVkbExxHxCfA/wFGtW5aZmTWmWQEuaa9anf8EvNg65ZiZWa5yOY3wLmAo0FNSJXAFMFRSKRDAMuA7bVeimZnVp9EAj4jT6ul9WxvUYmZmTbB9/5TezMwa5AA3M8soB7iZWUY5wM3MMsoBbmaWUQ5wM7OMcoCbmWWUA9zMLKMc4GZmGeUANzPLKAe4mVlGOcDNzDLKAW5mllEOcDOzjHKAm5lllAPczCyjHOBmZhnlADczy6hGA1zS7ZJWSXqxVr/ukuZIejX9+5m2LdPMzOrKZQ+8DBhZp99k4LGIOAB4LO02M7N21GiAR8STwNo6vccAs9Lns4CxrVuWmZk1prlt4L0iYkX6/B2gV0MjSpooqVxSeVVVVTMXZ2ZmdbX4IGZEBBDbGH5LRAyKiEFFRUUtXZyZmaWaG+ArJe0FkP5d1XolmZlZLpob4A8D49Pn44GHWqccMzPLVS6nEd4FPAMcJKlS0gTgWmCEpFeBE9JuMzNrRwWNjRARpzUwaHgr12JmZk3gX2KamWWUA9zMLKMc4GZmGeUANzPLKAe4mVlGOcDNzDLKAW5mllEOcDOzjHKAm5lllAPczCyjHOBmZhnlADczyygHuJlZRjnAzcwyygFuZpZRDnAzs4xygJuZZZQD3MwsoxzgZmYZ1eg9MbdF0jJgPfAxUB0Rg1qjKDMza1yLAjx1fESsboX5mJlZE7gJxcwso1oa4AH8QdI8SRPrG0HSREnlksqrqqpauDgzM6vR0gD/ckQcAZwIfF/SsXVHiIhbImJQRAwqKipq4eLMzKxGi9rAI+Lt9O8qSQ8ARwFPtkZhZmZZN+jqOaze8I+t+vfsugvll41o8fybvQcuaTdJ3WqeA18BXmxxRWZmO4j6wntb/ZuqJXvgvYAHJNXM586I+H2rVGVmZo1qdoBHxGvA4a1Yi5mZNYFPIzQzyygHuJlZRjnAzczaSM+uuzSpf1O1xk/pzcysHq1xquC2eA/czCyjHOBmZhnlADczyygHuJlZRjnAzcwyShHRfguTqoA32m2B29YTyOqNKLJcO7j+fHP9+dPc2vtFxFaXc23XAN+eSCrP6i3gslw7uP58c/3509q1uwnFzCyjHOBmZhm1Mwf4LfkuoAWyXDu4/nxz/fnTqrXvtG3gZmZZtzPvgZuZZZoD3Mwso3bKAJfUUdICSY/ku5amkrSnpPskLZb0iqQv5bumppD0Q0kvSXpR0l2SCvNd07ZIul3SKkkv1urXXdIcSa+mfz+Tzxq3pYH6r0//fxZKekDSnnkssUH11V5r2IWSQlLPfNSWi4bql3R++vq/JOk/W7KMnTLAgQuAV/JdRDP9N/D7iDiY5JZ2mVkPSX2AfwUGRUQJ0BH4Zn6ralQZMLJOv8nAYxFxAPBY2r29KmPr+ucAJRExAFgCXNreReWojK1rR9LeJDdRf7O9C2qiMurUL+l4YAxweEQcBtzQkgXsdAEuqS8wCrg137U0laQ9gGOB2wAi4h8RsS6vRTVdAbCrpAKgC7A8z/VsU0Q8Cayt03sMMCt9PgsY2541NUV99UfEHyKiOu38K9C33QvLQQOvPcA04GJguz4Do4H6vwtcGxGb0nFWtWQZO12AA9NJNv4nea6jOfYFqoCZaRPQrZJ2y3dRuYqIt0n2ON4EVgDvRsQf8ltVs/SKiBXp83eAXvkspoXOBn6X7yJyJWkM8HZEvJDvWprpQGCIpGclPSHpyJbMbKcKcEmjgVURMS/ftTRTAXAEcHNEDATeZ/v++r6FtK14DMkHUW9gN0mn57eqlonkPNztek+wIZL+DagG7sh3LbmQ1AX4EfDjfNfSAgVAd2AwMAm4R5KaO7OdKsCBY4CTJS0D7gaGSfp1fktqkkqgMiKeTbvvIwn0rDgBeD0iqiLiI+A3wNF5rqk5VkraCyD926Kvwfkg6UxgNDAusvNjkP1IPvxfSN/DfYH5kj6X16qaphL4TSSeI2kJaPaB2J0qwCPi0ojoGxHFJAfP/hQRmdkDjIh3gLckHZT2Gg68nMeSmupNYLCkLulex3AydBC2loeB8enz8cBDeaylySSNJGlGPDkiPsh3PbmKiEUR8dmIKE7fw5XAEen7IiseBI4HkHQgsAstuLLiThXgO4jzgTskLQRKgWvyW07u0m8O9wHzgUUk/3/b9c+iJd0FPAMcJKlS0gTgWmCEpFdJvlVcm88at6WB+n8KdAPmSKqQ9PO8FtmABmrPjAbqvx34fHpq4d3A+JZ8A/JP6c3MMsp74GZmGeUANzPLKAe4mVlGOcDNzDLKAW5mllEOcDOzjHKAm5ll1P8Hl+PcjZU63/wAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=2, n_runs=10, rxtx_flag=2)\n",
    "\n",
    "#get locations of Tx and Rx\n",
    "locs = RFchannel_scenario1.rxtx_locs\n",
    "print(\"Shape of output:\",locs.shape)\n",
    "plt.plot(locs[0,1:,0],locs[1,1:,0],'s',label='rx locs of first run')\n",
    "plt.plot(locs[0,0,0], locs[1,0,0],'*',label='txmtr of first run')\n",
    "plt.title('Location of first observation')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"RFchannel.calculate_Rxxdelay\" class=\"doc_header\"><code>RFchannel.calculate_Rxxdelay</code><a href=\"__main__.py#L187\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>RFchannel.calculate_Rxxdelay</code>(**`ch_delay_flag`**=*`1`*, **`tdoa_flag`**=*`1`*, **`seed`**=*`None`*)\n",
       "\n",
       "Calculates relative delay of wireless signals from a\n",
       "transmitter (Tx) to different receivers (Rx) based on given Rx\n",
       "and Tx locations for each run/observation. Assumes structure of\n",
       "first column is Tx, rest of columns are Rx. Third dimension is\n",
       "multiple runs of data (see `generate_RxTxlocations`). These \n",
       "relative delays are time delay estimates (TDE's).\n",
       "\n",
       "Time related variables are assumed to be nanoseconds in\n",
       "PoissonArray, time intervals are normalized to same.  Note that\n",
       "rxtx_locations is given in meters.  Perturbs the ideal TDE \n",
       "based on given statistical distribution(s) parameterized by\n",
       "values in PoissonArray.  In other words, describes impairments\n",
       "caused by multipath in a statistical sense ([^4]).\n",
       "\n",
       "__Parameters__\n",
       "\n",
       ">__ch_delay_flag__ : Integer/boolean, default=1\n",
       ">- Channel flag whether to add multipath (random) based on \n",
       ">PoissonArray parameters. \n",
       ">    - 0 - return ideal delays (absolute\n",
       ">or differential) \n",
       ">    - 1 (default) - return random offsets \n",
       ">characterized by poissonarray parameters\n",
       ">\n",
       ">__tdoa_flag__ : Integer/boolean, default=1 \n",
       ">- Type of measurement to return,\n",
       ">    - 0 - rtn abs time of flight (i.e. ToF) between Tx and Rx.\n",
       ">    - 1-(default)- returns differential time (i.e., TDOA) between\n",
       ">        pairs of sensors of format (rx1-rx2, rx1-rx3,... rx1-rxn, \n",
       ">        rx2-rx3,..., rx(n-1) - rxn\n",
       ">\n",
       ">__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
       ">- *set by class instantiation*\n",
       ">- Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
       ">\n",
       ">__poissonarray__ : list,[maxSpreadT, PoissonInvLambda, Poissoninvlambda, PoissonGamma, Poissongamma] \n",
       ">- *set by class instantiation*\n",
       ">- List of time-related propagation parameters in integers\n",
       ">    (nanosecond units)\n",
       ">\n",
       ">__seed__ : integer, default=None\n",
       ">- set for reprodducible results\n",
       "\n",
       "__Returns__\n",
       "\n",
       ">Self, sets self.rxx_delay\n",
       ">- Format is [num_runs] x [abs (num_rx)/diff delay measurements \n",
       ">(num_rx choose 2)] - units of nanoseconds\n",
       "\n",
       "__Notes__\n",
       "\n",
       "[^4]: A. A. M. Saleh and R. Valenzuela, \"A Statistical Model for\n",
       "    Indoor Multipath Propagation,\" in IEEE Journal on Selected \n",
       "    Areas in Communications, vol. 5, no. 2, pp. 128-137, February\n",
       "    1987, doi: 10.1109/JSAC.1987.1146527."
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(RFchannel.calculate_Rxxdelay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### calculate_Rxxdelay Examples\n",
    "\n",
    "The following shows 10 examples of time delay measurements of signal recieved at 2ea receivers (Rx) as transmited by 1ea (Tx) within a 20x60m area.  Emperically derived paramters, by Saleh, that describe the multipath distribution are provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    Observation #:   0   1   2   3   4   5   6   7   8   9\n",
      "Ideal TDOA's (ns): -77 -26 -14  25  88 -11  -6  55 -74  12\n",
      "Noisy TDOA's (ns): -70 -26 -31  16  88  31   5  46 -74   7\n"
     ]
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=2, n_runs=10, rxtx_flag=2)\n",
    "\n",
    "#calculate delays (TDOA)\n",
    "RFchannel_scenario1.calculate_Rxxdelay(ch_delay_flag=False)\n",
    "rxx_delay_no_noise_TDOA = RFchannel_scenario1.rxx_delay\n",
    "\n",
    "RFchannel_scenario1.calculate_Rxxdelay(ch_delay_flag=True)\n",
    "rxx_delay_noise_TDOA = RFchannel_scenario1.rxx_delay\n",
    "\n",
    "#pair of sensors returns 1ea differential value for each observation/run\n",
    "print(\"    Observation #:\",*('%3d'%x for x in range(RFchannel_scenario1.n_runs) ))\n",
    "print(\"Ideal TDOA's (ns):\",*('%3.0f'%x for x in rxx_delay_no_noise_TDOA))\n",
    "print(\"Noisy TDOA's (ns):\",*('%3.0f'%x for x in rxx_delay_noise_TDOA))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "The following example generates a set of observations and confirms distribution of measurement error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()  \n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=2, n_runs=10000, rxtx_flag=0) #fixed Tx\n",
    "\n",
    "#calculate delays (TDOA)\n",
    "rxx_delay_no_noise_TDOA = (RFchannel_scenario1.calculate_Rxxdelay(ch_delay_flag=False)).rxx_delay\n",
    "rxx_delay_noise_TDOA = (RFchannel_scenario1.calculate_Rxxdelay(ch_delay_flag=True)).rxx_delay\n",
    "\n",
    "#get difference (for error distribution)\n",
    "diff = rxx_delay_no_noise_TDOA-rxx_delay_noise_TDOA\n",
    "\n",
    "#plot histogram\n",
    "_ = plt.hist(diff, bins='auto',density=True, label='histogram of samples')  # arguments are passed to np.histogram\n",
    "\n",
    "#pdf\n",
    "from scipy.stats import laplace\n",
    "x=np.linspace(-40,40,100)\n",
    "#scale and locate pdf\n",
    "rv = laplace(loc=0,scale=RFchannel_scenario1.Poissoninvlambda)\n",
    "#plot pdf\n",
    "plt.plot(x, rv.pdf(x), 'r-', lw=2, label='pdf function')\n",
    "plt.title(\"TDoA Distribution\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"RFchannel.calculate_RxxRssi\" class=\"doc_header\"><code>RFchannel.calculate_RxxRssi</code><a href=\"__main__.py#L308\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>RFchannel.calculate_RxxRssi</code>(**`ch_gain_flag`**=*`1`*, **`drss_flag`**=*`0`*, **`seed`**=*`None`*)\n",
       "\n",
       "Calculates absolute or relative received power at each sensor\n",
       "(or pair of sensors) based on given Rx and Tx locations. Assumes\n",
       "structure of first column is Tx, rest of columns are Rx. Third \n",
       "dimension is multiple runs of data (see \n",
       "`generate_RxTxlocations`).  Returns absolute received signal \n",
       "strength (RSS) or relative power (RSSI).\n",
       "\n",
       "Received power is a log-normal Gaussian/Normal RV around a \n",
       "distance dependent mean ([^5]).\n",
       "\n",
       "__Parameters__\n",
       "\n",
       ">__ch_gain_flag__ : integer/boolean, default =1\n",
       ">- Whether to add shadowing based on LogNormalArray parameters\n",
       ">    - 0 - ideal free space loss\n",
       ">    - 1 - (default) - shadowing path loss\n",
       ">\n",
       ">__drss_flag__ : integer/boolean, default=0\n",
       ">- Type of measurement to return,\n",
       ">    - 0 - (default) return RSS\n",
       ">    - 1 - rtn differential RSS (n choose 2) between pairs of \n",
       ">    sensors of format (rx1-rx2, rx1-rx3,... rx1-rxn, \n",
       ">    rx2-rx3,..., rx(n-1) - rxn\n",
       ">\n",
       ">__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
       ">- *set by class instantiation*\n",
       ">-Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
       ">\n",
       ">__LogNormalArray__ : list, \n",
       ">- *set by class instantiation*\n",
       ">- List of RF channel parameters in relevant units:\n",
       ">    [PathLossN, Xsigma, Wavelength] where PathLossN is path loss\n",
       ">    exponent (ideal is 2) in dB, Xsigma is Std deviation of\n",
       ">    received power in dB (log-normal Gaussian RV), Wavelength \n",
       ">    is of RF signal emanating from Tx source in Hz\n",
       ">\n",
       ">__seed__ : integer, default=None\n",
       ">- set for reprodducible results\n",
       "\n",
       "__Returns__\n",
       "\n",
       ">Self, sets self.rxx_rssi\n",
       ">- Format is [num_runs] x [abs (num_rx)/diff delay measurements \n",
       ">    (num_rx choose 2)] - units of dB\n",
       "\n",
       "__Notes__\n",
       "\n",
       "[^5]: Theodore S. Rappaport's Wireless Communications: Principles\n",
       "    and Practice by IEEE Press, Inc. Prentic Hall ISBN: \n",
       "    0-7803-1167-1. Chapters 3 and 4"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(RFchannel.calculate_RxxRssi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### calculate_RxxRssi Examples\n",
    "\n",
    "The following shows 10 examples of received signal strength measurements by 2ea receivers (Rx) of a signal transmited by 1ea (Tx) within a 20x60m area.  Emperically derived parameters, by Rappaport, that describe typical path loss distribution are provided."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             Observation #:   0   1   2   3   4   5   6   7   8   9\n",
      "Sensor1 - Ideal RSS's (dB):  52  45  44  38  39  44  25  44  41  47\n",
      "Sensor2 - Noisy RSS's (dB):  68  57  55  54  46  59  17  54  46  57\n"
     ]
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=2, n_runs=10, rxtx_flag=2)\n",
    "\n",
    "#calculate received power (RSS)\n",
    "RFchannel_scenario1.calculate_RxxRssi(ch_gain_flag=False)\n",
    "rx_rssi_no_shadowing_RSS = RFchannel_scenario1.rxx_rssi\n",
    "RFchannel_scenario1.calculate_RxxRssi(ch_gain_flag=True)\n",
    "rx_rssi_shadowing_RSS = RFchannel_scenario1.rxx_rssi\n",
    "\n",
    "#pair of sensors over 10 observations, pick sensor one to display\n",
    "print(\"             Observation #:\",*('%3d'%x for x in range(RFchannel_scenario1.n_runs) ))\n",
    "print(\"Sensor1 - Ideal RSS's (dB):\",*('%3.0f'%x for x in rx_rssi_no_shadowing_RSS[:,0]))\n",
    "print(\"Sensor2 - Noisy RSS's (dB):\",*('%3.0f'%x for x in rx_rssi_shadowing_RSS[:,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "The following example generates a large number of samples and then inspects histogram of errors against expected log-normal Gaussian distribution (for here - normal distribution with units in dB).  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=1, n_runs=10000, rxtx_flag=0)\n",
    "\n",
    "#calculate received power (RSS)\n",
    "rx_rssi_no_shadowing_RSS = (RFchannel_scenario1.calculate_RxxRssi(ch_gain_flag=False)).rxx_rssi\n",
    "rx_rssi_shadowing_RSS = (RFchannel_scenario1.calculate_RxxRssi(ch_gain_flag=True)).rxx_rssi\n",
    "\n",
    "#get difference (for error distribution)\n",
    "diff = rx_rssi_no_shadowing_RSS-rx_rssi_shadowing_RSS\n",
    "\n",
    "#plot histogram\n",
    "fig = plt.figure()\n",
    "_ = plt.hist(diff, bins='auto',density=True, label='histogram of samples')  # arguments are passed to np.histogram\n",
    "\n",
    "#pdf\n",
    "from scipy.stats import norm\n",
    "x=np.linspace(-40,10,100)\n",
    "\n",
    "#scale and locate pdf - fix offset due to reference value in path loss and distance\n",
    "avg_dist = np.mean(np.linalg.norm(locs[:,1,:]-locs[:,0,1][:,np.newaxis],axis=0)) #get average distance\n",
    "offset=-10*(RFchannel_scenario1.PathLossN-2)*np.log10(avg_dist) #calc avg offset based on distance PLE diff\n",
    "rv = norm(loc=offset,scale=RFchannel_scenario1.Xsigma)\n",
    "\n",
    "#plot pdf\n",
    "plt.plot(x, rv.pdf(x), 'r-', lw=2, label='pdf function')\n",
    "plt.title(\"RSS Distribution\")\n",
    "plt.legend()\n",
    "txt = \"PDF may be shift from histogram if random point -- here ({:.1f}, {:.1f}) -- chosen is sufficiently far from a median point -- biases the average distance\".format(locs[:,0,1][0],locs[:,0,1][1])\n",
    "fig.text(.5, .01, txt, wrap=True, ha='center')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"RFchannel.calculate_AoA\" class=\"doc_header\"><code>RFchannel.calculate_AoA</code><a href=\"__main__.py#L405\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>RFchannel.calculate_AoA</code>(**`ch_angle_flag`**=*`1`*, **`daoa_flag`**=*`0`*, **`seed`**=*`None`*)\n",
       "\n",
       "Calculates AoA based on given Rx and Tx locations. Assumes\n",
       "structure of first column is Tx, rest of columns are Rx. Third\n",
       "dimension is multiple runs of data.  For noisy case, ([^7]) \n",
       "assumes uniform distribution [0,2pi) of clusters, each cluster\n",
       "has Laplacian distribution around a specific AoA with width \n",
       "just under 30 degrees.  Assumption is specular component (or \n",
       "strongest) mean value is correct value.\n",
       "\n",
       "__Parameters__\n",
       "\n",
       ">__ch_angle_flag__ : Integer/boolean, default=1\n",
       ">- Flag whether to add multipath affect based on AoAsigma\n",
       ">    parameters.  \n",
       ">    - 0 - return ideal AoA (absolute or differential)\n",
       ">    - 1 (default) - return random offsets characterized by\n",
       ">    AoAsigma parameters  \n",
       ">    \n",
       ">__daoa_flag__ : integer/boolean, default=0\n",
       ">- Type of measurement to return,\n",
       ">    - 0 - (default) return AoA\n",
       ">    - 1 - rtn differential AoA (n choose 2) between pairs of\n",
       ">    sensors of format (rx1-rx2, rx1-rx3,... rx1-rxn, \n",
       ">    rx2-rx3,..., rx(n-1) - rxn\n",
       ">\n",
       ">__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
       ">- *set by class instantiation*\n",
       ">- Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
       ">\n",
       ">__AoAArray__ : list, self.AoAsigma\n",
       ">- *set by class instantiation*\n",
       ">- List of RF channel parameters in relevant units: [AoAsigma]\n",
       ">    which is Laplacian standard deviation of angle of arrival \n",
       ">    error in radians of RF signal emanating from Tx source \n",
       ">\n",
       ">__seed__ : integer, default=None\n",
       ">- set for reprodducible results\n",
       "\n",
       "__Returns__\n",
       "\n",
       ">Self, sets self.rxx_rssi\n",
       ">- Format is [num_runs] x [abs (num_rx)/diff angle measurements \n",
       ">    (num_rx choose 2)] - units of radians\n",
       "\n",
       "__Notes__\n",
       "\n",
       "[^7]: Q. H. Spencer, B. D. Jeffs, M. A. Jensen and A. L. \n",
       "    Swindlehurst, \"Modeling the statistical time and angle of \n",
       "    arrival characteristics of an indoor multipath channel,\" in\n",
       "    IEEE Journal on Selected Areas in Communications, vol. 18, no. \n",
       "    3, pp. 347-360, March 2000, doi: 10.1109/49.840194.   "
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(RFchannel.calculate_AoA)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### calculate_AoA Examples\n",
    "\n",
    "The following example shows 10 examples of angle of arrival measurements by 2ea receivers (Rx) of a signal transmited by 1ea (Tx) within a 20x60m area.  Emperically derived paramters, by Spencer, that describe typical angle of arrival distribution are provided.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            Observation #:     0     1     2     3     4     5     6     7     8     9\n",
      "Sensor1 - Ideal AoA (rad): +1.90 +2.12 +3.00 -0.87 -1.44 -1.05 -2.21 +1.13 -1.36 +1.53\n",
      "Sensor2 - Noisy AoA (rad): +3.20 +2.33 +2.83 -1.17 -1.50 -0.90 -1.74 +1.39 -1.95 +1.06\n"
     ]
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=2, n_runs=10, rxtx_flag=2)\n",
    "\n",
    "#calculate angle of arrival (AoA)\n",
    "RFchannel_scenario1.calculate_AoA(ch_angle_flag=False)\n",
    "rx_ideal_aoa = RFchannel_scenario1.rxx_aoa\n",
    "\n",
    "RFchannel_scenario1.calculate_AoA(ch_angle_flag=True)\n",
    "rx_noisy_aoa = RFchannel_scenario1.rxx_aoa\n",
    "\n",
    "#pair of sensors over 10 observations, pick sensor one to display\n",
    "print(\"            Observation #:\",*('%5d'%x for x in range(RFchannel_scenario1.n_runs) ))\n",
    "print(\"Sensor1 - Ideal AoA (rad):\",*('%+2.2f'%x for x in rx_ideal_aoa[:,0]))\n",
    "print(\"Sensor2 - Noisy AoA (rad):\",*('%+2.2f'%x for x in rx_noisy_aoa[:,0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "The following example generates a large number of samples and then inspects histogram of errors against expected Laplacian distribution.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=1, n_runs=10000, rxtx_flag=0) #fixed Tx\n",
    "\n",
    "#calculate angle of arrival (AoA)\n",
    "rx_ideal_aoa = (RFchannel_scenario1.calculate_AoA(ch_angle_flag=False)).rxx_aoa\n",
    "rx_noisy_aoa = (RFchannel_scenario1.calculate_AoA(ch_angle_flag=True)).rxx_aoa\n",
    "\n",
    "#get difference (for error distribution)\n",
    "diff = rx_ideal_aoa-rx_noisy_aoa\n",
    "\n",
    "#plot histogram\n",
    "_ = plt.hist(diff, bins='auto',density=True, label='histogram of samples')  # arguments are passed to np.histogram\n",
    "\n",
    "#pdf\n",
    "from scipy.stats import laplace\n",
    "x=np.linspace(-4,4,100)\n",
    "#scale and locate pdf\n",
    "rv = laplace(loc=0,scale=RFchannel_scenario1.AoAsigma)\n",
    "#plot pdf\n",
    "plt.plot(x, rv.pdf(x), 'r-', lw=2, label='pdf function')\n",
    "plt.title(\"AoA Distribution\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "<h4 id=\"RFchannel.generate_Xmodel\" class=\"doc_header\"><code>RFchannel.generate_Xmodel</code><a href=\"__main__.py#L492\" class=\"source_link\" style=\"float:right\">[source]</a></h4>\n",
       "\n",
       "> <code>RFchannel.generate_Xmodel</code>(**`ch_delay_flag`**=*`1`*, **`ch_gain_flag`**=*`1`*, **`ch_angle_flag`**=*`1`*, **`meas_flag`**=*`6`*, **`diff_array`**=*`[1, 0, 0]`*, **`seed`**=*`None`*)\n",
       "\n",
       "Generates a set of measurements based on passed parameters \n",
       "that can be used for a dictionary or training/testing of \n",
       "different optimization algorithms.\n",
       "\n",
       "___Parameters___\n",
       "\n",
       ">__rxtx_locations__ : ndarray, self.rxtx_locs_  \n",
       ">- *set by class instantiation*\n",
       ">- Format of [location dims] x [num_rx + 1] x [num_runs] array\n",
       ">\n",
       ">__poissonarray__ : list, default=[maxSpreadT, PoissonInvLambda, Poissoninvlambda, PoissonGamma, Poissongamma] \n",
       ">- *set by class instantiation*\n",
       ">- List of time-related propagation parameters in integers\n",
       ">    (nanosecond units)\n",
       ">\n",
       ">__ch_delay_flag__ : Integer/boolean, default=1\n",
       ">- Channel flag whether to add multipath (random) based on \n",
       ">    PoissonArray parameters.\n",
       ">    - 0 - return ideal delays (absolute\n",
       ">    - or differential) 1 (default) - return random offsets \n",
       ">    characterized by poissonarray parameters\n",
       ">\n",
       ">__LogNormalArray__ : list, default=[PathLossN, Xsigma, Wavelength]\n",
       ">- *set by class instantiation*\n",
       ">- List of RF channel parameters in relevant units:\n",
       ">     where PathLossN is path loss\n",
       ">    exponent (ideal is 2) in dB, Xsigma is Std deviation of\n",
       ">    received power in dB (log-normal Gaussian RV), Wavelength \n",
       ">    is of RF signal emanating from Tx source in Hz\n",
       ">\n",
       ">__ch_gain_flag__ : integer/boolean, default =1\n",
       ">- Whether to add shadowing based on LogNormalArray parameters\n",
       ">    - 0 - ideal free space loss\n",
       ">    - 1 - (default) - shadowing path loss\n",
       "> \n",
       ">__AoAArray__ : list, self.AoAsigma\n",
       ">- *set by class instantiation*\n",
       ">- List of RF channel parameters in relevant units: [AoAsigma]\n",
       ">    which is Laplacian standard deviation of angle of arrival \n",
       ">    error in radians of RF signal emanating from Tx source\n",
       ">    \n",
       ">__ch_angle_flag__ : Integer/boolean, default=1\n",
       ">- Flag whether to add multipath affect based on AoAsigma\n",
       ">    parameters.  \n",
       ">    - 0 - return ideal AoA (absolute or differential)\n",
       ">    - 1 (default) - return random offsets characterized by\n",
       ">    AoAsigma parameters  \n",
       ">\n",
       ">__meas_flag__ : Integer, default=6\n",
       ">    - Determines which measurement types are generated for\n",
       ">    a given channel.  Options are: \n",
       ">        - 0-tdoa, \n",
       ">        - 1-drss, \n",
       ">        - 2-aoa,\n",
       ">        - 3-tdoa/drss, \n",
       ">        - 4-tdoa/aoa, \n",
       ">        - 5-drss/aoa, \n",
       ">        - 6-tdoa/drss/aoa\n",
       ">            \n",
       ">__diff_array__ : Boolean list, default = [1,0,0] \n",
       ">- List sets whether measurement types are differential or \n",
       ">    absolute measurements for TDOA, RSS, and AoA, e.g.,\n",
       ">    - [1,0,0] - TDOA, RSS, and AoA\n",
       ">    - [1,1,0] - TDOA, DRSS, and AoA\n",
       ">    - [1,1,1] - TDOA, DRSS, and DAoA\n",
       ">    - [tdoa_flag, drss_flag, daoa_flag]\n",
       ">\n",
       ">__seed__ : integer, default=None\n",
       ">- set for reprodducible results        \n",
       "\n",
       "___Returns___\n",
       "\n",
       ">Self, sets self.X_model\n",
       ">- Format is [n_runs]x[measurements] (sized set by meas_flag,\n",
       ">    diff_array parameters) "
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_doc(RFchannel.generate_Xmodel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "#### generate_Xmodel Example\n",
    "\n",
    "The following illustrates using a single method to generate a set of measurements, i.e., dictionary, using any combination of the covered TDoA, RSS, and AoA methods.  Note that parameters to generate_Xmodel are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "        TDoA0:1 TDoA0:2 TDoA1:2    RSS0    RSS1    RSS2    AoA0    AoA1    AoA2\n",
      "obs 0:  +117.77  +85.69  -32.08  +59.77  +19.01  +46.02   +1.53   +2.96   +1.43\n",
      "obs 1:   -66.41 -165.88  -99.47  +37.58  +65.72  +67.42   +0.66   +1.68   +1.43\n",
      "obs 2:   +87.25  +78.33   -8.91  +66.54  +60.11  +62.02   +1.77   +1.79   +1.70\n",
      "obs 3:   +42.91  -38.26  -81.17  +54.16  +32.58  +70.58   +1.38   -1.66   +1.69\n",
      "obs 4:   +76.21  -17.05  -93.26  +74.65  +48.64  +85.26   +1.34   +3.99   +1.49\n",
      "obs 5:  -130.17 -147.57  -17.40  +28.57  +58.01  +66.60   +0.69   +0.90   +1.65\n",
      "obs 6:   +26.83  +39.46  +12.63  +65.20  +64.41  +54.35   +0.92   +2.06   +1.83\n",
      "obs 7:    -7.41  +80.33  +87.74  +86.03  +70.87  +61.53   +2.15   +1.74   +2.33\n",
      "obs 8:   +73.13 +133.10  +59.98  +65.34  +55.59  +48.81   +1.38   +2.80   +0.56\n",
      "obs 9:   -60.54  +24.63  +85.17  +54.46  +68.63  +62.59   +1.88   +1.48   +1.84\n"
     ]
    }
   ],
   "source": [
    "#generate channel scenario\n",
    "RFchannel_scenario1 = RFchannel()\n",
    "#from channel, generate locations for Tx and Rx\n",
    "RFchannel_scenario1.generate_RxTxlocations(n_rx=3, n_runs=10, rxtx_flag=0)\n",
    "\n",
    "#create set of measurements\n",
    "RFchannel_scenario1.generate_Xmodel(ch_delay_flag=1, ch_gain_flag=1, ch_angle_flag=1, \n",
    "                        meas_flag=6, diff_array= [1,0,0])\n",
    "\n",
    "#pull out full set of measurements from instance\n",
    "X = RFchannel_scenario1.X_model\n",
    "\n",
    "num_rx=RFchannel_scenario1.n_rx\n",
    "#3ea sensors over 10 observations, generate TDOA, RSS, and AoA\n",
    "print(\"       \",*('TDoA%d:%d'%x for x in combinations(range(num_rx),2) ),*('   RSS%d'%x for x in range(num_rx)),*('   AoA%d'%x for x in range(num_rx)))\n",
    "for i in range(RFchannel_scenario1.n_runs):    \n",
    "    print(\"obs {:d}: \".format(i),*('{0:+7.2f}'.format(x) for x in X[i]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}