示例#1
0
    def replay(self, fig=[], ax=[], **kwargs):
        """ replay a trajectory

        Parameters
        ----------

        fig
        ax

        speed : float
            speed ratio

        """

        # plt.ion()
        if fig == []:
            fig = plt.gcf()
        if ax == []:
            ax = plt.gca()

        limkwargs = copy.copy(kwargs)
        if "c" in kwargs:
            limkwargs.pop("c")
        if "color" in kwargs:
            limkwargs.pop("c")
        limkwargs["marker"] = "*"
        limkwargs["s"] = 20

        if ("m" or "marker") not in kwargs:
            kwargs["marker"] = "o"
        if ("c" or "color") not in kwargs:
            kwargs["color"] = "b"

        L = Layout(self.Lfilename)
        fig, ax = L.showG("s", fig=fig, ax=ax, **kwargs)

        time = self[0].time()

        line, = ax.plot([], [], "ob", lw=2)
        time_template = "time = %.1fs"
        time_text = ax.text(0.05, 0.9, "", transform=ax.transAxes)

        def init():
            line.set_data([], [])
            time_text.set_text("")
            return line, time_text

        def animate(it):
            X = []
            Y = []
            for t in self:
                if t.typ == "ag":
                    X.append(t["x"].values[it])
                    Y.append(t["y"].values[it])
            line.set_data(X, Y)
            time_text.set_text(time_template % (time[it]))
            return line, time_text

        ani = animation.FuncAnimation(fig, animate, np.arange(1, len(time)), interval=25, blit=True, init_func=init)
        plt.show()
示例#2
0
    def create_layout(self):
        """
        Create Layout in Simpy the_world thanks to Tk backend

        """

        self.the_world = world(width = float(self.lay_opt['the_world_width']), 
                               height = float(self.lay_opt['the_world_height']),
                               scale=float(self.lay_opt['the_world_scale']))

        # tk = self.the_world.tk
        # canvas, x_, y_ = tk.canvas, tk.x_, tk.y_
        # canvas.create_rectangle(x_(-1), y_(-1), x_(100), y_(100), fill='white')

        _filename = self.lay_opt['filename']
        #sl=Slab.SlabDB(self.lay_opt['slab'],self.lay_opt['slabmat'])
        #G1   = Graph.Graph(sl=sl,filename=_filename)
        self.L = Layout(_filename)
        #if _filename.split('.')[1] == 'str':
        #    self.L.loadstr(_filename)
        #elif _filename.split('.')[1] == 'str2':
        #    self.L.loadstr2(_filename)
        #elif _filename.split('.')[1] == 'ini':
        #    self.L.loadini(_filename)


        try:
            self.L.dumpr()
            print 'Layout graphs are loaded from ',basename,'/struc/ini'
        except:
        #self.L.sl = sl
        #self.L.loadGr(G1)
            print 'This is the first time the layout file is used\
            Layout graphs are curently being built, it may take few minutes.'
            self.L.build()     
            self.L.dumpw()
        x_offset = 0  # float(self.lay_opt['x_offset'])
        y_offset = 0  # float(self.lay_opt['y_offset'])
        for ks in self.L.Gs.pos.keys():
            self.L.Gs.pos[ks] = (self.L.Gs.pos[ks][0] +
                                 x_offset, self.L.Gs.pos[ks][1] + y_offset)
        for ks in self.L.Gr.pos.keys():
            self.L.Gr.pos[ks] = (self.L.Gr.pos[ks][0] +
                                 x_offset, self.L.Gr.pos[ks][1] + y_offset)
        for ks in self.L.Gw.pos.keys():
            self.L.Gw.pos[ks] = (self.L.Gw.pos[ks][0] +
                                 x_offset, self.L.Gw.pos[ks][1] + y_offset)

        #
        # Create Layout
        #
        walls = self.L.thwall(0, 0)
        for wall in walls:
            points = []
            # for point in wall:
            #          points.append(x_(point[0]))
            #          points.append(y_(point[1]))
            #      canvas.create_polygon(points, fill='maroon', outline='black')
            for ii in range(0, len(wall) - 1):
                self.the_world.add_wall(wall[ii], wall[ii + 1])
示例#3
0
    def create_layout(self):
        """ create Layout in Simpy the_world thanks to Tk backend

        """

        _filename = self.lay_opt['filename']

        self.L = Layout(_filename)

        self.the_world = world()

        try:
            self.L.dumpr()
            print 'Layout graphs are loaded from ',basename,'/struc/ini'
        except:
        #self.L.sl = sl
        #self.L.loadGr(G1)
            print 'This is the first time the layout file is used\
            Layout graphs are curently being built, it may take few minutes.'
            self.L.build()     
            self.L.dumpw()

        #
        # Create Layout
        #
        walls = self.L.thwall(0, 0)
        for wall in walls:
            for ii in range(0, len(wall) - 1):
                self.the_world.add_wall(wall[ii], wall[ii + 1])
示例#4
0
    def __init__(self,_fileini='coverage.ini'):


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))
        self.plm = dict(self.config.items('pl_model'))
        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.txopt = dict(self.config.items('tx'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        self.L = Layout(self.layoutopt['filename'])
        self.model = PLSmodel(f=eval(self.plm['fghz']),
                         rssnp=eval(self.plm['rssnp']),
                         d0=eval(self.plm['d0']),
                         sigrss=eval(self.plm['sigrss']))

        self.nx = eval(self.gridopt['nx'])
        self.ny = eval(self.gridopt['ny'])
        self.mode = eval(self.gridopt['full'])
        self.boundary = eval(self.gridopt['boundary'])
        # transitter section
        self.fGHz = eval(self.txopt['fghz'])
        self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        self.ptdbm = eval(self.txopt['ptdbm'])
        self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        self.rxsens = eval(self.rxopt['sensitivity'])
        kBoltzmann = 1.3806503e-23
        self.bandwidthmhz = eval(self.rxopt['bandwidthmhz'])
        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        
        Pn = (10**(self.noisefactordb/10.)+1)*kBoltzmann*self.temperaturek*self.bandwidthmhz*1e3
        self.pndbm = 10*np.log10(Pn)+60

        self.show = str2bool(self.showopt['show'])

        try:
            self.L.Gt.nodes()
        except:
            pass
        try:
            self.L.dumpr('t')
        except:
            self.L.buildGt()
            self.L.dumpw('t')

        self.creategrid(full=self.mode,boundary=self.boundary)
示例#5
0
    def load_simul(self, source):
        """  load a simultraj configuration file

        Parameters
        ----------

        source : string
            name of simulation file to be loaded

        """
        self.filetraj = source
        if not os.path.isfile(source):
            raise AttributeError('Trajectory file'+source+'has not been found.\
             Please make sure you have run a simulnet simulation before runining simultraj.')

        # get the trajectory
        traj = tr.Trajectories()
        traj.loadh5(self.filetraj)

        # get the layout
        self.L = Layout(traj.Lfilename)

        # resample trajectory
        for ut, t in enumerate(traj):
            if t.typ == 'ag':
                person = Body(t.name + '.ini')
                tt = t.time()
                self.dpersons.update({t.name: person})
                self._tmin = tt[0]
                self._tmax = tt[-1]
                self.time = tt
            else:
                pos = np.array([t.x[0], t.y[0], t.z[0]])
                self.dap.update({t.ID: {'pos': pos,
                                        'ant': antenna.Antenna(),
                                        'name': t.name
                                        }
                                 })
        self.ctime = np.nan
        self.Nag = len(self.dpersons.keys())
        self.Nap = len(self.dap.keys())
        self.traj = traj
示例#6
0
    def load_simul(self, source):
        """  load a simultraj configuration file

        Parameters
        ----------

        source : string
            name of simulation file to be loaded

        """
        self.filetraj = source


        # get the trajectory
        traj = tr.Trajectories()
        traj.loadh5(self.filetraj)

        # get the layout
        self.L = Layout(traj.Lfilename)

        # resample trajectory
        for ut, t in enumerate(traj):
            
            if t.typ == 'ag':
                person = Body(t.name + '.ini')
                tt = t.time()
                self.dpersons.update({t.name: person})
                self._tmin = tt[0]
                self._tmax = tt[-1]
                self.time = tt
            else:
                pos = np.array([t.x[0], t.y[0], t.z[0]])
                self.dap.update({t.ID: {'pos': pos,
                                        'ant': antenna.Antenna(),
                                        'name': t.name
                                        }
                                 })
        self.ctime = np.nan
        self.Nag = len(self.dpersons.keys())
        self.Nap = len(self.dap.keys())
        self.traj = traj
示例#7
0
    def layout(self, _filestruc):
        """ load a layout in the simulation oject

        Parameters
        ----------

        _filestruc : string
            short file name of the Layout object

        Examples
        --------

        >>> from pylayers.simul.simulem import *
        >>> S = Simul()
        >>> S.layout('defstr.ini')

        """
        self.filestr = _filestruc

        self.L = Layout(_filestruc)
        # update config
        self.config.set("files", "struc", self.filestr)
        self.save()
示例#8
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt
import doctest

plt.ion()
#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout('WHERE1.ini')
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.build()
L.dumpr()
L.showG('i', en=11)
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#9
0
    def __init__(self, **args):
        """ Mobile Agent Init

           Parameters
           ----------

           'ID': string
                agent ID
           'name': string
                Agent name
           'typ': string
                agent typ . 'ag' for moving agent, 'ap' for static acces point
           'pos' : np.array([])
                numpy array containing the initial position of the agent
           'roomId': int
                Room number where the agent is initialized (Layout.Gr)
           'meca_updt': float
                update time interval for the mechanical process
           'loc': bool
                enable/disable localization process of the agent
           'loc_updt': float
                update time interval for localization process
           'L': pylayers.gis.Layout()
           'net':pylayers.network.Network(),
           'wstd': list of string
                list of used radio access techology of the agent
           'world': transit.world()
                Soon deprecated
           'save': list of string
                list of save method ( soon deprecated)
           'sim':Simpy.SimulationRT.Simulation(),
           'epwr': dictionnary
                dictionnary of emmited power of transsmitter{'wstd#':epwr value}
           'sens': dictionnary
                dictionnary of sensitivity of reveicer {'wstd#':sens value}
           'dcond': dictionnary
                Not used yet
           'gcom':pylayers.communication.Gcom()
                Communication graph
           'comm_mod': string
                Communication between nodes mode:
                'autonomous': all TOAs are refreshed regulary
                'synchro' : only visilbe TOAs are refreshed
        """
        defaults = {'ID': '0',
                    'name': 'johndoe',
                    'typ': 'ag',
                    'color': 'k',
                    'pdshow': False,
                    'pos': np.array([]),
                    'roomId': -1,
                    'froom': [],
                    'wait': [],
                    'seed': 0,
                    'cdest': 'random',
                    'meca_updt': 0.1,
                    'loc': False,
                    'loc_updt': 0.5,
                    'loc_method': ['geo'],
                    'L': Layout(),
                    'network': True,
                    'net': Network(),
                    'wstd': ['rat1'],
                    'world': world(),
                    'save': [],
                    'sim': Simulation(),
                    'epwr': {},
                    'sens': {},
                    'dcond': {},
                    'gcom': Gcom(),
                    'comm_mode': 'autonomous'}

        for key, value in defaults.items():
            if key not in args:
                args[key] = value

        self.args = args
        self.ID = args['ID']
        self.name = args['name']
        self.typ = args['typ']
        # Create Network
        self.net = args['net']
        self.epwr = args['epwr']
        self.gcom = args['gcom']
        self.sim = args['sim']
        self.wstd = args['wstd']
        if args['epwr'] == {}:
            self.epwr = {x: 0 for x in self.wstd}
        else:
            self.epwr = args['epwr']

        if args['sens'] == {}:
            self.sens = {x: -180 for x in self.wstd}
        else:
            self.sens = args['sens']

        try:
            self.dcond = args['dcond']
        except:
            pass

        # check if node id already given
        if self.ID in self.net.nodes():
            raise NameError(
                'another agent has the ID: ' + self.ID + ' .Please use an other ID')

        if self.typ == 'ag':
            # mechanical init
            self.meca = Person(ID=self.ID,
                               color=args['color'],
                               pdshow=args['pdshow'],
                               roomId=args['roomId'],
                               L=args['L'],
                               net=self.net,
                               interval=args['meca_updt'],
                               wld=args['world'],
                               sim=args['sim'],
                               seed=args['seed'],
                               moving=True,
                               froom=args['froom'],
                               wait=args['wait'],
                               cdest=args['cdest'],
                               save=args['save']
                               )
            self.meca.behaviors = [Seek(), Containment(),
                                   Separation(), InterpenetrationConstraint()]
            self.meca.steering_mind = queue_steering_mind
            # Network init
            self.node = Node(ID=self.ID,name=self.name, p=conv_vecarr(self.meca.position),
                             t=self.sim.now(), wstd=args['wstd'],
                             epwr=self.epwr, sens=self.sens, typ=self.typ)
            self.net.add_nodes_from(self.node.nodes(data=True))

            self.sim.activate(self.meca, self.meca.move(), 0.0)
            self.PN = self.net.node[self.ID]['PN']

            # Communication init

            if args['comm_mode'] == 'synchro' and args['network']:
                # The TOA requests are made every refreshTOA time ( can be modified in agent.ini)
                # This Mode will be deprecated in future version

                self.rxr = RX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)

                self.rxt = RX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)

                self.sim.activate(self.rxr, self.rxr.refresh_RSS(), 0.0)
                self.sim.activate(self.rxt, self.rxt.refresh_TOA(), 0.0)

            elif args['comm_mode'] == 'autonomous' and args['network']:
                # The requests are made by node only when they are in
                # visibility of pairs.

                # self.rxr only manage a refresh RSS process
                self.rxr = RX(net=self.net, ID=self.ID,
                              gcom=self.gcom, sim=self.sim)
                # self.tx manage all requests to other nodes
                self.tx = TX(net=self.net, ID=self.ID,
                             gcom=self.gcom, sim=self.sim)
                # self.tx replies to  requests from self.tx
                self.rx = RX(net=self.net, ID=self.ID,
                             gcom=self.gcom, sim=self.sim)

                self.sim.activate(self.rxr, self.rxr.refresh_RSS(), 0.0)
                self.sim.activate(self.tx, self.tx.request(), 0.0)
                self.sim.activate(self.rx, self.rx.wait_request(), 0.0)

        elif self.typ == 'ap':
            if args['roomId'] == -1:
                self.node = Node(ID=self.ID, p=self.args['pos'],
                                 t=self.sim.now(), wstd=args['wstd'],
                                 epwr=self.epwr, sens=self.sens, typ=self.typ)
            else:
                pp = np.array(args['L'].Gr.pos[self.args['roomId']])
                self.node = Node(
                    ID=self.ID, p=pp, t=self.sim.now(), wstd=args['wstd'],
                    epwr=self.epwr, sens=self.sens, typ=self.typ)
            self.net.add_nodes_from(self.node.nodes(data=True))
            self.sim = args['sim']

            self.PN = self.net.node[self.ID]['PN']
            self.PN.node[self.ID]['pe'] = self.net.node[self.ID]['p']
            if args['comm_mode'] == 'autonomous' and args['network']:
                self.rx = RX(net=self.net, ID=self.ID,
                             gcom=self.gcom, sim=self.sim)
                self.sim.activate(self.rx, self.rx.wait_request(), 0.0)

            p = self.args['pos']
            self.posdf = pd.DataFrame(
                {'t': pd.Timestamp(0), 'x': p[0], 'y': p[1], 'z': p[2],
                                       'vx': np.array([0.0]), 'vy': np.array([0.0]),
                                       'ax': np.array([0.0]), 'ay': np.array([0.0]),
                 }, columns=['t', 'x', 'y', 'z', 'vx', 'vy', 'ax', 'ay'], index=np.array([0]))

        else:
            raise NameError(
                'wrong agent typ, it must be either agent (ag) or acces point (ap) ')

        if self.typ == 'ap':
            self.MoA = 1
        else:
            self.MoA = 0

        if 'mysql' in args['save']:
            config = ConfigParser.ConfigParser()
            config.read(pyu.getlong('simulnet.ini', 'ini'))
            sql_opt = dict(config.items('Mysql'))
            db = Database(sql_opt['host'], sql_opt['user'],
                          sql_opt['passwd'], sql_opt['dbname'])
            db.writenode(self.ID, self.name, self.MoA)

        if 'txt' in args['save']:
            pyu.writenode(self)
        if self.typ != 'ap' and args['loc']:

            self.loc = Localization(net=self.net, ID=self.ID,
                                    method=args['loc_method'])
            self.Ploc = PLocalization(loc=self.loc,
                                      loc_updt_time=args['loc_updt'],
                                      tx=self.tx,
                                      sim=args['sim'])

            self.sim.activate(self.Ploc, self.Ploc.run(), 1.5)
示例#10
0
    def replay(self, fig=[], ax=[], **kwargs):
        """ replay a trajectory

        Parameters
        ----------

        fig
        ax

        speed : float
            speed ratio

        """

        # plt.ion()
        if fig==[]:
            fig = plt.gcf()
        if ax == []:
            ax = plt.gca()

        limkwargs = copy.copy(kwargs)
        if 'c' in kwargs:
            limkwargs.pop('c')
        if 'color'in kwargs:
            limkwargs.pop('c')
        limkwargs['marker'] = '*'
        limkwargs['s'] = 20

        if ('m' or 'marker') not in kwargs:
            kwargs['marker'] = 'o'
        if ('c' or 'color') not in kwargs:
            kwargs['color'] = 'b'

        L=Layout(self.Lfilename)
        fig, ax = L.showG('s',fig=fig, ax=ax, **kwargs)

        time=self[0].time()


        line, = ax.plot([], [], 'ob', lw=2)
        time_template = 'time = %.1fs'
        time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)

        def init():
            line.set_data([],[])
            time_text.set_text('')
            return line, time_text

        def animate(it):
            X=[]
            Y=[]
            for t in self:
                if t.typ == 'ag':
                    X.append(t['x'].values[it])
                    Y.append(t['y'].values[it])
            line.set_data(X,Y)
            time_text.set_text(time_template%(time[it]))
            return line, time_text

        ani = animation.FuncAnimation(fig, animate, np.arange(1, len(time)),
            interval=25, blit=True, init_func=init)
        plt.show()
示例#11
0
    def replay(self, fig=[], ax=[], **kwargs):
        """ replay a trajectory

        Parameters
        ----------

        fig
        ax

        speed : float
            speed ratio

        """

        # plt.ion()
        if fig == []:
            fig = plt.gcf()
        if ax == []:
            ax = plt.gca()

        limkwargs = copy.copy(kwargs)
        if 'c' in kwargs:
            limkwargs.pop('c')
        if 'color' in kwargs:
            limkwargs.pop('c')
        limkwargs['marker'] = '*'
        limkwargs['s'] = 20

        if ('m' or 'marker') not in kwargs:
            kwargs['marker'] = 'o'
        if ('c' or 'color') not in kwargs:
            kwargs['color'] = 'b'

        L = Layout(self.Lfilename)
        fig, ax = L.showG('s', fig=fig, ax=ax, **kwargs)

        time = self[0].time()

        line, = ax.plot([], [], 'ob', lw=2)
        time_template = 'time = %.1fs'
        time_text = ax.text(0.05, 0.9, '', transform=ax.transAxes)

        def init():
            line.set_data([], [])
            time_text.set_text('')
            return line, time_text

        def animate(it):
            X = []
            Y = []
            for t in self:
                if t.typ == 'ag':
                    X.append(t['x'].values[it])
                    Y.append(t['y'].values[it])
            line.set_data(X, Y)
            time_text.set_text(time_template % (time[it]))
            return line, time_text

        ani = animation.FuncAnimation(fig,
                                      animate,
                                      np.arange(1, len(time)),
                                      interval=25,
                                      blit=True,
                                      init_func=init)
        plt.show()
示例#12
0
from pylayers.gis.layout import Layout
import matplotlib.pyplot as plt
import doctest

#doctest.testmod(layout)

#L = Layout('TA-Office.ini')
L = Layout('DLR.ini')
try:
    L.dumpr()
except:
    L.build()
    L.dumpw()
#L.editor()
fig = plt.gcf()
#ax1  = fig.add_subplot(221)
ax1 = fig.add_subplot(321)
L.display['thin'] = True
fig, ax1 = L.showGs(fig=fig, ax=ax1)
#L.display['edlabel']=True
#L.display['edlblsize']=50
# display selected segments
L.display['thin'] = True
L.showG(fig=fig, ax=ax1, graph='t')
fig = plt.gcf()
ax1 = plt.gca()
fig, ax1 = L.showGs(fig=fig, ax=ax1, edlist=[125], width=4)
ax11 = fig.add_subplot(322)
L.showG(fig=fig, ax=ax11, graph='')
#plt.savefig('graphGs.png')
#build topological graph
示例#13
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt
import doctest

plt.ion()
#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout('WHERE1.ini')
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.build()
L.dumpr()
L.showG('i',en=11)
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#14
0
    def __init__(self, _fileini='coverage.ini'):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """

        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini, pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.apopt = dict(self.config.items('ap'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        # get the Layout
        filename = self.layoutopt['filename']
        if filename.endswith('lay'):
            self.typ = 'indoor'
            self.L = Layout(filename)

            # get the receiving grid
            self.nx = eval(self.gridopt['nx'])
            self.ny = eval(self.gridopt['ny'])
            self.mode = self.gridopt['mode']
            assert self.mode in ['file', 'full',
                                 'zone'], "Error reading grid mode "
            self.boundary = eval(self.gridopt['boundary'])
            self.filespa = self.gridopt['file']
            #
            # create grid
            #
            self.creategrid(mode=self.mode,
                            boundary=self.boundary,
                            _fileini=self.filespa)

            self.dap = {}
            for k in self.apopt:
                kwargs = eval(self.apopt[k])
                ap = std.AP(**kwargs)
                self.dap[eval(k)] = ap
            try:
                self.L.Gt.nodes()
            except:
                pass
            try:
                self.L.dumpr()
            except:
                self.L.build()
                self.L.dumpw()

        else:
            self.typ = 'outdoor'
            self.E = ez.Ezone(filename)
            self.E.loadh5()
            self.E.rebase()

        # The frequency is fixed from the AP nature
        self.fGHz = np.array([])
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        #self.rxsens = eval(self.rxopt['sensitivity'])

        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        # show section
        self.bshow = str2bool(self.showopt['show'])
示例#15
0
from pylayers.gis.layout import Layout
from pylayers.util.project import *
import pylayers.util.pyutil as pyu
import networkx as nx
import matplotlib.pyplot as plt
import warnings
import shutil

warnings.filterwarnings("error")

#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout()
lL = L.ls()
for tL in lL:
    print 'Layout :     ', tL
    print '--------------------------'
    L = Layout(tL, bbuild=0, bgraphs=0)
    if L.check():
        L.save()
        filein = pyu.getlong(L._filename, pstruc['DIRLAY'])
        fileout = '/home/uguen/Documents/rch/devel/pylayers/data/struc/lay/' + L._filename
        print fileout
        shutil.copy2(filein, fileout)
#figure(figsize=(20,10))
#plt.axis('off')
#f,a = L.showG('s',nodes=False,fig=f)
#plt.show()
#f,a = L.showG('r',edge_color='b',linewidth=4,fig=f)
#L= Layout('11Dbibli.ini')
#L.show()
示例#16
0
 def Lname(self,Lname):
     # change layout and build/load
     self._L = Layout(Lname)
     self._Lname = Lname
     self.reset_config()
示例#17
0
from pylayers.gis.layout import Layout
import matplotlib.pyplot as plt 
import doctest 

#doctest.testmod(layout)


L = Layout()
L.load('TA-Office.str')
#L.editor()
fig = plt.gcf()
#ax1  = fig.add_subplot(221)
ax1  = fig.add_subplot(111)
L.display['thin']=True
fig,ax1  = L.showGs(fig=fig,ax=ax1)
L.display['thin']=False
L.display['edlabel']=True
L.display['edlblsize']=50
fig,ax1 =  L.showGs(fig=fig,ax=ax1,edlist=[10,7,54],width=4)
plt.show()
#plt.savefig('graphGs.png')
# build topological graph 
#L.buildGt()
#ax2 = fig.add_subplot(222)
#L.showG(fig=fig,ax=ax2,graph='t')
#plt.title('Topological graph')
#plt.savefig('graphGt.png')
# build graph of rooms
#L.buildGr()
#ax3 = fig.add_subplot(223)
#L.showG(fig=fig,ax=ax3,graph='r')
示例#18
0
    def __init__(self, **kwargs):
        """ deterministic link evaluation

        Parameters
        ----------

        L : Layout
            Layout to be used
        a : np.ndarray (3,)
            position of a device dev_a
        b : np.ndarray (3,)
            position of a device dev_b
        Aa : Antenna
            Antenna of device dev_a
        Ab : Antenna
            Antenna of device dev_b
        Ta : np.ndarray (3,3)
            Rotation matrice of Antenna of device dev_a relative to global Layout scene
        Tb : np.ndarray (3,3)
            Rotation matrice of Antenna of device dev_b relative to global Layout scene
        fGHz : np.ndarray (Nf,)
            frequency range of Nf points used for evaluation of channel
        wav : Waveform
            Waveform to be applied on the channel
        save_idx : int
            number to identify the h5 file generated

        Advanced (change only if you really know what you do !)

        save_opt : list (['sig','ray','Ct','H'])
            information to be saved in the Links h5 file. Should never be Modified !

        force_create : Boolean (False)
            forcecreating the h5py file (if already exist, will be erased)


        Notes
        -----

        All simulations are stored into a unique file in your <PyProject>/output directory
        using the following convention:

        Links_<save_idx>_<LayoutFilename>.h5

        where
            <save_idx> is an integer number to distinguish different links simulations
        and <LayoutFilename> is the Layout used for the link simulation.



        Dataset organisation:

        Links_<idx>_<Layout_name>.h5
            |
            |/sig/si_ID#0/
            |    /si_ID#1/
            |    ...
            |
            |/ray/ray_ID#0/
            |    /ray_ID#1/
            |    ...
            |
            |/Ct/Ct_ID#0/
            |   /Ct_ID#1/
            |    ...
            |
            |/H/H_ID#0/
            |  /H_ID#1/
            |    ...
            |
            |
            |p_map
            |c_map
            |f_map
            |A_map
            |T_map



        Roots Dataset :

        c_map : Cycles (Nc x 3)
        p_map : Positions (Np x 3)
        f_map : Frequency (Nf x 3)
        T_map : Rotation matrices (Nt x 3)
        A_map : Antenna name (Na x 3)

        Groups and subgroups:


            Signature identifier (si_ID#N):
                ca_cb_cutoff

            Ray identifier (ray_ID#N):
                cutoff_ua_ub

            Ctilde identifier (Ct_ID#N):
                ua_ub_uf

            H identifier (H_ID#N):
                ua_ub_uf_uTa_uTb_uAa_uAb

            with
            ca : cycle number of a
            cb : cycle number of b
            cutoff : signature.run cutoff
            ua : indice of a position in 'p_map' position dataset
            ub : indice of a position in 'p_map' position dataset
            uf : indice of freq position in 'f_map' frequency dataset
            uTa : indice of a position in 'T_map' Rotation dataset
            uTb : indice of a position in 'T_map' Rotation dataset
            uAa : indice of a position in 'A_map' Antenna name dataset
            uAb : indice of b position in 'A_map' Antenna name dataset



        Examples
        --------

        >>> from pylayers.simul.link import *
        >>> L = DLink(verbose=False)
        >>> aktk = L.eval()


        """


        Link.__init__(self)

        defaults={ 'L':Layout(),
                   'a':np.array(()),
                   'b':np.array(()),
                   'Aa':Antenna(typ='Omni'),
                   'Ab':Antenna(typ='Omni'),
                   'Ta':np.eye(3),
                   'Tb':np.eye(3),
                   'fGHz':[],
                   'wav':wvf.Waveform(),
                   'cutoff':3,
                   'save_opt':['sig','ray','Ct','H'],
                   'save_idx':0,
                   'force_create':False,
                   'verbose':True,
                   'graph':'tcvirw'
                }

        self._ca=-1
        self._cb=-1
        specset = ['a','b','Aa','Ab','Ta','Tb','L','fGHz','wav']

        # set default attribute
        for key, value in defaults.items():
            if key not in kwargs:
                if key in specset :
                    setattr(self,'_'+key,value)
                else :
                    setattr(self,key,value)
            else :
                if key in specset :
                    setattr(self,'_'+key,kwargs[key])
                else :
                    setattr(self,key,kwargs[key])

        force=self.force_create
        delattr(self,'force_create')

        if self.fGHz == []:
            self.initfreq()
        else :
            pass

        try:
            self._Lname = self._L.filename
        except:
            self._L=Layout(self._L)
            self._Lname = self._L.filename

        ###########
        # Transmitter and Receiver positions
        ###########

        self.tx = RadioNode(name = '',
                            typ = 'tx',
                            _fileini = 'radiotx.ini',
                            )

        self.rx = RadioNode(name = '',
                            typ = 'rx',
                            _fileini = 'radiorx.ini',
                            )



        self.filename = 'Links_' + str(self.save_idx) + '_' + self._Lname + '.h5'
        filenameh5 = pyu.getlong(self.filename,pstruc['DIRLNK'])
        # check if save file alreasdy exists
        if not os.path.exists(filenameh5) or force:
            print 'Links save file for ' + self.L.filename + ' does not exist.'
            print 'Creating file. You\'ll see this message only once per Layout'
            self.save_init(filenameh5)

        # dictionnary data exists
        self.dexist={'sig':{'exist':False,'grpname':''},
                     'ray':{'exist':False,'grpname':''},
                     'Ct':{'exist':False,'grpname':''},
                     'H':{'exist':False,'grpname':''}
                    }



        try:
            self.L.dumpr()
        except:
            print('This is the first time the Layout is used. Graphs have to be built. Please Wait')
            self.L.build(graph=self.graph)
            self.L.dumpw()
        #self.L.build()

        ###########
        # init pos & cycles
        #
        # If a and b are not specified
        #  they are chosen as center of gravity of cycle 0
        #
        ###########
        if len(self.a)==0:
            self.ca = 1
            # self.a = self.L.cy2pt(self.ca)
        else:
            if len(kwargs['a']) ==2:
                a=np.r_[kwargs['a'],1.0]
            else:
                a=kwargs['a']
            self.a = a
            # self.ca = self.L.pt2cy(self.a)

        if len(self.b)==0:
            if len(self.L.Gt.node)>2:
                self.cb = 2
            else:
                self.cb = 1
            # self.b = self.L.cy2pt(self.cb)
        else:
            if len(kwargs['b']) ==2:
                b=np.r_[kwargs['b'],1.0]
            else:
                b=kwargs['b']
            self.b = b
            # self.cb = self.L.pt2cy(self.b)


        ###########
        # init freq
        # TODO Check where it is used redundant with fGHz
        ###########
        #self.fmin  = self.fGHz[0]
        #self.fmax  = self.fGHz[-1]
        #self.fstep = self.fGHz[1]-self.fGHz[0]


        self.Si = Signatures(self.L,self.ca,self.cb,cutoff=self.cutoff)
        self.R = Rays(self.a,self.b)
        self.C = Ctilde()
        self.H = Tchannel()
示例#19
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt

#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout()
lL = L.ls()
for tL in lL:
    print 'Layout :', tL
    try:
        L = Layout(tL)
        L.save()
    except:
        print 'Layout :', tL, ' problem'

#f = plt.figure(figsize=(20,10))
#plt.axis('off')
#f,a = L.showG('s',nodes=False,fig=f)
#plt.show()
#f,a = L.showG('r',edge_color='b',linewidth=4,fig=f)
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.buildGt()
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#20
0
class Coverage(PyLayers):
    """ Handle Layout Coverage
        Methods
        -------
        creategrid()
            create a uniform grid for evaluating losses
        cover()
            run the coverage calculation
        showPower()
            display the map of received power
        showLoss()
            display the map of losses
        Attributes
        ----------
        All attributes are read from fileini ino the ini directory of the
        current project
        _fileini
            default coverage.ini
        L     : a Layout
        nx    : number of point on x
        ny    : number of point on y
        tx    : transmitter position
        txpe  : transmitter power emmission level
        show  : boolean for automatic display power map
        na : number of access point
    """
    def __init__(self, _fileini='coverage.ini'):
        """ object constructor
        Parameters
        ----------
        _fileini : string
            name of the configuration file
        Notes
        -----
        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.
        """

        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini, pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.apopt = dict(self.config.items('ap'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        # get the Layout
        filename = self.layoutopt['filename']
        if filename.endswith('lay'):
            self.typ = 'indoor'
            self.L = Layout(filename)

            # get the receiving grid
            self.nx = eval(self.gridopt['nx'])
            self.ny = eval(self.gridopt['ny'])
            if 'zgrid' in self.gridopt:
                self.zgrid = eval(self.gridopt['zgrid'])
            else:
                self.zgrid = 1.0
            self.mode = self.gridopt['mode']
            assert self.mode in ['file', 'full',
                                 'zone'], "Error reading grid mode "
            self.boundary = eval(self.gridopt['boundary'])
            self.filespa = self.gridopt['file']
            #
            # create grid
            #
            self.creategrid(mode=self.mode,
                            boundary=self.boundary,
                            _fileini=self.filespa)

            self.dap = {}
            for k in self.apopt:
                kwargs = eval(self.apopt[k])
                ap = std.AP(**kwargs)
                self.dap[eval(k)] = ap
            try:
                self.L.Gt.nodes()
            except:
                pass
            try:
                self.L.dumpr()
            except:
                self.L.build()
                self.L.dumpw()

        else:
            self.typ = 'outdoor'
            self.E = ez.Ezone(filename)
            self.E.loadh5()
            self.E.rebase()

        # The frequency is fixed from the AP nature
        self.fGHz = np.array([])
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        #self.rxsens = eval(self.rxopt['sensitivity'])

        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])
        self.PtDB = eval(self.rxopt['ptdb'])
        self.Gt = eval(self.rxopt['gt'])
        self.Gr = eval(self.rxopt['gr'])
        self.do = eval(self.rxopt['do'])
        self.Prdo = eval(self.rxopt['prdo'])
        self.n = eval(self.rxopt['n'])
        self.desviopadrao = eval(self.rxopt['desviopadrao'])
        self.x0 = eval(self.rxopt['x0'])
        self.y0 = eval(self.rxopt['y0'])
        self.xt = eval(self.rxopt['xt'])
        self.yt = eval(self.rxopt['yt'])

        # show section
        self.bshow = str2bool(self.showopt['show'])

    def __repr__(self):
        st = ''
        if self.typ == 'indoor':
            st = st + 'Layout file : ' + self.L._filename + '\n\n'
            st = st + '-----list of Access Points ------' + '\n'
            for k in self.dap:
                st = st + self.dap[k].__repr__() + '\n'
            st = st + '-----Rx------' + '\n'
            st = st + 'temperature (K) : ' + str(self.temperaturek) + '\n'
            st = st + 'noisefactor (dB) : ' + str(self.noisefactordb) + '\n\n'
            st = st + '--- Grid ----' + '\n'
            st = st + 'mode : ' + str(self.mode) + '\n'
            if self.mode <> 'file':
                st = st + 'nx : ' + str(self.nx) + '\n'
                st = st + 'ny : ' + str(self.ny) + '\n'
            if self.mode == 'zone':
                st = st + 'boundary (xmin,ymin,xmax,ymax) : ' + str(
                    self.boundary) + '\n\n'
            if self.mode == 'file':
                st = st + ' filename : ' + self.filespa + '\n'
        return (st)

    def creategrid(self, mode='full', boundary=[], _fileini=''):
        """ create a grid
        Parameters
        ----------
        full : boolean
            default (True) use all the layout area
        boundary : (xmin,ymin,xmax,ymax)
            if full is False the boundary argument is used
        """

        if mode == "file":
            self.RN = RadioNode(name='',
                                typ='rx',
                                _fileini=_fileini,
                                _fileant='def.vsh3')
            self.grid = self.RN.position[0:2, :].T
        else:
            if mode == "full":
                mi = np.min(self.L.Gs.pos.values(), axis=0) + 0.01
                ma = np.max(self.L.Gs.pos.values(), axis=0) - 0.01
            if mode == "zone":
                assert boundary <> []
                mi = np.array([boundary[0], boundary[1]])
                ma = np.array([boundary[2], boundary[3]])

            x = np.linspace(mi[0], ma[0], self.nx)
            y = np.linspace(mi[1], ma[1], self.ny)

            self.grid = np.array((list(np.broadcast(*np.ix_(x, y)))))

        self.ng = self.grid.shape[0]

    def where1(self):
        """
        Unfinished : Not sure this is the right place (too specific)
        """
        M1 = UWBMeasure(1)
        self.dap = {}
        self.dap[1] = {}
        self.dap[2] = {}
        self.dap[3] = {}
        self.dap[4] = {}
        self.dap[1]['p'] = M1.rx[1, 0:2]
        self.dap[2]['p'] = M1.rx[1, 0:2]
        self.dap[3]['p'] = M1.rx[1, 0:2]
        self.dap[4]['p'] = M1.rx[1, 0:2]
        for k in range(300):
            try:
                M = UWBMeasure(k)
                tx = M.tx
                self.grid = np.vstack((self.grid, tx[0:2]))
                D = M.rx - tx[np.newaxis, :]
                D2 = D * D
                dist = np.sqrt(np.sum(D2, axis=1))[1:]
                Emax = M.Emax()
                Etot = M.Etot()[0]
                try:
                    td1 = np.hstack((td1, dist[0]))
                    td2 = np.hstack((td2, dist[1]))
                    td3 = np.hstack((td3, dist[2]))
                    td4 = np.hstack((td4, dist[3]))
                    te1 = np.hstack((te1, Emax[0]))
                    te2 = np.hstack((te2, Emax[1]))
                    te3 = np.hstack((te3, Emax[2]))
                    te4 = np.hstack((te4, Emax[3]))
                    tt1 = np.hstack((tt1, Etot[0]))
                    tt2 = np.hstack((tt2, Etot[1]))
                    tt3 = np.hstack((tt3, Etot[2]))
                    tt4 = np.hstack((tt4, Etot[3]))
                    #tdist = np.hstack((tdist,dist))
                    #te = np.hstack((te,Emax))
                except:
                    td1 = np.array(dist[0])
                    td2 = np.array(dist[1])
                    td3 = np.array(dist[2])
                    td4 = np.array(dist[3])
                    te1 = np.array(Emax[0])
                    te2 = np.array(Emax[1])
                    te3 = np.array(Emax[2])
                    te4 = np.array(Emax[3])
                    tt1 = np.array(Etot[0])
                    tt2 = np.array(Etot[1])
                    tt3 = np.array(Etot[2])
                    tt4 = np.array(Etot[3])
            except:
                pass

    def cover(self, sinr=True, snr=True, best=True):
        """ run the coverage calculation
        Parameters
        ----------
        sinr : boolean
        snr  : boolean
        best : boolean
        Examples
        --------
        .. plot::
            :include-source:
            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a=C.show(typ='sinr',figsize=(10,8))
            >>> plt.show()
        Notes
        -----
        self.fGHz is an array, it means that Coverage is calculated at once
        for a whole set of frequencies. In practice, it would be the center
        frequency of a given standard channel.
        This function is calling `loss.Losst` which calculates Losses along a
        straight path.
        In a future implementation we will
        abstract the EM solver in order to make use of other calculation
        approaches as a full or partial Ray Tracing.
        The following members variables are evaluated :
        + freespace Loss @ fGHz   PL()  PathLoss (shoud be rename FS as free space) $
        + prdbmo : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{odB}`
        + prdbmp : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{pdB}`
        + snro : SNR polar o (H)
        + snrp : SNR polar p (H)
        See Also
        --------
        pylayers.antprop.loss.Losst
        pylayers.antprop.loss.PL
        """
        #
        # select active AP
        #
        lactiveAP = []
        try:
            del self.aap
            del self.ptdbm
        except:
            pass

        self.kB = 1.3806503e-23  # Boltzmann constant
        #
        # Loop opver access points
        #
        for iap in self.dap:
            if self.dap[iap]['on']:
                lactiveAP.append(iap)
                fGHz = self.dap[iap].s.fcghz
                # The frequency band is set here
                self.fGHz = np.unique(np.hstack((self.fGHz, fGHz)))
                apchan = self.dap[iap]['chan']
                try:
                    self.aap = np.vstack((self.aap, self.dap[iap]['p']))
                    self.ptdbm = np.vstack(
                        (self.ptdbm, self.dap[iap]['PtdBm']))
                    self.bmhz = np.vstack(
                        (self.bmhz, self.dap[iap].s.chan[apchan[0]]['BMHz']))
                except:
                    self.aap = self.dap[iap]['p']
                    self.ptdbm = np.array(self.dap[iap]['PtdBm'])
                    self.bmhz = np.array(
                        self.dap[iap].s.chan[apchan[0]]['BMHz'])

        PnW = np.array((10**(self.noisefactordb / 10.)) * self.kB *
                       self.temperaturek * self.bmhz * 1e6)
        self.pnw = PnW
        # Evaluate Noise Power (in dBm)
        self.pndbm = np.array(10 * np.log10(PnW) + 30)

        #lchan = map(lambda x: self.dap[x]['chan'],lap)
        #apchan = zip(self.dap.keys(),lchan)
        #self.bmhz = np.array(map(lambda x: self.dap[x[0]].s.chan[x[1][0]]['BMHz']*len(x[1]),apchan))

        self.ptdbm = self.ptdbm.T
        self.pndbm = self.pndbm.T
        # creating all links
        # all grid to all ap
        #
        if len(self.pndbm.shape) == 0:
            self.ptdbm = self.ptdbm.reshape(1, 1)
            self.pndbm = self.pndbm.reshape(1, 1)

        p = product(range(self.ng), lactiveAP)
        #
        # pa : access point
        # pg : grid point
        #
        # 1 x na

        for k in p:
            pg = self.grid[k[0], :]
            pa = np.array(self.dap[k[1]]['p'])
            # exemple with 3 AP
            # 321 0
            # 321 1
            # 321 2
            # 322 0
            try:
                self.pa = np.vstack((self.pa, pa))
            except:
                self.pa = pa
            try:
                self.pg = np.vstack((self.pg, pg))
            except:
                self.pg = pg

        self.pa = self.pa.T
        shpa = self.pa.shape
        shpg = self.pg.shape

        if shpa[0] != 3:
            self.pa = np.vstack((self.pa, np.ones(shpa[1])))
        self.pg = self.pg.T
        self.pg = np.vstack((self.pg, self.zgrid * np.ones(shpg[0])))

        self.nf = len(self.fGHz)

        # retrieving dimensions along the 3 axis
        na = len(lactiveAP)
        self.na = na
        ng = self.ng
        nf = self.nf

        for k, iap in enumerate(self.dap):
            # select only one access point
            u = na * np.arange(0, ng, 1).astype('int') + k
            if self.dap[iap]['on']:
                pt = self.pa[:, u]
                pr = self.pg[:, u]
                azoffset = self.dap[iap]['phideg'] * np.pi / 180.
                self.dap[iap].A.eval(fGHz=self.fGHz,
                                     pt=pt,
                                     pr=pr,
                                     azoffset=azoffset)

                gain = (self.dap[iap].A.G).T
                #pdb.set_trace()
                # to handle omnidirectional antenna (nf,1,1)
                if gain.shape[1] == 1:
                    gain = np.repeat(gain, ng, axis=1)
                try:
                    tgain = np.dstack((tgain, gain[:, :, None]))
                except:
                    tgain = gain[:, :, None]

        #Lwo,Lwp,Edo,Edp = loss.Losst(self.L,self.fGHz,self.pa,self.pg,dB=False)
        Lwo, Lwp, Edo, Edp = loss.Losst(self.L,
                                        self.fGHz,
                                        self.pa,
                                        self.pg,
                                        dB=False)

        self.Lwo = Lwo.reshape(nf, ng, na)
        self.Edo = Edo.reshape(nf, ng, na)
        self.Lwp = Lwp.reshape(nf, ng, na)
        self.Edp = Edp.reshape(nf, ng, na)

        freespace = loss.PL(self.fGHz, self.pa, self.pg, dB=False)
        self.freespace = freespace.reshape(nf, ng, na)

        # transmitting power
        # f x g x a

        # CmW : Received Power coverage in mW
        self.CmWo = 10**(self.ptdbm[np.newaxis, ...] /
                         10.) * self.Lwo * self.freespace * tgain
        self.CmWp = 10**(self.ptdbm[np.newaxis, ...] /
                         10.) * self.Lwp * self.freespace * tgain
        if self.typ == 'intensity':
            self.cmWo = 10 * np.log10(self.cmWo)
            self.cmWo = 10 * np.log10(self.cmWp)

        if snr:
            self.evsnr()
        if sinr:
            self.evsinr()
        if best:
            self.evbestsv()

    def evsnr(self):
        """ calculates signal to noise ratio
        """

        NmW = 10**(self.pndbm / 10.)[np.newaxis, :]

        self.snro = self.CmWo / NmW
        self.snrp = self.CmWp / NmW

    def evsinr(self):
        """ calculates sinr
        """

        # na : number of access point
        na = self.na

        # U : 1 x 1 x na x na
        U = (np.ones((na, na)) - np.eye(na))[np.newaxis, np.newaxis, :, :]

        # CmWo : received power in mW orthogonal polarization
        # CmWp : received power in mW parallel polarization

        ImWo = np.einsum('ijkl,ijl->ijk', U, self.CmWo)
        ImWp = np.einsum('ijkl,ijl->ijk', U, self.CmWp)

        NmW = 10**(self.pndbm / 10.)[np.newaxis, :]

        self.sinro = self.CmWo / (ImWo + NmW)
        self.sinrp = self.CmWp / (ImWp + NmW)

    def evbestsv(self):
        """ determine the best server map
        Notes
        -----
        C.bestsv
        """
        na = self.na
        ng = self.ng
        nf = self.nf
        # find best server regions
        Vo = self.CmWo
        Vp = self.CmWp
        self.bestsvo = np.empty(nf * ng * na).reshape(nf, ng, na)
        self.bestsvp = np.empty(nf * ng * na).reshape(nf, ng, na)
        for kf in range(nf):
            MaxVo = np.max(Vo[kf, :, :], axis=1)
            MaxVp = np.max(Vp[kf, :, :], axis=1)
            for ka in range(na):
                uo = np.where(Vo[kf, :, ka] == MaxVo)
                up = np.where(Vp[kf, :, ka] == MaxVp)
                self.bestsvo[kf, uo, ka] = ka + 1
                self.bestsvp[kf, up, ka] = ka + 1

    def plot(self, **kwargs):
        """
        """
        defaults = {
            'typ': 'pr',
            'grid': False,
            'f': 0,
            'a': 0,
            'db': True,
            'label': '',
            'pol': 'p',
            'col': 'b'
        }
        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        if 'fig' in kwargs:
            fig = kwargs['fig']
        else:
            fig = plt.figure()

        if 'ax' in kwargs:
            ax = kwargs['ax']
        else:
            ax = fig.add_subplot(111)

        if kwargs['typ'] == 'pr':
            if kwargs['a'] <> -1:
                if kwargs['pol'] == 'p':
                    U = self.CmWp[kwargs['f'], :, kwargs['a']]
                if kwargs['pol'] == 'o':
                    U = self.CmWo[kwargs['f'], :, kwargs['a']]
            else:
                if kwargs['pol'] == 'p':
                    U = self.CmWp[kwargs['f'], :, :].reshape(self.na * self.ng)
                else:
                    U = self.CmWo[kwargs['f'], :, :].reshape(self.na * self.ng)
            if kwargs['db']:
                U = 10 * np.log10(U)

        D = np.sqrt(np.sum((self.pa - self.pg) * (self.pa - self.pg), axis=0))
        if kwargs['a'] <> -1:
            D = D.reshape(self.ng, self.na)
            ax.semilogx(D[:, kwargs['a']],
                        U,
                        '.',
                        color=kwargs['col'],
                        label=kwargs['label'])
        else:
            ax.semilogx(D, U, '.', color=kwargs['col'], label=kwargs['label'])

        return fig, ax

    def show(self, **kwargs):
        """ show coverage
        Parameters
        ----------
        typ : string
            'pr' | 'sinr' | 'capacity' | 'loss' | 'best' | 'egd'
        grid : boolean
        polar : string
            'o' | 'p'
        best : boolean
            draw best server contour if True
        f : int
            frequency index
        a : int
            access point index (-1 all access point)
        Examples
        --------
        .. plot::
            :include-source:
            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a = C.show(typ='pr',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='best',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='loss',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='sinr',figsize=(10,8))
            >>> plt.show()
        See Also
        --------
        pylayers.gis.layout.Layout.showG
        """
        defaults = {
            'typ': 'pr',
            'grid': False,
            'polar': 'p',
            'f': 0,
            'a': -1,
            'db': True,
            'cmap': cm.jet,
            'best': True
        }

        title = self.dap[self.dap.keys()[0]].s.name + ' : '

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]
        polar = kwargs['polar']
        assert polar in ['p', 'o'], "polar wrongly defined in show coverage"

        if 'fig' in kwargs:
            if 'ax' in kwargs:
                fig, ax = self.L.showG('s', fig=kwargs['fig'], ax=kwargs['ax'])
            else:
                fig, ax = self.L.showG('s', fig=kwargs['fig'])
        else:
            if 'figsize' in kwargs:
                fig, ax = self.L.showG('s', figsize=kwargs['figsize'])
            else:
                fig, ax = self.L.showG('s')

        # plot the grid
        self.typ = kwargs['typ']
        typ = kwargs['typ']
        if kwargs['grid']:
            for k in self.dap:
                p = self.dap[k].p
                ax.plot(p[0], p[1], 'or')

        f = kwargs['f']
        a = kwargs['a']
        assert typ in [
            'best', 'egd', 'sinr', 'snr', 'capacity', 'pr', 'loss',
            'intensity', 'losssombreamento', 'prsombreamento',
            'snrsombreamento'
        ], "typ unknown in show coverage"
        best = kwargs['best']

        dB = kwargs['db']

        # setting the grid

        l = self.grid[0, 0]
        r = self.grid[-1, 0]
        b = self.grid[0, 1]
        t = self.grid[-1, -1]

        arq = open('cobertura.txt', 'w')
        texto = '''dBm e V/m \n'''
        arq.write(texto)
        arq.close()

        if typ == 'best':
            title = title + 'Best server' + ' fc = ' + str(
                self.fGHz[f]) + ' GHz' + ' polar : ' + polar
            for ka in range(self.na):
                if polar == 'p':
                    bestsv = self.bestsvp[f, :, ka]
                if polar == 'o':
                    bestsv = self.bestsvo[f, :, ka]
                m = np.ma.masked_where(bestsv == 0, bestsv)
                if self.mode <> 'file':
                    W = m.reshape(self.nx, self.ny).T
                    ax.imshow(W,
                              extent=(l, r, b, t),
                              origin='lower',
                              vmin=1,
                              vmax=self.na + 1)
                else:
                    ax.scatter(self.grid[:, 0],
                               self.grid[:, 1],
                               c=m,
                               s=20,
                               linewidth=0)
            ax.set_title(title)
        else:
            if typ == 'egd':
                title = title + 'excess group delay : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                V = self.Ed
                dB = False
                legcb = 'Delay (ns)'
            if typ == 'sinr':
                title = title + 'SINR : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar == 'o':
                    V = self.sinro
                if polar == 'p':
                    V = self.sinrp
            if typ == 'snr':
                title = title + 'SNR : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar == 'o':
                    V = self.snro
                if polar == 'p':
                    V = self.snrp
            if typ == 'capacity':
                title = title + 'Capacity : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                legcb = 'Mbit/s'
                if polar == 'o':
                    V = self.bmhz.T[np.newaxis, :] * np.log(
                        1 + self.sinro) / np.log(2)
                if polar == 'p':
                    V = self.bmhz.T[np.newaxis, :] * np.log(
                        1 + self.sinrp) / np.log(2)

            if typ == 'pr':
                title = title + 'Pr : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dBm'
                else:
                    lgdcb = 'mW'
                if polar == 'o':
                    V = self.CmWo
                if polar == 'p':
                    V = self.CmWp

            if typ == 'loss':
                title = title + 'Loss : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar == 'o':
                    V = self.Lwo * self.freespace
                if polar == 'p':
                    V = self.Lwp * self.freespace

            if typ == 'losssombreamento':
                #relaxa que esse so muda no final
                title = title + 'Loss Log : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    lgdcb = 'Linear scale'
                if polar == 'o':
                    V = self.CmWo
                if polar == 'p':
                    V = self.CmWp

            if typ == 'prsombreamento':
                #relaxa que esse so muda no final
                title = title + 'Pr Log : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dBm'
                else:
                    lgdcb = 'Linear scale'
                if polar == 'o':
                    V = self.CmWo
                if polar == 'p':
                    V = self.CmWp

            if typ == 'snrsombreamento':
                #relaxa que esse so muda no final
                title = title + 'SNR Log : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    lgdcb = 'Linear scale'
                if polar == 'o':
                    V = self.CmWo
                if polar == 'p':
                    V = self.CmWp

            if typ == 'intensity':
                title = title + 'Intensity : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                legcb = 'V/m'
                if polar == 'o':
                    V = np.power(10, (
                        (self.CmWo + 20 * np.log10(self.fGHz[f] * 1000) + 77.2)
                        / 20)) * 0.000001
                if polar == 'p':
                    V = np.power(10, (
                        (self.CmWp + 20 * np.log10(self.fGHz[f] * 1000) + 77.2)
                        / 20)) * 0.000001

            if a == -1:
                V = np.max(V[f, :, :], axis=1)
            else:
                V = V[f, :, a]

            # reshaping the data on the grid
            if self.mode != 'file':
                U = V.reshape((self.nx, self.ny)).T
            else:
                U = V

            if dB and typ != 'intensity':
                if typ == 'losssombreamento' or typ == 'prsombreamento' or typ == 'snrsombreamento':
                    f = self.fGHz[f] * 1000
                    Lf = self.PtDB - self.Prdo + self.Gt + self.Gr

                    medidas1 = []

                    dx = np.linspace(0, self.xt, self.nx)
                    dy = np.linspace(0, self.yt, self.ny)

                    for i in range(self.ny):
                        medidas1.append([])

                    for i in range(self.ny):
                        for j in range(self.nx):
                            medidas1[i].append(
                                np.sqrt(
                                    np.power(dx[j] - self.x0, 2) +
                                    np.power(dy[i] - self.y0, 2)) / 1000)

                    desvio = 0

                    X = np.random.normal(0, self.desviopadrao, len(medidas1))

                    PL2 = []
                    maior, menor = 0, 100

                    for i in range(self.ny):
                        PL2.append([])

                    for i in range(self.ny):
                        for j in range(self.nx):
                            oi = Lf + 10 * self.n * np.log10(
                                medidas1[i][j] / self.do) + X[i]
                            PL2[i].append(oi)
                            if (maior < oi):
                                maior = oi
                            if (menor > oi):
                                menor = oi

                    menor = np.floor(menor / 10) * 10
                    maior = np.ceil(maior / 10) * 10

                    if typ == 'prsombreamento':
                        maior, menor = -100, 0
                        pr = []
                        for i in range(self.ny):
                            pr.append([])

                        for i in range(self.ny):
                            for j in range(self.nx):
                                oi = self.PtDB - PL2[i][j]
                                pr[i].append(oi)
                                if (maior < oi):
                                    maior = oi
                                if (menor > oi):
                                    menor = oi
                        menor = np.floor(menor / 10) * 10
                        maior = np.ceil(maior / 10) * 10
                        U = pr
                    elif typ == 'snrsombreamento':
                        maior, menor = -100, 100
                        pr = []
                        for i in range(self.ny):
                            pr.append([])

                        for i in range(self.ny):
                            for j in range(self.nx):
                                oi = PL2[i][j] / self.pnw[0][0]
                                pr[i].append(oi)
                                if (maior < oi):
                                    maior = oi
                                if (menor > oi):
                                    menor = oi
                        menor = np.floor(menor / 10) * 10
                        maior = np.ceil(maior / 10) * 10
                        U = pr
                    else:
                        U = PL2
                else:
                    U = 10 * np.log10(U)
                #print U

            arq = open('cobertura.txt', 'w')
            texto = []
            for linha in U:
                texto.append(str(linha) + '\n')
            arq.writelines(texto)
            arq.close()

            if 'vmin' in kwargs:
                vmin = kwargs['vmin']
            else:
                if typ == 'losssombreamento' or typ == 'prsombreamento' or typ == 'snrsombreamento':
                    vmin = menor
                else:
                    vmin = U.min()

            if 'vmax' in kwargs:
                vmax = kwargs['vmax']
            else:
                if typ == 'losssombreamento' or typ == 'prsombreamento' or typ == 'snrsombreamento':
                    vmax = maior
                else:
                    vmax = U.max()

            if self.mode != 'file':
                img = ax.imshow(U,
                                extent=(l, r, b, t),
                                origin='lower',
                                vmin=vmin,
                                vmax=vmax,
                                cmap=kwargs['cmap'])
            else:
                img = ax.scatter(self.grid[:, 0],
                                 self.grid[:, 1],
                                 c=U,
                                 s=20,
                                 linewidth=0,
                                 cmap=kwargs['cmap'],
                                 vmin=vmin,
                                 vmax=vmax)

            for k in range(self.na):
                ax.annotate(str(k), xy=(self.pa[0, k], self.pa[1, k]))
            ax.set_title(title)

            divider = make_axes_locatable(ax)
            cax = divider.append_axes("right", size="5%", pad=0.05)
            clb = fig.colorbar(img, cax)
            clb.set_label(legcb)
            if typ == 'losssombreamento' or typ == 'prsombreamento' or typ == 'snrsombreamento':
                print 'Modelo do Sombreamento Log Normal'
            else:
                if best:
                    if self.mode <> 'file':
                        if polar == 'o':
                            ax.contour(np.sum(self.bestsvo,
                                              axis=2)[f, :].reshape(
                                                  self.nx, self.ny).T,
                                       extent=(l, r, b, t),
                                       linestyles='dotted')
                        if polar == 'p':
                            ax.contour(np.sum(self.bestsvp,
                                              axis=2)[f, :].reshape(
                                                  self.nx, self.ny).T,
                                       extent=(l, r, b, t),
                                       linestyles='dotted')

        # display access points
        if a == -1:
            ax.scatter(self.pa[0, :], self.pa[1, :], s=30, c='r', linewidth=0)
        else:
            ax.scatter(self.pa[0, a], self.pa[1, a], s=30, c='r', linewidth=0)
        plt.tight_layout()
        return (fig, ax)
示例#21
0
class Coverage(PyLayers):
    """ Handle Layout Coverage

        Methods
        -------

        creategrid()
            create a uniform grid for evaluating losses
        cover()
            run the coverage calculation
        showPower()
            display the map of received power
        showLoss()
            display the map of losses


        Attributes
        ----------

        All attributes are read from fileini ino the ini directory of the
        current project

        _fileini
            default coverage.ini

        L     : a Layout
        nx    : number of point on x
        ny    : number of point on y
        tx    : transmitter position
        txpe  : transmitter power emmission level
        show  : boolean for automatic display power map
        na : number of access point

    """


    def __init__(self,_fileini='coverage.ini'):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt   = dict(self.config.items('grid'))
        self.apopt     = dict(self.config.items('ap'))
        self.rxopt     = dict(self.config.items('rx'))
        self.showopt   = dict(self.config.items('show'))

        # get the Layout
        filename = self.layoutopt['filename']
        if filename.endswith('ini'):
            self.typ = 'indoor'
            self.L = Layout(filename)

            # get the receiving grid
            self.nx = eval(self.gridopt['nx'])
            self.ny = eval(self.gridopt['ny'])
            self.mode = self.gridopt['mode']
            self.boundary = eval(self.gridopt['boundary'])
            self.filespa = self.gridopt['file']
            #
            # create grid
            #
            self.creategrid(mode=self.mode,boundary=self.boundary,_fileini=self.filespa)
            self.dap = {}
            for k in self.apopt:
                kwargs  = eval(self.apopt[k])
                ap = std.AP(**kwargs)
                self.dap[eval(k)] = ap
            try:
                self.L.Gt.nodes()
            except:
                pass
            try:
                self.L.dumpr()
            except:
                self.L.build()
                self.L.dumpw()


        else:
            self.typ='outdoor'
            self.E = ez.Ezone(filename)
            self.E.loadh5()
            self.E.rebase()

        self.fGHz = np.array([])
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        #self.rxsens = eval(self.rxopt['sensitivity'])

        self.temperaturek  = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        # show section
        self.bshow = str2bool(self.showopt['show'])

    def __repr__(self):
        st=''
        if self.typ=='indoor':
            st = st+ 'Layout file : '+self.L.filename + '\n\n'
            st = st + '-----list of Access Points ------'+'\n'
            for k in self.dap:
                st = st + self.dap[k].__repr__()+'\n'
            st = st + '-----Rx------'+'\n'
            st= st+ 'temperature (K) : '+ str(self.temperaturek) + '\n'
            st= st+ 'noisefactor (dB) : '+ str(self.noisefactordb) + '\n\n'
            st = st + '--- Grid ----'+'\n'
            st= st+ 'mode : ' + str(self.mode) + '\n'
            if self.mode<>'file':
                st= st+ 'nx : ' + str(self.nx) + '\n'
                st= st+ 'ny : ' + str(self.ny) + '\n'
            if self.mode=='zone':
                st= st+ 'boundary (xmin,ymin,xmax,ymax) : ' + str(self.boundary) + '\n\n'
            if self.mode=='file':
                st = st+' filename : '+self.filespa+'\n'
        return(st)

    def creategrid(self,mode='full',boundary=[],_fileini=''):
        """ create a grid

        Parameters
        ----------

        full : boolean
            default (True) use all the layout area
        boundary : (xmin,ymin,xmax,ymax)
            if full is False the boundary argument is used

        """
        if mode=="file":
            self.RN = RadioNode(name='',
                               typ='rx',
                               _fileini = _fileini,
                               _fileant = 'def.vsh3')
            self.grid =self.RN.position[0:2,:].T
        else:
            if mode=="full":
                mi=np.min(self.L.Gs.pos.values(),axis=0)+0.01
                ma=np.max(self.L.Gs.pos.values(),axis=0)-0.01
            if mode=="zone":
                assert boundary<>[]
                mi = np.array([boundary[0],boundary[1]])
                ma = np.array([boundary[2],boundary[3]])

            x = np.linspace(mi[0],ma[0],self.nx)
            y = np.linspace(mi[1],ma[1],self.ny)

            self.grid=np.array((list(np.broadcast(*np.ix_(x, y)))))

        self.ng = self.grid.shape[0]

    def where1(self):
        """
        Unfinished : Not sure this is the right place (too specific)
        """
        M1 = UWBMeasure(1)
        self.dap={}
        self.dap[1]={}
        self.dap[2]={}
        self.dap[3]={}
        self.dap[4]={}
        self.dap[1]['p']=M1.rx[1,0:2]
        self.dap[2]['p']=M1.rx[1,0:2]
        self.dap[3]['p']=M1.rx[1,0:2]
        self.dap[4]['p']=M1.rx[1,0:2]
        for k in range(300):
            try:
                M = UWBMeasure(k)
                tx = M.tx
                self.grid=np.vstack((self.grid,tx[0:2]))
                D  = M.rx-tx[np.newaxis,:]
                D2 = D*D
                dist = np.sqrt(np.sum(D2,axis=1))[1:]
                Emax = M.Emax()
                Etot = M.Etot()[0]
                try:
                    td1 = np.hstack((td1,dist[0]))
                    td2 = np.hstack((td2,dist[1]))
                    td3 = np.hstack((td3,dist[2]))
                    td4 = np.hstack((td4,dist[3]))
                    te1 = np.hstack((te1,Emax[0]))
                    te2 = np.hstack((te2,Emax[1]))
                    te3 = np.hstack((te3,Emax[2]))
                    te4 = np.hstack((te4,Emax[3]))
                    tt1 = np.hstack((tt1,Etot[0]))
                    tt2 = np.hstack((tt2,Etot[1]))
                    tt3 = np.hstack((tt3,Etot[2]))
                    tt4 = np.hstack((tt4,Etot[3]))
                    #tdist = np.hstack((tdist,dist))
                    #te = np.hstack((te,Emax))
                except:
                    td1=np.array(dist[0])
                    td2=np.array(dist[1])
                    td3=np.array(dist[2])
                    td4=np.array(dist[3])
                    te1 =np.array(Emax[0])
                    te2 =np.array(Emax[1])
                    te3 =np.array(Emax[2])
                    te4 =np.array(Emax[3])
                    tt1 =np.array(Etot[0])
                    tt2 =np.array(Etot[1])
                    tt3 =np.array(Etot[2])
                    tt4 =np.array(Etot[3])
            except:
                pass

    def cover(self,sinr=True,snr=True,best=True):
        """ run the coverage calculation

        Parameters
        ----------

        sinr : boolean
        snr  : boolean
        best : boolean

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a=C.show(typ='sinr',figsize=(10,8))
            >>> plt.show()

        Notes
        -----

        self.fGHz is an array, it means that Coverage is calculated at once
        for a whole set of frequencies. In practice, it would be the center
        frequency of a given standard channel.

        This function is calling `loss.Losst` which calculates Losses along a
        straight path.

        In a future implementation we will
        abstract the EM solver in order to make use of other calculation
        approaches as a full or partial Ray Tracing.

        The following members variables are evaluated :

        + freespace Loss @ fGHz   PL()  PathLoss (shoud be rename FS as free space) $
        + prdbmo : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{odB}`
        + prdbmp : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{pdB}`
        + snro : SNR polar o (H)
        + snrp : SNR polar p (H)

        See Also
        --------

        pylayers.antprop.loss.Losst
        pylayers.antprop.loss.PL

        """
        #
        # select active AP
        #
        lactiveAP = []
        try:
            del self.aap
            del self.ptdbm
        except:
            pass

        self.kB = 1.3806503e-23 # Boltzmann constant
        for iap in self.dap:
            if self.dap[iap]['on']:
                lactiveAP.append(iap)
                fGHz = self.dap[iap].s.fcghz
                self.fGHz=np.unique(np.hstack((self.fGHz,fGHz)))
                apchan = self.dap[iap]['chan']
                try:
                    self.aap   = np.vstack((self.aap,self.dap[iap]['p'][0:2]))
                    self.ptdbm = np.vstack((self.ptdbm,self.dap[iap]['PtdBm']))
                    self.bmhz  = np.vstack((self.bmhz,
                                 self.dap[iap].s.chan[apchan[0]]['BMHz']))
                except:
                    self.aap   = self.dap[iap]['p'][0:2]
                    self.ptdbm = np.array(self.dap[iap]['PtdBm'])
                    self.bmhz  = np.array(self.dap[iap].s.chan[apchan[0]]['BMHz'])

        PnW = np.array((10**(self.noisefactordb/10.))*self.kB*self.temperaturek*self.bmhz*1e6)
        # Evaluate Noise Power (in dBm)
        self.pndbm = np.array(10*np.log10(PnW)+30)
        #lchan = map(lambda x: self.dap[x]['chan'],lap)
        #apchan = zip(self.dap.keys(),lchan)
        #self.bmhz = np.array(map(lambda x: self.dap[x[0]].s.chan[x[1][0]]['BMHz']*len(x[1]),apchan))

        self.ptdbm = self.ptdbm.T
        self.pndbm = self.pndbm.T
        # creating all links
        p = product(range(self.ng),lactiveAP)
        #
        # pa : access point
        # pg : grid point
        #
        # 1 x na
        for k in p:
            pg = self.grid[k[0],:]
            pa = self.dap[k[1]]['p'][0:2]
            try:
                self.pa = np.vstack((self.pa,pa))
            except:
                self.pa = pa
            try:
                self.pg = np.vstack((self.pg,pg))
            except:
                self.pg = pg

        self.pa = self.pa.T
        self.pg = self.pg.T
        self.nf = len(self.fGHz)

        # retrieving dimensions along the 3 axis
        na = len(lactiveAP)
        self.na = na
        ng = self.ng
        nf = self.nf

        Lwo,Lwp,Edo,Edp = loss.Losst(self.L,self.fGHz,self.pa,self.pg,dB=False)
        self.Lwo = Lwo.reshape(nf,ng,na)
        self.Edo = Edo.reshape(nf,ng,na)
        self.Lwp = Lwp.reshape(nf,ng,na)
        self.Edp = Edp.reshape(nf,ng,na)

        freespace = loss.PL(self.fGHz,self.pa,self.pg,dB=False)
        self.freespace = freespace.reshape(nf,ng,na)

        # transmitting power
        # f x g x a

        # CmW : Received Power coverage in mW
        self.CmWo = 10**(self.ptdbm[np.newaxis,...]/10.)*self.Lwo*self.freespace
        self.CmWp = 10**(self.ptdbm[np.newaxis,...]/10.)*self.Lwp*self.freespace


        if snr:
            self.evsnr()
        if sinr:
            self.evsinr()
        if best:
            self.evbestsv()

    def evsnr(self):
        """ calculates snr
        """

        NmW = 10**(self.pndbm/10.)[np.newaxis,:]

        self.snro = self.CmWo/NmW
        self.snrp = self.CmWp/NmW

    def evsinr(self):
        """ calculates sinr

        """

        # na : number of access point
        na = self.na

        # U : 1 x 1 x na x na
        U = (np.ones((na,na))-np.eye(na))[np.newaxis,np.newaxis,:,:]

        # CmWo : received power in mW orthogonal polarization
        # CmWp : received power in mW parallel polarization

        ImWo = np.einsum('ijkl,ijl->ijk',U,self.CmWo)
        ImWp = np.einsum('ijkl,ijl->ijk',U,self.CmWp)


        NmW = 10**(self.pndbm/10.)[np.newaxis,:]

        self.sinro = self.CmWo/(ImWo+NmW)
        self.sinrp = self.CmWp/(ImWp+NmW)

    def evbestsv(self):
        """ determine the best server map

        Notes
        -----

        C.bestsv

        """
        na = self.na
        ng = self.ng
        nf = self.nf
        # find best server regions
        Vo = self.CmWo
        Vp = self.CmWp
        self.bestsvo = np.empty(nf*ng*na).reshape(nf,ng,na)
        self.bestsvp = np.empty(nf*ng*na).reshape(nf,ng,na)
        for kf in range(nf):
            MaxVo = np.max(Vo[kf,:,:],axis=1)
            MaxVp = np.max(Vp[kf,:,:],axis=1)
            for ka in range(na):
                uo = np.where(Vo[kf,:,ka]==MaxVo)
                up = np.where(Vp[kf,:,ka]==MaxVp)
                self.bestsvo[kf,uo,ka]=ka+1
                self.bestsvp[kf,up,ka]=ka+1


#    def showEd(self,polar='o',**kwargs):
#        """ shows a map of direct path excess delay
#
#        Parameters
#        ----------
#
#        polar : string
#        'o' | 'p'
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            >> from pylayers.antprop.coverage import *
#            >> C = Coverage()
#            >> C.cover()
#            >> C.showEd(polar='o')
#
#        """
#
#        if not kwargs.has_key('alphacy'):
#            kwargs['alphacy']=0.0
#        if not kwargs.has_key('colorcy'):
#            kwargs['colorcy']='w'
#        if not kwargs.has_key('nodes'):
#            kwargs['nodes']=False
#
#        fig,ax = self.L.showG('s',**kwargs)
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        cdict = {
#        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
#        }
#        #generate the colormap with 1024 interpolated values
#        my_cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
#
#
#        if polar=='o':
#            mcEdof = np.ma.masked_where(prdbm < self.rxsens,self.Edo)
#
#            cov=ax.imshow(mcEdof.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'jet',
#                             origin='lower')
#
#
#
#            # cov=ax.imshow(self.Edo.reshape((self.nx,self.ny)).T,
#            #           extent=(l,r,b,t),
#            #           origin='lower')
#            titre = "Map of LOS excess delay, polar orthogonal"
#
#        if polar=='p':
#            mcEdpf = np.ma.masked_where(prdbm < self.rxsens,self.Edp)
#
#            cov=ax.imshow(mcEdpf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'jet',
#                             origin='lower')
#
#            # cov=ax.imshow(self.Edp.reshape((self.nx,self.ny)).T,
#            #           extent=(l,r,b,t),
#            #           origin='lower')
#            titre = "Map of LOS excess delay, polar parallel"
#
#        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
#        ax.set_title(titre)
#
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        clb = fig.colorbar(cov,cax)
#        clb.set_label('excess delay (ns)')
#
#        if self.show:
#            plt.show()
#        return fig,ax
#
#    def showPower(self,rxsens=True,nfl=True,polar='o',**kwargs):
#        """ show the map of received power
#
#        Parameters
#        ----------
#
#        rxsens : bool
#              clip the map with rx sensitivity set in self.rxsens
#        nfl : bool
#              clip the map with noise floor set in self.pndbm
#        polar : string
#            'o'|'p'
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            > from pylayers.antprop.coverage import *
#            > C = Coverage()
#            > C.cover()
#            > C.showPower()
#
#        """
#
#        if not kwargs.has_key('alphacy'):
#            kwargs['alphacy']=0.0
#        if not kwargs.has_key('colorcy'):
#            kwargs['colorcy']='w'
#        if not kwargs.has_key('nodes'):
#            kwargs['nodes']=False
#        fig,ax = self.L.showG('s',**kwargs)
#
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
##        tCM = plt.cm.get_cmap('jet')
##        tCM._init()
##        alphas = np.abs(np.linspace(.0,1.0, tCM.N))
##        tCM._lut[:-3,-1] = alphas
#
#        title='Map of received power - Pt = ' + str(self.ptdbm) + ' dBm'+str(' fGHz =') + str(self.fGHz) + ' polar = '+polar
#
#        cdict = {
#        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
#        }
#
#        if not kwargs.has_key('cmap'):
#        # generate the colormap with 1024 interpolated values
#            cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
#        else:
#            cmap = kwargs['cmap']
#        #my_cmap = cm.copper
#
#
#        if rxsens :
#
#            ## values between the rx sensitivity and noise floor
#            mcPrf = np.ma.masked_where((prdbm > self.rxsens)
#                                     & (prdbm < self.pndbm),prdbm)
#            # mcPrf = np.ma.masked_where((prdbm > self.rxsens) ,prdbm)
#
#            cov1 = ax.imshow(mcPrf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = cm.copper,
#                             vmin=self.rxsens,origin='lower')
#
#            ### values above the sensitivity
#            mcPrs = np.ma.masked_where(prdbm < self.rxsens,prdbm)
#            cov = ax.imshow(mcPrs.reshape((self.nx,self.ny)).T,
#                            extent=(l,r,b,t),
#                            cmap = cmap,
#                            vmin=self.rxsens,origin='lower')
#            title=title + '\n black : Pr (dBm) < %.2f' % self.rxsens + ' dBm'
#
#        else :
#            cov=ax.imshow(prdbm.reshape((self.nx,self.ny)).T,
#                          extent=(l,r,b,t),
#                          cmap = cmap,
#                          vmin=self.pndbm,origin='lower')
#
#        if nfl:
#            ### values under the noise floor
#            ### we first clip the value below the noise floor
#            cl = np.nonzero(prdbm<=self.pndbm)
#            cPr = prdbm
#            cPr[cl] = self.pndbm
#            mcPruf = np.ma.masked_where(cPr > self.pndbm,cPr)
#            cov2 = ax.imshow(mcPruf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'binary',
#                             vmax=self.pndbm,origin='lower')
#            title=title + '\n white : Pr (dBm) < %.2f' % self.pndbm + ' dBm'
#
#
#        ax.scatter(self.tx[0],self.tx[1],s=10,c='k',linewidth=0)
#
#        ax.set_title(title)
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        clb = fig.colorbar(cov,cax)
#        clb.set_label('Power (dBm)')
#
#        if self.show:
#            plt.show()
#
#        return fig,ax
#
#
#    def showTransistionRegion(self,polar='o'):
#        """
#
#        Notes
#        -----
#
#        See  : "Analyzing the Transitional Region in Low Power Wireless Links"
#                Marco Zuniga and Bhaskar Krishnamachari
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            > from pylayers.antprop.coverage import *
#            > C = Coverage()
#            > C.cover()
#            > C.showTransitionRegion()
#
#        """
#
#        frameLength = self.framelengthbytes
#
#        PndBm = self.pndbm
#        gammaU = 10*np.log10(-1.28*np.log(2*(1-0.9**(1./(8*frameLength)))))
#        gammaL = 10*np.log10(-1.28*np.log(2*(1-0.1**(1./(8*frameLength)))))
#
#        PrU = PndBm + gammaU
#        PrL = PndBm + gammaL
#
#        fig,ax = self.L.showGs()
#
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
#        zones = np.zeros(np.shape(prdbm))
#        #pdb.set_trace()
#
#        uconnected  = np.nonzero(prdbm>PrU)
#        utransition = np.nonzero((prdbm < PrU)&(prdbm > PrL))
#        udisconnected = np.nonzero(prdbm < PrL)
#
#        zones[uconnected] = 1
#        zones[utransition] = (prdbm[utransition]-PrL)/(PrU-PrL)
#        cov = ax.imshow(zones.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'BuGn',origin='lower')
#
#        title='PDR region'
#        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
#
#        ax.set_title(title)
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        fig.colorbar(cov,cax)
#        if self.show:
#            plt.show()
#
    def plot(self,**kwargs):
        """
        """
        defaults = { 'typ': 'pr',
                     'grid': False,
                     'f' : 0,
                     'a' : 0,
                     'db':True,
                     'col':'b'
                   }
        for k in defaults:
            if k not in kwargs:
                kwargs[k]=defaults[k]

        if 'fig' in kwargs:
            fig=kwargs['fig']
        else:
            fig=plt.figure()

        if 'ax' in kwargs:
            ax = kwargs['ax']
        else:
            ax = fig.add_subplot(111)

        if kwargs['typ']=='pr':
            if kwargs['a']<>-1:
                U = self.CmW[kwargs['f'],:,kwargs['a']]
            else:
                U = self.CmW[kwargs['f'],:,:].reshape(self.na*self.ng)
            if kwargs['db']:
                U = 10*np.log10(U)

        D = np.sqrt(np.sum((self.pa-self.pg)*(self.pa-self.pg),axis=0))
        if kwargs['a']<>-1:
            D = D.reshape(self.ng,self.na)
            ax.semilogx(D[:,kwargs['a']],U,'.',color=kwargs['col'])
        else:
            ax.semilogx(D,U,'.',color=kwargs['col'])

        return fig,ax

    def show(self,**kwargs):
        """ show coverage

        Parameters
        ----------

        typ : string
            'pr' | 'sinr' | 'capacity' | 'loss' | 'best' | 'egd'
        grid : boolean
        polar : string
            'o' | 'p'
        best : boolean
            draw best server contour if True
        f : int
            frequency index
        a : int
            access point index (-1 all access point)

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a = C.show(typ='pr',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='best',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='loss',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='sinr',figsize=(10,8))
            >>> plt.show()

        See Also
        --------

        pylayers.gis.layout.Layout.showG

        """
        defaults = { 'typ': 'pr',
                     'grid': False,
                     'polar':'p',
                     'f' : 0,
                     'a' :-1,
                     'db':True,
                     'cmap' :cm.jet,
                     'best':True
                   }

        title = self.dap[1].s.name+ ' : '

        for k in defaults:
            if k not in kwargs:
                kwargs[k]=defaults[k]
        polar = kwargs['polar']
        if 'fig' in kwargs:
            if 'ax' in kwargs:
                fig,ax=self.L.showG('s',fig=kwargs['fig'],ax=kwargs['ax'])
            else:
                fig,ax=self.L.showG('s',fig=kwargs['fig'])
        else:
            if 'figsize' in kwargs:
                fig,ax=self.L.showG('s',figsize=kwargs['figsize'])
            else:
                fig,ax=self.L.showG('s')

        # plot the grid
        if kwargs['grid']:
            for k in self.dap:
                p = self.dap[k].p
                ax.plot(p[0],p[1],'or')

        f = kwargs['f']
        a = kwargs['a']
        typ = kwargs['typ']
        best = kwargs['best']

        dB = kwargs['db']

        # setting the grid

        l = self.grid[0,0]
        r = self.grid[-1,0]
        b = self.grid[0,1]
        t = self.grid[-1,-1]

        if typ=='best':
            title = title + 'Best server'+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
            for ka in range(self.na):
                if polar=='p':
                    bestsv =  self.bestsvp[f,:,ka]
                if polar=='o':    
                    bestsv =  self.bestsvo[f,:,ka]
                m = np.ma.masked_where(bestsv == 0,bestsv)
                if self.mode<>'file':
                    W = m.reshape(self.nx,self.ny).T
                    ax.imshow(W, extent=(l,r,b,t),
                            origin='lower',
                            vmin=1,
                            vmax=self.na+1)
                else:
                    ax.scatter(self.grid[:,0],self.grid[:,1],c=m,s=20,linewidth=0)
            ax.set_title(title)
        else:
            if typ=='egd':
                title = title + 'excess group delay : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
                V = self.Ed
                dB = False
                legcb =  'Delay (ns)'
            if typ=='sinr':
                title = title + 'SINR : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar=='o':        
                    V = self.sinro
                if polar=='p':    
                    V = self.sinrp
            if typ=='snr':
                title = title + 'SNR : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar=='o':
                    V = self.snro
                if polar=='p':
                    V = self.snrp
            if typ=='capacity':
                title = title + 'Capacity : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
                legcb = 'Mbit/s'
                if polar=='o':
                    V = self.bmhz.T[np.newaxis,:]*np.log(1+self.sinro)/np.log(2)
                if polar=='p':
                    V = self.bmhz.T[np.newaxis,:]*np.log(1+self.sinrp)/np.log(2)
            if typ=='pr':
                title = title + 'Pr : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
                if dB:
                    legcb = 'dBm'
                else:
                    lgdcb = 'mW'
                if polar=='o':
                    V = self.CmWo
                if polar=='p':
                    V = self.CmWp

            if typ=='loss':
                title = title + 'Loss : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar=='o':
                    V = self.Lwo*self.freespace
                if polar=='p':
                    V = self.Lwp*self.freespace

            if a == -1:
                V = np.max(V[f,:,:],axis=1)
            else:
                V = V[f,:,a]

            # reshaping the data on the grid
            if self.mode!='file':
                U = V.reshape((self.nx,self.ny)).T
            else:
                U = V

            if dB:
                U = 10*np.log10(U)

            if 'vmin' in kwargs:
                vmin = kwargs['vmin']
            else:
                vmin = U.min()

            if 'vmax' in kwargs:
                vmax = kwargs['vmax']
            else:
                vmax = U.max()

            if self.mode!='file':
                img = ax.imshow(U,
                            extent=(l,r,b,t),
                            origin='lower',
                            vmin = vmin,
                            vmax = vmax,
                            cmap = kwargs['cmap'])
            else:
                img=ax.scatter(self.grid[:,0],self.grid[:,1],c=U,s=20,linewidth=0,cmap=kwargs['cmap'])

            for k in range(self.na):
                ax.annotate(str(k),xy=(self.pa[0,k],self.pa[1,k]))
            ax.set_title(title)

            divider = make_axes_locatable(ax)
            cax = divider.append_axes("right", size="5%", pad=0.05)
            clb = fig.colorbar(img,cax)
            clb.set_label(legcb)
            if best:
                if self.mode<>'file':
                    if polar=='o':
                        ax.contour(np.sum(self.bestsvo,axis=2)[f,:].reshape(self.nx,self.ny).T,extent=(l,r,b,t),linestyles='dotted')
                    if polar=='p':
                        ax.contour(np.sum(self.bestsvp,axis=2)[f,:].reshape(self.nx,self.ny).T,extent=(l,r,b,t),linestyles='dotted')

        # display access points
        if a==-1:
            ax.scatter(self.pa[0,:],self.pa[1,:],s=30,c='r',linewidth=0)
        else:
            ax.scatter(self.pa[0,a],self.pa[1,a],s=30,c='r',linewidth=0)
        plt.tight_layout()
        return(fig,ax)
示例#22
0
class Simul(PyLayers):
    """
    Link oriented simulation

    A simulation requires :

        + A Layout
        + A Person
        + A Trajectory

    or a CorSer instance

    Members
    -------

    dpersons : dictionnary of persons (agent)
    dap : dictionnary of access points

    Methods
    -------

    load_simul : load configuration file
    load_Corser : load a Corser file
    _gen_net : generate network and asociated links
    show : show layout and network
    evaldeter : run simulation over time


    """
    def __init__(self, source='simulnet_TA-Office.h5', verbose=False):
        """ object constructor

        Parameters
        ----------

        source : string
            h5 trajectory file default simulnet_TA-Office.h5

        verbose : boolean

        Notes
        -----

        The simultraj has a dataframe


        """

        # self.progress = -1  # simulation not loaded
        self.verbose = verbose
        self.cfield = []
        self.dpersons = {}

        self.dap = {}
        self.Nag = 0
        self.Nap = 0

        # source analysis
        if isinstance(source, str):
            self.filetraj = source
            self.load_simul(source)
            self.source = 'simul'
        elif 'pylayers' in source.__module__:
            self.filetraj = source._filename
            self.load_CorSer(source)
            cutoff = 2
            self.source = 'CorSer'

        # generate the Network
        # The wireless standard and frequency is fixed in this function
        #
        self._gen_net()
        # initialize Stochastic Link
        self.SL = SLink()
        # initialize Deterministic Link
        self.DL = DLink(L=self.L, verbose=self.verbose)
        self.DL.cutoff = cutoff

        self.filename = 'simultraj_' + self.filetraj + '.h5'

        # data is a panda container which is initialized
        #
        # We do not save all the simulation in a DataFRame anymore
        #
        #self.data = pd.DataFrame(columns=['id_a', 'id_b',
        #                                  'x_a', 'y_a', 'z_a',
        #                                  'x_b', 'y_b', 'z_b',
        #                                  'd', 'eng', 'typ',
        #                                  'wstd', 'fcghz',
        #                                  'fbminghz', 'fbmaxghz', 'fstep', 'aktk_id',
        #                                  'sig_id', 'ray_id', 'Ct_id', 'H_id'
        #                                  ])

        #self.data.index.name='t'
        self._filecsv = self.filename.split('.')[0] + '.csv'
        self.todo = {'OB': True, 'B2B': True, 'B2I': True, 'I2I': False}

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])

        if os.path.exists(filenameh5):
            self.loadpd()
        self.settime(0.)
        # self._saveh5_init()

    def __repr__(self):

        s = 'Simul trajectories class\n'
        s = s + '------------------------\n'
        s = s + '\n'
        s = s + 'Used layout: ' + self.L.filename + '\n'
        s = s + 'Number of Agents: ' + str(self.Nag) + '\n'
        s = s + 'Number of Access Points: ' + str(self.Nap) + '\n'
        s = s + 'Link to be evaluated: ' + str(self.todo) + '\n'
        s = s + 'tmin: ' + str(self._tmin) + '\n'
        s = s + 'tmax: ' + str(self._tmax) + '\n'
        s = s + '\n'
        # network info
        s = s + 'self.N :\n'
        s = s + self.N.__repr__() + '\n'
        s = s + 'CURRENT TIME: ' + str(self.ctime) + '\n'

        return s

    def load_simul(self, source):
        """  load a simultraj configuration file

        Parameters
        ----------

        source : string
            name of simulation file to be loaded

        """
        self.filetraj = source
        if not os.path.isfile(source):
            raise AttributeError('Trajectory file' + source +
                                 'has not been found.\
             Please make sure you have run a simulnet simulation before runining simultraj.'
                                 )

        # get the trajectory
        traj = tr.Trajectories()
        traj.loadh5(self.filetraj)

        # get the layout
        self.L = Layout(traj.Lfilename)

        # resample trajectory
        for ut, t in enumerate(traj):
            if t.typ == 'ag':
                person = Body(t.name + '.ini')
                tt = t.time()
                self.dpersons.update({t.name: person})
                self._tmin = tt[0]
                self._tmax = tt[-1]
                self.time = tt
            else:
                pos = np.array([t.x[0], t.y[0], t.z[0]])
                self.dap.update({
                    t.ID: {
                        'pos': pos,
                        'ant': antenna.Antenna(),
                        'name': t.name
                    }
                })
        self.ctime = np.nan
        self.Nag = len(self.dpersons.keys())
        self.Nap = len(self.dap.keys())
        self.traj = traj

    def load_CorSer(self, source):
        """ load CorSer file for simulation

        Parameters
        ----------

        source :
            name of simulation file to be loaded

        """

        if isinstance(source.B, Body):
            B = [source.B]
        elif isinstance(source.B, list):
            B = source.B
        elif isinstance(source.B, dict):
            B = source.B.values()
        else:
            raise AttributeError('CorSer.B must be a list or a Body')
        self.L = source.L
        self.traj = tr.Trajectories()
        self.traj.Lfilename = self.L._filename

        for b in B:
            self.dpersons.update({b.name: b})
            self._tmin = b.time[0]
            self._tmax = b.time[-1]
            self.time = b.time
            self.traj.append(b.traj)

        for ap in source.din:
            techno, ID = ap.split(':')
            if techno == 'HKB':
                techno = 'hikob'
            if techno == 'TCR':
                techno = 'tcr'
            if techno == 'BS':
                techno = 'bespoon'

            self.dap.update({
                ap: {
                    'pos': source.din[ap]['p'],
                    'ant': source.din[ap]['ant'],
                    'T': source.din[ap]['T'],
                    'name': techno
                }
            })
        self.ctime = np.nan
        self.Nag = len(B)
        self.Nap = len(source.din)
        self.corser = source

    def _gen_net(self):
        """ generate Network and associated links

        Notes
        -----

        Create self.N : Network object

        See Also
        --------

        pylayers.network.network

        """

        #
        # Create Network
        #
        N = Network()
        #
        # get devices on bodies
        #
        # forall person
        #   forall device
        for p in self.dpersons:
            D = []
            for dev in self.dpersons[p].dev:
                aDev = Device(self.dpersons[p].dev[dev]['name'], ID=dev)
                D.append(aDev)

                D[-1].ant['A1']['name'] = self.dpersons[p].dev[dev]['file']
                D[-1].ant['antenna'] = self.dpersons[p].dev[dev]['ant']
            N.add_devices(D, grp=p)
        #
        # get access point devices
        #
        for ap in self.dap:
            D = Device(self.dap[ap]['name'], ID=ap)
            D.ant['antenna'] = self.dap[ap]['ant']
            N.add_devices(D, grp='ap', p=self.dap[ap]['pos'])
            N.update_orient(ap, self.dap[ap]['T'], now=0.)
        # create Network
        #
        #    _get_wstd
        #    _get_grp
        #    _connect
        #    _init_PN
        #
        N.create()
        self.N = N

    def show(self):
        """ show actual simlulation configuration
        """
        fig, ax = self.L.showGs()
        fig, ax = self.N.show(fig=fig, ax=ax)
        return fig, ax

    def evaldeter(self, na, nb, wstd, fmod='force', nf=10, fGHz=[], **kwargs):
        """ deterministic evaluation of a link

        Parameters
        ----------

        na : string:
            node a id in self.N (Network)
        nb : string:
            node b id in self.N (Network)
        wstd : string:
            wireless standard used for commmunication between na and nb
        fmode : string ('center'|'band'|'force')
            mode of frequency evaluation
            center : single frequency (center frequency of a channel)
            band : nf points on the whole band
            force : takes directly fGHz
        nf : int:
            number of frequency points (if fmode = 'band')
        **kwargs : argument of DLink

        Returns
        -------

        (a, t )

        a : ndarray
            alpha_k
        t : ndarray
            tau_k

        See Also
        --------

        pylayers.simul.link.DLink

        """

        # todo in network :
        # take into consideration the postion and rotation of antenna and not device

        self.DL.Aa = self.N.node[na]['ant']['antenna']
        self.DL.a = self.N.node[na]['p']
        self.DL.Ta = self.N.node[na]['T']

        self.DL.Ab = self.N.node[nb]['ant']['antenna']
        self.DL.b = self.N.node[nb]['p']
        self.DL.Tb = self.N.node[nb]['T']

        #
        # The frequency band is chosen from the selected standard
        #  if fmode == 'center'
        #      only center frequency is calculated
        #
        #'
        if fmod == 'center':
            self.DL.fGHz = self.N.node[na]['wstd'][wstd]['fcghz']
        if fmod == 'band':
            fminGHz = self.N.node[na]['wstd'][wstd]['fbminghz']
            fmaxGHz = self.N.node[na]['wstd'][wstd]['fbmaxghz']
            self.DL.fGHz = np.linspace(fminGHz, fmaxGHz, nf)
        if fmod == 'force':
            assert len(fGHz) > 0, "fGHz has not been defined"
            self.DL.fGHz = fGHz

        a, t = self.DL.eval(**kwargs)

        return a, t

    def evalstat(self, na, nb):
        """ statistical evaluation of a link

        Parameters
        ----------

        na : string:
            node a id in self.N (Netwrok)
        nb : string:
            node b id in self.N (Netwrok)

        Returns
        -------

        (a, t, eng)

        a : ndarray
            alpha_k
        t : ndarray
            tau_k
        eng : float
            engagement
        """

        pa = self.N.node[na]['p']
        pb = self.N.node[nb]['p']
        if self.source == 'simul':
            dida, name = na.split('_')
            didb, name = nb.split('_')
        elif self.source == 'CorSer':
            bpa, absolutedida, dida, name, technoa = self.corser.devmapper(na)
            bpb, absolutedidb, didb, name, technob = self.corser.devmapper(nb)

        ak, tk, eng = self.SL.onbody(self.dpersons[name], dida, didb, pa, pb)

        return ak, tk, eng

    def settime(self, t):
        """ set current time
        """
        self.ctime = t
        self._traj = copy.copy(self.traj)
        self.update_pos(t)

    def run(self, **kwargs):
        """ run the link evaluation along a trajectory


        Parameters
        ----------

        OB: boolean
            perform on body statistical link evaluation
        B2B:  boolean
            perform body to body deterministic link evaluation
        B2I: boolean
            perform body to infrastructure deterministic link evaluation
        I2I:  boolean
            perform infrastructure to infrastructure deterministic link eval.
        links: dict
            dictionnary of link to be evaluated (key is wtsd and value is a list of links)
            (if [], all link are considered)
        wstd: list
            list of wstd to be evaluated
            (if [], all wstd are considered)
        t: np.array
            list of timestamp to be evaluated
            (if [], all timestamps are considered)
        tbr : boolean
            time in bit reverse order (tmin,tmax,N) Npoints=2**N
        replace_data: boolean (True)
            if True , reference id of all already simulated link will be erased
                and replace by new simulation id

        fGHz : np.array
            frequency in GHz


        Examples
        --------

        >>> from pylayers.simul.simultraj import *
        >>> from pylayers.measures.cormoran import *
        >>> C=CorSer(layout=True)
        >>> S=Simul(C,verbose=True)
        >>> link={'ieee802154':[]}
        >>> link['ieee802154'].append(S.N.links['ieee802154'][0])
        >>> lt = [0,0.2,0.3,0.4,0.5]
        >>> S.run(links=link,t=lt)


        """
        defaults = {
            'OB': True,
            'B2B': True,
            'B2I': True,
            'I2I': False,
            'links': {},
            'wstd': [],
            't': np.array([]),
            'btr': True,
            'DLkwargs': {},
            'replace_data': True,
            'fmod': 'force',
            'fGHz': np.array([2.45])
        }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        DLkwargs = kwargs.pop('DLkwargs')
        links = kwargs.pop('links')
        wstd = kwargs.pop('wstd')
        OB = kwargs.pop('OB')
        B2B = kwargs.pop('B2B')
        B2I = kwargs.pop('B2I')
        I2I = kwargs.pop('I2I')
        fmod = kwargs.pop('fmod')
        self.fGHz = kwargs.pop('fGHz')

        self.todo.update({'OB': OB, 'B2B': B2B, 'B2I': B2I, 'I2I': I2I})

        # Check link attribute

        if links == {}:
            links = self.N.links
        elif not isinstance(links, dict):
            raise AttributeError(
                'links is {wstd:[list of links]}, see self.N.links')

        for k in links.keys():
            checkl = [l in self.N.links[k] for l in links[k]]
            if len(np.where(checkl == False)[0]) > 0:
                # if sum(checkl) != len(self.N.links):
                uwrong = np.where(np.array(checkl) is False)[0]
                raise AttributeError(
                    str(np.array(links)[uwrong]) +
                    ' links does not exist in Network')

        wstd = links.keys()
        # # Check wstd attribute
        # if wstd == []:
        #     wstd = self.N.wstd.keys()
        # elif not isinstance(wstd, list):
        #     wstd = [wstd]

        checkw = [w in self.N.wstd.keys() for w in wstd]
        if sum(checkw) != len(wstd):
            uwrong = np.where(np.array(checkw) is False)[0]
            raise AttributeError(
                str(np.array(wstd)[uwrong]) + ' wstd are not in Network')

        # force time attribute compliant

        if not isinstance(kwargs['t'], np.ndarray):
            if isinstance(kwargs['t'], list):
                lt = np.array(kwargs['t'])
            elif (isinstance(kwargs['t'], int)
                  or isinstance(kwargs['t'], float)):
                lt = np.array([kwargs['t']])
        else:
            lt = kwargs['t']

        #if len(lt) == 0:
        #    lt = self.time
        # check time attribute
        if kwargs['btr']:
            if (lt[0] < self._tmin) or\
               (lt[1] > self._tmax) :
                raise AttributeError('Requested time range not available')

        # self._traj is a copy of self.traj, which is affected by resampling.
        # it is only a temporary attribute for a given run
        # if len(lt) > 1:
        #     sf = 1/(1.*lt[1]-lt[0])
        #     self._traj = self.traj.resample(sf=sf, tstart=lt[0])

        # else:
        #     self._traj = self.traj.resample(sf=1.0, tstart=lt[0])
        #     self._traj.time()
        # self.time = self._traj.t
        # self._time = pd.to_datetime(self.time,unit='s')
        #
        # Nested Loops
        #
        #  time
        #    standard
        #      links
        #           evaldeter &| evalstat
        #
        #lt = self.get_sim_time(lt)
        #self._time=self.get_sim_time(lt)

        init = True
        if kwargs['btr']:
            tmin = lt[0]
            tmax = lt[1]
            Nt = int(2**lt[2])
            ta = np.linspace(tmin, tmax, Nt)
            it = np.hstack((np.r_[0], np.r_[pyu.bitreverse(Nt, int(lt[2]))]))
            #trev = t[it]
        else:
            ta = kwargs['t']
            it = range(len(ta))

        ## Start to loop over time
        ##   ut : counter
        ##   t  : time value (s)
        #for ut, t in enumerate(lt):
        for ks, ut in enumerate(it):
            t = ta[ut]
            self.ctime = t
            # update spatial configuration of the scene for time t
            self.update_pos(t)
            # print self.N.__repr__()
            ## Start to loop over available Wireless standard
            ##
            for w in wstd:
                ## Start to loop over the chosen links stored in links
                ##
                for na, nb, typ in links[w]:
                    # If type of link is valid (Body 2 Body,...)
                    #
                    if self.todo[typ]:
                        if self.verbose:
                            print '-' * 30
                            print 'time:', t, '/', lt[-1], ' time idx:', ut,
                            '/', len(ta), '/', ks
                            print 'processing: ', na, ' <-> ', nb, 'wstd: ', w
                            print '-' * 30
                        eng = 0
                        #
                        # Invoque link deterministic simulation
                        #
                        #  node : na
                        #  node : nb
                        #  wstd : w
                        #
                        self.evaldeter(na,
                                       nb,
                                       w,
                                       applywav=False,
                                       fmod=fmod,
                                       fGHz=self.fGHz,
                                       **DLkwargs)
                        # if typ == 'OB':
                        #     self.evalstat(na, nb)
                        #     eng = self.SL.eng
                        #     L = self.DL + self.SL
                        #     self._ak = L.H.ak
                        #     self._tk = L.H.tk
                        # else :

                        # Get alphak an tauk
                        self._ak = self.DL.H.ak
                        self._tk = self.DL.H.tk
                        aktk_id = str(ut) + '_' + na + '_' + nb + '_' + w
                        # this is a dangerous way to proceed !
                        # the id as a finite number of characters
                        while len(aktk_id) < 40:
                            aktk_id = aktk_id + ' '
                        df = pd.DataFrame(
                            {
                                'id_a': na,
                                'id_b': nb,
                                'x_a': self.N.node[na]['p'][0],
                                'y_a': self.N.node[na]['p'][1],
                                'z_a': self.N.node[na]['p'][2],
                                'x_b': self.N.node[nb]['p'][0],
                                'y_b': self.N.node[nb]['p'][1],
                                'z_b': self.N.node[nb]['p'][2],
                                'd': self.N.edge[na][nb]['d'],
                                'eng': eng,
                                'typ': typ,
                                'wstd': w,
                                'fcghz': self.N.node[na]['wstd'][w]['fcghz'],
                                'fbminghz': self.fGHz[0],
                                'fbmaxghz': self.fGHz[-1],
                                'nf': len(self.fGHz),
                                'aktk_id': aktk_id,
                                'sig_id': self.DL.dexist['sig']['grpname'],
                                'ray_id': self.DL.dexist['ray']['grpname'],
                                'Ct_id': self.DL.dexist['Ct']['grpname'],
                                'H_id': self.DL.dexist['H']['grpname'],
                            },
                            columns=[
                                'id_a', 'id_b', 'x_a', 'y_a', 'z_a', 'x_b',
                                'y_b', 'z_b', 'd', 'eng', 'typ', 'wstd',
                                'fcghz', 'fbminghz', 'fbmaxghz', 'fstep',
                                'aktk_id', 'sig_id', 'ray_id', 'Ct_id', 'H_id'
                            ],
                            index=[t])  #self._time[ut]])

                        self.savepd(df)

    def replace_data(self, df):
        """check if a dataframe df already exists in self.data

        Parameters
        ----------
        df : pd.DataFrame

        Returns
        -------

        boolean
            True if already exists
            False otherwise

        """
        self.data[(self.data.index == df.index)
                  & (self.data['id_a'] == df['id_a'].values[0]) &
                  (self.data['id_b'] == df['id_b'].values[0]) &
                  (self.data['wstd'] == df['wstd'].values[0])] = df.values

    def check_exist(self, df):
        """check if a dataframe df already exists in self.data

        Parameters
        ----------
        df : pd.DataFrame

        Returns
        -------

        boolean
            True if already exists
            False otherwise

        """
        # check init case
        if not len(self.data.index) == 0:

            ud = self.data[(self.data.index == df.index)
                           & (self.data['id_a'] == df['id_a'].values[0]) &
                           (self.data['id_b'] == df['id_b'].values[0]) &
                           (self.data['wstd'] == df['wstd'].values[0])]

            if len(ud) == 0:
                return False
            else:
                return True
        else:
            return False

    def savepd(self, df):
        """ save data information of a simulation

        Parameters
        ----------

        df : one index data

        Notes
        -----


        """
        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        store = pd.HDFStore(filenameh5)
        #self.data=self.data.sort()
        store.append('df', df)
        store.close()

    def loadpd(self):
        """ load data from previous simulations
        """
        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        store = pd.HDFStore(filenameh5)
        #self.data = pd.read_hdf(filenameh5,'df')
        self.data = store.get('df')
        self.data.index.name = 't'
        self.data = self.data.sort()

    def get_sim_time(self, t):
        """ retrieve closest time value in regard of passed t value in parameter
        """

        if not isinstance(t, list) and not isinstance(t, np.ndarray):
            return np.array([self.time[np.where(self.time <= t)[0][-1]]])
        else:
            return np.array([self.get_sim_time(tt) for tt in t])[:, 0]

    def get_df_from_link(self, id_a, id_b, wstd=''):
        """ Return a restricted data frame for a specific link

            Parameters
            ----------

            id_a : str
                node id a
            id_b: str
                node id b
            wstd: str
                optionnal :wireslees standard
        """
        if wstd == '':
            return self.data[(self.data['id_a'] == id_a)
                             & (self.data['id_b'] == id_b)]
        else:
            return self.data[(self.data['id_a'] == id_a)
                             & (self.data['id_b'] == id_b)
                             & self.data['wstd'] == wstd]

    def update_pos(self, t):
        """ update positions of devices and bodies for a given time index

        Parameters
        ----------

        t : int
            time value

        """

        # if a bodies are involved in simulation
        if ((self.todo['OB']) or (self.todo['B2B']) or (self.todo['B2I'])):
            nodeid = []
            pos = []
            devlist = []
            orient = []
            for up, person in enumerate(self.dpersons.values()):
                person.settopos(self._traj[up], t=t, cs=True)
                name = person.name
                dev = person.dev.keys()
                devlist.extend(dev)
                #nodeid.extend([n + '_' + name for n in dev])
                pos.extend([person.dcs[d][:, 0] for d in dev])
                orient.extend([person.acs[d] for d in dev])
            # TODO !!!!!!!!!!!!!!!!!!!!
            # in a future version , the network update must also update
            # antenna position in the device coordinate system
            self.N.update_pos(devlist, pos, now=t)
            self.N.update_orient(devlist, orient, now=t)
        self.N.update_dis()

    def get_value(self, **kwargs):
        """ retrieve output parameter at a specific time

        Parameters
        ----------

        typ : list
                list of parameters to be retrieved
                (R | C |H | ak | tk | rss )
        links: list
            dictionnary of link to be evaluated (key is wtsd and value is a list of links)
            (if [], all link are considered)
        t: int or np.array
            list of timestamp to be evaluated | singlr time instant

        Returns
        -------

        output: dict
                [link_key]['t']
                          ['ak']
                ...
        """

        # get time
        defaults = {
            't': 0,
            'typ': ['ak'],
            'links': {},
            'wstd': [],
            'angles': False
        }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        # allocate an empty dictionnary for wanted selected output
        output = {}

        # manage time t can be a list or a float
        t = kwargs['t']
        t = self.get_sim_time(t)
        dt = self.time[1] - self.time[0]

        # manage links
        plinks = kwargs['links']
        links = []
        if isinstance(plinks, dict):
            for l in plinks.keys():
                links.extend(plinks[l])

        if len(links) == 0:
            raise AttributeError('Please give valid links to get values')
        # output['t']=[]
        # output['time_to_simul']=[]
        # for each requested time step
        for tt in t:
            # for each requested links
            for link in links:
                linkname = link[0] + '-' + link[1]
                if not output.has_key(linkname):
                    output[linkname] = {}
                if not output[linkname].has_key('t'):
                    output[linkname]['t'] = []

                # restrict global dataframe self.data to the specific link
                df = self.get_df_from_link(link[0], link[1])
                # restrict global dataframe self.data to the specific z
                df = df[(df.index > tt - dt) & (df.index <= tt + dt)]

                if len(df) != 0:
                    output[linkname]['t'].append(tt)
                    if len(df) > 1:
                        print 'Warning possible issue in self.get_value'
                    line = df.iloc[-1]
                    # # get info of the corresponding timestamp
                    # line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])].iloc[-1]
                    # if len(line) == 0:
                    #     line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
                    #     if len(line) == 0:
                    #         raise AttributeError('invalid link')

                    #retrieve correct position and orientation given the time
                    #self.update_pos(t=tt)
                    # antennas positions
                    #self.DL.a = self.N.node[link[0]]['p']
                    #self.DL.b = self.N.node[link[1]]['p']
                    # antennas orientation
                    #self.DL.Ta = self.N.node[link[0]]['T']
                    #self.DL.Tb = self.N.node[link[1]]['T']
                    # antennas object
                    #self.DL.Aa = self.N.node[link[0]]['ant']['antenna']
                    #self.DL.Ab = self.N.node[link[1]]['ant']['antenna']
                    # get the antenna index
                    #uAa_opt, uAa = self.DL.get_idx('A_map',self.DL.Aa._filename)
                    #uAb_opt, uAb = self.DL.get_idx('A_map',self.DL.Ab._filename)

                    if 'ak' in kwargs['typ'] or 'tk' in kwargs[
                            'typ'] or 'rss' in kwargs['typ']:
                        H_id = line['H_id'].decode('utf8')
                        # load the proper link
                        # parse index
                        lid = H_id.split('_')
                        #if (lid[5]==str(uAa))&(lid[6]==str(uAb)):
                        self.DL.load(self.DL.H, H_id)
                        if 'ak' in kwargs['typ']:
                            if not output[linkname].has_key('ak'):
                                output[linkname]['ak'] = []
                            output[linkname]['ak'].append(
                                copy.deepcopy(self.DL.H.ak))
                        if 'tk' in kwargs['typ']:
                            if not output[linkname].has_key('tk'):
                                output[linkname]['tk'] = []
                            output[linkname]['tk'].append(
                                copy.deepcopy(self.DL.H.tk))
                        if 'rss' in kwargs['typ']:
                            if not output[linkname].has_key('rss'):
                                output[linkname]['rss'] = []
                            output[linkname]['rss'].append(
                                copy.deepcopy(self.DL.H.rssi()))

                    if 'R' in kwargs['typ']:
                        if not output[linkname].has_key('R'):
                            output[linkname]['R'] = []
                        ray_id = line['ray_id']
                        self.DL.load(self.DL.R, ray_id)
                        output[linkname]['R'].append(copy.deepcopy(self.DL.R))

                    if 'C' in kwargs['typ']:
                        if not output[linkname].has_key('C'):
                            output[linkname]['C'] = []
                        Ct_id = line['Ct_id']
                        self.DL.load(self.DL.C, Ct_id)

                        if kwargs['angles']:
                            self.DL.C.islocal = False
                            self.DL.C.locbas(Tt=self.DL.Ta, Tr=self.DL.Tb)
                        #T channel
                        output[linkname]['C'].append(copy.deepcopy(self.DL.C))

                    if 'H' in kwargs['typ']:
                        if not output[linkname].has_key('H'):
                            output[linkname]['H'] = []
                        H_id = line['H_id']
                        lid = H_id.split('_')
                        #if (lid[5]==str(uAa))&(lid[6]==str(uAb)):
                        self.DL.load(self.DL.H, H_id)
                        output[linkname]['H'].append(copy.deepcopy(self.DL.H))

                # if time value not found in dataframe
                else:
                    if not output[linkname].has_key('time_to_simul'):
                        output[linkname]['time_to_simul'] = []
                    output[linkname]['time_to_simul'].append(tt)

        for l in output.keys():
            if output[l].has_key('time_to_simul'):
                print 'link', l, 'require simulation for timestamps', output[
                    l]['time_to_simul']

        return (output)

    def get_link(self, **kwargs):
        """ retrieve a Link specific time from a simultraj

        Parameters
        ----------

        typ : list
                list of parameters to be retrieved
                (ak | tk | R |C)
        links: list
            dictionnary of link to be evaluated (key is wtsd and value is a list of links)
            (if [], all link are considered)
        t: int or np.array
            list of timestamp to be evaluated | singlr time instant

        Returns
        -------

        DL : DLink

        Examples
        --------

            >>> from pylayers.simul.simultraj import *
            >>> from pylayers.measures.cormoran import *
            >>> C=CorSer(serie=6,day=11,layout=True)
            >>> S = Simul(C,verbose=False)
            >>> DL = S.get_link(typ=['R','C','H'])
        """

        # get time
        defaults = {
            't': 0,
            'typ': ['ak'],
            'links': {},
            'wstd': [],
            'angles': False
        }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        output = {}

        # manage time
        t = kwargs['t']
        t = self.get_sim_time(t)
        dt = self.time[1] - self.time[0]

        # manage links
        plinks = kwargs['links']
        links = []
        if isinstance(plinks, dict):
            for l in plinks.keys():
                links.extend(plinks[l])

        if len(links) == 0:
            raise AttributeError('Please give valid links to get values')
        # output['t']=[]
        # output['time_to_simul']=[]
        # for each requested time step
        for tt in t:
            # for each requested links
            for link in links:
                linkname = link[0] + '-' + link[1]
                if not output.has_key(linkname):
                    output[linkname] = {}
                if not output[linkname].has_key('t'):
                    output[linkname]['t'] = []

                # restrict global dataframe self.data to the specific link
                df = self.get_df_from_link(link[0], link[1])
                # restrict global dataframe self.data to the specific z
                df = df[(df.index > tt - dt) & (df.index <= tt + dt)]

                if len(df) != 0:
                    output[linkname]['t'].append(tt)
                    if len(df) > 1:
                        print 'Warning possible issue in self.get_link'
                    line = df.iloc[-1]
                    # # get info of the corresponding timestamp
                    # line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])].iloc[-1]
                    # if len(line) == 0:
                    #     line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
                    #     if len(line) == 0:
                    #         raise AttributeError('invalid link')

                    #retrieve correct position and orientation given the time
                    self.update_pos(t=tt)
                    self.DL.a = self.N.node[link[0]]['p']
                    self.DL.b = self.N.node[link[1]]['p']
                    self.DL.Ta = self.N.node[link[0]]['T']
                    self.DL.Tb = self.N.node[link[1]]['T']
                    #self.DL.Aa = self.N.node[link[0]]['ant']['antenna']
                    #self.DL.Ab = self.N.node[link[1]]['ant']['antenna']

                    #H_id = line['H_id'].decode('utf8')
                    #self.DL.load(self.DL.H,H_id)

                    if 'R' in kwargs['typ']:
                        ray_id = line['ray_id']
                        self.DL.load(self.DL.R, ray_id)

                    if 'C' in kwargs['typ']:
                        Ct_id = line['Ct_id']
                        self.DL.load(self.DL.C, Ct_id)

                        if kwargs['angles']:
                            self.DL.C.islocal = False
                            self.DL.C.locbas(Tt=self.DL.Ta, Tr=self.DL.Tb)

                    if 'H' in kwargs['typ']:
                        H_id = line['H_id']
                        self.DL.load(self.DL.H, H_id)

        return (self.DL)

    def _show3(self, **kwargs):
        """ 3D show using Mayavi

        Parameters
        ----------

        t: float
            time index
        link: list
            [id_a, id_b]
            id_a : node id a
            id_b : node id b
        'lay': bool
            show layout
        'net': bool
            show net
        'body': bool
            show bodies
        'rays': bool
            show rays
        """

        defaults = {
            't': 0,
            'link': [],
            'wstd': [],
            'lay': True,
            'net': True,
            'body': True,
            'rays': True,
            'ant': False
        }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        link = kwargs['link']
        self.update_pos(kwargs['t'])

        if len(self.data) != 0:
            df = self.data[self.data.index == pd.to_datetime(kwargs['t'])]
            if len(df) != 0:
                raise AttributeError('invalid time')

            # default
            if link == []:
                line = df[df.index <= pd.to_datetime(0)]
                link = [line['id_a'].values[0], line['id_b'].values[0]]
            else:
                # get info of the corresponding timestamp
                line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])]
            if len(line) == 0:
                line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
                if len(line) == 0:
                    raise AttributeError('invalid link')
            rayid = line['ray_id'].values[0]

            self.DL.a = self.N.node[link[0]]['p']
            self.DL.b = self.N.node[link[1]]['p']
            self.DL.Ta = self.N.node[link[0]]['T']
            self.DL.Tb = self.N.node[link[1]]['T']
            self.DL.load(self.DL.R, rayid)

            self.DL._show3(newfig=False,
                           lay=kwargs['lay'],
                           rays=kwargs['rays'],
                           ant=False)
        else:
            self.DL._show3(newfig=False, lay=True, rays=False, ant=False)
        if kwargs['net']:
            self.N._show3(newfig=False)
        if kwargs['body']:
            for p in self.dpersons:
                self.dpersons[p]._show3(newfig=False,
                                        topos=True,
                                        pattern=kwargs['ant'])

    # def _saveh5_init(self):
    #     """ initialization of the h5py file
    #     """
    #     filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
    #     import ipdb
    #     try:
    #         f5 = h5py.File(filenameh5, 'w')
    #         f5.create_dataset('time', shape=self.time.shape, data=self.time)
    #         f5.close()
    #     except:
    #         f5.close()
    #         raise NameError('simultra.saveinit: \
    #                         issue when writting h5py file')

    def _saveh5(self, ut, ida, idb, wstd):
        """ Save in h5py format

        Parameters
        ----------

        ut : int
            time index in self.time
        ida : string
            node a index
        idb : string
            node b index
        wstd : string
            wireless standard of used link

        Notes
        -----

        Dataset organisation:

        simultraj_<trajectory_filename.h5>.h5
            |
            |time
            |    ...
            |
            |/<tidx_ida_idb_wstd>/ |attrs
            |                      |a_k
            |                      |t_k


        Root dataset :
        time : array
            range of simulation time

        Group identifier :
            tidx : index in time dataset
            ida : node a index in Network
            idb : node b index in Network
            wstd : wireless standar of link interest


        Inside group:
            a_k : alpha_k values
            t_k : tau_k values

        See Also
        --------

        pylayers.simul.links

        """

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        grpname = str(ut) + '_' + ida + '_' + idb + '_' + wstd
        # try/except to avoid loosing the h5 file if
        # read/write error
        try:
            fh5 = h5py.File(filenameh5, 'a')
            if not grpname in fh5.keys():
                fh5.create_group(grpname)
                f = fh5[grpname]
                # for k in kwargs:
                #     f.attrs[k] = kwargs[k]

                f.create_dataset('alphak',
                                 shape=self._ak.shape,
                                 maxshape=(None),
                                 data=self._ak)
                f.create_dataset('tauk',
                                 shape=self._tk.shape,
                                 maxshape=(None),
                                 data=self._tk)
            else:
                pass  #print grpname + ' already exists in ' + filenameh5

            fh5.close()
        except:
            fh5.close()
            raise NameError('Simultraj._saveh5: issue when writting h5py file')

    def _loadh5(self, grpname):
        """ Load in h5py format

        Parameters
        ----------

        grpname : string
            group name which can be found sin self.data aktk_idx column

        Returns
        -------

        (ak, tk, conf)

        ak : ndarray:
            alpha_k
        tk : ndarray:
            alpha_k
        """

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        # try/except to avoid loosing the h5 file if
        # read/write error
        try:
            fh5 = h5py.File(filenameh5, 'r')
            if not grpname in fh5.keys():
                fh5.close()
                raise NameError(grpname + ' cannot be reached in ' +
                                self.filename)
            f = fh5[grpname]
            # for k in f.attrs.keys():
            #     conf[k]=f.attrs[k]
            ak = f['alphak'][:]
            tk = f['tauk'][:]
            fh5.close()

            return ak, tk
        except:
            fh5.close()
            raise NameError('Simultraj._loadh5: issue when reading h5py file')

    def tocsv(self, ut, ida, idb, wstd, init=False):

        filecsv = pyu.getlong(self._filecsv, pstruc['DIRLNK'])

        with open(filecsv, 'a') as csvfile:
            fil = csv.writer(csvfile, delimiter=';', quoting=csv.QUOTE_MINIMAL)
            if init:
                keys = self.data.iloc[-1].keys()
                data = [k for k in keys]
                data.append('ak')
                data.append('tk')
                fil.writerow(data)

            values = self.data.iloc[-1].values
            data = [v for v in values]
            sak = str(self._ak.tolist())
            stk = str(self._tk.tolist())
            data.append(sak)
            data.append(stk)
            fil.writerow(data)
示例#23
0
class Coverage(PyLayers):
    """ Handle Layout Coverage

        Methods
        -------

        creategrid()
            create a uniform grid for evaluating losses
        cover()
            run the coverage calculation
        showPower()
            display the map of received power
        showLoss()
            display the map of losses


        Attributes
        ----------

        All attributes are read from fileini ino the ini directory of the
        current project

        _fileini
            default coverage.ini

        L :  a Layout
        nx    : number of point on x
        ny    : number of point on y
        tx    : transmitter position
        txpe  : transmitter power emmission level
        show  : boolean for automatic display power map
        na : number of access point

    """


    def __init__(self,_fileini='coverage.ini'):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.apopt = dict(self.config.items('ap'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        # get the Layout
        self.L = Layout(self.layoutopt['filename'])

        # get the receiving grid

        self.nx = eval(self.gridopt['nx'])
        self.ny = eval(self.gridopt['ny'])
        self.ng = self.nx*self.ny
        self.mode = eval(self.gridopt['full'])
        self.boundary = eval(self.gridopt['boundary'])

        # create grid
        # we could here construct a grid locally around the access point
        # to be done later for code acceleration
        #
        self.creategrid(full=self.mode,boundary=self.boundary)

        self.dap = {}
        for k in self.apopt:
            kwargs  = eval(self.apopt[k])
            ap = std.AP(**kwargs)
            self.dap[eval(k)] = ap
            try:
                self.aap = np.vstack((self.aap,ap['p'][0:2]))
                self.ptdbm = np.vstack((self.ptdbm,ap['PtdBm']))
            except:
                self.aap = ap['p'][0:2]
                self.ptdbm = ap['PtdBm']
        # 1 x na
        self.ptdbm = self.ptdbm.T

        # number of access points
        self.na = len(self.dap)

        # creating all links
        p = product(range(self.ng),range(self.na))
        #
        # a : access point
        # g : grid
        #
        for k in p:
            pg = self.grid[k[0],:]
            pa = self.aap[k[1]]
            try:
                self.pa = np.vstack((self.pa,pa))
            except:
                self.pa = pa
            try:
                self.pg = np.vstack((self.pg,pg))
            except:
                self.pg = pg

        self.pa = self.pa.T
        self.pg = self.pg.T

        # frequency is chosen as all the center frequencies of the standard
        # warning assuming the same standard
        self.fGHz = self.dap[0].s.fcghz
        self.nf = len(self.fGHz)

        # AP section
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        self.rxsens = eval(self.rxopt['sensitivity'])

        kBoltzmann = 1.3806503e-23
        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        # list of access points
        lap  = self.dap.keys()
        # list of channels
        lchan = map(lambda x: self.dap[x]['chan'],lap)

        apchan = zip(self.dap.keys(),lchan)
        self.bmhz = np.array(map(lambda x: self.dap[x[0]].s.chan[x[1][0]]['BMHz']*len(x[1]),apchan))
        # Evaluate Noise Power (in dBm)

        Pn = (10**(self.noisefactordb/10.)+1)*kBoltzmann*self.temperaturek*self.bmhz*1e3
        self.pndbm = 10*np.log10(Pn)+60

        # show section
        self.bshow = str2bool(self.showopt['show'])

        try:
            self.L.Gt.nodes()
        except:
            pass
        try:
            self.L.dumpr()
        except:
            self.L.build()
            self.L.dumpw()


    def __repr__(self):
        st=''
        st = st+ 'Layout file : '+self.L.filename + '\n\n'
        st = st + '-----list of Access Points ------'+'\n'
        for k in self.dap:
            st = st + self.dap[k].__repr__()+'\n'
        st = st + '-----Rx------'+'\n'
        st= st+ 'rxsens (dBm) : '+ str(self.rxsens) + '\n'
        st= st+ 'bandwith (Mhz) : '+ str(self.bmhz) + '\n'
        st= st+ 'temperature (K) : '+ str(self.temperaturek) + '\n'
        st= st+ 'noisefactor (dB) : '+ str(self.noisefactordb) + '\n\n'
        st = st + '--- Grid ----'+'\n'
        st= st+ 'nx : ' + str(self.nx) + '\n'
        st= st+ 'ny : ' + str(self.ny) + '\n'
        st= st+ 'nlink : ' + str(self.ng*self.na) + '\n'
        st= st+ 'full grid : ' + str(self.mode) + '\n'
        st= st+ 'boundary (xmin,ymin,xmax,ymax) : ' + str(self.boundary) + '\n\n'
        return(st)

    def creategrid(self,full=True,boundary=[]):
        """ create a grid

        Parameters
        ----------

        full : boolean
            default (True) use all the layout area
        boundary : (xmin,ymin,xmax,ymax)
            if full is False the boundary argument is used

        """

        if full:
            mi=np.min(self.L.Gs.pos.values(),axis=0)+0.01
            ma=np.max(self.L.Gs.pos.values(),axis=0)-0.01
        else:
            assert boundary<>[]
            mi = np.array([boundary[0],boundary[1]])
            ma = np.array([boundary[2],boundary[3]])

        x = np.linspace(mi[0],ma[0],self.nx)
        y = np.linspace(mi[1],ma[1],self.ny)

        self.grid=np.array((list(np.broadcast(*np.ix_(x, y)))))



#    def coverold(self):
#        """ run the coverage calculation (Deprecated)
#
#        Parameters
#        ----------
#
#        lay_bound : bool
#            If True, the coverage is performed only inside the Layout
#            and clip the values of the grid chosen in coverage.ini
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            >> from pylayers.antprop.coverage import *
#            >> C = Coverage()
#            >> C.cover()
#            >> C.showPower()
#
#        Notes
#        -----
#
#        self.fGHz is an array it means that coverage is calculated at once
#        for a whole set of frequencies. In practice the center frequency of a
#        given standard channel.
#
#        This function is calling `Losst` which calculates Losses along a
#        straight path. In a future implementation we will
#        abstract the EM solver in order to make use of other calculation
#        approaches as full or partial Ray Tracing.
#
#        The following members variables are evaluated :
#
#        + freespace Loss @ fGHz   PL()  PathLoss (shoud be rename FS as free space) $
#        + prdbmo : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{odB}`
#        + prdbmp : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{pdB}`
#        + snro : SNR polar o (H)
#        + snrp : SNR polar p (H)
#
#        See Also
#        --------
#
#        pylayers.antprop.loss.Losst
#        pylayers.antprop.loss.PL
#
#        """
#
#        self.Lwo,self.Lwp,self.Edo,self.Edp = loss.Losst(self.L,self.fGHz,self.grid.T,self.tx)
#        self.freespace = loss.PL(self.fGHz,self.grid,self.tx)
#
#        self.prdbmo = self.ptdbm - self.freespace - self.Lwo
#        self.prdbmp = self.ptdbm - self.freespace - self.Lwp
#        self.snro = self.prdbmo - self.pndbm
#        self.snrp = self.prdbmp - self.pndbm

    def cover(self,polar='o',sinr=True,snr=True,best=True):
        """ run the coverage calculation

        Parameters
        ----------

        polar : string
            'o' | 'p'
        sinr : boolean
        snr  : boolean
        best : boolean

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a=C.show(typ='sinr')
            >>> plt.show()

        Notes
        -----

        self.fGHz is an array it means that coverage is calculated at once
        for a whole set of frequencies. In practice the center frequency of a
        given standard channel.

        This function is calling `Losst` which calculates Losses along a
        straight path. In a future implementation we will
        abstract the EM solver in order to make use of other calculation
        approaches as full or partial Ray Tracing.

        The following members variables are evaluated :

        + freespace Loss @ fGHz   PL()  PathLoss (shoud be rename FS as free space) $
        + prdbmo : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{odB}`
        + prdbmp : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{pdB}`
        + snro : SNR polar o (H)
        + snrp : SNR polar p (H)

        See Also
        --------

        pylayers.antprop.loss.Losst
        pylayers.antprop.loss.PL

        """

        # retrieving dimensions along the 3 axis
        na = self.na
        ng = self.ng
        nf = self.nf

        Lwo,Lwp,Edo,Edp = loss.Losst(self.L,self.fGHz,self.pa,self.pg,dB=False)
        if polar=='o':
            self.polar='o'
            self.Lw = Lwo.reshape(nf,ng,na)
            self.Ed = Edo.reshape(nf,ng,na)
        if polar=='p':
            self.polar='p'
            self.Lw = Lwp.reshape(nf,ng,na)
            self.Ed = Edp.reshape(nf,ng,na)

        freespace = loss.PL(self.fGHz,self.pa,self.pg,dB=False)
        self.freespace = freespace.reshape(nf,ng,na)

        # Warning we are assuming here all transmitters have the same
        # transmitting power (to be modified)
        # f x g x a

        # CmW : Received Power coverage in mW
        self.CmW = 10**(self.ptdbm[np.newaxis,...]/10.)*self.Lw*self.freespace

        if snr:
            self.snr()
        if sinr:
            self.sinr()
        if best:
            self.best()

    def snr(self):
        """ calculate snr
        """

        NmW = 10**(self.pndbm/10.)[np.newaxis,np.newaxis,:]

        self.snr = self.CmW/NmW

    def sinr(self):
        """ calculate sinr
        """

        na = self.na

        U = (np.ones((na,na))-np.eye(na))[np.newaxis,np.newaxis,:,:]

        ImW = np.einsum('ijkl,ijl->ijk',U,self.CmW)

        NmW = 10**(self.pndbm/10.)[np.newaxis,np.newaxis,:]

        self.sinr = self.CmW/(ImW+NmW)

    def best(self):
        """ determine best server map

        Notes
        -----

        C.bestsv

        """
        na = self.na
        ng = self.ng
        nf = self.nf
        # find best server regions
        V = self.CmW
        self.bestsv = np.zeros(nf*ng*na).reshape(nf,ng,na)
        for kf in range(nf):
            MaxV = np.max(V[kf,:,:],axis=1)
            for ka in range(na):
                u = np.where(V[kf,:,ka]==MaxV)
                self.bestsv[kf,u,ka]=ka+1


#    def showEd(self,polar='o',**kwargs):
#        """ shows a map of direct path excess delay
#
#        Parameters
#        ----------
#
#        polar : string
#        'o' | 'p'
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            >> from pylayers.antprop.coverage import *
#            >> C = Coverage()
#            >> C.cover()
#            >> C.showEd(polar='o')
#
#        """
#
#        if not kwargs.has_key('alphacy'):
#            kwargs['alphacy']=0.0
#        if not kwargs.has_key('colorcy'):
#            kwargs['colorcy']='w'
#        if not kwargs.has_key('nodes'):
#            kwargs['nodes']=False
#
#        fig,ax = self.L.showG('s',**kwargs)
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        cdict = {
#        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
#        }
#        #generate the colormap with 1024 interpolated values
#        my_cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
#
#
#        if polar=='o':
#            mcEdof = np.ma.masked_where(prdbm < self.rxsens,self.Edo)
#
#            cov=ax.imshow(mcEdof.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'jet',
#                             origin='lower')
#
#
#
#            # cov=ax.imshow(self.Edo.reshape((self.nx,self.ny)).T,
#            #           extent=(l,r,b,t),
#            #           origin='lower')
#            titre = "Map of LOS excess delay, polar orthogonal"
#
#        if polar=='p':
#            mcEdpf = np.ma.masked_where(prdbm < self.rxsens,self.Edp)
#
#            cov=ax.imshow(mcEdpf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'jet',
#                             origin='lower')
#
#            # cov=ax.imshow(self.Edp.reshape((self.nx,self.ny)).T,
#            #           extent=(l,r,b,t),
#            #           origin='lower')
#            titre = "Map of LOS excess delay, polar parallel"
#
#        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
#        ax.set_title(titre)
#
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        clb = fig.colorbar(cov,cax)
#        clb.set_label('excess delay (ns)')
#
#        if self.show:
#            plt.show()
#        return fig,ax
#
#    def showPower(self,rxsens=True,nfl=True,polar='o',**kwargs):
#        """ show the map of received power
#
#        Parameters
#        ----------
#
#        rxsens : bool
#              clip the map with rx sensitivity set in self.rxsens
#        nfl : bool
#              clip the map with noise floor set in self.pndbm
#        polar : string
#            'o'|'p'
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            > from pylayers.antprop.coverage import *
#            > C = Coverage()
#            > C.cover()
#            > C.showPower()
#
#        """
#
#        if not kwargs.has_key('alphacy'):
#            kwargs['alphacy']=0.0
#        if not kwargs.has_key('colorcy'):
#            kwargs['colorcy']='w'
#        if not kwargs.has_key('nodes'):
#            kwargs['nodes']=False
#        fig,ax = self.L.showG('s',**kwargs)
#
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
##        tCM = plt.cm.get_cmap('jet')
##        tCM._init()
##        alphas = np.abs(np.linspace(.0,1.0, tCM.N))
##        tCM._lut[:-3,-1] = alphas
#
#        title='Map of received power - Pt = ' + str(self.ptdbm) + ' dBm'+str(' fGHz =') + str(self.fGHz) + ' polar = '+polar
#
#        cdict = {
#        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
#        }
#
#        if not kwargs.has_key('cmap'):
#        # generate the colormap with 1024 interpolated values
#            cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
#        else:
#            cmap = kwargs['cmap']
#        #my_cmap = cm.copper
#
#
#        if rxsens :
#
#            ## values between the rx sensitivity and noise floor
#            mcPrf = np.ma.masked_where((prdbm > self.rxsens)
#                                     & (prdbm < self.pndbm),prdbm)
#            # mcPrf = np.ma.masked_where((prdbm > self.rxsens) ,prdbm)
#
#            cov1 = ax.imshow(mcPrf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = cm.copper,
#                             vmin=self.rxsens,origin='lower')
#
#            ### values above the sensitivity
#            mcPrs = np.ma.masked_where(prdbm < self.rxsens,prdbm)
#            cov = ax.imshow(mcPrs.reshape((self.nx,self.ny)).T,
#                            extent=(l,r,b,t),
#                            cmap = cmap,
#                            vmin=self.rxsens,origin='lower')
#            title=title + '\n black : Pr (dBm) < %.2f' % self.rxsens + ' dBm'
#
#        else :
#            cov=ax.imshow(prdbm.reshape((self.nx,self.ny)).T,
#                          extent=(l,r,b,t),
#                          cmap = cmap,
#                          vmin=self.pndbm,origin='lower')
#
#        if nfl:
#            ### values under the noise floor
#            ### we first clip the value below the noise floor
#            cl = np.nonzero(prdbm<=self.pndbm)
#            cPr = prdbm
#            cPr[cl] = self.pndbm
#            mcPruf = np.ma.masked_where(cPr > self.pndbm,cPr)
#            cov2 = ax.imshow(mcPruf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'binary',
#                             vmax=self.pndbm,origin='lower')
#            title=title + '\n white : Pr (dBm) < %.2f' % self.pndbm + ' dBm'
#
#
#        ax.scatter(self.tx[0],self.tx[1],s=10,c='k',linewidth=0)
#
#        ax.set_title(title)
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        clb = fig.colorbar(cov,cax)
#        clb.set_label('Power (dBm)')
#
#        if self.show:
#            plt.show()
#
#        return fig,ax
#
#
#    def showTransistionRegion(self,polar='o'):
#        """
#
#        Notes
#        -----
#
#        See  : "Analyzing the Transitional Region in Low Power Wireless Links"
#                Marco Zuniga and Bhaskar Krishnamachari
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            > from pylayers.antprop.coverage import *
#            > C = Coverage()
#            > C.cover()
#            > C.showTransitionRegion()
#
#        """
#
#        frameLength = self.framelengthbytes
#
#        PndBm = self.pndbm
#        gammaU = 10*np.log10(-1.28*np.log(2*(1-0.9**(1./(8*frameLength)))))
#        gammaL = 10*np.log10(-1.28*np.log(2*(1-0.1**(1./(8*frameLength)))))
#
#        PrU = PndBm + gammaU
#        PrL = PndBm + gammaL
#
#        fig,ax = self.L.showGs()
#
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
#        zones = np.zeros(np.shape(prdbm))
#        #pdb.set_trace()
#
#        uconnected  = np.nonzero(prdbm>PrU)
#        utransition = np.nonzero((prdbm < PrU)&(prdbm > PrL))
#        udisconnected = np.nonzero(prdbm < PrL)
#
#        zones[uconnected] = 1
#        zones[utransition] = (prdbm[utransition]-PrL)/(PrU-PrL)
#        cov = ax.imshow(zones.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'BuGn',origin='lower')
#
#        title='PDR region'
#        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
#
#        ax.set_title(title)
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        fig.colorbar(cov,cax)
#        if self.show:
#            plt.show()
#
    def show(self,**kwargs):
        """ show coverage

        Parameters
        ----------

        typ : string
            'pr' | 'sinr' | 'capacity' | 'loss' | 'best'
        grid : boolean
        best : boolean
            draw best server contour if True
        f : int
            frequency index
        a : int
            access point index (-1 all access point)

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover(polar='o')
            >>> f,a = C.show(typ='pr')
            >>> plt.show()
            >>> f,a = C.show(typ='best')
            >>> plt.show()
            >>> f,a = C.show(typ='loss')
            >>> plt.show()
            >>> f,a = C.show(typ='sinr')
            >>> plt.show()

        """
        defaults = { 'typ': 'pr',
                     'grid': False,
                     'f' : 0,
                     'a' :-1,
                     'db':True,
                     'cmap' :cm.jet,
                     'best':True
                   }

        title = self.dap[0].s.name+ ' : '
        for k in defaults:
            if k not in kwargs:
                kwargs[k]=defaults[k]

        if 'fig' in kwargs:
            fig,ax=self.L.showG('s',fig=kwargs['fig'])
        else:
            fig,ax=self.L.showG('s')

        # plot the grid
        if kwargs['grid']:
            for k in self.dap:
                p = self.dap[k].p
                ax.plot(p[0],p[1],'or')

        f = kwargs['f']
        a = kwargs['a']
        typ = kwargs['typ']
        best = kwargs['best']

        dB = kwargs['db']

        # setting the grid

        l = self.grid[0,0]
        r = self.grid[-1,0]
        b = self.grid[0,1]
        t = self.grid[-1,-1]

        if typ=='best':
            title = title + 'Best server'+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+self.polar
            for ka in range(self.na):
                bestsv =  self.bestsv[f,:,ka]
                m = np.ma.masked_where(bestsv == 0,bestsv)
                W = m.reshape(self.nx,self.ny).T
                ax.imshow(W, extent=(l,r,b,t),
                            origin='lower',
                            vmin=1,
                            vmax=self.na+1)
            ax.set_title(title)
        else:
            if typ=='sinr':
                title = title + 'SINR : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+self.polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                V = self.sinr

            if typ=='snr':
                title = title + 'SNR : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+self.polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                V = self.snr

            if typ=='capacity':
                title = title + 'Capacity : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+self.polar
                legcb = 'Mbit/s'
                V = self.bmhz[np.newaxis,np.newaxis,:]*np.log(1+self.sinr)/np.log(2)

            if typ=='pr':
                title = title + 'Pr : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+self.polar
                if dB:
                    legcb = 'dBm'
                else:
                    lgdcb = 'mW'
                V = self.CmW

            if typ=='loss':
                title = title + 'Loss : '+' fc = '+str(self.fGHz[f])+' GHz'+ ' polar : '+self.polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'

                V = self.Lw*self.freespace

            if a == -1:
                V = np.max(V[f,:,:],axis=1)
            else:
                V = V[f,:,a]

            # reshaping the data on the grid
            U = V.reshape((self.nx,self.ny)).T
            if dB:
                U = 10*np.log10(U)

            if 'vmin' in kwargs:
                vmin = kwargs['vmin']
            else:
                vmin = U.min()

            if 'vmax' in kwargs:
                vmax = kwargs['vmax']
            else:
                vmax = U.max()

            img = ax.imshow(U,
                            extent=(l,r,b,t),
                            origin='lower',
                            vmin = vmin,
                            vmax = vmax,
                            cmap = kwargs['cmap'])

            for k in range(self.na):
                ax.annotate(str(k),xy=(self.pa[0,k],self.pa[1,k]))
            ax.set_title(title)

            divider = make_axes_locatable(ax)
            cax = divider.append_axes("right", size="5%", pad=0.05)
            clb = fig.colorbar(img,cax)
            clb.set_label(legcb)
            if best:
                ax.contour(np.sum(self.bestsv,axis=2)[f,:].reshape(self.nx,self.ny).T,extent=(l,r,b,t),linestyles='dotted')

        # display access points
        ax.scatter(self.pa[0,:],self.pa[1,:],s=10,c='k',linewidth=0)

        return(fig,ax)
示例#24
0
from pylayers.gis.layout import Layout
from pylayers.util.project import * 
import pylayers.util.pyutil as pyu
import networkx as nx
import matplotlib.pyplot as plt
import warnings
import shutil

warnings.filterwarnings("error")

#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L =  Layout()
lL = L.ls()
for tL in lL:
    print  'Layout :     ',tL
    print  '--------------------------'
    if 'Munich' not in tL:
        L = Layout(tL,bbuild=0,bgraphs=0)
        f,a = L.showG('s')
        plt.title(tL,fontsize=32)
        plt.show()
        plt.close('all')
    #if L.check():
    #    L.save()
        #filein = pyu.getlong(L._filename, pstruc['DIRLAY'])
        #fileout = '/home/uguen/Documents/rch/devel/pylayers/data/struc/lay/'+L._filename
        #print fileout
        #shutil.copy2(filein,fileout)
#figure(figsize=(20,10))
#plt.axis('off')
示例#25
0
    def load(self, _filesimul):
        """ load a simulation configuration file

         each transmiter simulation results in the creation of an .ini file
         with the following sections
         related to the results obtained for different receivers

        Parameters
        ----------

        _filesimul   : file in the simul directory of the Project

        """

        self.filesimul = _filesimul
        filesimul = pyu.getlong(self.filesimul, "ini")

        self.config.read(filesimul)

        sections = self.config.sections()
        try:
            _filetx = self.config.get("files", "tx")
        except:
            raise NameError('Error in section tx from ' + _filesimul)

        try:
            _filerx = self.config.get("files", "rx")
        except:
            raise NameError('Error in section rx from ' + _filesimul)

        try:
            _fileini = self.config.get("files", "struc")
        except:
            raise NameError('Error in section struc from ' + _fileini)

        try:
            _fileanttx = self.config.get("files", "txant")
        except:
            raise NameError('Error in section txant from ' + _filesimul)

        try:
            _fileantrx = self.config.get("files", "rxant")
        except:
            raise NameError('Error in section rxant from ' + _filesimul)

        try:
            self.tx = RadioNode(name='',
                                typ='tx',
                                _fileini=_filetx,
                                _fileant=_fileanttx)

            self.rx = RadioNode(name='',
                                typ='rx',
                                _fileini=_filerx,
                                _fileant=_fileantrx)
        except:
            raise NameError('Error during Radionode load')
#
# Load Layout
#
        try:
            self.L = Layout(_fileini)
        except:
            raise NameError('Layout load error')

#
# Frequency base
#
        if "frequency" in sections:
            try:
                self.fGHz = np.linspace(
                    float(self.config.getfloat("frequency", "fghzmin")),
                    float(self.config.getfloat("frequency", "fghzmax")),
                    int(self.config.getint("frequency", "nf")),
                    endpoint=True)
            except:
                raise NameError('Error in section frequency from ' +
                                _filesimul)
            # update .freq file in tud directory

            filefreq = pyu.getlong(self.filefreq, pstruc['DIRTUD'])
            fd = open(filefreq, "w")
            chaine = self.config.get("frequency", "fghzmin") + ' ' + \
                self.config.get("frequency", "fghzmax") + ' ' + \
                self.config.get("frequency", "nf")
            fd.write(chaine)
            fd.close
#
# Simulation Progress
#
#        self.output = {}
#        if "output" in sections:
#            for itx in self.config.options("output"):
#                _filename  =  self.config.get("output", itx)
#                self.dout[int(itx)] = _filename
#                filename = pyu.getlong(_filename, "output")
#                output = ConfigParser.ConfigParser()
#                output.read(filename)
#                secout = output.sections()
#                self.dtra[int(itx)] = {}
#                self.dtud[int(itx)] = {}
#                self.dtang[int(itx)] = {}
#                self.drang[int(itx)] = {}
#                self.dtauk[int(itx)] = {}
#                self.dfield[int(itx)] = {}
#                self.dcir[int(itx)] = {}
#                if "launch" in secout:
#                    self.progress = 1
#                    keys_launch = output.options("launch")
#                    for kl in keys_launch:
#                        self.dlch[int(kl)] = output.get("launch", kl)
#                if "trace" in secout:
#                    self.progress = 2
#                    keys_tra = output.options("trace")
#                    for kt in keys_tra:
#                        self.dtra[int(itx)][int(kt)] = output.get("trace", kt)
#
#                if "tang" in secout:
#                    self.progress = 3
#                    keys_tang = output.options("tang")
#                    for kt in keys_tang:
#                        self.dtang[int(itx)][int(kt)] = output.get("tang", kt)
#                        self.drang[int(itx)][int(kt)] = output.get("rang", kt)
#                        self.dtud[int(itx)][int(kt)] = output.get("tud", kt)
#                if "field" in secout:
#                    self.progress = 4
#                    keys_field = output.options("field")
#                    for kt in keys_field:
#                        self.dfield[int(itx)][int(kt)] = output.get(
#                            "field", kt)
#                        self.dtauk[int(itx)][int(kt)] = output.get("tauk", kt)
#                if "cir" in secout:
#                    self.progress = 5
#                    keys_cir = output.options("cir")
#                    for kt in keys_cir:
#                        self.dcir[int(itx)][int(kt)] = output.get("cir", kt)
#
#                self.output[int(itx)] = output
#
# Waveform section
#
        self.wav = wvf.Waveform()
        self.wav.read(self.config)
示例#26
0
class Coverage(object):
    """ Handle Layout Coverage 

        Methods
        -------
  
        create grid()
            create a uniform grid for evaluating losses
        cover()
            run the coverage calculation
        showPower()
            display the map of received power
        showLoss()
            display the map of losses 


        Attributes
        ----------
        
        All attributes are read from fileini ino the ini directory of the
        current project

        _fileini
            default coverage.ini

        L :  a Layout
        model : a pylayers.network.model object.
        xstep : x step for grid
        ystep : y step for grid
        tx    : transmitter position
        txpe  : transmitter power emmission level
        show  : boolean for automatic display power map

    """


    def __init__(self,_fileini='coverage.ini'):


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))
        self.plm = dict(self.config.items('pl_model'))
        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.txopt = dict(self.config.items('tx'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt=dict(self.config.items('show'))

        self.L=Layout(self.layoutopt['filename'])
        self.model=Model(f=eval(self.plm['f']),
                         rssnp=eval(self.plm['rssnp']),
                         d0=eval(self.plm['d0']),
                         sigrss=eval(self.plm['sigrss']))
        self.xstep = eval(self.gridopt['xstep'])
        self.ystep = eval(self.gridopt['ystep'])
        # transitter section
        self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        self.ptdbm = eval(self.txopt['ptdbm'])
        self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        self.rxsens = eval(self.rxopt['sensitivity'])
        kBoltzmann = 1.3806503e-23
        self.bandwidthmhz = eval(self.rxopt['bandwidthmhz'])
        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        Pn = (10**(self.noisefactordb/10.)+1)*kBoltzmann*self.temperaturek*self.bandwidthmhz*1e3
        self.pndbm = 10*np.log10(Pn)+60

        self.show = str2bool(self.showopt['show'])

        try:
            self.L.Gt.nodes()
        except:
            pass
        try:
            self.L.dumpr('t')
        except:
            self.L.buildGt()
            self.L.dumpw('t')
        self.creategrid()


    def creategrid(self):
        """create a grid
            create a grid for various evaluation

        """
        mi=np.min(self.L.Gs.pos.values(),axis=0)+0.01
        ma=np.max(self.L.Gs.pos.values(),axis=0)-0.01
        x=np.linspace(mi[0],ma[0],self.xstep)
        y=np.linspace(mi[1],ma[1],self.ystep)
        self.grid=np.array((list(np.broadcast(*np.ix_(x, y)))))




    def cover(self):
        """ start the coverage calculation

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showPr()

        """
        self.Lwo,self.Lwp,self.Edo,self.Edp = Loss0_v2(self.L,self.grid,self.model.f,self.tx)
        self.freespace = PL(self.grid,self.model.f,self.tx)
        self.prdbmo = self.ptdbm - self.freespace - self.Lwo
        self.prdbmp = self.ptdbm - self.freespace - self.Lwp


    def showEd(self,polarization='o'):
        """ show direct path excess of delay map

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showEdo()
        """

        fig=plt.figure()
        fig,ax=self.L.showGs(fig=fig)
        l=self.grid[0,0]
        r=self.grid[-1,0]
        b=self.grid[0,1]
        t=self.grid[-1,-1]
        if polarization=='o':
            cov=ax.imshow(self.Edo.reshape((self.xstep,self.ystep)).T,
                      extent=(l,r,b,t),
                      origin='lower')
            titre = "Map of LOS excess delay, polar orthogonal"
        if polarization=='p':
            cov=ax.imshow(self.Edp.reshape((self.xstep,self.ystep)).T,
                      extent=(l,r,b,t),
                      origin='lower')
            titre = "Map of LOS excess delay, polar parallel"

        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
        ax.set_title(titre)

        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        clb = fig.colorbar(cov,cax)
        clb.set_label('excess delay (ns)')
        if self.show:
            plt.show()


    def showPower(self,rxsens=True,nfl=True,polarization='o'):
        """ show the map of received power

        Parameters
        ----------

        rxsens : bool
              clip the map with rx sensitivity set in self.rxsens
        nfl : bool
              clip the map with noise floor set in self.pndbm
        polarization : string
            'o'|'p'

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showPower()

        """

        fig=plt.figure()
        fig,ax=self.L.showGs(fig=fig)
        l=self.grid[0,0]
        r=self.grid[-1,0]
        b=self.grid[0,1]
        t=self.grid[-1,-1]

        if polarization=='o':
            prdbm=self.prdbmo
        if polarization=='p':
            prdbm=self.prdbmp

#        tCM = plt.cm.get_cmap('jet')
#        tCM._init()
#        alphas = np.abs(np.linspace(.0,1.0, tCM.N))
#        tCM._lut[:-3,-1] = alphas
        title='Map of received power - Pt = '+str(self.ptdbm)+' dBm'

        cdict = {
        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
        }
        #generate the colormap with 1024 interpolated values
        my_cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)



        if rxsens :

            ### values between the rx sensitivity and noise floor
            mcPrf = np.ma.masked_where((prdbm > self.rxsens) 
                                     & (prdbm < self.pndbm),prdbm)
            cov1 = ax.imshow(mcPrf.reshape((self.xstep,self.ystep)).T,
                             extent=(l,r,b,t),cmap = my_cmap,
                             vmin=self.rxsens,origin='lower')

            ### values above the sensitivity
            mcPrs = np.ma.masked_where(prdbm < self.rxsens,prdbm)
            cov = ax.imshow(mcPrs.reshape((self.xstep,self.ystep)).T,
                            extent=(l,r,b,t),
                            cmap = 'jet',
                            vmin=self.rxsens,origin='lower')
            title=title + '\n gray : Pr (dBm) < %.2f' % self.rxsens + ' dBm'

        else :
            cov=ax.imshow(prdbm.reshape((self.xstep,self.ystep)).T,
                          extent=(l,r,b,t),
                          cmap = 'jet',
                          vmin=self.PndBm,origin='lower')

        if nfl:
            ### values under the noise floor 
            ### we first clip the value below he noise floor
            cl = np.nonzero(prdbm<=self.pndbm)
            cPr = prdbm
            cPr[cl] = self.pndbm
            mcPruf = np.ma.masked_where(cPr > self.pndbm,cPr)
            cov2 = ax.imshow(mcPruf.reshape((self.xstep,self.ystep)).T,
                             extent=(l,r,b,t),cmap = 'binary',
                             vmax=self.pndbm,origin='lower')
            title=title + '\n white : Pr (dBm) < %.2f' % self.pndbm + ' dBm'


        ax.scatter(self.tx[0],self.tx[1],s=10,linewidth=0)

        ax.set_title(title)
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        clb = fig.colorbar(cov,cax)
        clb.set_label('Power (dBm)')
        if self.show:
            plt.show()


    def showTransistionRegion(self,polarization='o'):
        """
        Notes
        -----
        See  : Analyzing the Transitional Region in Low Power Wireless Links
                  Marco Zuniga and Bhaskar Krishnamachari

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showTransitionRegion()

        """
        frameLength = self.framelengthbytes
        PndBm = self.pndbm
        gammaU = 10*np.log10(-1.28*np.log(2*(1-0.9**(1./(8*frameLength)))))
        gammaL = 10*np.log10(-1.28*np.log(2*(1-0.1**(1./(8*frameLength)))))
        PrU = PndBm + gammaU
        PrL = PndBm + gammaL

        fig=plt.figure()
        fig,ax = self.L.showGs(fig=fig)
        l = self.grid[0,0]
        r = self.grid[-1,0]
        b = self.grid[0,1]
        t = self.grid[-1,-1]

        if polarization=='o':
            prdbm=self.prdbmo
        if polarization=='p':
            prdbm=self.prdbmp

        zones = np.zeros(len(prdbm))
        uconnected  = np.nonzero(prdbm>PrU)[0]
        utransition = np.nonzero((prdbm < PrU)&(prdbm > PrL))[0]
        udisconnected = np.nonzero(prdbm < PrL)[0]

        zones[uconnected] = 1
        zones[utransition] = (prdbm[utransition]-PrL)/(PrU-PrL)
        cov = ax.imshow(zones.reshape((self.xstep,self.ystep)).T,
                             extent=(l,r,b,t),cmap = 'BuGn',origin='lower')

        title='PDR region'
        ax.scatter(self.tx[0],self.tx[1],linewidth=0)

        ax.set_title(title)
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        fig.colorbar(cov,cax)
        if self.show:
            plt.show()

    def showLoss(self,polarization='o'):
        """ show losses map

        Parameters
        ----------
        polarization : string 
            'o'|'p'|'both'

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showLoss(polarization='o')
            >>> C.showLoss(polarization='p')
            
        """
        fig = plt.figure()
        fig,ax=self.L.showGs(fig=fig)
        l=self.grid[0,0]
        r=self.grid[-1,0]
        b=self.grid[0,1]
        t=self.grid[-1,-1]

        if polarization=='o':
            cov = ax.imshow(self.Lwo.reshape((self.xstep,self.ystep)).T,
                            extent=(l,r,b,t),
                            origin='lower')
            title = ('Map of losses, orthogonal (V) polarization') 
        if polarization=='p':
            cov = ax.imshow(self.Lwp.reshape((self.xstep,self.ystep)).T,
                            extent=(l,r,b,t),
                            origin='lower')
            title = ('Map of losses, parallel (H) polarization') 

        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
        ax.set_title(title)

        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        fig.colorbar(cov,cax)

        if self.show:
            plt.show()
示例#27
0
    def __init__(self, **args):
        """ Mobile Agent Init

           Parameters
           ----------
           'ID': string
                agent ID
           'name': string
                Agent name
           'type': string
                agent type . 'ag' for moving agent, 'ap' for static acces point
           'pos' : np.array([])
                numpy array containing the initial position of the agent
           'roomId': int
                Room number where the agent is initialized (Layout.Gr)
           'meca_updt': float
                update time interval for the mechanical process
           'loc': bool
                enable/disable localization process of the agent
           'loc_updt': float
                update time interval for localization process
           'Layout': pylayers.gis.Layout()
           'net':pylayers.network.Network(),
           'RAT': list of string
                list of used radio access techology of the agent
           'world': transit.world()
                Soon deprecated
           'save': list of string
                list of save method ( soon deprecated)
           'sim':Simpy.SimulationRT.Simulation(),
           'epwr': dictionnary
                dictionnary of emmited power of transsmitter{'rat#':epwr value}
           'sens': dictionnary
                dictionnary of sensitivity of reveicer {'rat#':sens value}
           'dcond': dictionnary
                Not used yet
           'gcom':pylayers.communication.Gcom()
                Communication graph
           'comm_mod': string
                Communication between nodes mode: 
                'autonomous': all TOAs are refreshed regulary
                'synchro' : only visilbe TOAs are refreshed 
        """
        defaults = {
            'ID': 0,
            'name': 'johndoe',
            'type': 'ag',
            'pos': np.array([]),
            'roomId': 0,
            'froom': [],
            'wait': [],
            'cdest': 'random',
            'meca_updt': 0.1,
            'loc': False,
            'loc_updt': 0.5,
            'loc_method': ['geo'],
            'Layout': Layout(),
            'net': Network(),
            'RAT': ['wifi'],
            'world': world(),
            'save': [],
            'sim': Simulation(),
            'epwr': {},
            'sens': {},
            'dcond': {},
            'gcom': Gcom(),
            'comm_mode': 'autonomous'
        }

        for key, value in defaults.items():
            if key not in args:
                args[key] = value

        self.args = args
        self.ID = args['ID']
        self.name = args['name']
        self.type = args['type']
        # Create Network
        self.net = args['net']
        self.epwr = args['epwr']
        self.gcom = args['gcom']
        try:
            self.dcond = args['dcond']
        except:
            pass

        if self.type == 'ag':
            # mechanical init
            self.meca = Person(ID=self.ID,
                               roomId=args['roomId'],
                               L=args['Layout'],
                               net=self.net,
                               interval=args['meca_updt'],
                               wld=args['world'],
                               sim=args['sim'],
                               moving=True,
                               froom=args['froom'],
                               wait=args['wait'],
                               cdest=args['cdest'],
                               save=args['save'])
            self.meca.behaviors = [Queuing(),Seek(), Containment(),\
                                   Separation(), InterpenetrationConstraint()]
            self.meca.steering_mind = queue_steering_mind
            #            self.meca.steering_mind = queue_steering_mind
            # filll in network

            ## Network init
            self.node = Node(ID=self.ID,
                             p=conv_vecarr(self.meca.position),
                             t=time.time(),
                             RAT=args['RAT'],
                             epwr=args['epwr'],
                             sens=args['sens'],
                             type=self.type)
            self.net.add_nodes_from(self.node.nodes(data=True))
            self.sim = args['sim']
            self.sim.activate(self.meca, self.meca.move(), 0.0)
            self.PN = self.net.node[self.ID]['PN']

            ## Communication init

            if args['comm_mode'] == 'synchro':
                ## The TOA requests are made every refreshTOA time ( can be modified in agent.ini)

                self.rxr = RX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)
                self.rxt = RX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)

                self.sim.activate(self.rxr, self.rxr.refresh_RSS(), 0.0)
                self.sim.activate(self.rxt, self.rxt.refresh_TOA(), 0.0)

            elif args['comm_mode'] == 'autonomous':
                ## The TOA requests are made by node only when they are in visibility of pairs.

                self.rxr = RX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)
                self.rxt = RX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)
                self.txt = TX(net=self.net,
                              ID=self.ID,
                              dcond=self.dcond,
                              gcom=self.gcom,
                              sim=self.sim)

                self.sim.activate(self.rxr, self.rxr.refresh_RSS(), 0.0)
                self.sim.activate(self.rxt, self.rxt.wait_TOArq(), 0.0)
                self.sim.activate(self.txt, self.txt.request_TOA(), 0.0)

        elif self.type == 'ap':
            if args['roomId'] == -1:
                self.node = Node(ID=self.ID,
                                 p=self.args['pos'],
                                 t=time.time(),
                                 RAT=args['RAT'],
                                 epwr=args['epwr'],
                                 sens=args['sens'],
                                 type=self.type)
            else:
                pp = np.array(args['Layout'].Gr.pos[self.args['roomId']])
                self.node = Node(ID=self.ID,
                                 p=pp,
                                 t=time.time(),
                                 RAT=args['RAT'],
                                 epwr=args['epwr'],
                                 sens=args['sens'],
                                 type=self.type)
            self.net.add_nodes_from(self.node.nodes(data=True))
            self.sim = args['sim']
            #            self.sim.activate(self.meca, self.meca.move(),0.0)
            self.PN = self.net.node[self.ID]['PN']
            self.PN.node[self.ID]['pe'] = self.net.node[self.ID]['p']

        else:
            raise NameError(
                'wrong agent type, it must be either agent (ag) or acces point (ap) '
            )

        if self.type == 'ap':
            self.MoA = 1
        else:
            self.MoA = 0

        if 'mysql' in args['save']:
            config = ConfigParser.ConfigParser()
            config.read(pyu.getlong('simulnet.ini', 'ini'))
            sql_opt = dict(config.items('Mysql'))
            db = Database(sql_opt['host'], sql_opt['user'], sql_opt['passwd'],
                          sql_opt['dbname'])
            db.writenode(self.ID, self.name, self.MoA)

        if 'txt' in args['save']:
            pyu.writenode(self)
        if args['loc'] and self.type != 'ap':

            self.loc = Localization(net=self.net,
                                    ID=self.ID,
                                    method=args['loc_method'])
            self.Ploc = PLocalization(loc=self.loc,
                                      loc_updt_time=args['loc_updt'],
                                      sim=args['sim'])
            self.sim.activate(self.Ploc, self.Ploc.run(), 1.5)
示例#28
0
import time
from pylayers.util.project import *
import pylayers.util.pyutil as pyu
from pylayers.util.utilnet import str2bool
from pylayers.gis.layout import Layout
from pylayers.antprop.multiwall import *
from pylayers.antprop.coverage import *
from pylayers.network.model import *


L = Layout('TA-Office.ini')
L.dumpr()
A=np.array((4,1)) # defining transmitter position 
B=np.array((30,12)) # defining receiver position
fGHz = 2.4
r = np.array((B,B))

示例#29
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt
import doctest

plt.ion()
#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout('WHERE1.ini')
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.build()
L.dumpr()
L.showGi(en=11)
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#30
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt

#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout()
lL = L.ls()
for tL in lL:
    print tL 
#f = plt.figure(figsize=(20,10))
#plt.axis('off')
#f,a = L.showG('s',nodes=False,fig=f)
#plt.show()
#f,a = L.showG('r',edge_color='b',linewidth=4,fig=f)
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.buildGt()
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#31
0
    def ishow(self):
        """
            interactive show of trajectories

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.mobility.trajectory import *
            >>> T=Trajectories()
            >>> T.loadh5()
            >>> T.ishow()

        """

        fig, ax = plt.subplots()
        fig.subplots_adjust(bottom=0.2, left=0.3)

        t = np.arange(0, len(self[0].index), self[0].ts)
        L = Layout(self.Lfilename)
        fig, ax = L.showG('s', fig=fig, ax=ax)

        valinit = 0
        lines = []
        labels = []
        colors = "bgrcmykw"

        for iT, T in enumerate(self):
            if T.typ == 'ag':
                lines.extend(ax.plot(T['x'][0:valinit],T['y'][0:valinit], 'o',
                             color=colors[iT], visible=True))
                labels.append(T.name + ':' + T.ID)
            else:
                lines.extend(ax.plot(T['x'][0], T['y'][0], '^', ms=12,
                             color=colors[iT], visible=True))
                labels.append(T.name + ':' + T.ID)

        t = self[0].time()

        # init boolean value for visible in checkbutton
        blabels = [True]*len(labels)


        ########
        # slider
        ########
        slider_ax = plt.axes([0.1, 0.1, 0.8, 0.02])
        slider = Slider(slider_ax, "time", self[0].tmin, self[0].tmax,
                        valinit=valinit, color='#AAAAAA')

        def update(val):
            if val >= 1:
                pval=np.where(val>t)[0]
                ax.set_title(str(self[0].index[pval[-1]].time())[:11].ljust(12),
                             loc='left')
                for iT, T in enumerate(self):
                    if T.typ == 'ag':
                        lines[iT].set_xdata(T['x'][pval])
                        lines[iT].set_ydata(T['y'][pval])
                fig.canvas.draw()
        slider.on_changed(update)


        ########
        # choose
        ########
        rax = plt.axes([0.02, 0.5, 0.3, 0.2], aspect='equal')
        # check (ax.object, name of the object , bool value for the obsject)
        check = CheckButtons(rax, labels, tuple(blabels))

        def func(label):
            i = labels.index(label)
            lines[i].set_visible(not lines[i].get_visible())
            fig.canvas.draw()

        check.on_clicked(func)
        fig.canvas.draw()
        plt.show(fig)
示例#32
0
class Simul(PyLayers):
    """ Simulation Class

    Methods
    -------

    gui()
        graphical user interface
    choose()
        choose a simulation file in simuldir
    info()
        info about the simulation
    showray(itx,irx,iray)
        show a single ray
    help()
        help on using Simulation object
    freq()
        return the frequency base
    save()
        save Simulation file
    layout
        load a Layout file
    load()
        load Simulation
    show3()
        geomview vizualization
    show3l(itx,irx)
        geomview vizualization of link itx irx
    show()
        2D visualization of simulation with furniture
    run(itx,irx)
        run simulation for links (itx,irx)
    cir(itx,irx,store_level=0,alpha=1.0)
        Channel Impulse Response calculation


    Attributes
    ----------

    fileconf

    filetauk
    filetang
    filerang

    tx
    rx

    progress

    indoor
    mat
    sl

    Notes
    ------

    This class group together all the parametrization files of a simulation

    Directory list file :

        fileconf

    Constitutive parameters file :

        fileslab
        filemat

    Ray Tracing parameters files :

        filepalch
        filetra

    Frequency list file :

        filefreq

    """
    def __init__(self, _filesimul='default.ini'):
        self.filesimul = _filesimul
        self.config = ConfigParser.ConfigParser()
        self.config.add_section("files")
        self.config.add_section("frequency")
        self.config.add_section("waveform")
        self.config.add_section("output")

        self.dtang = {}
        self.drang = {}
        self.dtauk = {}
        self.dfield = {}
        self.dcir = {}
        self.output = {}

        #
        # Here was a nasty bug : Rule for the future
        #    "Always precise the key value of the passed argument"
        #
        # Mal nommer les choses, c'est ajouter au malheur du monde ( Albert Camus )
        #
        self.tx = RadioNode(name = '',
                            typ = 'tx',
                            _fileini = 'radiotx.ini',
                            _fileant = 'defant.vsh3',
                            )

        self.rx = RadioNode(name = '',
                            typ = 'rx',
                            _fileini = 'radiorx.ini',
                            _fileant = 'defant.vsh3',
                            )

        self.filefreq = "def.freq"

        self.progress = -1  # simulation not loaded

        self.filetang = []
        self.filerang = []
        self.filetauk = []
        self.filefield = []

        self.fileconf = "project.conf"
        self.cfield = []
        self.fGHz = np.linspace(2, 11, 181, endpoint=True)
        self.wav = wvf.Waveform()
        try:
            self.load(_filesimul)
        except:
            pass


    def gui(self):
        """ gui to modify the simulation file
        """
        simulgui = multenterbox('', 'Simulation file',
                                ('filesimul',
                                 'filestr',
                                 'filefreq',
                                 'filespaTx',
                                 'filespaRx',
                                 'fileantTx'
                                 'fileantRx'),
                                (self.filesimul,
                                 self.filestr,
                                 self.filefreq,
                                 self.filespaTx,
                                 self.filespaRx,
                                 self.fileantTx,
                                 self.fileantRx))
        if simulgui is not None:
            self.filesimul = simulgui[0]
            self.filestr = simulgui[1]
            self.filefreq = simulgui[6]
            self.filespaTx = simulgui[7]
            self.filespaRx = simulgui[8]
            self.fileantTx = simulgui[9]
            self.fileantRx = simulgui[10]

    def updcfg(self):
        """ update simulation .ini config file 
        
        with values currently in use.
        """
        self.config.set("files", "struc", self.filestr)
        self.config.set("files", "conf", self.fileconf)
        self.config.set("files", "txant", self.tx.fileant)
        self.config.set("files", "rxant", self.rx.fileant)
        self.config.set("files", "tx", self.tx.fileini)
        self.config.set("files", "rx", self.rx.fileini)
        self.config.set("files", "mat", self.filematini)
        self.config.set("files", "slab", self.fileslabini)

        self.config.set("tud", "purc", str(self.patud.purc))
        self.config.set("tud", "nrmax", str(self.patud.nrmax))
        self.config.set("tud", "num", str(self.patud.num))

        #
        # frequency section
        #

        self.config.set("frequency", "fghzmin", self.fGHz[0])
        self.config.set("frequency", "fghzmax", self.fGHz[-1])
        self.config.set("frequency", "nf", str(len(self.fGHz)))
        #
        # waveform section
        #
        self.config.set("waveform", "tw", str(self.wav['twns']))
        self.config.set("waveform", "band", str(self.wav['bandGHz']))
        self.config.set("waveform", "fc", str(self.wav['fcGHz']))
        self.config.set("waveform", "thresh", str(self.wav['threshdB']))
        self.config.set("waveform", "type", str(self.wav['typ']))
        self.config.set("waveform", "fe", str(self.wav['feGHz']))
        #
        # output section
        #
        for k in self.output.keys():
            self.config.set("output",str(k),self.dout[k])

        # Initialize waveform
        self.wav = wvf.Waveform()
        # Update waveform 
        self.wav.read(self.config)
        self.save()

    def clean(self, level=1):
        """ clean

       Notes
       -----
       obsolete

        Parameters
        ----------
            level  = 1


        """
        if level > 0:
            for itx in range(self.tx.N):
                filename = pyu.getlong(self.filelch[itx], pstruc['DIRLCH'])
                print filename
        if level > 1:
            for itx in range(self.tx.N):
                for irx in range(self.rx.N):
                    filename = pyu.getlong(self.filetra[itx][irx],
                                           pstruc(['DIRTRA']))
                    print filename
        if level > 2:
            for itx in range(self.tx.N):
                for irx in range(self.rx.N):
                    filename = pyu.getlong(self.filetud[itx][irx], pstruc['DIRTUD'])
                    print filename
                    filename = pyu.getlong(self.filetauk[itx][irx],pstruc['DIRTUD'])
                    print filename
        if level > 3:
            for itx in range(self.tx.N):
                for irx in range(self.rx.N):
                    filename = pyu.getlong(self.filetang[itx][irx], pstruc['DIRTUD'])
                    print filename
                    filename = pyu.getlong(self.filerang[itx][irx], pstruc['DIRTUD'])
                    print filename
                    filename = pyu.getlong(self.filefield[itx][irx], pstruc['DIRTUD'])
                    print filename


    def clean_project(self,verbose= True):
        """
        Clean Pyrpoject directory

        remove .lch, .tra, .field .tud, .tauk, .tang, .rang, <pyproject>/output

        remove [output] entries into .ini of self.filesimul


        Parameters
        ----------
 
        verbose : boolean
            Verbose mode on/off


        Returns
        -------
            Boolean:
                True if the project has been cleaned, False otherwise


        """

        if verbose:

            print "-----------------------------------"
            print "-----------------------------------"
            print "          WARNING                  "
            print "-----------------------------------"
            print "-----------------------------------"
            print "You are about to remove ALL previous computed raytracing files."
            print "If you decide to remove it, you will need to restart the entire \
    raytracing simulation to exploit simulation results"
            print "\n Do you want to remove these simulation files ? y/n"
            r=raw_input()

        else :
            r =='y'

        if r == 'y':
            inifile=self.filesimul
            try:
                path=os.getenv('BASENAME')
            except:
                print('Error : there is no project  directory in $BASENAME')



            dirlist=['output']
            extension=['.lch','.field','.tra','.tud','.tang','.rang','.tauk']
            rindic=False


            # remove file

            for d in dirlist:
                for ex in extension:
                    files = os.listdir(path +'/' +d )
                    for f in files:
                        if not os.path.isdir(path+'/'+d+'/'+f) and ex in f:
                            rindic=True
                            if verbose:
                                print f
                            os.remove(path+'/'+d+'/'+f)



                    if rindic:
                        if verbose:
                            print 'removed *' + ex +' from ' +d +'\n'
                        rindic=False


            # remove output into the self.filesimul ini file

            simcfg = ConfigParser.ConfigParser()
            simcfg.read(pyu.getlong(inifile,pstruc['DIRSIMUL']))
            simcfg.remove_section('output')
            f=open(pyu.getlong(inifile,pstruc['DIRSIMUL']),'wb')
            simcfg.write(f)
            f.close()
            self.dout = {}
            self.dlch = {}
            self.dtra = {}
            self.dtud = {}
            self.dtang = {}
            self.drang = {}
            self.dtauk = {}
            self.dfield = {}
            self.dcir = {}
            self.output = {}

            if verbose:
                print 'removed [output] entries into ' +inifile +'\n'
                print 'Project CLEANED'
            return True
        else :
            if verbose:
                print "clean project process ABORTED"
            return False


    def save(self):
        """ save simulation file

        Simulation files are .ini files which are saved in a dedicated
        directory basename/ini in the Project tree

        """
        filesimul = pyu.getlong(self.filesimul, "ini")
        fd = open(filesimul, "w")
        # getting current spa file if any
        try:
            self.config.set("files", "tx", self.tx.fileini)
        except:
            pass
        try:
            self.config.set("files", "rx", self.rx.fileini)
        except:
            pass
        self.config.write(fd)
        fd.close()
        # save tx
        self.tx.save()
        # save rx
        self.rx.save()
        # save slab and mat file
        # --
        # self.slab.save(self.fileslabini)
        # self.slab.mat.save(self.filematini)
        # --
        # fix bug #189
        #   slab is a member of S.L not of S anymore
        #   mat is a member of S.L.sl not of S.slab
        try:
            self.L.sl.save(self.fileslabini)
        except:
            pass
        try:
            self.L.sl.mat.save(self.filematini)
        except:
            pass

#    def saveold(self):
#        """ save simulation file

#        """
#        filesimul = pyu.getlong(self.filesimul, "ini")
#        fd = open(filesimul, "w")
#        config = ConfigParser.ConfigParser()

#        #
#        # files section
#        #
#        #config.add_section("files")
#        self.config.set("files", "conf", self.fileconf)
#        self.config.set("files", "struc", self.filestr)
#        self.config.set("files", "slab", self.fileslab)
#        self.config.set("files", "mat", self.filemat)

#        try:
#            self.config.set("files", "tx", self.tx.filespa)
#        except:
#            pass
#        try:
#            self.config.set("files", "rx", self.rx.filespa)
#        except:
#            pass
#        try:
#            self.config.set("files", "txant", self.tx.fileant)
#        except:
#            pass
#        try:
#            self.config.set("files", "rxant", self.rx.fileant)
#        except:
#            pass
#        self.config.set("files", "patra", self.filepatra)
#        self.config.set("files", "palch", self.filepalch)
#        self.palch.save()
#        self.patra.save()

#        #
#        # tud section
#        #

#        self.config.set("tud", "purc", self.patud.purc)
#        self.config.set("tud", "nrmax", self.patud.nrmax)
#        self.config.set("tud", "num", self.patud.num)

#        #
#        # frequency section
#        #
#        self.config.set("frequency", "fghzmin", self.freq[0])
#        self.config.set("frequency", "fghzmax", self.freq[-1])
#        self.config.set("frequency", "Nf", len(self.freq))

#        #
#        # output section
#        #
#        #filelch exists
#        if self.progress > 0:
#            #config.add_section("output")
#            for k in range(len(self.filelch)):
#                _fileout = "out" + "???"
#                filename = self.filelch[k]
#                self.config.set("launch", str(k + 1), filename)

#        # filetra exists
#        for k in range(len(self.filelch)):
#            if self.progress > 1:
#                #self.config.add_section("trace")
#                for l in arange(len(self.filetra[k])):
#                    filename = self.filetra[k][l]
#                    self.config.set("trace", "rx" + str(l + 1), filename)

#        # .tang exists
#        # .rang exists
#        # .tud exists
#            if self.progress > 2:
#                #config.add_section("tud")
#                #config.add_section("tang")
#                #config.add_section("rang")

#                for l in arange(len(self.filetud[k])):
#                    ftud = self.filetud[k][l]
#                    self.config.set("tud", "rx" + str(l + 1), ftud)

#                for l in arange(len(self.filetang[k])):
#                    ftang = self.filetang[k][l]
#                    self.config.set("tang", "rx" + str(l + 1), ftang)

#                for l in arange(len(self.filerang[k])):
#                    frang = self.filerang[k][l]
#                    self.config.set("rang", "rx" + str(l + 1), frang)

#        # .field exist
#        # .tauk exist
#            if self.progress > 3:
#                #config.add_section("tauk")
#                #config.add_section("field")
#                for l in arange(len(self.filetud[k])):
#                    ftauk = self.filetud[k][l]
#                    self.config.set("tauk", "rx" + str(l + 1), ftauk)

#                for l in arange(len(self.filefield[k])):
#                    ffield = self.filefield[k][l]
#                    self.config.set("field", "rx" + str(l + 1), ffield)

#        self.config.write(fd)
#        fd.close()

    def save_project(self):
        """ save Simulation files in a zipfile

        Simulation files are .ini files which are saved in a dedicated
        directory basename/ini in the Project tree

        """
        root = Tkinter.Tk()
        zipfileName = tkFileDialog.asksaveasfilename(parent=root,
                            filetypes = [("zipped file","zip")] ,
                            title="Save Project",
                            )
        pyu.zipd(basename,zipfileName)
        root.withdraw()
        print "Current project saved in", zipfileName

    def load_project(self):
        """ load Simulation files from a zipfile

        Simulation files are .ini files which are saved in a dedicated
        directory basename/ini in the Project tree

        """
        root = Tkinter.Tk()
        zipfileName= tkFileDialog.askopenfile(parent=root,
                                            mode='rb',
                                            title='Choose a project')
        dirname = tkFileDialog.askdirectory(parent=root,
                                    initialdir=basename,
                                    title='Please select a directory',
                                    mustexist=0)
        pyu.unzipd(dirname,zipfileName)
        root.withdraw()
        print "Current project loaded in", dirname

    def choose(self):
        """
            Choose a simulation file in simuldir

        """
        import tkFileDialog as FD
        fichsimul = FD.askopenfilename(filetypes=[("Fichiers simul ",
                                                   "*.simul"),
                                                  ("All", "*")],
                                       title="Please choose a simulation file",
                                       initialdir=simuldir)
        self.filesimul = pyu.getshort(fichsimul)
        self.load()

    def load(self, _filesimul):
        """ load a simulation configuration file

         each transmiter simulation results in the creation of an .ini file
         with the following sections
         related to the results obtained for different receivers

        Parameters
        ----------

        _filesimul   : file in the simul directory of the Project

        """

        self.filesimul = _filesimul
        filesimul = pyu.getlong(self.filesimul, "ini")

        self.config.read(filesimul)

        sections = self.config.sections()
        try:
            _filetx = self.config.get("files", "tx")
        except:
            raise NameError('Error in section tx from '+ _filesimul)

        try:
            _filerx = self.config.get("files", "rx")
        except:
            raise NameError('Error in section rx from '+ _filesimul)


        try:
            _fileanttx = self.config.get("files", "txant")
        except:
            raise NameError('Error in section txant from '+ _filesimul)

        try:
           _fileantrx = self.config.get("files", "rxant")
        except:
            raise NameError('Error in section rxant from '+ _filesimul)

        try:
            self.tx = RadioNode(name = '',
                                typ = 'tx',
                                _fileini = _filetx,
                                _fileant = _fileanttx,
                                _filestr = self.filestr)

            self.rx = RadioNode(name = '',
                                typ = 'rx',
                                _fileini = _filerx,
                                _fileant = _fileantrx,
                                _filestr = self.filestr)
        except:
            raise NameError('Error during Radionode load')
#
# Load Layout
# 
        try:
            self.L = Layout(self.filestr)
        except:
            raise NameError('Layout load error')

#
# Frequency base
#
        if "frequency" in sections:
            try:
                self.fGHz = np.linspace(float(self.config.getfloat("frequency", "fghzmin")),
                                        float(self.config.getfloat("frequency", "fghzmax")),
                                        int(self.config.getint("frequency", "nf")),
                                        endpoint=True)
            except:
                raise NameError('Error in section frequency from '+ _filesimul)
            # update .freq file in tud directory

            filefreq = pyu.getlong(self.filefreq, pstruc['DIRTUD'])
            fd = open(filefreq, "w")
            chaine = self.config.get("frequency", "fghzmin") + ' ' + \
                self.config.get("frequency", "fghzmax") + ' ' + \
                self.config.get("frequency", "nf")
            fd.write(chaine)
            fd.close
#
# Simulation Progress
#
        self.output = {}
        if "output" in sections:
            for itx in self.config.options("output"):
                _filename  =  self.config.get("output", itx)
                self.dout[int(itx)] = _filename
                filename = pyu.getlong(_filename, "output")
                output = ConfigParser.ConfigParser()
                output.read(filename)
                secout = output.sections()
                self.dtra[int(itx)] = {}
                self.dtud[int(itx)] = {}
                self.dtang[int(itx)] = {}
                self.drang[int(itx)] = {}
                self.dtauk[int(itx)] = {}
                self.dfield[int(itx)] = {}
                self.dcir[int(itx)] = {}
                if "launch" in secout:
                    self.progress = 1
                    keys_launch = output.options("launch")
                    for kl in keys_launch:
                        self.dlch[int(kl)] = output.get("launch", kl)
                if "trace" in secout:
                    self.progress = 2
                    keys_tra = output.options("trace")
                    for kt in keys_tra:
                        self.dtra[int(itx)][int(kt)] = output.get("trace", kt)

                if "tang" in secout:
                    self.progress = 3
                    keys_tang = output.options("tang")
                    for kt in keys_tang:
                        self.dtang[int(itx)][int(kt)] = output.get("tang", kt)
                        self.drang[int(itx)][int(kt)] = output.get("rang", kt)
                        self.dtud[int(itx)][int(kt)] = output.get("tud", kt)
                if "field" in secout:
                    self.progress = 4
                    keys_field = output.options("field")
                    for kt in keys_field:
                        self.dfield[int(itx)][int(kt)] = output.get(
                            "field", kt)
                        self.dtauk[int(itx)][int(kt)] = output.get("tauk", kt)
                if "cir" in secout:
                    self.progress = 5
                    keys_cir = output.options("cir")
                    for kt in keys_cir:
                        self.dcir[int(itx)][int(kt)] = output.get("cir", kt)

                self.output[int(itx)] = output
        #
        # Waveform section
        #
        self.wav = wvf.Waveform()
        self.wav.read(self.config)

    def layout(self, _filestruc):
        """ load a layout in the simulation oject

        Parameters
        ----------

        _filestruc : string
            short file name of the Layout object

        Examples
        --------

        >>> from pylayers.simul.simulem import *
        >>> S = Simul()
        >>> S.layout('defstr.ini')

        """
        self.filestr = _filestruc

        self.L = Layout(_filestruc)
        # update config
        self.config.set("files", "struc", self.filestr)
        self.save()

    def show(self, itx=[-1], irx=[-1], furniture=True, s=8, c='b', traj=False, num=False,fig=[],ax=[]):
        """ show simulation

            Parameters
            -----------
            itx        : list of tx indices
            irx        : list of rx indices
            furniture  : boolean for METALIC furniture display
            s          : scale fir scatter plot  (default 8)
            c          : color for scatter plot  (default 'b')
            traj       : boolean  (def False)
            num        : boolean  (def False)
                display a number


            Examples
            --------
            >>> import matplotlib.pyplot as plt
            >>> from pylayers.simul.simulem import *
            >>> S = Simul()
            >>> S.load('w1.ini')
            >>> S.L.loadfur('FurW1.ini')
            >>> S.show()
            >>> plt.show()



        """
        if type(itx) == int:
            itx = [itx]
        if type(irx) == int:
            irx = [irx]


        if fig ==[]:
            fig = plt.gcf()
        if ax==[]:
            ax = fig.gca()

        #self.L.display['scaled']=False
        fig,ax=self.L.showG('s',fig=fig,ax=ax, aw=True)
        #
        if furniture:
            if 'lfur' in self.L.__dict__:
                for fur in self.L.lfur:
                    if fur.Matname == 'METAL':
                        fur.show(fig, ax)
            else:
                print "Warning : no furniture file loaded"

        if irx[0] == -1:
            ax.scatter(self.rx.position[0,:],
                       self.rx.position[1,:], c='b', s=s, alpha=0.5)
            #ax.scatter(self.rx.position[0,0],self.rx.position[0,1],c='k',s=s,linewidth=0)
            #ax.scatter(self.rx.position[1,0],self.rx.position[1,1],c='b',s=s,linewidth=0)
            #ax.scatter(self.rx.position[2,0],self.rx.position[2,1],c='g',s=s,linewidth=0)
            #ax.scatter(self.rx.position[3,0],self.rx.position[3,1],c='c',s=s,linewidth=0)
        else:
            for k in irx:
                ax.scatter(self.rx.position[0,k - 1],
                           self.rx.position[1,k - 1], c='b', s=s, alpha=0.5)
                if num:
                    ax.text(self.rx.position[0,k - 1],
                            self.rx.position[1,k - 1],
                            str(k), color='blue')

        if itx[0] == -1:
            ax.scatter(self.tx.position[0,:],
                       self.tx.position[1,:], c='r', s=s)
        else:
            if traj:
                cpt = 1
            for k in itx:
                ax.scatter(self.tx.position[0,k - 1],
                           self.tx.position[1,k - 1],
                           c=c, s=s, linewidth=0)
                if num:
                    if traj:
                        ax.text(self.tx.position[0,k - 1],
                                self.tx.position[1,k - 1],
                                str(cpt), color='black')
                        cpt = cpt + 1
                    else:
                        ax.text(self.tx.position[0,k - 1],
                                self.tx.position[1,k - 1],
                                str(k), color='black')

        return (fig,ax)
        #for k in range(self.tx.N):
        #    ax.text(self.tx.position[0,k],self.tx.position[1,k],str(k+1),color='black')
        #    ax.scatter(self.tx.position[0,:],self.tx.position[0,:],

        #for k in range(self.rx.N):
        #   ax.text(self.rx.position[0,k],self.rx.position[1,k],str(k),color='black')

    def PL(self, itx):
        """ plot Path Loss

        itx
        """
        td = []
        tEa = []
        tEo = []
        for irx in self.dcir[itx].keys():
            d = self.delay(itx, irx) * 0.3
            cira, ciro = self.loadcir(itx, irx)

            td.append(d)
            tEa.append(Ea)
            tEo.append(Eo)

        plt.semilogx(td, 10 * np.log10(tEa), 'xr')
        plt.semilogx(td, 10 * np.log10(tEo), 'xb')
        plt.show()
        return td, tEa, tEo

    def evalcir(self,cutoff=4,algo='new'):
        """
        Parameters
        ----------

        S
        tx
        rx
        wav
        cutoff

        """

        crxp =-1
        ctxp =-1
        tcir = {}
        tx = self.tx.position
        Ntx = len(tx[0])
        rx = self.rx.position
        Nrx = len(rx[0])

        #for kt in range(1,Ntx-1):
        #print kt+1
        kt=0
        tcir[kt] = {}
        t = np.array([self.tx.position[0,kt],self.tx.position[1,kt],self.tx.position[2,kt]])
        for kr in range(Nrx):
            if (np.mod(kr,10)==0):
                print kr+1
            r = np.array([self.rx.position[0,kr],self.rx.position[1,kr],self.rx.position[2,kr]])
            ctx = self.L.pt2cy(t)
            crx = self.L.pt2cy(r)
            if (ctx<>ctxp)|(crx<>crxp):
                Si  = signature.Signatures(self.L,ctx,crx)
                ctxp = ctx
                crxp = crx
                Si.run4(cutoff=cutoff,algo=algo)
            r2d = Si.rays(t,r)
            #r2d.show(S.L)

            r3d = r2d.to3D(self.L)
            r3d.locbas(self.L)
            r3d.fillinter(self.L)
            Ct  = r3d.eval(self.fGHz)
            sca = Ct.prop2tran(self.tx.A,self.rx.A)
            cir = sca.applywavB(self.wav.sfg)
            tcir[kt][kr] = cir
        return(tcir)

    def loadcir(self, itx, irx):
        """

        Parameters
        ----------

        itx : Tx index
        irx : Rx index

        Returns
        -------

        cir(itx,irx)
        """
        _filecir = self.dcir[itx][irx] + '.mat'
        ext = str(itx)
        if len(ext) == 1:
            ext = '00' + ext
        if len(ext) == 2:
            ext = '0' + ext

        filecir = pyu.getlong(_filecir, pstruc['DIRCIR']+'/Tx' + ext)
        D = spio.loadmat(filecir)

        kxa = 'ta' + str(irx)
        kya = 'cira' + str(irx)

        kxo = 'to' + str(irx)
        kyo = 'ciro' + str(irx)

        cira = bs.TUsignal(D[kxa], D[kya][:, 0])
        ciro = bs.TUsignal(D[kxo], D[kyo][:, 0])

        return(cira, ciro)

    def pltcir(self, itx=1, irx=1, mode='linear', noise=False, color='b',format='a',fig=[],ax=[]):
        """ plot Channel Impulse Response

        Parameters
        ----------

        itx : Tx index
        irx : Rx index
        mode : str
            {'linear','dB'}
            noise : boolean
        color : string
            default 'b'

        >>> from pylayers.simul.simulem import *
        >>> S = Simul()
        >>> S.load('where2.ini')
        >>> S.run(1,1)
        >>> S.pltcir(1,1,mode='linear',noise=False,color='k')

        """

        if fig ==[]:
            fig = plt.gcf()
        #if ax==[]:
        #    ax = fig.gca()

        _filecir = self.dcir[itx][irx] + '.mat'
        filecir = pyu.getlong(_filecir, pstruc['DIRCIR']+'/Tx' + str('%0.3d' % itx))
        D = spio.loadmat(filecir)
        ax = fig.add_subplot('211')

        fig,ax=self.show(itx, irx,fig=fig,ax=ax)
        ax=fig.add_subplot('212')
        if 'a' in format :
            kxa = 't'
            kya = 'cir'
            ta = D[kxa]
            Tobs = ta[-1] - ta[0]
            te = ta[1] - ta[0]
            if noise:
                na = bs.Noise(Tobs + te, 1. / te)
                naf = na.gating(4.493, 0.5)
            cira = bs.TUsignal(ta, D[kya][:, 0])


        if 'o' in format:
            kxo = 'to' + str(irx)
            kyo = 'ciro' + str(irx)
            to = D[kxo]
            Tobs = to[-1] - to[0]
            te = to[1] - to[0]
            if noise:
                no = bs.Noise(Tobs + te, 1. / te)
                nof = no.gating(4.493, 0.5)
            ciro = bs.TUsignal(to, D[kyo][:, 0])

        if mode == 'linear':
            #plt.plot(ta,naf.y,color='k',label='Noise')
            plt.plot(ta, D[kya], label='Rx ' + str(irx), color=color)
            plt.xlabel('Time (ns)')

            '''if noise:
                naf.plot(col='k')
            cira.plot(col=color)'''
        else:
            '''if noise:
                naf.plotdB(col='k')
            cira.plotdB()'''
            plt.plot(ta, 20 * np.log10(abs(D[kya])), label='Rx ' + str(irx), color=color)
            plt.xlabel('Time (ns)')
#        plt.legend()
        plt.show()
        #plt.savefig('Tx'+str(itx),format=pdf,dpi=300)

    def scatter(self, itx, irx, values,
                cmap=plt.cm.gray,
                s=30,
                spl=221,
                title='',
                vaxis=((-30, 10, 2, 18)),
                vmin=0,
                vmax=1,
                colbool=False,
                cblabel='dB'):
        """
            Parameters
            ----------

            itx
            irx
            values
            cmap
            s
            spl
            title
            vaxis
            vmin
            vmax
            colbool
            clabel

        """
        fig = plt.gcf()
        ax = fig.add_subplot(spl)
        xtx = self.tx.position[itx, 0]
        ytx = self.tx.position[itx, 1]
        xrx = self.rx.position[irx, 0]
        yrx = self.rx.position[irx, 1]
        self.L.display['title'] = title
        self.L.showGs(ax)
        for furk in siradel.siradel_furniture.keys():
            fur = siradel.siradel_furniture[furk]
            if fur.Matname == 'METAL':
                fur.show(fig, ax)

        #self.show(furniture=True)
        plt.axis(vaxis)
        b1 = ax.scatter(xtx, ytx, s=s, c=values, cmap=cmap,
                        linewidths=0, vmin=vmin, vmax=vmax)
        ax.scatter(xrx, yrx, s=30, c='b', linewidths=0)
        if colbool:
            cb = colorbar(b1)
            cb.set_label(cblabel, fontsize=14)
        return(b1)

    def info(self, itx=[], irx=[]):
        """ display simulation information

         Parameters
         ----------
         itx : Tx index
         irx : Rx index

        """
        print self.filesimul
        print '------------------------------------------'
        try:
            print "Layout Info : \n", self.L.info()
        except:
            print "provide a Layout in the simulation : S.L "
            print ">>> S.layout(filename.str) "
            print "or "
            print ">>> S.layout(filename.str2 "
            print "or "
            print ">>> S.layout(filename.str,filematini,filematini) "
            print "default files exists for filematini and fileslabini "

            return
        try:
            print "Tx Info :\n", self.tx.info()
        except:
            print "provide a tx in the simulation : S.tx "
            return
        try:
            print "Rx Info :\n", self.rx.info()
        except:
            print "provide a rx in the simulation : S.rx "
            return

        #    print "Tx : ",self.tx.points[itx]
            print "Rx : ", self.rx.points[itx]
            print "Delay (ns) :", self.delay(itx, irx)
            print "Distance (m) :", 0.3 / self.delay(itx, irx)
            print ""
            if itx in self.dlch.keys():
                print "-----"
                print "Launching "
                print "-----"
                print " ", self.dlch[itx]
            if irx in self.dtra[itx].keys():
                print "-----"
                print "Tracing "
                print "-----"
                print " ", self.dtra[itx][irx]
                gr = GrRay3D()
                gr.load(self.dtra[itx][irx], self.L)
                gr.info()
            if irx in self.dtud[itx].keys():
                print "-----"
                print "Tud parameters "
                print "-----"
                print " ", self.dtud[itx][irx]
                print " ", self.dtang[itx][irx]
                print " ", self.drang[itx][irx]
                gt = GrRay3D.GrRayTud()
                gt.load(self.dtud[itx][irx],
                        self.dtang[itx][irx],
                        self.drang[itx][irx], self.sl)
            if irx in self.dtauk[itx].keys():
                print self.dtauk[itx][irx]
                print self.dfield[itx][irx]
                VC = self.VC(itx, irx)
            if irx in self.dcir[itx].keys():
                print self.dcir[itx][irx]

    def info2(self):
        for i, j in enumerate(self.__dict__.keys()):
            print j, ':', self.__dict__.values()[i]

    def filtray(self, itx, irx, tau0, tau1, col='b'):
        """ filter rays

        Parameters
        ----------
        itx :
        irx :
        tau0 :
        tau1 :
        col :

        Display ray and nstr
        """
        gr = GrRay3D()
        gr.load(self.dtra[itx][irx], self.L)
        self.L.display['Thin'] = True
        self.L.display['Node'] = False
        self.L.display['NodeNum'] = False
        self.L.display['EdgeNum'] = False
        plt.axis('scaled')
        #self.L.show(fig,ax,nodelist,seglist)
        self.L.showGs()
        delays = gr.delay()
        rayset = np.nonzero((delays >= tau0) & (delays <= tau1))[0]
        fig = plt.gcf()
        ax = fig.get_axes()[0]
        gr.show(ax, rayset, col=col, node=False)
        plt.title('Tx' + str(itx) + '-Rx' + str(irx) + ' : ' + str(
            tau0) + ' < tau < ' + str(tau1))

    def showray(self, itx, irx, iray=np.array([]), fig=[], ax=[]):
        """ show layout and rays for a radio link

        Parameters
        ----------
        itx  : tx index
        irx  : rx index
        iray : list of rays to be displayed ndarray


        """

        #if ax==[]:
        #    fig = plt.figure()
        #    ax  = fig.add_subplot('111')

        gr = GrRay3D()
        gr.load(self.dtra[itx][irx], self.L)
        if len(iray == 1):
            ray = gr.ray3d[iray[0]]
            nstr = ray.nstr[1:-1]
            uneg = np.nonzero(nstr < 0)
            upos = np.nonzero((nstr > 0) & (nstr <= self.L.Ne))
            uceil = np.nonzero(nstr == self.L.Ne + 1)
            ufloor = np.nonzero(nstr == self.L.Ne + 2)
        #seglist  = nstr[upos[0]]-1
        #nodelist = -nstr[uneg[0]]-1
        #seglist2 = S.L.segpt(nodelist)
        self.L.display['Thin'] = True
        self.L.display['Node'] = False
        self.L.display['NodeNum'] = False
        self.L.display['EdgeNum'] = False
        #self.L.show(fig,ax)
        #print ray.nn
        #print len(ray.nstr)
        #print ray.nstr
        #print nodelist
        #print seglist
        #print seglist2
        #seglist = hstack((seglist,seglist2))
        self.L.display['Node'] = False
        self.L.display['Thin'] = False
        self.L.display['NodeNum'] = True
        self.L.display['EdgeNum'] = True
        plt.axis('scaled')
        #self.L.show(fig,ax,nodelist,seglist)
        fig, ax = self.L.showGs(show=False)
        gr.show(ax, iray, col='b', node=False)

        if len(iray) == 1:
            plt.title(str(nstr))
        else:
            plt.title('Tx' + str(itx) + '-Rx' + str(irx) +
                      ' ' + str(min(iray)) + ' ' + str(max(iray)))

    def show3l(self, itx, irx):
        """ geomview display of a specific link

        g = S.show3l(itx,irx)

        Parameters
        ----------
        itx
            transmitter index
        irx
            receiver index

        """
        filetra = self.dtra[itx][irx]
        gr = GrRay3D()
        gr.load(filetra, self.L)
        gr.show3()

        return(gr)

    def _show3(self,rays=[],newfig = False,**kwargs):
        """ display of the simulation configuration
            using Mayavi

        Parameters
        ----------

        rays: Ray3d object :
            display the rays of the simulation
        newfig : boolean (default : False)
        kwargs of Rays.show3()


        see also
        --------

        pylayers.gis.layout
        pylayers.antprop.antenna
        pylayers.antprop.rays

        """
        Atx = self.tx.A
        Arx = self.rx.A
        Ttx = self.tx.orientation
        Trx = self.rx.orientation
        ptx = self.tx.position
        prx = self.rx.position

        self.L._show3(newfig=False,opacity=0.7)
        Atx._show3(T=Ttx.reshape(3,3),po=ptx,
            title=False,colorbar=False,newfig=False)
        Arx._show3(T=Trx.reshape(3,3),po=prx,
            title=False,colorbar=False,newfig=False)
        if rays != []:
            rays._show3(**kwargs)



    def show3(self,rays=[],**kwargs):
        """ geomview display of the simulation configuration

        Parameters
        ----------

        centered : boolean
            center the scene if True
        bdis  : boolean
            display local basis

        """
        try:
            self.tx.save()
        except:
            print('tx set is no defined')
        try:
            self.rx.save()
        except:
            print('rx set is no defined')
        _filename = self.filesimul.replace('.ini', '.off')
        filename = pyu.getlong(_filename, pstruc['DIRGEOM'])
        fo = open(filename, "w")
        fo.write("LIST\n")
        try:
            sttx = "{<" + self.tx.filegeom + "}\n"
        except:
            sttx = "\n"
        try:
            strx = "{<" + self.rx.filegeom + "}\n"
        except:
            strx = "\n"
        try:
            stst = "{<" + self.L.filegeom + "}\n"
        except:
            stst = "\n"
        fo.write(sttx)
        fo.write(strx)
        fo.write(stst)
        fo.write("{</usr/share/geomview/geom/xyz.vect}\n")
        if rays !=[]:
            kwargs['bdis']=False
            kwargs['L']=self.L
            kwargs['centered']=False
            fo.write("{<" + rays.show3(**kwargs) + "}")

        fo.close()


        command = "geomview -nopanel -b 1 1 1 " + filename + " 2>/dev/null &"
        os.system(command)

    def run(self, link, cirforce=True,verbose=False,cutoff=4):
        """ run the simulation for 1 tx and a set of rx

            Parameters
            ----------

            itx      : tx index
            srx      : list of rx index
            cirforce : boolean

            Warnings
            --------

            index point start with 1

            Example
            -------

            >>> from pylayers.simul.simulem import *
            >>> itx = 1
            >>> srx = [1,2,3]
            >>> S   = Simul()
            >>> S.load('where2.ini')
            >>> out = S.run(itx,srx)


        """
        
        # get file prefix

        link = DLink(force=True,L=self.L,fGHz=self.fGHz, verbose=False)
        prefix = self.filesimul.replace('.ini', '') 
        lsig = []
        for k,il in enumerate(link):
            tx = self.tx.points[il[0]]
            rx = self.rx.points[il[1]]
            ctx = S.L.pt2cy(tx)
            crx = S.L.pt2cy(rx)
            _filecir = prefix +'-cir-'+str(k)+'-'+str(link)+'-'+str((ctx,crx))
            D = {}
            D['Tx'] = tx
            D['Rx'] = rx

            
            link.a = tx
            link.b = rx
            ak,tauk = link.eval(verbose=False,diffrction=True)
            if (ctx,crx) not in lsig:
                Si  = signature.Signatures(S.L,ctx,crx)
                #
                # Change the run number depending on
                # the algorithm used for signature determination
                #
                Si.run4(cutoff=cutoff)
                # keep track and save signature
                _filesir = prefix + '-sig-'+str((ctx,crx))
                fd = open(filesig,'w')
                pickle.dump(Si,filesig)
                fd.close()
                lsig.appeng((ctx,crx))
                Si.dump(S.L,(ctx,crx))



            r2d = Si.rays(tx,rx)
            r2d.show(S.L)
    
            r3d = r2d.to3D()
            r3d.locbas(S.L)
            r3d.fillinter(S.L)

            Ct  = r3d.eval(S.freq)
            sco = Ct.prop2tran(a='theta',b='phi')
            sca = Ct.prop2tran(a=S.tx.A,b=S.rx.A)

            ciro = sco.applywavB(self.wav.sfg)
            cira = sca.applywavB(self.wav.sfg)

            D['to'] = ciro.x
            D['ciro'] = ciro.y
            D['t'] = cira.x
            D['cir'] = cira.y

            filename = pyu.getlong(_filename, cirdir)
            spio.savemat(filename, D)
            
    def delay(self, itx, irx):
        """ calculate LOS link delay

            Parameters
            ----------

            itx
            irx

            Returns
            -------

            delay : float 
                delay in ns

        """
        tx = self.tx.points[itx]
        rx = self.rx.points[irx]
        df = tx - rx
        dist = np.sqrt(np.dot(df, df))
        return(dist / 0.3)
示例#33
0
    def ishow(self):
        """
            interactive show of trajectories

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.mobility.trajectory import *
            >>> T=Trajectories()
            >>> T.loadh5()
            >>> T.ishow()

        """

        fig, ax = plt.subplots()
        fig.subplots_adjust(bottom=0.2, left=0.3)

        t = np.arange(0, len(self[0].index), self[0].ts)
        L = Layout(self.Lfilename)
        fig, ax = L.showG('s', fig=fig, ax=ax)

        valinit = 0
        lines = []
        labels = []
        colors = "bgrcmykw"

        for iT, T in enumerate(self):
            if T.typ == 'ag':
                lines.extend(
                    ax.plot(T['x'][0:valinit],
                            T['y'][0:valinit],
                            'o',
                            color=colors[iT],
                            visible=True))
                labels.append(T.name + ':' + T.ID)
            else:
                lines.extend(
                    ax.plot(T['x'][0],
                            T['y'][0],
                            '^',
                            ms=12,
                            color=colors[iT],
                            visible=True))
                labels.append(T.name + ':' + T.ID)

        t = self[0].time()

        # init boolean value for visible in checkbutton
        blabels = [True] * len(labels)

        ########
        # slider
        ########
        slider_ax = plt.axes([0.1, 0.1, 0.8, 0.02])
        slider = Slider(slider_ax,
                        "time",
                        self[0].tmin,
                        self[0].tmax,
                        valinit=valinit,
                        color='#AAAAAA')

        def update(val):
            if val >= 1:
                pval = np.where(val > t)[0]
                ax.set_title(str(
                    self[0].index[pval[-1]].time())[:11].ljust(12),
                             loc='left')
                for iT, T in enumerate(self):
                    if T.typ == 'ag':
                        lines[iT].set_xdata(T['x'][pval])
                        lines[iT].set_ydata(T['y'][pval])
                fig.canvas.draw()

        slider.on_changed(update)

        ########
        # choose
        ########
        rax = plt.axes([0.02, 0.5, 0.3, 0.2], aspect='equal')
        # check (ax.object, name of the object , bool value for the obsject)
        check = CheckButtons(rax, labels, tuple(blabels))

        def func(label):
            i = labels.index(label)
            lines[i].set_visible(not lines[i].get_visible())
            fig.canvas.draw()

        check.on_clicked(func)
        fig.canvas.draw()
        plt.show(fig)
示例#34
0
    def load(self, _filesimul):
        """ load a simulation configuration file

         each transmiter simulation results in the creation of an .ini file
         with the following sections
         related to the results obtained for different receivers

        Parameters
        ----------

        _filesimul   : file in the simul directory of the Project

        """

        self.filesimul = _filesimul
        filesimul = pyu.getlong(self.filesimul, "ini")

        self.config.read(filesimul)

        sections = self.config.sections()
        try:
            _filetx = self.config.get("files", "tx")
        except:
            raise NameError('Error in section tx from '+ _filesimul)

        try:
            _filerx = self.config.get("files", "rx")
        except:
            raise NameError('Error in section rx from '+ _filesimul)


        try:
            _fileanttx = self.config.get("files", "txant")
        except:
            raise NameError('Error in section txant from '+ _filesimul)

        try:
           _fileantrx = self.config.get("files", "rxant")
        except:
            raise NameError('Error in section rxant from '+ _filesimul)

        try:
            self.tx = RadioNode(name = '',
                                typ = 'tx',
                                _fileini = _filetx,
                                _fileant = _fileanttx,
                                _filestr = self.filestr)

            self.rx = RadioNode(name = '',
                                typ = 'rx',
                                _fileini = _filerx,
                                _fileant = _fileantrx,
                                _filestr = self.filestr)
        except:
            raise NameError('Error during Radionode load')
#
# Load Layout
# 
        try:
            self.L = Layout(self.filestr)
        except:
            raise NameError('Layout load error')

#
# Frequency base
#
        if "frequency" in sections:
            try:
                self.fGHz = np.linspace(float(self.config.getfloat("frequency", "fghzmin")),
                                        float(self.config.getfloat("frequency", "fghzmax")),
                                        int(self.config.getint("frequency", "nf")),
                                        endpoint=True)
            except:
                raise NameError('Error in section frequency from '+ _filesimul)
            # update .freq file in tud directory

            filefreq = pyu.getlong(self.filefreq, pstruc['DIRTUD'])
            fd = open(filefreq, "w")
            chaine = self.config.get("frequency", "fghzmin") + ' ' + \
                self.config.get("frequency", "fghzmax") + ' ' + \
                self.config.get("frequency", "nf")
            fd.write(chaine)
            fd.close
#
# Simulation Progress
#
        self.output = {}
        if "output" in sections:
            for itx in self.config.options("output"):
                _filename  =  self.config.get("output", itx)
                self.dout[int(itx)] = _filename
                filename = pyu.getlong(_filename, "output")
                output = ConfigParser.ConfigParser()
                output.read(filename)
                secout = output.sections()
                self.dtra[int(itx)] = {}
                self.dtud[int(itx)] = {}
                self.dtang[int(itx)] = {}
                self.drang[int(itx)] = {}
                self.dtauk[int(itx)] = {}
                self.dfield[int(itx)] = {}
                self.dcir[int(itx)] = {}
                if "launch" in secout:
                    self.progress = 1
                    keys_launch = output.options("launch")
                    for kl in keys_launch:
                        self.dlch[int(kl)] = output.get("launch", kl)
                if "trace" in secout:
                    self.progress = 2
                    keys_tra = output.options("trace")
                    for kt in keys_tra:
                        self.dtra[int(itx)][int(kt)] = output.get("trace", kt)

                if "tang" in secout:
                    self.progress = 3
                    keys_tang = output.options("tang")
                    for kt in keys_tang:
                        self.dtang[int(itx)][int(kt)] = output.get("tang", kt)
                        self.drang[int(itx)][int(kt)] = output.get("rang", kt)
                        self.dtud[int(itx)][int(kt)] = output.get("tud", kt)
                if "field" in secout:
                    self.progress = 4
                    keys_field = output.options("field")
                    for kt in keys_field:
                        self.dfield[int(itx)][int(kt)] = output.get(
                            "field", kt)
                        self.dtauk[int(itx)][int(kt)] = output.get("tauk", kt)
                if "cir" in secout:
                    self.progress = 5
                    keys_cir = output.options("cir")
                    for kt in keys_cir:
                        self.dcir[int(itx)][int(kt)] = output.get("cir", kt)

                self.output[int(itx)] = output
        #
        # Waveform section
        #
        self.wav = wvf.Waveform()
        self.wav.read(self.config)
示例#35
0
class Simul(SimulationRT): # Sympy 2
#class Simul(sympy.RealtimeEnvironment):
    """

    Attributes
    ----------
    config  : config parser instance
    sim_opt : dictionary of configuration option for simulation
    ag_opt : dictionary of configuration option for agent
    lay_opt : dictionary of  configuration option for layout
    meca_opt : dictionary of  configuration option for mecanic
    net_opt : dictionary of  configuration option for network
    loc_opt : dictionary of  configuration option for localization
    save_opt : dictionary of  configuration option for save
    sql_opt : dictionary of  configuration option for sql

    Notes
    ------
     All the prvious dictionnary are obtained from the chosen simulnet.ini file
    in the project directory

    """
    def __init__(self):
        SimulationRT.__init__(self) #Sympy 2
        #sympy.RealtimeEnvironment.__init__(self)  #simpy 3
        self.initialize()
        self.config = ConfigParser.ConfigParser()
        filename = pyu.getlong('simulnet.ini','ini')
        self.config.read(filename)
        self.sim_opt = dict(self.config.items('Simulation'))
        self.lay_opt = dict(self.config.items('Layout'))
        self.meca_opt = dict(self.config.items('Mechanics'))
        self.net_opt = dict(self.config.items('Network'))
        self.loc_opt = dict(self.config.items('Localization'))
        self.save_opt = dict(self.config.items('Save'))
        self.sql_opt = dict(self.config.items('Mysql'))

        self.verbose = str2bool(self.sim_opt['verbose'])
        if str2bool(self.net_opt['ipython_nb_show']):
            self.verbose = False
        self.roomlist=[]

        self.create()

    def create_layout(self):
        """
        Create Layout in Simpy the_world thanks to Tk backend

        """

        self.the_world = world(width = float(self.lay_opt['the_world_width']), 
                               height = float(self.lay_opt['the_world_height']),
                               scale=float(self.lay_opt['the_world_scale']))

        # tk = self.the_world.tk
        # canvas, x_, y_ = tk.canvas, tk.x_, tk.y_
        # canvas.create_rectangle(x_(-1), y_(-1), x_(100), y_(100), fill='white')

        _filename = self.lay_opt['filename']
        #sl=Slab.SlabDB(self.lay_opt['slab'],self.lay_opt['slabmat'])
        #G1   = Graph.Graph(sl=sl,filename=_filename)
        self.L = Layout(_filename)
        #if _filename.split('.')[1] == 'str':
        #    self.L.loadstr(_filename)
        #elif _filename.split('.')[1] == 'str2':
        #    self.L.loadstr2(_filename)
        #elif _filename.split('.')[1] == 'ini':
        #    self.L.loadini(_filename)


        try:
            self.L.dumpr()
            print 'Layout graphs are loaded from ',basename,'/struc/ini'
        except:
        #self.L.sl = sl
        #self.L.loadGr(G1)
            print 'This is the first time the layout file is used\
            Layout graphs are curently being built, it may take few minutes.'
            self.L.build()     
            self.L.dumpw()
        x_offset = 0  # float(self.lay_opt['x_offset'])
        y_offset = 0  # float(self.lay_opt['y_offset'])
        for ks in self.L.Gs.pos.keys():
            self.L.Gs.pos[ks] = (self.L.Gs.pos[ks][0] +
                                 x_offset, self.L.Gs.pos[ks][1] + y_offset)
        for ks in self.L.Gr.pos.keys():
            self.L.Gr.pos[ks] = (self.L.Gr.pos[ks][0] +
                                 x_offset, self.L.Gr.pos[ks][1] + y_offset)
        for ks in self.L.Gw.pos.keys():
            self.L.Gw.pos[ks] = (self.L.Gw.pos[ks][0] +
                                 x_offset, self.L.Gw.pos[ks][1] + y_offset)

        #
        # Create Layout
        #
        walls = self.L.thwall(0, 0)
        for wall in walls:
            points = []
            # for point in wall:
            #          points.append(x_(point[0]))
            #          points.append(y_(point[1]))
            #      canvas.create_polygon(points, fill='maroon', outline='black')
            for ii in range(0, len(wall) - 1):
                self.the_world.add_wall(wall[ii], wall[ii + 1])

    def create_agent(self):
        """    
        create simulation's Agents

        ..todo:: change lAg list to a dictionnary ( modification in show.py too) 

        """


        self.lAg = []
        agents=[]
        Cf = ConfigParser.ConfigParser()
        Cf.read(pyu.getlong('agent.ini','ini'))
        agents=eval(dict(Cf.items('used_agent'))['list'])
        for i, ag in enumerate(agents):
            ag_opt = dict(Cf.items(ag))
            self.lAg.append(Agent(
                            ID=ag_opt['id'],
                            name=ag_opt['name'],
                            type=ag_opt['type'],
                            pos=np.array(eval(ag_opt['pos'])),
                            roomId=int(ag_opt['roomid']),
                            froom=eval(ag_opt['froom']),
                            meca_updt=float(self.meca_opt['mecanic_update_time']),
                            wait=float(ag_opt['wait']),
                            cdest=eval(self.meca_opt['choose_destination']),
                            loc=str2bool(self.loc_opt['localization']),
                            loc_updt=float(self.loc_opt['localization_update_time']),
                            loc_method=eval(self.loc_opt['method']),
                            Layout=self.L,
                            net=self.net,
                            epwr=dict([(eval((ag_opt['rat']))[ep],eval((ag_opt['epwr']))[ep]) for ep in range(len(eval((ag_opt['rat']))))]),
                            sens=dict([(eval((ag_opt['rat']))[ep],eval((ag_opt['sensitivity']))[ep]) for ep in range(len(eval((ag_opt['rat']))))]),
                            world=self.the_world,
                            RAT=eval(ag_opt['rat']),
                            save=eval(self.save_opt['save']),
                            gcom=self.gcom,
                            comm_mode=eval(self.net_opt['communication_mode']),
                            sim=self))
#                            
            if self.lAg[i].type == 'ag':
                self.activate(self.lAg[i].meca,
                              self.lAg[i].meca.move(), 0.0)

    def create_EMS(self):
        """
            Electromagnetic Solver object
        """
        self.EMS = EMSolver(L=self.L)

    def create_network(self):
        """
            create the whole network
        """

        self.net = Network(EMS=self.EMS)
        self.gcom=Gcom(net=self.net,sim=self)

        self.create_agent()
        # create network

        self.net.create()

        # create All Personnal networks
        for n in self.net.nodes():
            self.net.node[n]['PN'].get_RAT()
            self.net.node[n]['PN'].get_SubNet()
        self.gcom.create()


       # create Process Network
        self.Pnet = PNetwork(net=self.net,
                             net_updt_time=float(self.net_opt['network_update_time']),
                             L=self.L,
                             sim=self,
                             show_sg=str2bool(self.net_opt['show_sg']),
                             disp_inf=str2bool(self.net_opt['dispinfo']),
                             save=eval(self.save_opt['save']))
        self.activate(self.Pnet, self.Pnet.run(), 0.0)

    def create_visual(self):
        """ Create visual Tk process
        """

        self.visu = Updater(
            interval=float(self.sim_opt['show_interval']), sim=self)
        self.activate(self.visu, self.visu.execute(), 0.0)

    def create(self):
        """ Create the simulation 
            This method is called at the end of __init__

        """

        # this is just to redump the database at each simulation
        if 'mysql' in self.save_opt['save']:
            if str2bool(self.sql_opt['dumpdb']):
                os.popen('mysql -u ' + self.sql_opt['user'] + ' -p ' + self.sql_opt['dbname'] +\
                '< /private/staff/t/ot/niamiot/svn2/devel/simulator/pyray/SimWHERE2.sql' )

        ## TODO supprimer la ref en dur 
        if 'txt' in self.save_opt['save']:
            pyu.writeDetails(self)
            if os.path.isfile(basename+'/output/Nodes.txt'):
                print 'would you like to erase previous txt files ?'
                A=raw_input()
                if A == 'y':
                    for f in os.listdir(basename+'/output/'):
                        try:
                            fi,ext=f.split('.')
                            if ext == 'txt':
                                os.remove(basename+'/output/'+f)
                        except:
                            pass
                        
        self.create_layout()
        self.create_EMS()
        self.create_network()
        if str2bool(self.sim_opt['showtk']):
            self.create_visual()
        self.create_show()

        if str2bool(self.save_opt['savep']):
            self.save=Save(L=self.L,net=self.net,sim=self)
            self.activate(self.save,self.save.run(),0.0)
#        if str2bool(self.save_opt['savep']):
#            self.save=Save(net=self.net,
#                    L= self.L,
#                    sim = self)
#            self.activate(self.save, self.save.run(), 0.0)



    def create_show(self):
        """ 
        """

        plt.ion()
        fig_net = 'network'
        fig_table = 'table'

        if str2bool(self.net_opt['show']):
            if str2bool(self.net_opt['ipython_nb_show']):
                notebook=True
            else:
                notebook =False
            self.sh = ShowNet(net=self.net, L=self.L,sim=self,fname=fig_net,notebook=notebook)
            self.activate(self.sh,self.sh.run(),1.0)

        if str2bool(self.net_opt['show_table']):
            self.sht = ShowTable(net=self.net,lAg=self.lAg,sim=self,fname=fig_table)
            self.activate(self.sht,self.sht.run(),1.0)


    def runsimul(self):
        """ Run simulation
        """

        self.simulate(until=float(self.sim_opt['duration']),
                      real_time=True,
                      rel_speed=float(self.sim_opt['speedratio']))
#        self.simulate(until=float(self.sim_opt['duration']))
        if self.save_opt['savep']:
            print 'Processing save results, please wait'
            self.save.mat_export()
示例#36
0
from pylayers.gis.layout import Layout
import matplotlib.pyplot as plt 
import doctest 

#doctest.testmod(layout)


#L = Layout('TA-Office.ini')
L = Layout('DLR.ini')
try:
    L.dumpr()
except:
    L.build()
    L.dumpw()
#L.editor()
fig = plt.gcf()
#ax1  = fig.add_subplot(221)
ax1  = fig.add_subplot(321)
L.display['thin']=True
fig,ax1  = L.showGs(fig=fig,ax=ax1)
#L.display['edlabel']=True
#L.display['edlblsize']=50
# display selected segments
L.display['thin']=True
L.showG(fig=fig,ax=ax1,graph='t')
fig = plt.gcf()
ax1 = plt.gca()
fig,ax1 =  L.showGs(fig=fig,ax=ax1,edlist=[125],width=4)
ax11 = fig.add_subplot(322)
L.showG(fig=fig,ax=ax11,graph='')
#plt.savefig('graphGs.png')
示例#37
0
class Coverage(PyLayers):
    """ Handle Layout Coverage

        Methods
        -------

        creategrid()
            create a uniform grid for evaluating losses
        cover()
            run the coverage calculation
        showPower()
            display the map of received power
        showLoss()
            display the map of losses


        Attributes
        ----------

        All attributes are read from fileini ino the ini directory of the
        current project

        _fileini
            default coverage.ini

        L     : a Layout
        nx    : number of point on x
        ny    : number of point on y
        tx    : transmitter position
        txpe  : transmitter power emmission level
        show  : boolean for automatic display power map
        na : number of access point

    """
    def __init__(self, _fileini='coverage.ini'):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """

        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini, pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.apopt = dict(self.config.items('ap'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        # get the Layout
        filename = self.layoutopt['filename']
        if filename.endswith('ini'):
            self.typ = 'indoor'
            self.L = Layout(filename)

            # get the receiving grid
            self.nx = eval(self.gridopt['nx'])
            self.ny = eval(self.gridopt['ny'])
            self.mode = self.gridopt['mode']
            assert self.mode in ['file', 'full',
                                 'zone'], "Error reading grid mode "
            self.boundary = eval(self.gridopt['boundary'])
            self.filespa = self.gridopt['file']
            #
            # create grid
            #
            self.creategrid(mode=self.mode,
                            boundary=self.boundary,
                            _fileini=self.filespa)

            self.dap = {}
            for k in self.apopt:
                kwargs = eval(self.apopt[k])
                ap = std.AP(**kwargs)
                self.dap[eval(k)] = ap
            try:
                self.L.Gt.nodes()
            except:
                pass
            try:
                self.L.dumpr()
            except:
                self.L.build()
                self.L.dumpw()

        else:
            self.typ = 'outdoor'
            self.E = ez.Ezone(filename)
            self.E.loadh5()
            self.E.rebase()

        # The frequency is fixed from the AP nature
        self.fGHz = np.array([])
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        #self.rxsens = eval(self.rxopt['sensitivity'])

        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        # show section
        self.bshow = str2bool(self.showopt['show'])

    def __repr__(self):
        st = ''
        if self.typ == 'indoor':
            st = st + 'Layout file : ' + self.L._filename + '\n\n'
            st = st + '-----list of Access Points ------' + '\n'
            for k in self.dap:
                st = st + self.dap[k].__repr__() + '\n'
            st = st + '-----Rx------' + '\n'
            st = st + 'temperature (K) : ' + str(self.temperaturek) + '\n'
            st = st + 'noisefactor (dB) : ' + str(self.noisefactordb) + '\n\n'
            st = st + '--- Grid ----' + '\n'
            st = st + 'mode : ' + str(self.mode) + '\n'
            if self.mode <> 'file':
                st = st + 'nx : ' + str(self.nx) + '\n'
                st = st + 'ny : ' + str(self.ny) + '\n'
            if self.mode == 'zone':
                st = st + 'boundary (xmin,ymin,xmax,ymax) : ' + str(
                    self.boundary) + '\n\n'
            if self.mode == 'file':
                st = st + ' filename : ' + self.filespa + '\n'
        return (st)

    def creategrid(self, mode='full', boundary=[], _fileini=''):
        """ create a grid

        Parameters
        ----------

        full : boolean
            default (True) use all the layout area
        boundary : (xmin,ymin,xmax,ymax)
            if full is False the boundary argument is used

        """

        if mode == "file":
            self.RN = RadioNode(name='',
                                typ='rx',
                                _fileini=_fileini,
                                _fileant='def.vsh3')
            self.grid = self.RN.position[0:2, :].T
        else:
            if mode == "full":
                mi = np.min(self.L.Gs.pos.values(), axis=0) + 0.01
                ma = np.max(self.L.Gs.pos.values(), axis=0) - 0.01
            if mode == "zone":
                assert boundary <> []
                mi = np.array([boundary[0], boundary[1]])
                ma = np.array([boundary[2], boundary[3]])

            x = np.linspace(mi[0], ma[0], self.nx)
            y = np.linspace(mi[1], ma[1], self.ny)

            self.grid = np.array((list(np.broadcast(*np.ix_(x, y)))))

        self.ng = self.grid.shape[0]

    def where1(self):
        """
        Unfinished : Not sure this is the right place (too specific)
        """
        M1 = UWBMeasure(1)
        self.dap = {}
        self.dap[1] = {}
        self.dap[2] = {}
        self.dap[3] = {}
        self.dap[4] = {}
        self.dap[1]['p'] = M1.rx[1, 0:2]
        self.dap[2]['p'] = M1.rx[1, 0:2]
        self.dap[3]['p'] = M1.rx[1, 0:2]
        self.dap[4]['p'] = M1.rx[1, 0:2]
        for k in range(300):
            try:
                M = UWBMeasure(k)
                tx = M.tx
                self.grid = np.vstack((self.grid, tx[0:2]))
                D = M.rx - tx[np.newaxis, :]
                D2 = D * D
                dist = np.sqrt(np.sum(D2, axis=1))[1:]
                Emax = M.Emax()
                Etot = M.Etot()[0]
                try:
                    td1 = np.hstack((td1, dist[0]))
                    td2 = np.hstack((td2, dist[1]))
                    td3 = np.hstack((td3, dist[2]))
                    td4 = np.hstack((td4, dist[3]))
                    te1 = np.hstack((te1, Emax[0]))
                    te2 = np.hstack((te2, Emax[1]))
                    te3 = np.hstack((te3, Emax[2]))
                    te4 = np.hstack((te4, Emax[3]))
                    tt1 = np.hstack((tt1, Etot[0]))
                    tt2 = np.hstack((tt2, Etot[1]))
                    tt3 = np.hstack((tt3, Etot[2]))
                    tt4 = np.hstack((tt4, Etot[3]))
                    #tdist = np.hstack((tdist,dist))
                    #te = np.hstack((te,Emax))
                except:
                    td1 = np.array(dist[0])
                    td2 = np.array(dist[1])
                    td3 = np.array(dist[2])
                    td4 = np.array(dist[3])
                    te1 = np.array(Emax[0])
                    te2 = np.array(Emax[1])
                    te3 = np.array(Emax[2])
                    te4 = np.array(Emax[3])
                    tt1 = np.array(Etot[0])
                    tt2 = np.array(Etot[1])
                    tt3 = np.array(Etot[2])
                    tt4 = np.array(Etot[3])
            except:
                pass

    def cover(self, sinr=True, snr=True, best=True):
        """ run the coverage calculation

        Parameters
        ----------

        sinr : boolean
        snr  : boolean
        best : boolean

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a=C.show(typ='sinr',figsize=(10,8))
            >>> plt.show()

        Notes
        -----

        self.fGHz is an array, it means that Coverage is calculated at once
        for a whole set of frequencies. In practice, it would be the center
        frequency of a given standard channel.

        This function is calling `loss.Losst` which calculates Losses along a
        straight path.

        In a future implementation we will
        abstract the EM solver in order to make use of other calculation
        approaches as a full or partial Ray Tracing.

        The following members variables are evaluated :

        + freespace Loss @ fGHz   PL()  PathLoss (shoud be rename FS as free space) $
        + prdbmo : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{odB}`
        + prdbmp : Received power in dBm .. math:`P_{rdBm} =P_{tdBm} - L_{pdB}`
        + snro : SNR polar o (H)
        + snrp : SNR polar p (H)

        See Also
        --------

        pylayers.antprop.loss.Losst
        pylayers.antprop.loss.PL

        """
        #
        # select active AP
        #
        lactiveAP = []
        try:
            del self.aap
            del self.ptdbm
        except:
            pass

        self.kB = 1.3806503e-23  # Boltzmann constant
        for iap in self.dap:
            if self.dap[iap]['on']:
                lactiveAP.append(iap)
                fGHz = self.dap[iap].s.fcghz
                # The frequency band is set here
                self.fGHz = np.unique(np.hstack((self.fGHz, fGHz)))
                apchan = self.dap[iap]['chan']
                try:
                    self.aap = np.vstack((self.aap, self.dap[iap]['p'][0:2]))
                    self.ptdbm = np.vstack(
                        (self.ptdbm, self.dap[iap]['PtdBm']))
                    self.bmhz = np.vstack(
                        (self.bmhz, self.dap[iap].s.chan[apchan[0]]['BMHz']))
                except:
                    self.aap = self.dap[iap]['p'][0:2]
                    self.ptdbm = np.array(self.dap[iap]['PtdBm'])
                    self.bmhz = np.array(
                        self.dap[iap].s.chan[apchan[0]]['BMHz'])

        PnW = np.array((10**(self.noisefactordb / 10.)) * self.kB *
                       self.temperaturek * self.bmhz * 1e6)
        # Evaluate Noise Power (in dBm)
        self.pndbm = np.array(10 * np.log10(PnW) + 30)
        #lchan = map(lambda x: self.dap[x]['chan'],lap)
        #apchan = zip(self.dap.keys(),lchan)
        #self.bmhz = np.array(map(lambda x: self.dap[x[0]].s.chan[x[1][0]]['BMHz']*len(x[1]),apchan))

        self.ptdbm = self.ptdbm.T
        self.pndbm = self.pndbm.T
        # creating all links
        p = product(range(self.ng), lactiveAP)
        #
        # pa : access point
        # pg : grid point
        #
        # 1 x na

        for k in p:
            pg = self.grid[k[0], :]
            pa = np.array(self.dap[k[1]]['p'][0:2])
            try:
                self.pa = np.vstack((self.pa, pa))
            except:
                self.pa = pa
            try:
                self.pg = np.vstack((self.pg, pg))
            except:
                self.pg = pg

        self.pa = self.pa.T
        shpa = self.pa.shape
        shpg = self.pg.shape
        self.pa = np.vstack((self.pa, np.ones(shpa[1])))
        self.pg = self.pg.T
        self.pg = np.vstack((self.pg, np.ones(shpg[0])))

        self.nf = len(self.fGHz)

        # retrieving dimensions along the 3 axis
        na = len(lactiveAP)
        self.na = na
        ng = self.ng
        nf = self.nf
        #Lwo,Lwp,Edo,Edp = loss.Losst(self.L,self.fGHz,self.pa,self.pg,dB=False)
        Lwo, Lwp, Edo, Edp = loss.Losst(self.L,
                                        self.fGHz,
                                        self.pa,
                                        self.pg,
                                        dB=False)

        self.Lwo = Lwo.reshape(nf, ng, na)
        self.Edo = Edo.reshape(nf, ng, na)
        self.Lwp = Lwp.reshape(nf, ng, na)
        self.Edp = Edp.reshape(nf, ng, na)

        freespace = loss.PL(self.fGHz, self.pa, self.pg, dB=False)
        self.freespace = freespace.reshape(nf, ng, na)

        # transmitting power
        # f x g x a

        # CmW : Received Power coverage in mW
        self.CmWo = 10**(self.ptdbm[np.newaxis, ...] /
                         10.) * self.Lwo * self.freespace
        self.CmWp = 10**(self.ptdbm[np.newaxis, ...] /
                         10.) * self.Lwp * self.freespace

        if snr:
            self.evsnr()
        if sinr:
            self.evsinr()
        if best:
            self.evbestsv()

    def evsnr(self):
        """ calculates signal to noise ratio
        """

        NmW = 10**(self.pndbm / 10.)[np.newaxis, :]

        self.snro = self.CmWo / NmW
        self.snrp = self.CmWp / NmW

    def evsinr(self):
        """ calculates sinr

        """

        # na : number of access point
        na = self.na

        # U : 1 x 1 x na x na
        U = (np.ones((na, na)) - np.eye(na))[np.newaxis, np.newaxis, :, :]

        # CmWo : received power in mW orthogonal polarization
        # CmWp : received power in mW parallel polarization

        ImWo = np.einsum('ijkl,ijl->ijk', U, self.CmWo)
        ImWp = np.einsum('ijkl,ijl->ijk', U, self.CmWp)

        NmW = 10**(self.pndbm / 10.)[np.newaxis, :]

        self.sinro = self.CmWo / (ImWo + NmW)
        self.sinrp = self.CmWp / (ImWp + NmW)

    def evbestsv(self):
        """ determine the best server map

        Notes
        -----

        C.bestsv

        """
        na = self.na
        ng = self.ng
        nf = self.nf
        # find best server regions
        Vo = self.CmWo
        Vp = self.CmWp
        self.bestsvo = np.empty(nf * ng * na).reshape(nf, ng, na)
        self.bestsvp = np.empty(nf * ng * na).reshape(nf, ng, na)
        for kf in range(nf):
            MaxVo = np.max(Vo[kf, :, :], axis=1)
            MaxVp = np.max(Vp[kf, :, :], axis=1)
            for ka in range(na):
                uo = np.where(Vo[kf, :, ka] == MaxVo)
                up = np.where(Vp[kf, :, ka] == MaxVp)
                self.bestsvo[kf, uo, ka] = ka + 1
                self.bestsvp[kf, up, ka] = ka + 1

#    def showEd(self,polar='o',**kwargs):
#        """ shows a map of direct path excess delay
#
#        Parameters
#        ----------
#
#        polar : string
#        'o' | 'p'
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            >> from pylayers.antprop.coverage import *
#            >> C = Coverage()
#            >> C.cover()
#            >> C.showEd(polar='o')
#
#        """
#
#        if not kwargs.has_key('alphacy'):
#            kwargs['alphacy']=0.0
#        if not kwargs.has_key('colorcy'):
#            kwargs['colorcy']='w'
#        if not kwargs.has_key('nodes'):
#            kwargs['nodes']=False
#
#        fig,ax = self.L.showG('s',**kwargs)
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        cdict = {
#        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
#        }
#        #generate the colormap with 1024 interpolated values
#        my_cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
#
#
#        if polar=='o':
#            mcEdof = np.ma.masked_where(prdbm < self.rxsens,self.Edo)
#
#            cov=ax.imshow(mcEdof.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'jet',
#                             origin='lower')
#
#
#
#            # cov=ax.imshow(self.Edo.reshape((self.nx,self.ny)).T,
#            #           extent=(l,r,b,t),
#            #           origin='lower')
#            titre = "Map of LOS excess delay, polar orthogonal"
#
#        if polar=='p':
#            mcEdpf = np.ma.masked_where(prdbm < self.rxsens,self.Edp)
#
#            cov=ax.imshow(mcEdpf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'jet',
#                             origin='lower')
#
#            # cov=ax.imshow(self.Edp.reshape((self.nx,self.ny)).T,
#            #           extent=(l,r,b,t),
#            #           origin='lower')
#            titre = "Map of LOS excess delay, polar parallel"
#
#        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
#        ax.set_title(titre)
#
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        clb = fig.colorbar(cov,cax)
#        clb.set_label('excess delay (ns)')
#
#        if self.show:
#            plt.show()
#        return fig,ax
#
#    def showPower(self,rxsens=True,nfl=True,polar='o',**kwargs):
#        """ show the map of received power
#
#        Parameters
#        ----------
#
#        rxsens : bool
#              clip the map with rx sensitivity set in self.rxsens
#        nfl : bool
#              clip the map with noise floor set in self.pndbm
#        polar : string
#            'o'|'p'
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            > from pylayers.antprop.coverage import *
#            > C = Coverage()
#            > C.cover()
#            > C.showPower()
#
#        """
#
#        if not kwargs.has_key('alphacy'):
#            kwargs['alphacy']=0.0
#        if not kwargs.has_key('colorcy'):
#            kwargs['colorcy']='w'
#        if not kwargs.has_key('nodes'):
#            kwargs['nodes']=False
#        fig,ax = self.L.showG('s',**kwargs)
#
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
##        tCM = plt.cm.get_cmap('jet')
##        tCM._init()
##        alphas = np.abs(np.linspace(.0,1.0, tCM.N))
##        tCM._lut[:-3,-1] = alphas
#
#        title='Map of received power - Pt = ' + str(self.ptdbm) + ' dBm'+str(' fGHz =') + str(self.fGHz) + ' polar = '+polar
#
#        cdict = {
#        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
#        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
#        }
#
#        if not kwargs.has_key('cmap'):
#        # generate the colormap with 1024 interpolated values
#            cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)
#        else:
#            cmap = kwargs['cmap']
#        #my_cmap = cm.copper
#
#
#        if rxsens :
#
#            ## values between the rx sensitivity and noise floor
#            mcPrf = np.ma.masked_where((prdbm > self.rxsens)
#                                     & (prdbm < self.pndbm),prdbm)
#            # mcPrf = np.ma.masked_where((prdbm > self.rxsens) ,prdbm)
#
#            cov1 = ax.imshow(mcPrf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = cm.copper,
#                             vmin=self.rxsens,origin='lower')
#
#            ### values above the sensitivity
#            mcPrs = np.ma.masked_where(prdbm < self.rxsens,prdbm)
#            cov = ax.imshow(mcPrs.reshape((self.nx,self.ny)).T,
#                            extent=(l,r,b,t),
#                            cmap = cmap,
#                            vmin=self.rxsens,origin='lower')
#            title=title + '\n black : Pr (dBm) < %.2f' % self.rxsens + ' dBm'
#
#        else :
#            cov=ax.imshow(prdbm.reshape((self.nx,self.ny)).T,
#                          extent=(l,r,b,t),
#                          cmap = cmap,
#                          vmin=self.pndbm,origin='lower')
#
#        if nfl:
#            ### values under the noise floor
#            ### we first clip the value below the noise floor
#            cl = np.nonzero(prdbm<=self.pndbm)
#            cPr = prdbm
#            cPr[cl] = self.pndbm
#            mcPruf = np.ma.masked_where(cPr > self.pndbm,cPr)
#            cov2 = ax.imshow(mcPruf.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'binary',
#                             vmax=self.pndbm,origin='lower')
#            title=title + '\n white : Pr (dBm) < %.2f' % self.pndbm + ' dBm'
#
#
#        ax.scatter(self.tx[0],self.tx[1],s=10,c='k',linewidth=0)
#
#        ax.set_title(title)
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        clb = fig.colorbar(cov,cax)
#        clb.set_label('Power (dBm)')
#
#        if self.show:
#            plt.show()
#
#        return fig,ax
#
#
#    def showTransistionRegion(self,polar='o'):
#        """
#
#        Notes
#        -----
#
#        See  : "Analyzing the Transitional Region in Low Power Wireless Links"
#                Marco Zuniga and Bhaskar Krishnamachari
#
#        Examples
#        --------
#
#        .. plot::
#            :include-source:
#
#            > from pylayers.antprop.coverage import *
#            > C = Coverage()
#            > C.cover()
#            > C.showTransitionRegion()
#
#        """
#
#        frameLength = self.framelengthbytes
#
#        PndBm = self.pndbm
#        gammaU = 10*np.log10(-1.28*np.log(2*(1-0.9**(1./(8*frameLength)))))
#        gammaL = 10*np.log10(-1.28*np.log(2*(1-0.1**(1./(8*frameLength)))))
#
#        PrU = PndBm + gammaU
#        PrL = PndBm + gammaL
#
#        fig,ax = self.L.showGs()
#
#        l = self.grid[0,0]
#        r = self.grid[-1,0]
#        b = self.grid[0,1]
#        t = self.grid[-1,-1]
#
#        if polar=='o':
#            prdbm=self.prdbmo
#        if polar=='p':
#            prdbm=self.prdbmp
#
#        zones = np.zeros(np.shape(prdbm))
#        #pdb.set_trace()
#
#        uconnected  = np.nonzero(prdbm>PrU)
#        utransition = np.nonzero((prdbm < PrU)&(prdbm > PrL))
#        udisconnected = np.nonzero(prdbm < PrL)
#
#        zones[uconnected] = 1
#        zones[utransition] = (prdbm[utransition]-PrL)/(PrU-PrL)
#        cov = ax.imshow(zones.reshape((self.nx,self.ny)).T,
#                             extent=(l,r,b,t),cmap = 'BuGn',origin='lower')
#
#        title='PDR region'
#        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
#
#        ax.set_title(title)
#        divider = make_axes_locatable(ax)
#        cax = divider.append_axes("right", size="5%", pad=0.05)
#        fig.colorbar(cov,cax)
#        if self.show:
#            plt.show()
#

    def plot(self, **kwargs):
        """
        """
        defaults = {
            'typ': 'pr',
            'grid': False,
            'f': 0,
            'a': 0,
            'db': True,
            'label': '',
            'pol': 'p',
            'col': 'b'
        }
        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        if 'fig' in kwargs:
            fig = kwargs['fig']
        else:
            fig = plt.figure()

        if 'ax' in kwargs:
            ax = kwargs['ax']
        else:
            ax = fig.add_subplot(111)

        if kwargs['typ'] == 'pr':
            if kwargs['a'] <> -1:
                if kwargs['pol'] == 'p':
                    U = self.CmWp[kwargs['f'], :, kwargs['a']]
                if kwargs['pol'] == 'o':
                    U = self.CmWo[kwargs['f'], :, kwargs['a']]
            else:
                if kwargs['pol'] == 'p':
                    U = self.CmWp[kwargs['f'], :, :].reshape(self.na * self.ng)
                else:
                    U = self.CmWo[kwargs['f'], :, :].reshape(self.na * self.ng)
            if kwargs['db']:
                U = 10 * np.log10(U)

        D = np.sqrt(np.sum((self.pa - self.pg) * (self.pa - self.pg), axis=0))
        if kwargs['a'] <> -1:
            D = D.reshape(self.ng, self.na)
            ax.semilogx(D[:, kwargs['a']],
                        U,
                        '.',
                        color=kwargs['col'],
                        label=kwargs['label'])
        else:
            ax.semilogx(D, U, '.', color=kwargs['col'], label=kwargs['label'])

        return fig, ax

    def show(self, **kwargs):
        """ show coverage

        Parameters
        ----------

        typ : string
            'pr' | 'sinr' | 'capacity' | 'loss' | 'best' | 'egd'
        grid : boolean
        polar : string
            'o' | 'p'
        best : boolean
            draw best server contour if True
        f : int
            frequency index
        a : int
            access point index (-1 all access point)

        Examples
        --------

        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> f,a = C.show(typ='pr',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='best',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='loss',figsize=(10,8))
            >>> plt.show()
            >>> f,a = C.show(typ='sinr',figsize=(10,8))
            >>> plt.show()

        See Also
        --------

        pylayers.gis.layout.Layout.showG

        """
        defaults = {
            'typ': 'pr',
            'grid': False,
            'polar': 'p',
            'f': 0,
            'a': -1,
            'db': True,
            'cmap': cm.jet,
            'best': True
        }

        title = self.dap[1].s.name + ' : '

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]
        polar = kwargs['polar']
        assert polar in ['p', 'o'], "polar wrongly defined in show coverage"

        if 'fig' in kwargs:
            if 'ax' in kwargs:
                fig, ax = self.L.showG('s', fig=kwargs['fig'], ax=kwargs['ax'])
            else:
                fig, ax = self.L.showG('s', fig=kwargs['fig'])
        else:
            if 'figsize' in kwargs:
                fig, ax = self.L.showG('s', figsize=kwargs['figsize'])
            else:
                fig, ax = self.L.showG('s')

        # plot the grid
        if kwargs['grid']:
            for k in self.dap:
                p = self.dap[k].p
                ax.plot(p[0], p[1], 'or')

        f = kwargs['f']
        a = kwargs['a']
        typ = kwargs['typ']
        assert typ in ['best', 'egd', 'sinr', 'snr', 'capacity', 'pr',
                       'loss'], "typ unknown in show coverage"
        best = kwargs['best']

        dB = kwargs['db']

        # setting the grid

        l = self.grid[0, 0]
        r = self.grid[-1, 0]
        b = self.grid[0, 1]
        t = self.grid[-1, -1]

        if typ == 'best':
            title = title + 'Best server' + ' fc = ' + str(
                self.fGHz[f]) + ' GHz' + ' polar : ' + polar
            for ka in range(self.na):
                if polar == 'p':
                    bestsv = self.bestsvp[f, :, ka]
                if polar == 'o':
                    bestsv = self.bestsvo[f, :, ka]
                m = np.ma.masked_where(bestsv == 0, bestsv)
                if self.mode <> 'file':
                    W = m.reshape(self.nx, self.ny).T
                    ax.imshow(W,
                              extent=(l, r, b, t),
                              origin='lower',
                              vmin=1,
                              vmax=self.na + 1)
                else:
                    ax.scatter(self.grid[:, 0],
                               self.grid[:, 1],
                               c=m,
                               s=20,
                               linewidth=0)
            ax.set_title(title)
        else:
            if typ == 'egd':
                title = title + 'excess group delay : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                V = self.Ed
                dB = False
                legcb = 'Delay (ns)'
            if typ == 'sinr':
                title = title + 'SINR : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar == 'o':
                    V = self.sinro
                if polar == 'p':
                    V = self.sinrp
            if typ == 'snr':
                title = title + 'SNR : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar == 'o':
                    V = self.snro
                if polar == 'p':
                    V = self.snrp
            if typ == 'capacity':
                title = title + 'Capacity : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                legcb = 'Mbit/s'
                if polar == 'o':
                    V = self.bmhz.T[np.newaxis, :] * np.log(
                        1 + self.sinro) / np.log(2)
                if polar == 'p':
                    V = self.bmhz.T[np.newaxis, :] * np.log(
                        1 + self.sinrp) / np.log(2)
            if typ == 'pr':
                title = title + 'Pr : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dBm'
                else:
                    lgdcb = 'mW'
                if polar == 'o':
                    V = self.CmWo
                if polar == 'p':
                    V = self.CmWp

            if typ == 'loss':
                title = title + 'Loss : ' + ' fc = ' + str(
                    self.fGHz[f]) + ' GHz' + ' polar : ' + polar
                if dB:
                    legcb = 'dB'
                else:
                    legcb = 'Linear scale'
                if polar == 'o':
                    V = self.Lwo * self.freespace
                if polar == 'p':
                    V = self.Lwp * self.freespace

            if a == -1:
                V = np.max(V[f, :, :], axis=1)
            else:
                V = V[f, :, a]

            # reshaping the data on the grid
            if self.mode != 'file':
                U = V.reshape((self.nx, self.ny)).T
            else:
                U = V

            if dB:
                U = 10 * np.log10(U)

            if 'vmin' in kwargs:
                vmin = kwargs['vmin']
            else:
                vmin = U.min()

            if 'vmax' in kwargs:
                vmax = kwargs['vmax']
            else:
                vmax = U.max()

            if self.mode != 'file':
                img = ax.imshow(U,
                                extent=(l, r, b, t),
                                origin='lower',
                                vmin=vmin,
                                vmax=vmax,
                                cmap=kwargs['cmap'])
            else:
                img = ax.scatter(self.grid[:, 0],
                                 self.grid[:, 1],
                                 c=U,
                                 s=20,
                                 linewidth=0,
                                 cmap=kwargs['cmap'],
                                 vmin=vmin,
                                 vmax=vmax)

            for k in range(self.na):
                ax.annotate(str(k), xy=(self.pa[0, k], self.pa[1, k]))
            ax.set_title(title)

            divider = make_axes_locatable(ax)
            cax = divider.append_axes("right", size="5%", pad=0.05)
            clb = fig.colorbar(img, cax)
            clb.set_label(legcb)
            if best:
                if self.mode <> 'file':
                    if polar == 'o':
                        ax.contour(np.sum(self.bestsvo, axis=2)[f, :].reshape(
                            self.nx, self.ny).T,
                                   extent=(l, r, b, t),
                                   linestyles='dotted')
                    if polar == 'p':
                        ax.contour(np.sum(self.bestsvp, axis=2)[f, :].reshape(
                            self.nx, self.ny).T,
                                   extent=(l, r, b, t),
                                   linestyles='dotted')

        # display access points
        if a == -1:
            ax.scatter(self.pa[0, :], self.pa[1, :], s=30, c='r', linewidth=0)
        else:
            ax.scatter(self.pa[0, a], self.pa[1, a], s=30, c='r', linewidth=0)
        plt.tight_layout()
        return (fig, ax)
示例#38
0
class Simul(PyLayers):
    """
    Link oriented simulation

    A simulation requires :

        A Layout
        A Person
        A Trajectory

    """

    def __init__(self, _filetraj='simulnet_TA-Office.h5',verbose=False):
        """ object constructor

        Parameters
        ----------

        _filetraj : string
            h5 trajectory
        verbose : boolean

        """

        self.filetraj = _filetraj

        # self.progress = -1  # simulation not loaded
        self.verbose = verbose
        self.cfield = []
        self.dpersons = {}

        self.dap = {}
        self.Nag = 0
        self.Nap = 0
        self.load_config(_filetraj)
        self.gen_net()
        self.SL = SLink()
        self.DL = DLink(L=self.L,verbose=self.verbose)
        self.filename = 'simultraj_' + self.filetraj
        self.data = pd.DataFrame(columns=['id_a', 'id_b',
                                          'x_a', 'y_a', 'z_a',
                                          'x_b', 'y_b', 'z_b',
                                          'd', 'eng', 'typ',
                                          'wstd', 'fcghz',
                                          'fbminghz', 'fbmaxghz', 'fstep', 'aktk_id',
                                          'sig_id', 'ray_id', 'Ct_id', 'H_id'
                                          ])
        self.data.index.name='t'
        self._filecsv = self.filename.split('.')[0] + '.csv'
        self.todo = {'OB': True,
                    'B2B': True,
                    'B2I': True,
                    'I2I': False}
        filenameh5 = pyu.getlong(self.filename,pstruc['DIRLNK'])
        if os.path.exists(filenameh5) :
            self.loadpd()
        # self._saveh5_init()


    def __repr__(self):

        s = 'Simul trajectories class\n'
        s = s + '------------------------\n'
        s = s +'\n'
        s = s + 'Used layout: ' + self.L.filename + '\n'
        s = s + 'Number of Agents: ' + str(self.Nag) + '\n'
        s = s + 'Number of Access Points: ' + str(self.Nap) + '\n'
        s = s + 'Link to be evaluated: ' + str(self.todo) + '\n'
        s = s + 'tmin: ' + str(self._tmin) + '\n'
        s = s + 'tmax: ' + str(self._tmax) + '\n'
        s = s +'\n'
        # network info
        s = s + 'self.N :\n'
        s = s + self.N.__repr__() + '\n'
        s = s + 'CURRENT TIME: ' + str(self.ctime) + '\n'




        return s

    def load_config(self, _filetraj):
        """  load a simultraj configuration file

        Parameters
        ----------

        _filetraj : string
            name of simulation file to be loaded

        """
        self.filetraj = _filetraj


        # get the trajectory
        traj = tr.Trajectories()
        traj.loadh5(self.filetraj)

        # get the layout
        self.L = Layout(traj.Lfilename)

        # resample trajectory
        for ut, t in enumerate(traj):
            if t.typ == 'ag':
                person = Body(t.name + '.ini')
                tt = t.time()
                self.dpersons.update({t.name: person})
                self._tmin = tt[0]
                self._tmax = tt[-1]
                self.time = tt
            else:
                pos = np.array([t.x[0], t.y[0], t.z[0]])
                self.dap.update({t.ID: {'pos': pos,
                                        'ant': antenna.Antenna(),
                                        'name': t.name
                                        }
                                 })
        self.ctime = np.nan
        self.Nag = len(self.dpersons.keys())
        self.Nap = len(self.dap.keys())
        self.traj = traj


    def gen_net(self):
        """ generate Network and associated links

        Notes
        -----

        Create self.N : Network object

        See Also
        --------

        pylayers.network.network

        """

        N = Network()
        # get devices on bodies
        for p in self.dpersons:
            D = []
            for dev in self.dpersons[p].dev:
                D.append(
                    Device(self.dpersons[p].dev[dev]['name'], ID=dev + '_' + p))
            N.add_devices(D, grp=p)
        # get access point devices
        for ap in self.dap:
            D = Device(self.dap[ap]['name'], ID=ap)
            N.add_devices(D, grp='ap', p=self.dap[ap]['pos'])
        # create Network
        N.create()
        self.N = N

    def show(self):
        """ show actual simlulation configuration
        """
        fig, ax = self.L.showGs()
        fig, ax = self.N.show(fig=fig, ax=ax)
        return fig, ax

    def evaldeter(self, na, nb, wstd, fmode='band', nf=10):
        """ deterministic evaluation of a link

        Parameters
        ----------

        na : string:
            node a id in self.N (Network)
        nb : string:
            node b id in self.N (Network)
        wstd : string:
            wireless standard used for commmunication between na and nb
        fmode : string ('center'|'band')
            mode of frequency evaluation
            center : only on the centered frequency
            band : on the whole band
        nf : int:
            number of frequency points (if fmode = 'band')

        Returns
        -------

        (a, t )

        a : ndarray
            alpha_k
        t : ndarray
            tau_k

        """

        # todo in network : 
        # take into consideration the postion and rotation of antenna and not device
        self.DL.a = self.N.node[na]['p']
        self.DL.Ta = self.N.node[na]['T']
        self.DL.b = self.N.node[nb]['p']
        self.DL.Tb = self.N.node[nb]['T']
        if fmode == 'center':
            self.DL.fGHz = self.N.node[na]['wstd'][wstd]['fcghz']
        else:
            minb = self.N.node[na]['wstd'][wstd]['fbminghz']
            maxb = self.N.node[na]['wstd'][wstd]['fbmaxghz']
            self.DL.fGHz = np.linspace(minb, maxb, nf)
        a, t = self.DL.eval()

        return a, t

    def evalstat(self, na, nb):
        """ statistical evaluation of a link

        Parameters
        ----------

        na : string:
            node a id in self.N (Netwrok)
        nb : string:
            node b id in self.N (Netwrok)

        Returns
        -------

        (a, t, eng)

        a : ndarray
            alpha_k
        t : ndarray
            tau_k
        eng : float
            engagement
        """




        pa = self.N.node[na]['p']
        pb = self.N.node[nb]['p']
        dida, name = na.split('_')
        didb, name = nb.split('_')

        ak, tk, eng = self.SL.onbody(self.dpersons[name], dida, didb, pa, pb)

        return ak, tk, eng

    def run(self, **kwargs):
        """ run the link evaluation along a trajectory


        Parameters
        ----------

        'OB': boolean
            perform on body statistical link evaluation
        'B2B':  boolean
            perform body to body deterministic link evaluation
        'B2I': boolean
            perform body to infrastructure deterministic link evaluation
        'I2I':  boolean
            perform infrastructure to infrastructure deterministic link eval.
        'llink': list
            list of link to be evaluated
            (if [], all link are considered)
        'wstd': list
            list of wstd to be evaluated
            (if [], all wstd are considered)
        't': np.array
            list of timestamp to be evaluated
            (if [], all timestamps are considered)


        """
        defaults = {'OB': True,
                    'B2B': True,
                    'B2I': True,
                    'I2I': False,
                    'llink': [],
                    'wstd': [],
                    't': np.array([]),
                    }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        llink = kwargs.pop('llink')
        wstd = kwargs.pop('wstd')
        OB = kwargs.pop('OB')
        B2B = kwargs.pop('B2B')
        B2I = kwargs.pop('B2I')
        I2I = kwargs.pop('I2I')
        self.todo.update({'OB':OB,'B2B':B2B,'B2I':B2I,'I2I':I2I})

        # Check link attribute
        if llink == []:
            llink = self.N.links
        elif not isinstance(llink, list):
            llink = [llink]

        checkl = [l in self.N.links for l in llink]
        if sum(checkl) != len(self.N.links):
            uwrong = np.where(np.array(checkl) is False)[0]
            raise AttributeError(str(np.array(llink)[uwrong])
                                 + ' links does not exist in Network')

        # Check wstd attribute
        if wstd == []:
            wstd = self.N.wstd.keys()
        elif not isinstance(wstd, list):
            wstd = [wstd]

        checkw = [w in self.N.wstd.keys() for w in wstd]
        if sum(checkw) != len(self.N.wstd.keys()):
            uwrong = np.where(np.array(checkw) is False)[0]
            raise AttributeError(str(np.array(wstd)[uwrong])
                                 + ' wstd are not in Network')

        # force time attribute compliant

        if not isinstance(kwargs['t'],np.ndarray):
            if isinstance(kwargs['t'],list):
                lt = np.array(kwargs['t'])
            elif (isinstance(kwargs['t'], int)
                 or isinstance(kwargs['t'],float)):
                lt = np.array([kwargs['t']])
        else :
            lt = kwargs['t']

        if len(lt) == 0:
            lt = self.time
        # check time attribute
        if not lt[0] >= self._tmin and\
               lt[-1] <= self._tmax:
               raise AttributeError('Requested time range not available')

        # self._traj is a copy of self.traj, which is affected by resampling.
        # it is only a temporary attribute for a given run

        if len(lt) > 1:
            sf = 1/(1.*lt[1]-lt[0])
            self._traj = self.traj.resample(sf=sf, tstart=lt[0])

        else:
            self._traj = self.traj.resample(sf=1.0, tstart=lt[0])
            self._traj.time()

        self.time = self._traj.t
        self._time = pd.to_datetime(self.time,unit='s')

        #
        # Code
        #

        init = True
        for ut, t in enumerate(lt):
            self.ctime = t
            self.update_pos(t)
            print self.N.__repr__()
            for w in wstd:
                for na, nb, typ in llink[w]:
                    if self.todo[typ]:
                        if self.verbose:
                            print '-'*30
                            print 'time:', t, '/',  lt[-1] ,' time idx:', ut, '/',len(lt)
                            print 'processing: ',na, ' <-> ', nb, 'wstd: ', w
                            print '-'*30
                        eng = 0
                        self.evaldeter(na, nb, w)
                        if typ == 'OB':
                            self.evalstat(na, nb)
                            eng = self.SL.eng
                            L = self.DL + self.SL
                            self._ak = L.H.ak
                            self._tk = L.H.tk
                        else :
                            self._ak = self.DL.H.ak
                            self._tk = self.DL.H.tk
                        df = pd.DataFrame({\
                                    'id_a': na,
                                    'id_b': nb,
                                    'x_a': self.N.node[na]['p'][0],
                                    'y_a': self.N.node[na]['p'][1],
                                    'z_a': self.N.node[na]['p'][2],
                                    'x_b': self.N.node[nb]['p'][0],
                                    'y_b': self.N.node[nb]['p'][1],
                                    'z_b': self.N.node[nb]['p'][2],
                                    'd': self.N.edge[na][nb]['d'],
                                    'eng': eng,
                                    'typ': typ,
                                    'wstd': w,
                                    'fcghz': self.N.node[na]['wstd'][w]['fcghz'],
                                    'fbminghz': self.DL.fmin,
                                    'fbmaxghz': self.DL.fmax,
                                    'fstep': self.DL.fstep,
                                    'aktk_id': str(ut) + '_' + na + '_' + nb + '_' + w,
                                    'sig_id': self.DL.dexist['sig']['grpname'],
                                    'ray_id': self.DL.dexist['ray']['grpname'],
                                    'Ct_id': self.DL.dexist['Ct']['grpname'],
                                    'H_id': self.DL.dexist['H']['grpname'],
                                                },columns=['id_a', 'id_b',
                                              'x_a', 'y_a', 'z_a',
                                              'x_b', 'y_b', 'z_b',
                                              'd', 'eng', 'typ',
                                              'wstd', 'fcghz',
                                              'fbminghz', 'fbmaxghz', 'fstep', 'aktk_id',
                                              'sig_id', 'ray_id', 'Ct_id', 'H_id'
                                              ],index=[self._time[ut]])
                        if not self.check_exist(df):
                            self.data = self.data.append(df)
                            # self._index = self._index + 1
                            # save csv
                            self.tocsv(ut, na, nb, w,init=init)
                            init=False

                            # save pandas self.data
                            self.savepd()
                            # save ak tauk
                            self._saveh5(ut, na, nb, w)


    def check_exist(self, df):
        """check if a dataframe df already exists in self.data

        Parameters
        ----------
        df : pd.DataFrame

        Returns
        -------

        boolean
            True if already exists
            False otherwise

        """

        ud = self.data[(self.data.index == df.index)
                        & (self.data['id_a'] == df['id_a'].values[0])
                        & (self.data['id_b'] == df['id_b'].values[0])
                        & (self.data['wstd'] == df['wstd'].values[0])
                        ]
        if len(ud) == 0:
            return False
        else :
            return True


    def savepd(self):
        """ save data information of a simulation
        """
        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        store = pd.HDFStore(filenameh5,'a')
        self.data=self.data.sort()
        store['df'] = self.data
        store.close()

    def loadpd(self):
        """ load data from previous simulations
        """
        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        self.data = pd.read_hdf(filenameh5,'df')
        self.data.index.name='t'


    def update_pos(self, t):
        """ update positions of devices and bodies for a given time index

        Parameters
        ----------
        t : int
            time value 
        """ 

        # if a bodies are involved in simulation
        if ((self.todo['OB']) or (self.todo['B2B']) or (self.todo['B2I'])):
            nodeid = []
            pos = []
            orient = []
            for up, person in enumerate(self.dpersons.values()):
                person.settopos(self._traj[up], t=t, cs=True)
                name = person.name
                dev = person.dev.keys()
                nodeid.extend([n + '_' + name for n in dev])
                pos.extend([person.dcs[d][:, 0] for d in dev])
                orient.extend([person.acs[d] for d in dev])
            # TODO !!!!!!!!!!!!!!!!!!!!
            # in a future version , the network update must also update
            # antenna positon in the device coordinate system
            self.N.update_pos(nodeid, pos, now=t)
            self.N.update_orient(nodeid, orient, now=t)
        self.N.update_dis()

    def _show3(self, **kwargs):
        """ 3D show using Mayavi

        Parameters
        ----------

        t: float
            time index
        link: list
            [id_a, id_b]
            id_a : node id a
            id_b : node id b
        'lay': bool
            show layout
        'net': bool
            show net
        'body': bool
            show bodies
        'rays': bool
            show rays
        """

        defaults = {'t': 0,
                    'link': [],
                    'wstd':[],
                    'lay': True,
                    'net': True,
                    'body': True,
                    'rays': True,
                    'ant': False

                    }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        link = kwargs['link']

        df = self.data[self.data['t'] == kwargs['t']]
        if len(df) == 0:
            raise AttributeError('invalid time')

        # default
        if link ==[]:
            line = df[df.index==1]
            link = [line['id_a'].values[0],line['id_b'].values[0]]
        else :
            # get info of the corresponding timestamp
            line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])]
        if len(line) == 0:
            line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
            if len(line) == 0:
                raise AttributeError('invalid link')
        rayid = line['ray_id'].values[0]


        self.update_pos(kwargs['t'])
        self.DL.a = self.N.node[link[0]]['p']
        self.DL.b = self.N.node[link[1]]['p']
        self.DL.Ta = self.N.node[link[0]]['T']
        self.DL.Tb = self.N.node[link[1]]['T']
        self.DL.load(self.DL.R,rayid)

        self.DL._show3(newfig= False,
                       lay= kwargs['lay'],
                       rays= kwargs['rays'],
                       ant=False)
        if kwargs['net']:
            self.N._show3(newfig=False)
        if kwargs['body']:
            for p in self.dpersons:
                self.dpersons[p]._show3(newfig=False,
                                        topos=True,
                                        pattern=kwargs['ant'])








    # def _saveh5_init(self):
    #     """ initialization of the h5py file
    #     """
    #     filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
    #     import ipdb
    #     try:
    #         f5 = h5py.File(filenameh5, 'w')
    #         f5.create_dataset('time', shape=self.time.shape, data=self.time)
    #         f5.close()
    #     except:
    #         f5.close()
    #         raise NameError('simultra.saveinit: \
    #                         issue when writting h5py file')

    def _saveh5(self, ut, ida, idb, wstd):
        """ Save in h5py format

        Parameters
        ----------

        ut : int
            time index in self.time
        ida : string
            node a index
        idb : string
            node b index
        wstd : string
            wireless standard of used link

        Notes
        -----

        Dataset organisation:

        simultraj_<trajectory_filename.h5>.h5
            |
            |time
            |    ...
            |
            |/<tidx_ida_idb_wstd>/ |attrs
            |                      |a_k
            |                      |t_k


        Root dataset :
        time : array
            range of simulation time

        Group identifier :
            tidx : index in time dataset
            ida : node a index in Network
            idb : node b index in Network
            wstd : wireless standar of link interest


        Inside group:
            a_k : alpha_k values
            t_k : tau_k values

        See Also
        --------

        pylayers.simul.links

        """

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        grpname = str(ut) + '_' + ida + '_' + idb + '_' + wstd
        # try/except to avoid loosing the h5 file if
        # read/write error
        try:
            fh5 = h5py.File(filenameh5, 'a')
            if not grpname in fh5.keys():
                fh5.create_group(grpname)
                f = fh5[grpname]
                # for k in kwargs:
                #     f.attrs[k] = kwargs[k]

                f.create_dataset('alphak',
                                 shape=self._ak.shape,
                                 maxshape=(None),
                                 data=self._ak)
                f.create_dataset('tauk',
                                 shape=self._tk.shape,
                                 maxshape=(None),
                                 data=self._tk)
            else:
                pass#print grpname + ' already exists in ' + filenameh5


            fh5.close()
        except:
            fh5.close()
            raise NameError('Simultraj._saveh5: issue when writting h5py file')


    def _loadh5(self, grpname):
        """ Load in h5py format

        Parameters
        ----------

       grpname : string
            group name which can be found sin self.data aktk_idx column

        Returns
        -------
        (ak, tk, conf)

        ak : ndarray:
            alpha_k
        tk : ndarray:
            alpha_k
        """

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        # try/except to avoid loosing the h5 file if
        # read/write error
        try:
            fh5 = h5py.File(filenameh5, 'r')
            if not grpname in fh5.keys():
                fh5.close()
                raise NameError(grpname + ' cannot be reached in ' + self.filename)
            f = fh5[grpname]
            # for k in f.attrs.keys():
            #     conf[k]=f.attrs[k]
            ak = f['alphak'][:]
            tk = f['tauk'][:]
            fh5.close()

            return ak, tk
        except:
            fh5.close()
            raise NameError('Simultraj._loadh5: issue when reading h5py file')


    def tocsv(self, ut, ida, idb, wstd,init=False):

        filecsv = pyu.getlong(self._filecsv,pstruc['DIRLNK'])

        with open(filecsv, 'a') as csvfile:
            fil = csv.writer(csvfile, delimiter=';',
                             quoting=csv.QUOTE_MINIMAL)
            if init:
                keys = self.data.iloc[-1].keys()
                data = [k for k in keys]
                data .append('ak')
                data .append('tk')
                fil.writerow(data)

            values = self.data.iloc[-1].values
            data = [v for v in values]
            sak = str(self._ak.tolist())
            stk = str(self._tk.tolist())
            data.append(sak)
            data.append(stk)
            fil.writerow(data)
示例#39
0
    def __init__(self,_fileini='coverage.ini'):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt   = dict(self.config.items('grid'))
        self.apopt     = dict(self.config.items('ap'))
        self.rxopt     = dict(self.config.items('rx'))
        self.showopt   = dict(self.config.items('show'))

        # get the Layout
        filename = self.layoutopt['filename']
        if filename.endswith('ini'):
            self.typ = 'indoor'
            self.L = Layout(filename)

            # get the receiving grid
            self.nx = eval(self.gridopt['nx'])
            self.ny = eval(self.gridopt['ny'])
            self.mode = self.gridopt['mode']
            self.boundary = eval(self.gridopt['boundary'])
            self.filespa = self.gridopt['file']
            #
            # create grid
            #
            self.creategrid(mode=self.mode,boundary=self.boundary,_fileini=self.filespa)
            self.dap = {}
            for k in self.apopt:
                kwargs  = eval(self.apopt[k])
                ap = std.AP(**kwargs)
                self.dap[eval(k)] = ap
            try:
                self.L.Gt.nodes()
            except:
                pass
            try:
                self.L.dumpr()
            except:
                self.L.build()
                self.L.dumpw()


        else:
            self.typ='outdoor'
            self.E = ez.Ezone(filename)
            self.E.loadh5()
            self.E.rebase()

        self.fGHz = np.array([])
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        #self.rxsens = eval(self.rxopt['sensitivity'])

        self.temperaturek  = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        # show section
        self.bshow = str2bool(self.showopt['show'])
示例#40
0
class Simul(SimulationRT): # Sympy 2
#class Simul(sympy.RealtimeEnvironment):
    """

    Attributes
    ----------
    config  : config parser instance
    sim_opt : dictionary of configuration option for simulation
    ag_opt : dictionary of configuration option for agent
    lay_opt : dictionary of  configuration option for layout
    meca_opt : dictionary of  configuration option for mecanic
    net_opt : dictionary of  configuration option for network
    loc_opt : dictionary of  configuration option for localization
    save_opt : dictionary of  configuration option for save
    sql_opt : dictionary of  configuration option for sql


    Parameters
    ----------

    self.lAg  : list of Agent(Object)
        list of agents involved in simulation
    self.L : Layout
        Layout used in simulation

    Notes
    -----

    All the previous dictionnary are obtained from the chosen simulnet.ini file
    in the project directory

    """
    def __init__(self):
        SimulationRT.__init__(self) #Sympy 2
        #sympy.RealtimeEnvironment.__init__(self)  #simpy 3
        self.initialize()
        self.config = ConfigParser.ConfigParser()
        filename = pyu.getlong('simulnet.ini',pstruc['DIRSIMUL'])
        self.config.read(filename)
        self.sim_opt = dict(self.config.items('Simulation'))
        self.lay_opt = dict(self.config.items('Layout'))
        self.meca_opt = dict(self.config.items('Mechanics'))
        self.net_opt = dict(self.config.items('Network'))
        self.loc_opt = dict(self.config.items('Localization'))
        self.save_opt = dict(self.config.items('Save'))
        self.sql_opt = dict(self.config.items('Mysql'))
        self.seed = eval(self.sim_opt['seed'])
        self.traj=Trajectories()

        self.verbose = str2bool(self.sim_opt['verbose'])
        if str2bool(self.net_opt['ipython_nb_show']):
            self.verbose = False
        self.roomlist=[]

        self.finish = False
        self.create()

    def __repr__(self):

        s = 'Simulation information' + '\n----------------------'
        s = s + '\nLayout: ' + self.lay_opt['filename']
        s = s + '\nSimulation duration: ' + self.sim_opt['duration']
        s = s + '\nRandom seed: ' + self.sim_opt['seed']
        s = s + '\nSave simulation: ' + self.save_opt['savep']

        s = s + '\n\nUpdate times' + '\n-------------'
        s = s + '\nMechanical update: ' + self.meca_opt['mecanic_update_time']
        s = s + '\nNetwork update: ' + self.net_opt['network_update_time']
        s = s + '\nLocalization update: ' + self.net_opt['communication_mode']

        s = s + '\n\nAgents => self.lAg[i]' + '\n------'
        s = s + '\nNumber of agents :' + str(len(self.lAg))
        s = s + '\nAgents IDs: ' + str([self.lAg[i].ID for i in range(len(self.lAg))])
        s = s + '\nAgents names: ' + str([self.lAg[i].name for i in range(len(self.lAg))])
        s = s + '\nDestination of chosen agents: ' + self.meca_opt['choose_destination']

        s = s + '\n\nNetwork' + '\n-------'
        s = s + '\nNodes per wstd: ' + str(self.net.wstd)

        s = s + '\n\nLocalization'  + '------------'
        s = s + '\nLocalization enable: ' + self.loc_opt['localization']
        s = s + '\nPostion estimation methods: ' + self.loc_opt['method']


        return s


    def create_layout(self):
        """ create Layout in Simpy the_world thanks to Tk backend

        """

        _filename = self.lay_opt['filename']

        self.L = Layout(_filename)

        self.the_world = world()

        try:
            self.L.dumpr()
            print 'Layout graphs are loaded from ',basename,'/struc/ini'
        except:
        #self.L.sl = sl
        #self.L.loadGr(G1)
            print 'This is the first time the layout file is used\
            Layout graphs are curently being built, it may take few minutes.'
            self.L.build()     
            self.L.dumpw()

        #
        # Create Layout
        #
        walls = self.L.thwall(0, 0)
        for wall in walls:
            for ii in range(0, len(wall) - 1):
                self.the_world.add_wall(wall[ii], wall[ii + 1])

    def create_agent(self):
        """ create simulation's Agents

        ..todo:: change lAg list to a dictionnary ( modification in show.py too) 

        """


        self.lAg = []
        agents=[]
        Cf = ConfigParser.ConfigParser()
        Cf.read(pyu.getlong('agent.ini','ini'))
        agents=eval(dict(Cf.items('used_agent'))['list'])
        for i, ag in enumerate(agents):
            ag_opt = dict(Cf.items(ag))
            self.lAg.append(Agent(
                            ID=ag_opt['id'],
                            name=ag_opt['name'],
                            typ=ag_opt['typ'],
                            color=eval(ag_opt['color']),
                            pdshow=str2bool(self.meca_opt['pdshow']),
                            pos=np.array(eval(ag_opt['pos'])),
                            roomId=int(ag_opt['roomid']),
                            froom=eval(ag_opt['froom']),
                            meca_updt=float(self.meca_opt['mecanic_update_time']),
                            wait=float(ag_opt['wait']),
                            cdest=eval(self.meca_opt['choose_destination']),
                            loc=str2bool(self.loc_opt['localization']),
                            loc_updt=float(self.loc_opt['localization_update_time']),
                            loc_method=eval(self.loc_opt['method']),
                            L=self.L,
                            network=str2bool(self.net_opt['network']),
                            net=self.net,
                            epwr=dict([(eval((ag_opt['wstd']))[ep],eval((ag_opt['epwr']))[ep]) for ep in range(len(eval((ag_opt['wstd']))))]),
                            sens=dict([(eval((ag_opt['wstd']))[ep],eval((ag_opt['sensitivity']))[ep]) for ep in range(len(eval((ag_opt['wstd']))))]),
                            world=self.the_world,
                            wstd=eval(ag_opt['wstd']),
                            save=eval(self.save_opt['save']),
                            gcom=self.gcom,
                            comm_mode=eval(self.net_opt['communication_mode']),
                            sim=self,
                            seed=self.seed))


    def create_EMS(self):
        """ electromagnetic Solver object
        """
        self.EMS = EMSolver(L=self.L)

    def create_network(self):
        """ create the whole network
        """

        self.net = Network(EMS=self.EMS)
        self.gcom=Gcom(net=self.net,sim=self)

        self.create_agent()
        # create network
        if str2bool(self.net_opt['network']):
            self.net.create()

            # create All Personnal networks
            for n in self.net.nodes():
                self.net.node[n]['PN']._get_wstd()
                self.net.node[n]['PN']._get_SubNet()
            self.gcom.create()


           # create Process Network
            self.Pnet = PNetwork(net=self.net,
                                 net_updt_time=float(self.net_opt['network_update_time']),
                                 L=self.L,
                                 sim=self,
                                 show_sg=str2bool(self.net_opt['show_sg']),
                                 disp_inf=str2bool(self.net_opt['dispinfo']),
                                 save=eval(self.save_opt['save']))
            self.activate(self.Pnet, self.Pnet.run(), 0.0)

    def create_visual(self):
        """ create visual Tk process
        """

        self.visu = Updater(
            interval=float(self.sim_opt['show_interval']), sim=self)
        self.activate(self.visu, self.visu.execute(), 0.0)

    def create(self):
        """ create the simulation
            This method is called at the end of __init__

        """

        # this is just to redump the database at each simulation
        if 'mysql' in self.save_opt['save']:
            if str2bool(self.sql_opt['dumpdb']):
                os.popen('mysql -u ' + self.sql_opt['user'] + ' -p ' + self.sql_opt['dbname'] +\
                '< /private/staff/t/ot/niamiot/svn2/devel/simulator/pyray/SimWHERE2.sql' )

        ## TODO supprimer la ref en dur 
        if 'txt' in self.save_opt['save']:
            pyu.writeDetails(self)
            if os.path.isfile(basename+'/output/Nodes.txt'):
                print 'would you like to erase previous txt files ?'
                A=raw_input()
                if A == 'y':
                    for f in os.listdir(basename+'/output/'):
                        try:
                            fi,ext=f.split('.')
                            if ext == 'txt':
                                os.remove(basename+'/output/'+f)
                        except:
                            pass

        self.create_layout()
        self.create_EMS()
        self.create_network()
        if str2bool(self.sim_opt['showtk']):
            self.create_visual()
        self.create_show()

        if str2bool(self.save_opt['savep']):
            self.save=Save(L=self.L,net=self.net,sim=self)
            self.activate(self.save,self.save.run(),0.0)

    def create_show(self):
        """ create a vizualization
        """

        plt.ion()
        fig_net = 'network'
        fig_table = 'table'

        if str2bool(self.net_opt['show']):
            if str2bool(self.net_opt['ipython_nb_show']):
                notebook=True
            else:
                notebook =False
            self.sh = ShowNet(net=self.net, L=self.L,sim=self,fname=fig_net,notebook=notebook)
            self.activate(self.sh,self.sh.run(),1.0)

        if str2bool(self.net_opt['show_table']):
            self.sht = ShowTable(net=self.net,lAg=self.lAg,sim=self,fname=fig_table)
            self.activate(self.sht,self.sht.run(),1.0)


    def savepandas(self):
        """ save mechanics in pandas hdf5 format
        """
        filename=pyu.getlong(eval(self.sim_opt["filename"]),pstruc['DIRNETSAVE'])
        layfile = self.L.filename.split('.')[0]
        store = pd.HDFStore(filename+'_'+layfile+'.h5','w')
        for a in self.lAg :

            if a.typ != 'ap':
                store.put( a.ID,a.meca.df.convert_objects() )

            else : # if agent acces point, its position is saved
                store.put( a.ID,a.posdf )

            store.get_storer(a.ID).attrs.typ = a.typ
            store.get_storer(a.ID).attrs.name = a.name
            store.get_storer(a.ID).attrs.ID = a.ID
            store.get_storer(a.ID).attrs.layout = self.L.filename
        #saving metadata
        store.close()
        self.traj.loadh5(eval(self.sim_opt["filename"])+'_'+layfile+'.h5')



    def runsimul(self):
        """ run simulation
        """
        if not self.finish :
            seed(self.seed)
            self.simulate(until=float(self.sim_opt['duration']),
                          real_time=True,
                          rel_speed=float(self.sim_opt['speedratio']))
            self.the_world._boids={}


            if str2bool(self.save_opt['savep']):
                print 'Processing save results, please wait'
                self.save.mat_export()


            if str2bool(self.save_opt['savepd']):
                self.savepandas()
            self.finish = True
        else :
            raise NameError('Reinstantiate a new simul object to run again')
示例#41
0
    def __init__(self,_fileini='coverage.ini'):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))

        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.apopt = dict(self.config.items('ap'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        # get the Layout
        self.L = Layout(self.layoutopt['filename'])

        # get the receiving grid

        self.nx = eval(self.gridopt['nx'])
        self.ny = eval(self.gridopt['ny'])
        self.ng = self.nx*self.ny
        self.mode = eval(self.gridopt['full'])
        self.boundary = eval(self.gridopt['boundary'])

        # create grid
        # we could here construct a grid locally around the access point
        # to be done later for code acceleration
        #
        self.creategrid(full=self.mode,boundary=self.boundary)

        self.dap = {}
        for k in self.apopt:
            kwargs  = eval(self.apopt[k])
            ap = std.AP(**kwargs)
            self.dap[eval(k)] = ap
            try:
                self.aap = np.vstack((self.aap,ap['p'][0:2]))
                self.ptdbm = np.vstack((self.ptdbm,ap['PtdBm']))
            except:
                self.aap = ap['p'][0:2]
                self.ptdbm = ap['PtdBm']
        # 1 x na
        self.ptdbm = self.ptdbm.T

        # number of access points
        self.na = len(self.dap)

        # creating all links
        p = product(range(self.ng),range(self.na))
        #
        # a : access point
        # g : grid
        #
        for k in p:
            pg = self.grid[k[0],:]
            pa = self.aap[k[1]]
            try:
                self.pa = np.vstack((self.pa,pa))
            except:
                self.pa = pa
            try:
                self.pg = np.vstack((self.pg,pg))
            except:
                self.pg = pg

        self.pa = self.pa.T
        self.pg = self.pg.T

        # frequency is chosen as all the center frequencies of the standard
        # warning assuming the same standard
        self.fGHz = self.dap[0].s.fcghz
        self.nf = len(self.fGHz)

        # AP section
        #self.fGHz = eval(self.txopt['fghz'])
        #self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        #self.ptdbm = eval(self.txopt['ptdbm'])
        #self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        self.rxsens = eval(self.rxopt['sensitivity'])

        kBoltzmann = 1.3806503e-23
        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        # list of access points
        lap  = self.dap.keys()
        # list of channels
        lchan = map(lambda x: self.dap[x]['chan'],lap)

        apchan = zip(self.dap.keys(),lchan)
        self.bmhz = np.array(map(lambda x: self.dap[x[0]].s.chan[x[1][0]]['BMHz']*len(x[1]),apchan))
        # Evaluate Noise Power (in dBm)

        Pn = (10**(self.noisefactordb/10.)+1)*kBoltzmann*self.temperaturek*self.bmhz*1e3
        self.pndbm = 10*np.log10(Pn)+60

        # show section
        self.bshow = str2bool(self.showopt['show'])

        try:
            self.L.Gt.nodes()
        except:
            pass
        try:
            self.L.dumpr()
        except:
            self.L.build()
            self.L.dumpw()
示例#42
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt

#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout()
lL = L.ls()
for tL in lL:
    print tL
#f = plt.figure(figsize=(20,10))
#plt.axis('off')
#f,a = L.showG('s',nodes=False,fig=f)
#plt.show()
#f,a = L.showG('r',edge_color='b',linewidth=4,fig=f)
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.buildGt()
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#43
0
class Simul(PyLayers):
    """
    Link oriented simulation

    A simulation requires :

        + A Layout
        + A Person
        + A Trajectory

    or a CorSer instance

    Members
    -------

    dpersons : dictionnary of persons (agent)
    dap : dictionnary of access points

    Methods
    -------

    load_simul : load configuration file
    load_Corser : load a Corser file
    _gen_net : generate network and asociated links
    show : show layout and network
    evaldeter : run simulation over time


    """

    def __init__(self, source ='simulnet_TA-Office.h5',verbose=False):
        """ object constructor

        Parameters
        ----------

        source : string
            h5 trajectory file default simulnet_TA-Office.h5

        verbose : boolean

        Notes
        -----

        The simultraj has a dataframe


        """


        # self.progress = -1  # simulation not loaded
        self.verbose = verbose
        self.cfield = []
        self.dpersons = {}

        self.dap = {}
        self.Nag = 0
        self.Nap = 0

        # source analysis
        if isinstance(source,str):
            self.filetraj = source
            self.load_simul(source)
            self.source = 'simul'
        elif 'pylayers' in source.__module__:
            self.filetraj = source._filename
            self.load_CorSer(source)
            cutoff=2
            self.source = 'CorSer'


        # generate the Network
        # The wireless standard and frequency is fixed in this function
        #
        self._gen_net()
        # initialize Stochastic Link
        self.SL = SLink()
        # initialize Deterministic Link
        self.DL = DLink(L=self.L,verbose=self.verbose)
        self.DL.cutoff=cutoff

        self.filename = 'simultraj_' + self.filetraj + '.h5'

        # data is a panda container which is initialized 
        #
        # We do not save all the simulation in a DataFRame anymore
        #
        #self.data = pd.DataFrame(columns=['id_a', 'id_b',
        #                                  'x_a', 'y_a', 'z_a',
        #                                  'x_b', 'y_b', 'z_b',
        #                                  'd', 'eng', 'typ',
        #                                  'wstd', 'fcghz',
        #                                  'fbminghz', 'fbmaxghz', 'fstep', 'aktk_id',
        #                                  'sig_id', 'ray_id', 'Ct_id', 'H_id'
        #                                  ])

        #self.data.index.name='t'
        self._filecsv = self.filename.split('.')[0] + '.csv'
        self.todo = {'OB': True,
                    'B2B': True,
                    'B2I': True,
                    'I2I': False}

        filenameh5 = pyu.getlong(self.filename,pstruc['DIRLNK'])

        if os.path.exists(filenameh5) :
            self.loadpd()
        self.settime(0.)
        # self._saveh5_init()


    def __repr__(self):


        s = 'Simul trajectories class\n'
        s = s + '------------------------\n'
        s = s +'\n'
        s = s + 'Used layout: ' + self.L.filename + '\n'
        s = s + 'Number of Agents: ' + str(self.Nag) + '\n'
        s = s + 'Number of Access Points: ' + str(self.Nap) + '\n'
        s = s + 'Link to be evaluated: ' + str(self.todo) + '\n'
        s = s + 'tmin: ' + str(self._tmin) + '\n'
        s = s + 'tmax: ' + str(self._tmax) + '\n'
        s = s +'\n'
        # network info
        s = s + 'self.N :\n'
        s = s + self.N.__repr__() + '\n'
        s = s + 'CURRENT TIME: ' + str(self.ctime) + '\n'




        return s

    def load_simul(self, source):
        """  load a simultraj configuration file

        Parameters
        ----------

        source : string
            name of simulation file to be loaded

        """
        self.filetraj = source
        if not os.path.isfile(source):
            raise AttributeError('Trajectory file'+source+'has not been found.\
             Please make sure you have run a simulnet simulation before runining simultraj.')

        # get the trajectory
        traj = tr.Trajectories()
        traj.loadh5(self.filetraj)

        # get the layout
        self.L = Layout(traj.Lfilename)

        # resample trajectory
        for ut, t in enumerate(traj):
            if t.typ == 'ag':
                person = Body(t.name + '.ini')
                tt = t.time()
                self.dpersons.update({t.name: person})
                self._tmin = tt[0]
                self._tmax = tt[-1]
                self.time = tt
            else:
                pos = np.array([t.x[0], t.y[0], t.z[0]])
                self.dap.update({t.ID: {'pos': pos,
                                        'ant': antenna.Antenna(),
                                        'name': t.name
                                        }
                                 })
        self.ctime = np.nan
        self.Nag = len(self.dpersons.keys())
        self.Nap = len(self.dap.keys())
        self.traj = traj

    def load_CorSer(self,source):
        """ load CorSer file for simulation

        Parameters
        ----------

        source :
            name of simulation file to be loaded

        """

        if isinstance(source.B,Body):
            B=[source.B]
        elif isinstance(source.B,list):
            B=source.B
        elif isinstance(source.B,dict):
            B=source.B.values()
        else:
            raise AttributeError('CorSer.B must be a list or a Body')

        self.L=source.L
        self.traj = tr.Trajectories()
        self.traj.Lfilename=self.L.filename

        for b in B:
            self.dpersons.update({b.name: b})
            self._tmin = b.time[0]
            self._tmax = b.time[-1]
            self.time = b.time
            self.traj.append(b.traj)

        for ap in source.din:
            techno,ID=ap.split(':')
            if techno == 'HKB':
                techno = 'hikob'
            if techno == 'TCR':
                techno = 'tcr'
            if techno == 'BS':
                techno = 'bespoon'


            self.dap.update({ap: {'pos': source.din[ap]['p'],
                                  'ant': source.din[ap]['ant'],
                                  'T': source.din[ap]['T'],
                                  'name': techno
                                        }
                                 })
        self.ctime = np.nan
        self.Nag = len(B)
        self.Nap = len(source.din)
        self.corser = source

    def _gen_net(self):
        """ generate Network and associated links

        Notes
        -----

        Create self.N : Network object

        See Also
        --------

        pylayers.network.network

        """

        #
        # Create Network
        #
        N = Network()
        #
        # get devices on bodies
        #
        # forall person
        #   forall device
        for p in self.dpersons:
            D = []
            for dev in self.dpersons[p].dev:
                aDev = Device(self.dpersons[p].dev[dev]['name'], ID = dev)
                D.append(aDev)

                D[-1].ant['A1']['name'] = self.dpersons[p].dev[dev]['file']
                D[-1].ant['antenna'] = self.dpersons[p].dev[dev]['ant']
            N.add_devices(D, grp=p)
        #
        # get access point devices
        #
        for ap in self.dap:
            D = Device(self.dap[ap]['name'], ID = ap)
            D.ant['antenna'] = self.dap[ap]['ant']
            N.add_devices(D, grp = 'ap', p = self.dap[ap]['pos'])
            N.update_orient(ap, self.dap[ap]['T'], now = 0.)
        # create Network
        #
        #    _get_wstd
        #    _get_grp
        #    _connect
        #    _init_PN
        #
        N.create()
        self.N = N

    def show(self):
        """ show actual simlulation configuration
        """
        fig, ax = self.L.showGs()
        fig, ax = self.N.show(fig=fig, ax=ax)
        return fig, ax

    def evaldeter(self, na, nb, wstd, fmod='force',nf=10,fGHz=[], **kwargs):
        """ deterministic evaluation of a link

        Parameters
        ----------

        na : string:
            node a id in self.N (Network)
        nb : string:
            node b id in self.N (Network)
        wstd : string:
            wireless standard used for commmunication between na and nb
        fmode : string ('center'|'band'|'force')
            mode of frequency evaluation
            center : single frequency (center frequency of a channel)
            band : nf points on the whole band
            force : takes directly fGHz
        nf : int:
            number of frequency points (if fmode = 'band')
        **kwargs : argument of DLink

        Returns
        -------

        (a, t )

        a : ndarray
            alpha_k
        t : ndarray
            tau_k

        See Also
        --------

        pylayers.simul.link.DLink

        """

        # todo in network :
        # take into consideration the postion and rotation of antenna and not device

        self.DL.Aa = self.N.node[na]['ant']['antenna']
        self.DL.a = self.N.node[na]['p']
        self.DL.Ta = self.N.node[na]['T']

        self.DL.Ab = self.N.node[nb]['ant']['antenna']
        self.DL.b = self.N.node[nb]['p']
        self.DL.Tb = self.N.node[nb]['T']

        #
        # The frequency band is chosen from the selected standard
        #  if fmode == 'center'
        #      only center frequency is calculated
        #
        #'
        if fmod == 'center':
            self.DL.fGHz = self.N.node[na]['wstd'][wstd]['fcghz']
        if fmod == 'band':
            fminGHz = self.N.node[na]['wstd'][wstd]['fbminghz']
            fmaxGHz = self.N.node[na]['wstd'][wstd]['fbmaxghz']
            self.DL.fGHz = np.linspace(fminGHz, fmaxGHz, nf)
        if fmod == 'force':
            assert len(fGHz)>0,"fGHz has not been defined"
            self.DL.fGHz = fGHz

        a, t = self.DL.eval(**kwargs)

        return a, t

    def evalstat(self, na, nb):
        """ statistical evaluation of a link

        Parameters
        ----------

        na : string:
            node a id in self.N (Netwrok)
        nb : string:
            node b id in self.N (Netwrok)

        Returns
        -------

        (a, t, eng)

        a : ndarray
            alpha_k
        t : ndarray
            tau_k
        eng : float
            engagement
        """

        pa = self.N.node[na]['p']
        pb = self.N.node[nb]['p']
        if self.source == 'simul':
            dida, name = na.split('_')
            didb, name = nb.split('_')
        elif self.source =='CorSer':
            bpa,absolutedida,dida,name,technoa = self.corser.devmapper(na)
            bpb,absolutedidb,didb,name,technob = self.corser.devmapper(nb)

        ak, tk, eng = self.SL.onbody(self.dpersons[name], dida, didb, pa, pb)

        return ak, tk, eng


    def settime(self,t):
        """ set current time
        """
        self.ctime = t
        self._traj=copy.copy(self.traj)
        self.update_pos(t)


    def run(self, **kwargs):
        """ run the link evaluation along a trajectory


        Parameters
        ----------

        OB: boolean
            perform on body statistical link evaluation
        B2B:  boolean
            perform body to body deterministic link evaluation
        B2I: boolean
            perform body to infrastructure deterministic link evaluation
        I2I:  boolean
            perform infrastructure to infrastructure deterministic link eval.
        links: dict
            dictionnary of link to be evaluated (key is wtsd and value is a list of links)
            (if [], all link are considered)
        wstd: list
            list of wstd to be evaluated
            (if [], all wstd are considered)
        t: np.array
            list of timestamp to be evaluated
            (if [], all timestamps are considered)
        tbr : boolean
            time in bit reverse order (tmin,tmax,N) Npoints=2**N
        replace_data: boolean (True)
            if True , reference id of all already simulated link will be erased
                and replace by new simulation id

        fGHz : np.array
            frequency in GHz


        Examples
        --------

            >>> from pylayers.simul.simultraj import *
            >>> from pylayers.measures.cormoran import *
            >>> C=CorSer()
            >>> S=Simul(C,verbose=True)
            >>> link={'ieee802154':[]}
            >>> link['ieee802154'].append(S.N.links['ieee802154'][0])
            >>> lt = [0,0.2,0.3,0.4,0.5]
            >>> S.run(links=link,t=lt)


        """
        defaults = {'OB': True,
                    'B2B': True,
                    'B2I': True,
                    'I2I': False,
                    'links': {},
                    'wstd': [],
                    't': np.array([]),
                    'btr':True,
                    'DLkwargs':{},
                    'replace_data':True,
                    'fmod':'force',
                    'fGHz':np.array([2.45])
                    }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        DLkwargs = kwargs.pop('DLkwargs')
        links = kwargs.pop('links')
        wstd = kwargs.pop('wstd')
        OB = kwargs.pop('OB')
        B2B = kwargs.pop('B2B')
        B2I = kwargs.pop('B2I')
        I2I = kwargs.pop('I2I')
        fmod = kwargs.pop('fmod')
        self.fGHz = kwargs.pop('fGHz')

        self.todo.update({'OB':OB,'B2B':B2B,'B2I':B2I,'I2I':I2I})


        # Check link attribute

        if links == {}:
            links = self.N.links
        elif not isinstance(links, dict):
            raise AttributeError('links is {wstd:[list of links]}, see self.N.links')

        for k in links.keys():
            checkl = [l in self.N.links[k] for l in links[k]]
            if len(np.where(checkl==False)[0])>0:
            # if sum(checkl) != len(self.N.links):
                uwrong = np.where(np.array(checkl) is False)[0]
                raise AttributeError(str(np.array(links)[uwrong])
                                     + ' links does not exist in Network')

        wstd = links.keys()
        # # Check wstd attribute
        # if wstd == []:
        #     wstd = self.N.wstd.keys()
        # elif not isinstance(wstd, list):
        #     wstd = [wstd]

        checkw = [w in self.N.wstd.keys() for w in wstd]
        if sum(checkw) != len(wstd):
            uwrong = np.where(np.array(checkw) is False)[0]
            raise AttributeError(str(np.array(wstd)[uwrong])
                                 + ' wstd are not in Network')

        # force time attribute compliant

        if not isinstance(kwargs['t'],np.ndarray):
            if isinstance(kwargs['t'],list):
                lt = np.array(kwargs['t'])
            elif (isinstance(kwargs['t'], int)
                 or isinstance(kwargs['t'],float)):
                lt = np.array([kwargs['t']])
        else :
            lt = kwargs['t']

        #if len(lt) == 0:
        #    lt = self.time
        # check time attribute
        if kwargs['btr']:
            if (lt[0] < self._tmin) or\
               (lt[1] > self._tmax) :
                raise AttributeError('Requested time range not available')

        # self._traj is a copy of self.traj, which is affected by resampling.
        # it is only a temporary attribute for a given run
        # if len(lt) > 1:
        #     sf = 1/(1.*lt[1]-lt[0])
        #     self._traj = self.traj.resample(sf=sf, tstart=lt[0])

        # else:
        #     self._traj = self.traj.resample(sf=1.0, tstart=lt[0])
        #     self._traj.time()
        # self.time = self._traj.t
        # self._time = pd.to_datetime(self.time,unit='s')
        #
        # Nested Loops
        #
        #  time
        #    standard
        #      links
        #           evaldeter &| evalstat
        #
        #lt = self.get_sim_time(lt)
        #self._time=self.get_sim_time(lt)

        init = True
        if kwargs['btr']:
            tmin = lt[0]
            tmax = lt[1]
            Nt   = int(2**lt[2])
            ta   = np.linspace(tmin,tmax,Nt)
            it   = np.hstack((np.r_[0],np.r_[pyu.bitreverse(Nt,int(lt[2]))]))
            #trev = t[it]
        else:
            ta = kwargs['t']
            it = range(len(ta))

        ## Start to loop over time
        ##   ut : counter
        ##   t  : time value (s)
        #for ut, t in enumerate(lt):
        for ks,ut in enumerate(it):
            t  = ta[ut]
            self.ctime = t
            # update spatial configuration of the scene for time t
            self.update_pos(t)
            # print self.N.__repr__()
            ## Start to loop over available Wireless standard
            ##
            for w in wstd:
                ## Start to loop over the chosen links stored in links
                ##
                for na, nb, typ in links[w]:
                    # If type of link is valid (Body 2 Body,...)
                    #
                    if self.todo[typ]:
                        if self.verbose:
                            print '-'*30
                            print 'time:', t, '/',  lt[-1] ,' time idx:', ut,
                            '/',len(ta),'/',ks
                            print 'processing: ',na, ' <-> ', nb, 'wstd: ', w
                            print '-'*30
                        eng = 0
                        #
                        # Invoque link deterministic simulation 
                        #
                        #  node : na
                        #  node : nb
                        #  wstd : w
                        #
                        self.evaldeter(na, nb,
                                       w,
                                       applywav=False,
                                       fmod = fmod,
                                       fGHz = self.fGHz,
                                       **DLkwargs)
                        # if typ == 'OB':
                        #     self.evalstat(na, nb)
                        #     eng = self.SL.eng
                        #     L = self.DL + self.SL
                        #     self._ak = L.H.ak
                        #     self._tk = L.H.tk
                        # else :

                        # Get alphak an tauk
                        self._ak = self.DL.H.ak
                        self._tk = self.DL.H.tk
                        aktk_id = str(ut) + '_' + na + '_' + nb + '_' + w
                        # this is a dangerous way to proceed ! 
                        # the id as a finite number of characters
                        while len(aktk_id)<40:
                            aktk_id = aktk_id + ' '
                        df = pd.DataFrame({ 'id_a': na,
                                    'id_b': nb,
                                    'x_a': self.N.node[na]['p'][0],
                                    'y_a': self.N.node[na]['p'][1],
                                    'z_a': self.N.node[na]['p'][2],
                                    'x_b': self.N.node[nb]['p'][0],
                                    'y_b': self.N.node[nb]['p'][1],
                                    'z_b': self.N.node[nb]['p'][2],
                                    'd': self.N.edge[na][nb]['d'],
                                    'eng': eng,
                                    'typ': typ,
                                    'wstd': w,
                                    'fcghz': self.N.node[na]['wstd'][w]['fcghz'],
                                    'fbminghz': self.fGHz[0],
                                    'fbmaxghz': self.fGHz[-1],
                                    'nf': len(self.fGHz),
                                    'aktk_id':aktk_id,
                                    'sig_id': self.DL.dexist['sig']['grpname'],
                                    'ray_id': self.DL.dexist['ray']['grpname'],
                                    'Ct_id': self.DL.dexist['Ct']['grpname'],
                                    'H_id': self.DL.dexist['H']['grpname'],
                                                },columns=['id_a', 'id_b',
                                              'x_a', 'y_a', 'z_a',
                                              'x_b', 'y_b', 'z_b',
                                              'd', 'eng', 'typ',
                                              'wstd', 'fcghz',
                                              'fbminghz', 'fbmaxghz', 'fstep', 'aktk_id',
                                              'sig_id', 'ray_id', 'Ct_id', 'H_id'
                                              ],index= [t])  #self._time[ut]])

                        self.savepd(df)

    def replace_data(self, df):
        """check if a dataframe df already exists in self.data

        Parameters
        ----------
        df : pd.DataFrame

        Returns
        -------

        boolean
            True if already exists
            False otherwise

        """
        self.data[(self.data.index == df.index) &
                  (self.data['id_a'] == df['id_a'].values[0]) &
                  (self.data['id_b'] == df['id_b'].values[0]) &
                  (self.data['wstd'] == df['wstd'].values[0])]=df.values



    def check_exist(self, df):
        """check if a dataframe df already exists in self.data

        Parameters
        ----------
        df : pd.DataFrame

        Returns
        -------

        boolean
            True if already exists
            False otherwise

        """
        # check init case 
        if not len(self.data.index) == 0:

            ud = self.data[(self.data.index == df.index) & 
                           (self.data['id_a'] == df['id_a'].values[0]) & 
                           (self.data['id_b'] == df['id_b'].values[0]) & 
                           (self.data['wstd'] == df['wstd'].values[0])]

            if len(ud) == 0:
                return False
            else :
                return True
        else :
            return False


    def savepd(self,df):
        """ save data information of a simulation

        Parameters
        ----------

        df : one index data

        Notes
        -----


        """
        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        store = pd.HDFStore(filenameh5)
        #self.data=self.data.sort()
        store.append('df',df)
        store.close()

    def loadpd(self):
        """ load data from previous simulations
        """
        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        store = pd.HDFStore(filenameh5)
        #self.data = pd.read_hdf(filenameh5,'df')
        self.data = store.get('df')
        self.data.index.name='t'
        self.data = self.data.sort()

    def get_sim_time(self,t):
        """ retrieve closest time value in regard of passed t value in parameter
        """

        if not isinstance(t,list) and not isinstance(t,np.ndarray):
            return np.array([self.time[np.where(self.time <=t)[0][-1]]])
        else :
            return np.array([self.get_sim_time(tt) for tt in t])[:,0]


    def get_df_from_link(self,id_a,id_b,wstd=''):
        """ Return a restricted data frame for a specific link

            Parameters
            ----------

            id_a : str
                node id a
            id_b: str
                node id b
            wstd: str
                optionnal :wireslees standard
        """
        if wstd == '':
            return self.data[(self.data['id_a']==id_a) &
                             (self.data['id_b']==id_b)]
        else :
            return self.data[(self.data['id_a']==id_a) &
                             (self.data['id_b']==id_b) &
                             self.data['wstd']==wstd]


    def update_pos(self, t):
        """ update positions of devices and bodies for a given time index

        Parameters
        ----------

        t : int
            time value

        """

        # if a bodies are involved in simulation
        if ((self.todo['OB']) or (self.todo['B2B']) or (self.todo['B2I'])):
            nodeid = []
            pos = []
            devlist = []
            orient = []
            for up, person in enumerate(self.dpersons.values()):
                person.settopos(self._traj[up], t=t, cs=True)
                name = person.name
                dev = person.dev.keys()
                devlist.extend(dev)
                #nodeid.extend([n + '_' + name for n in dev])
                pos.extend([person.dcs[d][:, 0] for d in dev])
                orient.extend([person.acs[d] for d in dev])
            # TODO !!!!!!!!!!!!!!!!!!!!
            # in a future version , the network update must also update
            # antenna position in the device coordinate system
            self.N.update_pos(devlist, pos, now=t)
            self.N.update_orient(devlist, orient, now=t)
        self.N.update_dis()



    def get_value(self,**kwargs):
        """ retrieve output parameter at a specific time

        Parameters
        ----------

        typ : list
                list of parameters to be retrieved
                (R | C |H | ak | tk | rss )
        links: list
            dictionnary of link to be evaluated (key is wtsd and value is a list of links)
            (if [], all link are considered)
        t: int or np.array
            list of timestamp to be evaluated | singlr time instant

        Returns
        -------

        output: dict
                [link_key]['t']
                          ['ak']
                ...
        """



        # get time
        defaults = {'t': 0,
                    'typ':['ak'],
                    'links': {},
                    'wstd':[],
                    'angles':False
                    }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        # allocate an empty dictionnary for wanted selected output
        output={}

        # manage time t can be a list or a float
        t = kwargs['t']
        t = self.get_sim_time(t)
        dt = self.time[1]-self.time[0]

        # manage links
        plinks = kwargs['links']
        links=[]
        if isinstance(plinks,dict):
            for l in plinks.keys():
                links.extend(plinks[l])

        if len(links) == 0:
            raise AttributeError('Please give valid links to get values')
        # output['t']=[]
        # output['time_to_simul']=[]
        # for each requested time step
        for tt in t :
            # for each requested links
            for link in links:
                linkname=link[0]+'-'+link[1]
                if not output.has_key(linkname):
                    output[linkname] = {}
                if not output[linkname].has_key('t'):
                    output[linkname]['t'] = []

                # restrict global dataframe self.data to the specific link
                df = self.get_df_from_link(link[0],link[1])
                # restrict global dataframe self.data to the specific z
                df = df[(df.index > tt-dt) & (df.index <= tt+dt)]

                if len(df) != 0:
                    output[linkname]['t'].append(tt)
                    if len(df)>1:
                        print 'Warning possible issue in self.get_value'
                    line = df.iloc[-1]
                    # # get info of the corresponding timestamp
                    # line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])].iloc[-1]
                    # if len(line) == 0:
                    #     line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
                    #     if len(line) == 0:
                    #         raise AttributeError('invalid link')

                    #retrieve correct position and orientation given the time
                    #self.update_pos(t=tt)
                    # antennas positions
                    #self.DL.a = self.N.node[link[0]]['p']
                    #self.DL.b = self.N.node[link[1]]['p']
                    # antennas orientation
                    #self.DL.Ta = self.N.node[link[0]]['T']
                    #self.DL.Tb = self.N.node[link[1]]['T']
                    # antennas object
                    #self.DL.Aa = self.N.node[link[0]]['ant']['antenna']
                    #self.DL.Ab = self.N.node[link[1]]['ant']['antenna']
                    # get the antenna index
                    #uAa_opt, uAa = self.DL.get_idx('A_map',self.DL.Aa._filename)
                    #uAb_opt, uAb = self.DL.get_idx('A_map',self.DL.Ab._filename)

                    if 'ak' in kwargs['typ'] or 'tk' in kwargs['typ'] or 'rss' in kwargs['typ']:
                        H_id = line['H_id'].decode('utf8')
                        # load the proper link
                        # parse index
                        lid = H_id.split('_')
                        #if (lid[5]==str(uAa))&(lid[6]==str(uAb)):
                        self.DL.load(self.DL.H,H_id)
                        if 'ak' in kwargs['typ']:
                            if not output[linkname].has_key('ak'):
                                output[linkname]['ak']=[]
                            output[linkname]['ak'].append(copy.deepcopy(self.DL.H.ak))
                        if 'tk' in kwargs['typ']:
                            if not output[linkname].has_key('tk'):
                                output[linkname]['tk']=[]
                            output[linkname]['tk'].append(copy.deepcopy(self.DL.H.tk))
                        if 'rss' in kwargs['typ']:
                            if not output[linkname].has_key('rss'):
                                output[linkname]['rss']=[]
                            output[linkname]['rss'].append(copy.deepcopy(self.DL.H.rssi()))

                    if 'R' in kwargs['typ']:
                        if not output[linkname].has_key('R'):
                            output[linkname]['R']=[]
                        ray_id = line['ray_id']
                        self.DL.load(self.DL.R,ray_id)
                        output[linkname]['R'].append(copy.deepcopy(self.DL.R))

                    if 'C' in kwargs['typ']:
                        if not output[linkname].has_key('C'):
                            output[linkname]['C']=[]
                        Ct_id = line['Ct_id']
                        self.DL.load(self.DL.C,Ct_id)

                        if kwargs['angles']:
                            self.DL.C.islocal=False
                            self.DL.C.locbas(Tt=self.DL.Ta, Tr=self.DL.Tb)
                        #T channel
                        output[linkname]['C'].append(copy.deepcopy(self.DL.C))


                    if 'H' in kwargs['typ']:
                        if not output[linkname].has_key('H'):
                            output[linkname]['H']=[]
                        H_id = line['H_id']
                        lid = H_id.split('_')
                        #if (lid[5]==str(uAa))&(lid[6]==str(uAb)):
                        self.DL.load(self.DL.H,H_id)
                        output[linkname]['H'].append(copy.deepcopy(self.DL.H))

                # if time value not found in dataframe
                else:
                    if not output[linkname].has_key('time_to_simul'):
                        output[linkname]['time_to_simul'] = []
                    output[linkname]['time_to_simul'].append(tt)


        for l in output.keys():
            if output[l].has_key('time_to_simul'):
                print 'link', l , 'require simulation for timestamps', output[l]['time_to_simul']


        return(output)


    def get_link(self,**kwargs):
        """ retrieve a Link specific time from a simultraj

        Parameters
        ----------

        typ : list
                list of parameters to be retrieved
                (ak | tk | R |C)
        links: list
            dictionnary of link to be evaluated (key is wtsd and value is a list of links)
            (if [], all link are considered)
        t: int or np.array
            list of timestamp to be evaluated | singlr time instant

        Returns
        -------

        DL : DLink

        Examples
        --------

        >>> from pylayers.simul.simultraj import *
        >>> from pylayers.measures.cormoran import *
        >>> C=CorSer(serie=6i,day=11)
        >>> S = Simul(C,verb ose=False)
        >>> DL = S.get_link(typ=['R','C','H'])
                ...
        """



        # get time
        defaults = {'t': 0,
                    'typ':['ak'],
                    'links': {},
                    'wstd':[],
                    'angles':False
                    }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        output={}

        # manage time
        t = kwargs['t']
        t = self.get_sim_time(t)
        dt = self.time[1]-self.time[0]

        # manage links
        plinks = kwargs['links']
        links=[]
        if isinstance(plinks,dict):
            for l in plinks.keys():
                links.extend(plinks[l])

        if len(links) == 0:
            raise AttributeError('Please give valid links to get values')
        # output['t']=[]
        # output['time_to_simul']=[]
        # for each requested time step
        for tt in t :
            # for each requested links
            for link in links:
                linkname=link[0]+'-'+link[1]
                if not output.has_key(linkname):
                    output[linkname] = {}
                if not output[linkname].has_key('t'):
                    output[linkname]['t'] = []


                # restrict global dataframe self.data to the specific link
                df = self.get_df_from_link(link[0],link[1])
                # restrict global dataframe self.data to the specific z
                df = df[(df.index > tt-dt) & (df.index <= tt+dt)]

                if len(df) != 0:
                    output[linkname]['t'].append(tt)
                    if len(df)>1:
                        print 'Warning possible issue in self.get_link'
                    line = df.iloc[-1]
                    # # get info of the corresponding timestamp
                    # line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])].iloc[-1]
                    # if len(line) == 0:
                    #     line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
                    #     if len(line) == 0:
                    #         raise AttributeError('invalid link')

                    #retrieve correct position and orientation given the time
                    self.update_pos(t=tt)
                    self.DL.a = self.N.node[link[0]]['p']
                    self.DL.b = self.N.node[link[1]]['p']
                    self.DL.Ta = self.N.node[link[0]]['T']
                    self.DL.Tb = self.N.node[link[1]]['T']
                    #self.DL.Aa = self.N.node[link[0]]['ant']['antenna']
                    #self.DL.Ab = self.N.node[link[1]]['ant']['antenna']

                    #H_id = line['H_id'].decode('utf8')
                    #self.DL.load(self.DL.H,H_id)

                    if 'R' in kwargs['typ']:
                        ray_id = line['ray_id']
                        self.DL.load(self.DL.R,ray_id)

                    if 'C' in kwargs['typ']:
                        Ct_id = line['Ct_id']
                        self.DL.load(self.DL.C,Ct_id)

                        if kwargs['angles']:
                            self.DL.C.islocal=False
                            self.DL.C.locbas(Tt=self.DL.Ta, Tr=self.DL.Tb)

                    if 'H' in kwargs['typ']:
                        H_id = line['H_id']
                        self.DL.load(self.DL.H,H_id)

        return(self.DL)



    def _show3(self, **kwargs):
        """ 3D show using Mayavi

        Parameters
        ----------

        t: float
            time index
        link: list
            [id_a, id_b]
            id_a : node id a
            id_b : node id b
        'lay': bool
            show layout
        'net': bool
            show net
        'body': bool
            show bodies
        'rays': bool
            show rays
        """

        defaults = {'t': 0,
                    'link': [],
                    'wstd':[],
                    'lay': True,
                    'net': True,
                    'body': True,
                    'rays': True,
                    'ant': False

                    }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]

        link = kwargs['link']
        self.update_pos(kwargs['t'])

        if len(self.data) != 0:
            df = self.data[self.data.index == pd.to_datetime(kwargs['t'])]
            if len(df) != 0:
                raise AttributeError('invalid time')


            # default
            if link ==[]:
                line = df[df.index<=pd.to_datetime(0)]
                link = [line['id_a'].values[0],line['id_b'].values[0]]
            else :
                # get info of the corresponding timestamp
                line = df[(df['id_a'] == link[0]) & (df['id_b'] == link[1])]
            if len(line) == 0:
                line = df[(df['id_b'] == link[0]) & (df['id_a'] == link[1])]
                if len(line) == 0:
                    raise AttributeError('invalid link')
            rayid = line['ray_id'].values[0]


            self.DL.a = self.N.node[link[0]]['p']
            self.DL.b = self.N.node[link[1]]['p']
            self.DL.Ta = self.N.node[link[0]]['T']
            self.DL.Tb = self.N.node[link[1]]['T']
            self.DL.load(self.DL.R,rayid)





            self.DL._show3(newfig= False,
                           lay= kwargs['lay'],
                           rays= kwargs['rays'],
                           ant=False)
        else :
            self.DL._show3(newfig= False,
                           lay= True,
                           rays= False,
                           ant=False)
        if kwargs['net']:
            self.N._show3(newfig=False)
        if kwargs['body']:
            for p in self.dpersons:
                self.dpersons[p]._show3(newfig=False,
                                        topos=True,
                                        pattern=kwargs['ant'])

    # def _saveh5_init(self):
    #     """ initialization of the h5py file
    #     """
    #     filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
    #     import ipdb
    #     try:
    #         f5 = h5py.File(filenameh5, 'w')
    #         f5.create_dataset('time', shape=self.time.shape, data=self.time)
    #         f5.close()
    #     except:
    #         f5.close()
    #         raise NameError('simultra.saveinit: \
    #                         issue when writting h5py file')

    def _saveh5(self, ut, ida, idb, wstd):
        """ Save in h5py format

        Parameters
        ----------

        ut : int
            time index in self.time
        ida : string
            node a index
        idb : string
            node b index
        wstd : string
            wireless standard of used link

        Notes
        -----

        Dataset organisation:

        simultraj_<trajectory_filename.h5>.h5
            |
            |time
            |    ...
            |
            |/<tidx_ida_idb_wstd>/ |attrs
            |                      |a_k
            |                      |t_k


        Root dataset :
        time : array
            range of simulation time

        Group identifier :
            tidx : index in time dataset
            ida : node a index in Network
            idb : node b index in Network
            wstd : wireless standar of link interest


        Inside group:
            a_k : alpha_k values
            t_k : tau_k values

        See Also
        --------

        pylayers.simul.links

        """

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        grpname = str(ut) + '_' + ida + '_' + idb + '_' + wstd
        # try/except to avoid loosing the h5 file if
        # read/write error
        try:
            fh5 = h5py.File(filenameh5, 'a')
            if not grpname in fh5.keys():
                fh5.create_group(grpname)
                f = fh5[grpname]
                # for k in kwargs:
                #     f.attrs[k] = kwargs[k]

                f.create_dataset('alphak',
                                 shape=self._ak.shape,
                                 maxshape=(None),
                                 data=self._ak)
                f.create_dataset('tauk',
                                 shape=self._tk.shape,
                                 maxshape=(None),
                                 data=self._tk)
            else:
                pass#print grpname + ' already exists in ' + filenameh5


            fh5.close()
        except:
            fh5.close()
            raise NameError('Simultraj._saveh5: issue when writting h5py file')


    def _loadh5(self, grpname):
        """ Load in h5py format

        Parameters
        ----------

       grpname : string
            group name which can be found sin self.data aktk_idx column

        Returns
        -------
        (ak, tk, conf)

        ak : ndarray:
            alpha_k
        tk : ndarray:
            alpha_k
        """

        filenameh5 = pyu.getlong(self.filename, pstruc['DIRLNK'])
        # try/except to avoid loosing the h5 file if
        # read/write error
        try:
            fh5 = h5py.File(filenameh5, 'r')
            if not grpname in fh5.keys():
                fh5.close()
                raise NameError(grpname + ' cannot be reached in ' + self.filename)
            f = fh5[grpname]
            # for k in f.attrs.keys():
            #     conf[k]=f.attrs[k]
            ak = f['alphak'][:]
            tk = f['tauk'][:]
            fh5.close()

            return ak, tk
        except:
            fh5.close()
            raise NameError('Simultraj._loadh5: issue when reading h5py file')


    def tocsv(self, ut, ida, idb, wstd,init=False):

        filecsv = pyu.getlong(self._filecsv,pstruc['DIRLNK'])

        with open(filecsv, 'a') as csvfile:
            fil = csv.writer(csvfile, delimiter=';',
                             quoting=csv.QUOTE_MINIMAL)
            if init:
                keys = self.data.iloc[-1].keys()
                data = [k for k in keys]
                data .append('ak')
                data .append('tk')
                fil.writerow(data)

            values = self.data.iloc[-1].values
            data = [v for v in values]
            sak = str(self._ak.tolist())
            stk = str(self._tk.tolist())
            data.append(sak)
            data.append(stk)
            fil.writerow(data)
示例#44
0
class Simul(PyLayers):
    """ Simulation Class

    Methods
    -------

    gui()
        graphical user interface
    choose()
        choose a simulation file in simuldir
    info()
        info about the simulation
    showray(itx,irx,iray)
        show a single ray
    help()
        help on using Simulation object
    freq()
        return the frequency base
    save()
        save Simulation file
    layout
        load a Layout file
    load()
        load Simulation
    show3()
        geomview vizualization
    show3l(itx,irx)
        geomview vizualization of link itx irx
    show()
        2D visualization of simulation with furniture
    run(itx,irx)
        run simulation for links (itx,irx)
    cir(itx,irx,store_level=0,alpha=1.0)
        Channel Impulse Response calculation


    Attributes
    ----------

    fileconf

    filetauk
    filetang
    filerang

    tx
    rx

    progress

    indoor
    mat
    sl

    Notes
    ------

    This class group together all the parametrization files of a simulation

    """
    def __init__(self, _filesimul='default.ini'):
        self.filesimul = _filesimul
        self.config = ConfigParser.ConfigParser()
        self.config.add_section("files")
        self.config.add_section("frequency")
        self.config.add_section("waveform")
        self.config.add_section("output")

        self.dtang = {}
        self.drang = {}
        self.dtauk = {}
        self.dfield = {}
        self.dcir = {}
        self.output = {}

        #
        # Here was a nasty bug : Rule for the future
        #    "Always precise the key value of the passed argument"
        #
        # Mal nommer les choses, c'est ajouter au malheur du monde ( Albert Camus )
        #
        self.tx = RadioNode(
            name='',
            typ='tx',
            _fileini='radiotx.ini',
            _fileant='defant.vsh3',
        )

        self.rx = RadioNode(
            name='',
            typ='rx',
            _fileini='radiorx.ini',
            _fileant='defant.vsh3',
        )

        self.filefreq = "def.freq"

        self.progress = -1  # simulation not loaded

        self.filetang = []
        self.filerang = []
        self.filetauk = []
        self.filefield = []

        self.fileconf = "project.conf"
        self.cfield = []
        self.fGHz = np.linspace(2, 11, 181, endpoint=True)
        self.wav = wvf.Waveform()
        self.load(_filesimul)

    def gui(self):
        """ gui to modify the simulation file
        """
        simulgui = multenterbox(
            '', 'Simulation file', ('filesimul', 'filestr', 'filefreq',
                                    'filespaTx', 'filespaRx', 'fileantTx'
                                    'fileantRx'),
            (self.filesimul, self.filestr, self.filefreq, self.filespaTx,
             self.filespaRx, self.fileantTx, self.fileantRx))
        if simulgui is not None:
            self.filesimul = simulgui[0]
            self.filestr = simulgui[1]
            self.filefreq = simulgui[6]
            self.filespaTx = simulgui[7]
            self.filespaRx = simulgui[8]
            self.fileantTx = simulgui[9]
            self.fileantRx = simulgui[10]

    def updcfg(self):
        """ update simulation .ini config file 
        
        with values currently in use.
        """
        self.config.set("files", "struc", self.filestr)
        self.config.set("files", "conf", self.fileconf)
        self.config.set("files", "txant", self.tx.fileant)
        self.config.set("files", "rxant", self.rx.fileant)
        self.config.set("files", "tx", self.tx.fileini)
        self.config.set("files", "rx", self.rx.fileini)
        self.config.set("files", "mat", self.filematini)
        self.config.set("files", "slab", self.fileslabini)

        self.config.set("tud", "purc", str(self.patud.purc))
        self.config.set("tud", "nrmax", str(self.patud.nrmax))
        self.config.set("tud", "num", str(self.patud.num))

        #
        # frequency section
        #

        self.config.set("frequency", "fghzmin", self.fGHz[0])
        self.config.set("frequency", "fghzmax", self.fGHz[-1])
        self.config.set("frequency", "nf", str(len(self.fGHz)))
        #
        # waveform section
        #
        self.config.set("waveform", "tw", str(self.wav['twns']))
        self.config.set("waveform", "band", str(self.wav['bandGHz']))
        self.config.set("waveform", "fc", str(self.wav['fcGHz']))
        self.config.set("waveform", "thresh", str(self.wav['threshdB']))
        self.config.set("waveform", "type", str(self.wav['typ']))
        self.config.set("waveform", "fe", str(self.wav['feGHz']))
        #
        # output section
        #
        for k in self.output.keys():
            self.config.set("output", str(k), self.dout[k])

        # Initialize waveform
        self.wav = wvf.Waveform()
        # Update waveform
        self.wav.read(self.config)
        self.save()

    def clean_project(self, verbose=True):
        """
        Clean Pyrpoject directory

        remove .lch, .tra, .field .tud, .tauk, .tang, .rang, <pyproject>/output

        remove [output] entries into .ini of self.filesimul


        Parameters
        ----------
 
        verbose : boolean
            Verbose mode on/off


        Returns
        -------
            Boolean:
                True if the project has been cleaned, False otherwise


        """

        if verbose:

            print "-----------------------------------"
            print "-----------------------------------"
            print "          WARNING                  "
            print "-----------------------------------"
            print "-----------------------------------"
            print "You are about to remove ALL previous computed raytracing files."
            print "If you decide to remove it, you will need to restart the entire \
    raytracing simulation to exploit simulation results"

            print "\n Do you want to remove these simulation files ? y/n"
            r = raw_input()

        else:
            r == 'y'

        if r == 'y':
            inifile = self.filesimul
            try:
                path = os.getenv('BASENAME')
            except:
                print('Error : there is no project  directory in $BASENAME')

            dirlist = ['output']
            extension = [
                '.lch', '.field', '.tra', '.tud', '.tang', '.rang', '.tauk'
            ]
            rindic = False

            # remove file

            for d in dirlist:
                for ex in extension:
                    files = os.listdir(path + '/' + d)
                    for f in files:
                        if not os.path.isdir(path + '/' + d + '/' +
                                             f) and ex in f:
                            rindic = True
                            if verbose:
                                print f
                            os.remove(path + '/' + d + '/' + f)

                    if rindic:
                        if verbose:
                            print 'removed *' + ex + ' from ' + d + '\n'
                        rindic = False

            # remove output into the self.filesimul ini file

            simcfg = ConfigParser.ConfigParser()
            simcfg.read(pyu.getlong(inifile, pstruc['DIRSIMUL']))
            simcfg.remove_section('output')
            f = open(pyu.getlong(inifile, pstruc['DIRSIMUL']), 'wb')
            simcfg.write(f)
            f.close()
            self.dout = {}
            self.dlch = {}
            self.dtra = {}
            self.dtud = {}
            self.dtang = {}
            self.drang = {}
            self.dtauk = {}
            self.dfield = {}
            self.dcir = {}
            self.output = {}

            if verbose:
                print 'removed [output] entries into ' + inifile + '\n'
                print 'Project CLEANED'
            return True
        else:
            if verbose:
                print "clean project process ABORTED"
            return False

    def save(self):
        """ save simulation file

        Simulation files are .ini files which are saved in a dedicated
        directory basename/ini in the Project tree

        """
        filesimul = pyu.getlong(self.filesimul, "ini")
        fd = open(filesimul, "w")
        # getting current spa file if any
        try:
            self.config.set("files", "tx", self.tx.fileini)
        except:
            pass
        try:
            self.config.set("files", "rx", self.rx.fileini)
        except:
            pass
        self.config.write(fd)
        fd.close()
        # save tx
        self.tx.save()
        # save rx
        self.rx.save()
        # save slab and mat file
        # --
        # self.slab.save(self.fileslabini)
        # self.slab.mat.save(self.filematini)
        # --
        # fix bug #189
        #   slab is a member of S.L not of S anymore
        #   mat is a member of S.L.sl not of S.slab
        try:
            self.L.sl.save(self.fileslabini)
        except:
            pass
        try:
            self.L.sl.mat.save(self.filematini)
        except:
            pass

#    def saveold(self):
#        """ save simulation file

#        """
#        filesimul = pyu.getlong(self.filesimul, "ini")
#        fd = open(filesimul, "w")
#        config = ConfigParser.ConfigParser()

#        #
#        # files section
#        #
#        #config.add_section("files")
#        self.config.set("files", "conf", self.fileconf)
#        self.config.set("files", "struc", self.filestr)
#        self.config.set("files", "slab", self.fileslab)
#        self.config.set("files", "mat", self.filemat)

#        try:
#            self.config.set("files", "tx", self.tx.filespa)
#        except:
#            pass
#        try:
#            self.config.set("files", "rx", self.rx.filespa)
#        except:
#            pass
#        try:
#            self.config.set("files", "txant", self.tx.fileant)
#        except:
#            pass
#        try:
#            self.config.set("files", "rxant", self.rx.fileant)
#        except:
#            pass
#        self.config.set("files", "patra", self.filepatra)
#        self.config.set("files", "palch", self.filepalch)
#        self.palch.save()
#        self.patra.save()

#        #
#        # tud section
#        #

#        self.config.set("tud", "purc", self.patud.purc)
#        self.config.set("tud", "nrmax", self.patud.nrmax)
#        self.config.set("tud", "num", self.patud.num)

#        #
#        # frequency section
#        #
#        self.config.set("frequency", "fghzmin", self.freq[0])
#        self.config.set("frequency", "fghzmax", self.freq[-1])
#        self.config.set("frequency", "Nf", len(self.freq))

#        #
#        # output section
#        #
#        #filelch exists
#        if self.progress > 0:
#            #config.add_section("output")
#            for k in range(len(self.filelch)):
#                _fileout = "out" + "???"
#                filename = self.filelch[k]
#                self.config.set("launch", str(k + 1), filename)

#        # filetra exists
#        for k in range(len(self.filelch)):
#            if self.progress > 1:
#                #self.config.add_section("trace")
#                for l in arange(len(self.filetra[k])):
#                    filename = self.filetra[k][l]
#                    self.config.set("trace", "rx" + str(l + 1), filename)

#        # .tang exists
#        # .rang exists
#        # .tud exists
#            if self.progress > 2:
#                #config.add_section("tud")
#                #config.add_section("tang")
#                #config.add_section("rang")

#                for l in arange(len(self.filetud[k])):
#                    ftud = self.filetud[k][l]
#                    self.config.set("tud", "rx" + str(l + 1), ftud)

#                for l in arange(len(self.filetang[k])):
#                    ftang = self.filetang[k][l]
#                    self.config.set("tang", "rx" + str(l + 1), ftang)

#                for l in arange(len(self.filerang[k])):
#                    frang = self.filerang[k][l]
#                    self.config.set("rang", "rx" + str(l + 1), frang)

#        # .field exist
#        # .tauk exist
#            if self.progress > 3:
#                #config.add_section("tauk")
#                #config.add_section("field")
#                for l in arange(len(self.filetud[k])):
#                    ftauk = self.filetud[k][l]
#                    self.config.set("tauk", "rx" + str(l + 1), ftauk)

#                for l in arange(len(self.filefield[k])):
#                    ffield = self.filefield[k][l]
#                    self.config.set("field", "rx" + str(l + 1), ffield)

#        self.config.write(fd)
#        fd.close()

    def save_project(self):
        """ save Simulation files in a zipfile

        Simulation files are .ini files which are saved in a dedicated
        directory basename/ini in the Project tree

        """
        root = Tkinter.Tk()
        zipfileName = tkFileDialog.asksaveasfilename(
            parent=root,
            filetypes=[("zipped file", "zip")],
            title="Save Project",
        )
        pyu.zipd(basename, zipfileName)
        root.withdraw()
        print "Current project saved in", zipfileName

    def load_project(self):
        """ load Simulation files from a zipfile

        Simulation files are .ini files which are saved in a dedicated
        directory basename/ini in the Project tree

        """
        root = Tkinter.Tk()
        zipfileName = tkFileDialog.askopenfile(parent=root,
                                               mode='rb',
                                               title='Choose a project')
        dirname = tkFileDialog.askdirectory(parent=root,
                                            initialdir=basename,
                                            title='Please select a directory',
                                            mustexist=0)
        pyu.unzipd(dirname, zipfileName)
        root.withdraw()
        print "Current project loaded in", dirname

    def choose(self):
        """
            Choose a simulation file in simuldir

        """
        import tkFileDialog as FD
        fichsimul = FD.askopenfilename(filetypes=[("Fichiers simul ",
                                                   "*.simul"), ("All", "*")],
                                       title="Please choose a simulation file",
                                       initialdir=simuldir)
        self.filesimul = pyu.getshort(fichsimul)
        self.load()

    def load(self, _filesimul):
        """ load a simulation configuration file

         each transmiter simulation results in the creation of an .ini file
         with the following sections
         related to the results obtained for different receivers

        Parameters
        ----------

        _filesimul   : file in the simul directory of the Project

        """

        self.filesimul = _filesimul
        filesimul = pyu.getlong(self.filesimul, "ini")

        self.config.read(filesimul)

        sections = self.config.sections()
        try:
            _filetx = self.config.get("files", "tx")
        except:
            raise NameError('Error in section tx from ' + _filesimul)

        try:
            _filerx = self.config.get("files", "rx")
        except:
            raise NameError('Error in section rx from ' + _filesimul)

        try:
            _fileini = self.config.get("files", "struc")
        except:
            raise NameError('Error in section struc from ' + _fileini)

        try:
            _fileanttx = self.config.get("files", "txant")
        except:
            raise NameError('Error in section txant from ' + _filesimul)

        try:
            _fileantrx = self.config.get("files", "rxant")
        except:
            raise NameError('Error in section rxant from ' + _filesimul)

        try:
            self.tx = RadioNode(name='',
                                typ='tx',
                                _fileini=_filetx,
                                _fileant=_fileanttx)

            self.rx = RadioNode(name='',
                                typ='rx',
                                _fileini=_filerx,
                                _fileant=_fileantrx)
        except:
            raise NameError('Error during Radionode load')
#
# Load Layout
#
        try:
            self.L = Layout(_fileini)
        except:
            raise NameError('Layout load error')

#
# Frequency base
#
        if "frequency" in sections:
            try:
                self.fGHz = np.linspace(
                    float(self.config.getfloat("frequency", "fghzmin")),
                    float(self.config.getfloat("frequency", "fghzmax")),
                    int(self.config.getint("frequency", "nf")),
                    endpoint=True)
            except:
                raise NameError('Error in section frequency from ' +
                                _filesimul)
            # update .freq file in tud directory

            filefreq = pyu.getlong(self.filefreq, pstruc['DIRTUD'])
            fd = open(filefreq, "w")
            chaine = self.config.get("frequency", "fghzmin") + ' ' + \
                self.config.get("frequency", "fghzmax") + ' ' + \
                self.config.get("frequency", "nf")
            fd.write(chaine)
            fd.close
#
# Simulation Progress
#
#        self.output = {}
#        if "output" in sections:
#            for itx in self.config.options("output"):
#                _filename  =  self.config.get("output", itx)
#                self.dout[int(itx)] = _filename
#                filename = pyu.getlong(_filename, "output")
#                output = ConfigParser.ConfigParser()
#                output.read(filename)
#                secout = output.sections()
#                self.dtra[int(itx)] = {}
#                self.dtud[int(itx)] = {}
#                self.dtang[int(itx)] = {}
#                self.drang[int(itx)] = {}
#                self.dtauk[int(itx)] = {}
#                self.dfield[int(itx)] = {}
#                self.dcir[int(itx)] = {}
#                if "launch" in secout:
#                    self.progress = 1
#                    keys_launch = output.options("launch")
#                    for kl in keys_launch:
#                        self.dlch[int(kl)] = output.get("launch", kl)
#                if "trace" in secout:
#                    self.progress = 2
#                    keys_tra = output.options("trace")
#                    for kt in keys_tra:
#                        self.dtra[int(itx)][int(kt)] = output.get("trace", kt)
#
#                if "tang" in secout:
#                    self.progress = 3
#                    keys_tang = output.options("tang")
#                    for kt in keys_tang:
#                        self.dtang[int(itx)][int(kt)] = output.get("tang", kt)
#                        self.drang[int(itx)][int(kt)] = output.get("rang", kt)
#                        self.dtud[int(itx)][int(kt)] = output.get("tud", kt)
#                if "field" in secout:
#                    self.progress = 4
#                    keys_field = output.options("field")
#                    for kt in keys_field:
#                        self.dfield[int(itx)][int(kt)] = output.get(
#                            "field", kt)
#                        self.dtauk[int(itx)][int(kt)] = output.get("tauk", kt)
#                if "cir" in secout:
#                    self.progress = 5
#                    keys_cir = output.options("cir")
#                    for kt in keys_cir:
#                        self.dcir[int(itx)][int(kt)] = output.get("cir", kt)
#
#                self.output[int(itx)] = output
#
# Waveform section
#
        self.wav = wvf.Waveform()
        self.wav.read(self.config)

    def layout(self, _filestruc):
        """ load a layout in the simulation oject

        Parameters
        ----------

        _filestruc : string
            short file name of the Layout object

        Examples
        --------

        >>> from pylayers.simul.simulem import *
        >>> S = Simul()
        >>> S.layout('defstr.ini')

        """
        self.filestr = _filestruc

        self.L = Layout(_filestruc)
        # update config
        self.config.set("files", "struc", self.filestr)
        self.save()

    #def show(self, itx=[-1], irx=[-1], furniture=True, s=8, c='b', traj=False, num=False,fig=[],ax=[]):
    def show(self, **kwargs):
        """ show simulation

            Parameters
            -----------
            itx        : list of tx indices
            irx        : list of rx indices
            furniture  : boolean for METALIC furniture display
            s          : scale fir scatter plot  (default 8)
            c          : color for scatter plot  (default 'b')
            traj       : boolean  (def False)
            num        : boolean  (def False)
                display a number


            Examples
            --------
            >>> import matplotlib.pyplot as plt
            >>> from pylayers.simul.simulem import *
            >>> S = Simul()
            >>> S.load('w1.ini')
            >>> S.L.loadfur('FurW1.ini')
            >>> S.show()
            >>> plt.show()



        """

        defaults = {
            'itx': [-1],
            'irx': [-1],
            'furniture': True,
            's': 8,
            'c': 'b',
            'num': False,
            'fig': [],
            'ax': [],
            'aw': False
        }

        for k in defaults:
            if k not in kwargs:
                kwargs[k] = defaults[k]
            st = k + "=kwargs['" + k + "']"
            exec(st)

        if type(itx) == int:
            itx = [itx]
        if type(irx) == int:
            irx = [irx]

        if fig == []:
            fig = plt.gcf()
        if ax == []:
            ax = fig.gca()

        #self.L.display['scaled']=False
        fig, ax = self.L.showG('s', fig=fig, ax=ax, aw=aw)
        #
        if furniture:
            if 'lfur' in self.L.__dict__:
                for fur in self.L.lfur:
                    if fur.Matname == 'METAL':
                        fur.show(fig, ax)
            else:
                print "Warning : no furniture file loaded"

        if irx[0] == -1:
            ax.scatter(self.rx.position[0, :],
                       self.rx.position[1, :],
                       c='b',
                       s=s,
                       alpha=0.5)
            #ax.scatter(self.rx.position[0,0],self.rx.position[0,1],c='k',s=s,linewidth=0)
            #ax.scatter(self.rx.position[1,0],self.rx.position[1,1],c='b',s=s,linewidth=0)
            #ax.scatter(self.rx.position[2,0],self.rx.position[2,1],c='g',s=s,linewidth=0)
            #ax.scatter(self.rx.position[3,0],self.rx.position[3,1],c='c',s=s,linewidth=0)
        else:
            for k in irx:
                ax.scatter(self.rx.position[0, k - 1],
                           self.rx.position[1, k - 1],
                           c='b',
                           s=s,
                           alpha=0.5)
                if num:
                    ax.text(self.rx.position[0, k - 1],
                            self.rx.position[1, k - 1],
                            str(k),
                            color='blue')

        if itx[0] == -1:
            ax.scatter(self.tx.position[0, :],
                       self.tx.position[1, :],
                       c='r',
                       s=s)
        else:
            if traj:
                cpt = 1
            for k in itx:
                ax.scatter(self.tx.position[0, k - 1],
                           self.tx.position[1, k - 1],
                           c=c,
                           s=s,
                           linewidth=0)
                if num:
                    if traj:
                        ax.text(self.tx.position[0, k - 1],
                                self.tx.position[1, k - 1],
                                str(cpt),
                                color='black')
                        cpt = cpt + 1
                    else:
                        ax.text(self.tx.position[0, k - 1],
                                self.tx.position[1, k - 1],
                                str(k),
                                color='black')

        return (fig, ax)
        #for k in range(self.tx.N):
        #    ax.text(self.tx.position[0,k],self.tx.position[1,k],str(k+1),color='black')
        #    ax.scatter(self.tx.position[0,:],self.tx.position[0,:],

        #for k in range(self.rx.N):
        #   ax.text(self.rx.position[0,k],self.rx.position[1,k],str(k),color='black')

    def PL(self, itx):
        """ plot Path Loss

        itx
        """
        td = []
        tEa = []
        tEo = []
        for irx in self.dcir[itx].keys():
            d = self.delay(itx, irx) * 0.3
            cira, ciro = self.loadcir(itx, irx)

            td.append(d)
            tEa.append(Ea)
            tEo.append(Eo)

        plt.semilogx(td, 10 * np.log10(tEa), 'xr')
        plt.semilogx(td, 10 * np.log10(tEo), 'xb')
        plt.show()
        return td, tEa, tEo

    def eval(self, **kwrgs):
        """
        """
        for kt in range(Nb_tx):
            tx = np.array([
                self.tx.position[0, kt + 1], self.tx.position[1, kt + 1],
                self.tx.position[2, kt + 1]
            ])
            link.a = tx
            for kr in range(Nb_Run):
                rx = np.array([
                    S.rx.position[0, Run], S.rx.position[1, Run],
                    S.rx.position[2, Run]
                ])
                link.b = rx
                tic = time.clock()
                ak, tk = link.eval(verbose=False, diffraction=True)
                toc = time.clock()
                ciro = link.H.applywav(wav.sfg)
                cir = bs.TUsignal(ciro.x, np.squeeze(np.sum(ciro.y, axis=0)))
                tac = time.clock()
                tcir[Run] = cir
                print toc - tic, tac - toc

    def evalcir(self, cutoff=4, algo='new'):
        """
        Parameters
        ----------

        S
        tx
        rx
        wav
        cutoff

        """

        crxp = -1
        ctxp = -1
        tcir = {}
        tx = self.tx.position
        Ntx = len(tx[0])
        rx = self.rx.position
        Nrx = len(rx[0])

        #for kt in range(1,Ntx-1):
        #print kt+1
        kt = 0
        tcir[kt] = {}
        t = np.array([
            self.tx.position[0, kt], self.tx.position[1, kt],
            self.tx.position[2, kt]
        ])
        for kr in range(Nrx):
            if (np.mod(kr, 10) == 0):
                print kr + 1
            r = np.array([
                self.rx.position[0, kr], self.rx.position[1, kr],
                self.rx.position[2, kr]
            ])
            ctx = self.L.pt2cy(t)
            crx = self.L.pt2cy(r)
            if (ctx <> ctxp) | (crx <> crxp):
                Si = signature.Signatures(self.L, ctx, crx)
                ctxp = ctx
                crxp = crx
                Si.run4(cutoff=cutoff, algo=algo)
            r2d = Si.rays(t, r)
            #r2d.show(S.L)

            r3d = r2d.to3D(self.L)
            r3d.locbas(self.L)
            r3d.fillinter(self.L)
            Ct = r3d.eval(self.fGHz)
            sca = Ct.prop2tran(self.tx.A, self.rx.A)
            cir = sca.applywavB(self.wav.sfg)
            tcir[kt][kr] = cir
        return (tcir)

    def loadcir(self, itx, irx):
        """

        Parameters
        ----------

        itx : Tx index
        irx : Rx index

        Returns
        -------

        cir(itx,irx)
        """
        _filecir = self.dcir[itx][irx] + '.mat'
        ext = str(itx)
        if len(ext) == 1:
            ext = '00' + ext
        if len(ext) == 2:
            ext = '0' + ext

        filecir = pyu.getlong(_filecir, pstruc['DIRCIR'] + '/Tx' + ext)
        D = spio.loadmat(filecir)

        kxa = 'ta' + str(irx)
        kya = 'cira' + str(irx)

        kxo = 'to' + str(irx)
        kyo = 'ciro' + str(irx)

        cira = bs.TUsignal(D[kxa], D[kya][:, 0])
        ciro = bs.TUsignal(D[kxo], D[kyo][:, 0])

        return (cira, ciro)

    def pltcir(self,
               itx=1,
               irx=1,
               mode='linear',
               noise=False,
               color='b',
               format='a',
               fig=[],
               ax=[]):
        """ plot Channel Impulse Response

        Parameters
        ----------

        itx : Tx index
        irx : Rx index
        mode : str
            {'linear','dB'}
            noise : boolean
        color : string
            default 'b'

        >>> from pylayers.simul.simulem import *
        >>> S = Simul()
        >>> S.load('where2.ini')
        >>> S.run(1,1)
        >>> S.pltcir(1,1,mode='linear',noise=False,color='k')

        """

        if fig == []:
            fig = plt.gcf()
        #if ax==[]:
        #    ax = fig.gca()

        _filecir = self.dcir[itx][irx] + '.mat'
        filecir = pyu.getlong(_filecir,
                              pstruc['DIRCIR'] + '/Tx' + str('%0.3d' % itx))
        D = spio.loadmat(filecir)
        ax = fig.add_subplot('211')

        fig, ax = self.show(itx, irx, fig=fig, ax=ax)
        ax = fig.add_subplot('212')
        if 'a' in format:
            kxa = 't'
            kya = 'cir'
            ta = D[kxa]
            Tobs = ta[-1] - ta[0]
            te = ta[1] - ta[0]
            if noise:
                na = bs.Noise(Tobs + te, 1. / te)
                naf = na.gating(4.493, 0.5)
            cira = bs.TUsignal(ta, D[kya][:, 0])

        if 'o' in format:
            kxo = 'to' + str(irx)
            kyo = 'ciro' + str(irx)
            to = D[kxo]
            Tobs = to[-1] - to[0]
            te = to[1] - to[0]
            if noise:
                no = bs.Noise(Tobs + te, 1. / te)
                nof = no.gating(4.493, 0.5)
            ciro = bs.TUsignal(to, D[kyo][:, 0])

        if mode == 'linear':
            #plt.plot(ta,naf.y,color='k',label='Noise')
            plt.plot(ta, D[kya], label='Rx ' + str(irx), color=color)
            plt.xlabel('Time (ns)')
            '''if noise:
                naf.plot(col='k')
            cira.plot(col=color)'''
        else:
            '''if noise:
                naf.plotdB(col='k')
            cira.plotdB()'''
            plt.plot(ta,
                     20 * np.log10(abs(D[kya])),
                     label='Rx ' + str(irx),
                     color=color)
            plt.xlabel('Time (ns)')


#        plt.legend()
        plt.show()
        #plt.savefig('Tx'+str(itx),format=pdf,dpi=300)

    def scatter(self,
                itx,
                irx,
                values,
                cmap=plt.cm.gray,
                s=30,
                spl=221,
                title='',
                vaxis=((-30, 10, 2, 18)),
                vmin=0,
                vmax=1,
                colbool=False,
                cblabel='dB'):
        """
            Parameters
            ----------

            itx
            irx
            values
            cmap
            s
            spl
            title
            vaxis
            vmin
            vmax
            colbool
            clabel

        """
        fig = plt.gcf()
        ax = fig.add_subplot(spl)
        xtx = self.tx.position[itx, 0]
        ytx = self.tx.position[itx, 1]
        xrx = self.rx.position[irx, 0]
        yrx = self.rx.position[irx, 1]
        self.L.display['title'] = title
        self.L.showGs(ax)
        for furk in siradel.siradel_furniture.keys():
            fur = siradel.siradel_furniture[furk]
            if fur.Matname == 'METAL':
                fur.show(fig, ax)

        #self.show(furniture=True)
        plt.axis(vaxis)
        b1 = ax.scatter(xtx,
                        ytx,
                        s=s,
                        c=values,
                        cmap=cmap,
                        linewidths=0,
                        vmin=vmin,
                        vmax=vmax)
        ax.scatter(xrx, yrx, s=30, c='b', linewidths=0)
        if colbool:
            cb = colorbar(b1)
            cb.set_label(cblabel, fontsize=14)
        return (b1)

    def info(self, itx=[], irx=[]):
        """ display simulation information

         Parameters
         ----------
         itx : Tx index
         irx : Rx index

        """
        print self.filesimul
        print '------------------------------------------'
        try:
            print "Layout Info : \n", self.L.info()
        except:
            print "provide a Layout in the simulation : S.L "
            print ">>> S.layout(filename.str) "
            print "or "
            print ">>> S.layout(filename.str2 "
            print "or "
            print ">>> S.layout(filename.str,filematini,filematini) "
            print "default files exists for filematini and fileslabini "

            return
        try:
            print "Tx Info :\n", self.tx.info()
        except:
            print "provide a tx in the simulation : S.tx "
            return
        try:
            print "Rx Info :\n", self.rx.info()
        except:
            print "provide a rx in the simulation : S.rx "
            return

            #    print "Tx : ",self.tx.points[itx]
            print "Rx : ", self.rx.points[itx]
            print "Delay (ns) :", self.delay(itx, irx)
            print "Distance (m) :", 0.3 / self.delay(itx, irx)
            print ""
            if itx in self.dlch.keys():
                print "-----"
                print "Launching "
                print "-----"
                print " ", self.dlch[itx]
            if irx in self.dtra[itx].keys():
                print "-----"
                print "Tracing "
                print "-----"
                print " ", self.dtra[itx][irx]
                gr = GrRay3D()
                gr.load(self.dtra[itx][irx], self.L)
                gr.info()
            if irx in self.dtud[itx].keys():
                print "-----"
                print "Tud parameters "
                print "-----"
                print " ", self.dtud[itx][irx]
                print " ", self.dtang[itx][irx]
                print " ", self.drang[itx][irx]
                gt = GrRay3D.GrRayTud()
                gt.load(self.dtud[itx][irx], self.dtang[itx][irx],
                        self.drang[itx][irx], self.sl)
            if irx in self.dtauk[itx].keys():
                print self.dtauk[itx][irx]
                print self.dfield[itx][irx]
                VC = self.VC(itx, irx)
            if irx in self.dcir[itx].keys():
                print self.dcir[itx][irx]

    def info2(self):
        for i, j in enumerate(self.__dict__.keys()):
            print j, ':', self.__dict__.values()[i]

    def filtray(self, itx, irx, tau0, tau1, col='b'):
        """ filter rays

        Parameters
        ----------
        itx :
        irx :
        tau0 :
        tau1 :
        col :

        Display ray and nstr
        """
        gr = GrRay3D()
        gr.load(self.dtra[itx][irx], self.L)
        self.L.display['Thin'] = True
        self.L.display['Node'] = False
        self.L.display['NodeNum'] = False
        self.L.display['EdgeNum'] = False
        plt.axis('scaled')
        #self.L.show(fig,ax,nodelist,seglist)
        self.L.showGs()
        delays = gr.delay()
        rayset = np.nonzero((delays >= tau0) & (delays <= tau1))[0]
        fig = plt.gcf()
        ax = fig.get_axes()[0]
        gr.show(ax, rayset, col=col, node=False)
        plt.title('Tx' + str(itx) + '-Rx' + str(irx) + ' : ' + str(tau0) +
                  ' < tau < ' + str(tau1))

    def showray(self, itx, irx, iray=np.array([]), fig=[], ax=[]):
        """ show layout and rays for a radio link

        Parameters
        ----------
        itx  : tx index
        irx  : rx index
        iray : list of rays to be displayed ndarray


        """

        #if ax==[]:
        #    fig = plt.figure()
        #    ax  = fig.add_subplot('111')

        gr = GrRay3D()
        gr.load(self.dtra[itx][irx], self.L)
        if len(iray == 1):
            ray = gr.ray3d[iray[0]]
            nstr = ray.nstr[1:-1]
            uneg = np.nonzero(nstr < 0)
            upos = np.nonzero((nstr > 0) & (nstr <= self.L.Ne))
            uceil = np.nonzero(nstr == self.L.Ne + 1)
            ufloor = np.nonzero(nstr == self.L.Ne + 2)
        #seglist  = nstr[upos[0]]-1
        #nodelist = -nstr[uneg[0]]-1
        #seglist2 = S.L.segpt(nodelist)
        self.L.display['Thin'] = True
        self.L.display['Node'] = False
        self.L.display['NodeNum'] = False
        self.L.display['EdgeNum'] = False
        #self.L.show(fig,ax)
        #print ray.nn
        #print len(ray.nstr)
        #print ray.nstr
        #print nodelist
        #print seglist
        #print seglist2
        #seglist = hstack((seglist,seglist2))
        self.L.display['Node'] = False
        self.L.display['Thin'] = False
        self.L.display['NodeNum'] = True
        self.L.display['EdgeNum'] = True
        plt.axis('scaled')
        #self.L.show(fig,ax,nodelist,seglist)
        fig, ax = self.L.showGs(show=False)
        gr.show(ax, iray, col='b', node=False)

        if len(iray) == 1:
            plt.title(str(nstr))
        else:
            plt.title('Tx' + str(itx) + '-Rx' + str(irx) + ' ' +
                      str(min(iray)) + ' ' + str(max(iray)))

    def show3l(self, itx, irx):
        """ geomview display of a specific link

        g = S.show3l(itx,irx)

        Parameters
        ----------
        itx
            transmitter index
        irx
            receiver index

        """
        filetra = self.dtra[itx][irx]
        gr = GrRay3D()
        gr.load(filetra, self.L)
        gr.show3()

        return (gr)

    def _show3(self, rays=[], newfig=False, **kwargs):
        """ display of the simulation configuration
            using Mayavi

        Parameters
        ----------

        rays: Ray3d object :
            display the rays of the simulation
        newfig : boolean (default : False)
        kwargs of Rays.show3()


        see also
        --------

        pylayers.gis.layout
        pylayers.antprop.antenna
        pylayers.antprop.rays

        """
        Atx = self.tx.A
        Arx = self.rx.A
        Ttx = self.tx.orientation
        Trx = self.rx.orientation
        ptx = self.tx.position
        prx = self.rx.position

        self.L._show3(newfig=False, opacity=0.7)
        Atx._show3(T=Ttx.reshape(3, 3),
                   po=ptx,
                   title=False,
                   colorbar=False,
                   newfig=False)
        Arx._show3(T=Trx.reshape(3, 3),
                   po=prx,
                   title=False,
                   colorbar=False,
                   newfig=False)
        if rays != []:
            rays._show3(**kwargs)

    def show3(self, rays=[], **kwargs):
        """ geomview display of the simulation configuration

        Parameters
        ----------

        centered : boolean
            center the scene if True
        bdis  : boolean
            display local basis

        """
        try:
            self.tx.save()
        except:
            print('tx set is no defined')
        try:
            self.rx.save()
        except:
            print('rx set is no defined')
        _filename = self.filesimul.replace('.ini', '.off')
        filename = pyu.getlong(_filename, pstruc['DIRGEOM'])
        fo = open(filename, "w")
        fo.write("LIST\n")
        try:
            sttx = "{<" + self.tx.filegeom + "}\n"
        except:
            sttx = "\n"
        try:
            strx = "{<" + self.rx.filegeom + "}\n"
        except:
            strx = "\n"
        try:
            stst = "{<" + self.L.filegeom + "}\n"
        except:
            stst = "\n"
        fo.write(sttx)
        fo.write(strx)
        fo.write(stst)
        fo.write("{</usr/share/geomview/geom/xyz.vect}\n")
        if rays != []:
            kwargs['bdis'] = False
            kwargs['L'] = self.L
            kwargs['centered'] = False
            fo.write("{<" + rays.show3(**kwargs) + "}")

        fo.close()

        command = "geomview -nopanel -b 1 1 1 " + filename + " 2>/dev/null &"
        os.system(command)

    def run(self, link, cirforce=True, verbose=False, cutoff=4):
        """ run the simulation for 1 tx and a set of rx

            Parameters
            ----------

            itx      : tx index
            srx      : list of rx index
            cirforce : boolean

            Warnings
            --------

            index point start with 1

            Example
            -------

            >>> from pylayers.simul.simulem import *
            >>> itx = 1
            >>> srx = [1,2,3]
            >>> S   = Simul()
            >>> S.load('where2.ini')
            >>> out = S.run(itx,srx)


        """

        # get file prefix
        dl = DLink(force=True, L=self.L, fGHz=self.fGHz, verbose=False)
        prefix = self.filesimul.replace('.ini', '')
        lsig = []
        self.chan = {}
        for k, il in enumerate(link):
            tx = self.tx.points[il[0]]
            rx = self.rx.points[il[1]]
            ctx = self.L.pt2cy(tx)
            crx = self.L.pt2cy(rx)
            _filecir = prefix + '-cir-' + str(k) + '-' + str(link) + '-' + str(
                (ctx, crx))
            D = {}
            D['Tx'] = tx
            D['Rx'] = rx

            dl.a = tx
            dl.b = rx
            ak, tauk = dl.eval(verbose=False, diffraction=True)
            self.chan[k] = dl
            #cira = dl.H.applywavB(self.wav.sf)
            #cira = dl.H.applywavB(self.wav.sfg)

            #D['t'] = cira.x
            #D['cir'] = cira.y

            #filename = pyu.getlong(_filecir, 'output')
            #spio.savemat(filename, D)

    def delay(self, itx, irx):
        """ calculate LOS link delay

            Parameters
            ----------

            itx
            irx

            Returns
            -------

            delay : float 
                delay in ns

        """
        tx = self.tx.points[itx]
        rx = self.rx.points[irx]
        df = tx - rx
        dist = np.sqrt(np.dot(df, df))
        return (dist / 0.3)
示例#45
0
class Coverage(object):
    """ Handle Layout Coverage

        Methods
        -------
        create grid()
            create a uniform grid for evaluating losses
        cover()
            run the coverage calculation
        showPower()
            display the map of received power
        showLoss()
            display the map of losses


        Attributes
        ----------
        All attributes are read from fileini ino the ini directory of the
        current project

        _fileini
            default coverage.ini

        L :  a Layout
        model : a pylayers.network.model object.
        nx    : number of point on x
        ny    : number of point on y
        tx    : transmitter position
        txpe  : transmitter power emmission level
        show  : boolean for automatic display power map

    """


    def __init__(self,_fileini='coverage.ini'):


        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini,pstruc['DIRSIMUL']))
        self.plm = dict(self.config.items('pl_model'))
        self.layoutopt = dict(self.config.items('layout'))
        self.gridopt = dict(self.config.items('grid'))
        self.txopt = dict(self.config.items('tx'))
        self.rxopt = dict(self.config.items('rx'))
        self.showopt = dict(self.config.items('show'))

        self.L = Layout(self.layoutopt['filename'])
        self.model = PLSmodel(f=eval(self.plm['fghz']),
                         rssnp=eval(self.plm['rssnp']),
                         d0=eval(self.plm['d0']),
                         sigrss=eval(self.plm['sigrss']))

        self.nx = eval(self.gridopt['nx'])
        self.ny = eval(self.gridopt['ny'])
        self.mode = eval(self.gridopt['full'])
        self.boundary = eval(self.gridopt['boundary'])
        # transitter section
        self.fGHz = eval(self.txopt['fghz'])
        self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        self.ptdbm = eval(self.txopt['ptdbm'])
        self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        self.rxsens = eval(self.rxopt['sensitivity'])
        kBoltzmann = 1.3806503e-23
        self.bandwidthmhz = eval(self.rxopt['bandwidthmhz'])
        self.temperaturek = eval(self.rxopt['temperaturek'])
        self.noisefactordb = eval(self.rxopt['noisefactordb'])

        
        Pn = (10**(self.noisefactordb/10.)+1)*kBoltzmann*self.temperaturek*self.bandwidthmhz*1e3
        self.pndbm = 10*np.log10(Pn)+60

        self.show = str2bool(self.showopt['show'])

        try:
            self.L.Gt.nodes()
        except:
            pass
        try:
            self.L.dumpr('t')
        except:
            self.L.buildGt()
            self.L.dumpw('t')

        self.creategrid(full=self.mode,boundary=self.boundary)

    def __repr__(self):
        st=''
        st= st+ 'tx :'+str(self.txopt) + '\n'
        st= st+ 'rx :'+str(self.rxopt) + '\n'

    def creategrid(self,full=True,boundary=[]):
        """ create a grid

        Parameters
        ----------
        full : boolean
            default (True) use all the layout area
        boundary : (xmin,ymin,xmax,ymax)
            if full is False the boundary is used

        """
        if full:
            mi=np.min(self.L.Gs.pos.values(),axis=0)+0.01
            ma=np.max(self.L.Gs.pos.values(),axis=0)-0.01
        else:
            mi = np.array([boundary[0],boundary[1]])
            ma = np.array([boundary[2],boundary[3]])

        x=np.linspace(mi[0],ma[0],self.nx)
        y=np.linspace(mi[1],ma[1],self.ny)
        self.grid=np.array((list(np.broadcast(*np.ix_(x, y)))))




    def cover(self):
        """ start the coverage calculation

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showPr()

        """
        self.Lwo,self.Lwp,self.Edo,self.Edp = Loss0_v2(self.L,self.grid,self.model.f,self.tx)
        self.freespace = PL(self.grid,self.model.f,self.tx)
        self.prdbmo = self.ptdbm - self.freespace - self.Lwo
        self.prdbmp = self.ptdbm - self.freespace - self.Lwp
        self.snro = self.prdbmo - self.pndbm
        self.snrp = self.prdbmp - self.pndbm


    def showEd(self,polarization='o'):
        """ show direct path excess of delay map

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showEdo()
        """

        fig=plt.figure()
        fig,ax=self.L.showGs(fig=fig)
        l=self.grid[0,0]
        r=self.grid[-1,0]
        b=self.grid[0,1]
        t=self.grid[-1,-1]
        if polarization=='o':
            cov=ax.imshow(self.Edo.reshape((self.nx,self.ny)).T,
                      extent=(l,r,b,t),
                      origin='lower')
            titre = "Map of LOS excess delay, polar orthogonal"
        if polarization=='p':
            cov=ax.imshow(self.Edp.reshape((self.nx,self.ny)).T,
                      extent=(l,r,b,t),
                      origin='lower')
            titre = "Map of LOS excess delay, polar parallel"

        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
        ax.set_title(titre)

        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        clb = fig.colorbar(cov,cax)
        clb.set_label('excess delay (ns)')
        if self.show:
            plt.show()


    def showPower(self,rxsens=True,nfl=True,polarization='o'):
        """ show the map of received power

        Parameters
        ----------

        rxsens : bool
              clip the map with rx sensitivity set in self.rxsens
        nfl : bool
              clip the map with noise floor set in self.pndbm
        polarization : string
            'o'|'p'

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showPower()

        """

        fig=plt.figure()
        fig,ax=self.L.showGs(fig=fig)
        l=self.grid[0,0]
        r=self.grid[-1,0]
        b=self.grid[0,1]
        t=self.grid[-1,-1]

        if polarization=='o':
            prdbm=self.prdbmo
        if polarization=='p':
            prdbm=self.prdbmp

#        tCM = plt.cm.get_cmap('jet')
#        tCM._init()
#        alphas = np.abs(np.linspace(.0,1.0, tCM.N))
#        tCM._lut[:-3,-1] = alphas
        title='Map of received power - Pt = '+str(self.ptdbm)+' dBm'

        cdict = {
        'red'  :  ((0., 0.5, 0.5), (1., 1., 1.)),
        'green':  ((0., 0.5, 0.5), (1., 1., 1.)),
        'blue' :  ((0., 0.5, 0.5), (1., 1., 1.))
        }
        #generate the colormap with 1024 interpolated values
        my_cmap = m.colors.LinearSegmentedColormap('my_colormap', cdict, 1024)



        if rxsens :

            ### values between the rx sensitivity and noise floor
            mcPrf = np.ma.masked_where((prdbm > self.rxsens) 
                                     & (prdbm < self.pndbm),prdbm)
            cov1 = ax.imshow(mcPrf.reshape((self.nx,self.ny)).T,
                             extent=(l,r,b,t),cmap = my_cmap,
                             vmin=self.rxsens,origin='lower')

            ### values above the sensitivity
            mcPrs = np.ma.masked_where(prdbm < self.rxsens,prdbm)
            cov = ax.imshow(mcPrs.reshape((self.nx,self.ny)).T,
                            extent=(l,r,b,t),
                            cmap = 'jet',
                            vmin=self.rxsens,origin='lower')
            title=title + '\n gray : Pr (dBm) < %.2f' % self.rxsens + ' dBm'

        else :
            cov=ax.imshow(prdbm.reshape((self.nx,self.ny)).T,
                          extent=(l,r,b,t),
                          cmap = 'jet',
                          vmin=self.pndbm,origin='lower')

        if nfl:
            ### values under the noise floor 
            ### we first clip the value below he noise floor
            cl = np.nonzero(prdbm<=self.pndbm)
            cPr = prdbm
            cPr[cl] = self.pndbm
            mcPruf = np.ma.masked_where(cPr > self.pndbm,cPr)
            cov2 = ax.imshow(mcPruf.reshape((self.nx,self.ny)).T,
                             extent=(l,r,b,t),cmap = 'binary',
                             vmax=self.pndbm,origin='lower')
            title=title + '\n white : Pr (dBm) < %.2f' % self.pndbm + ' dBm'


        ax.scatter(self.tx[0],self.tx[1],s=10,linewidth=0)

        ax.set_title(title)
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        clb = fig.colorbar(cov,cax)
        clb.set_label('Power (dBm)')
        if self.show:
            plt.show()


    def showTransistionRegion(self,polarization='o'):
        """
        Notes
        -----
        See  : Analyzing the Transitional Region in Low Power Wireless Links
                  Marco Zuniga and Bhaskar Krishnamachari

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showTransitionRegion()

        """
        frameLength = self.framelengthbytes
        PndBm = self.pndbm
        gammaU = 10*np.log10(-1.28*np.log(2*(1-0.9**(1./(8*frameLength)))))
        gammaL = 10*np.log10(-1.28*np.log(2*(1-0.1**(1./(8*frameLength)))))
        PrU = PndBm + gammaU
        PrL = PndBm + gammaL

        fig=plt.figure()
        fig,ax = self.L.showGs(fig=fig)
        l = self.grid[0,0]
        r = self.grid[-1,0]
        b = self.grid[0,1]
        t = self.grid[-1,-1]

        if polarization=='o':
            prdbm=self.prdbmo
        if polarization=='p':
            prdbm=self.prdbmp

        zones = np.zeros(len(prdbm))
        uconnected  = np.nonzero(prdbm>PrU)[0]
        utransition = np.nonzero((prdbm < PrU)&(prdbm > PrL))[0]
        udisconnected = np.nonzero(prdbm < PrL)[0]

        zones[uconnected] = 1
        zones[utransition] = (prdbm[utransition]-PrL)/(PrU-PrL)
        cov = ax.imshow(zones.reshape((self.nx,self.ny)).T,
                             extent=(l,r,b,t),cmap = 'BuGn',origin='lower')

        title='PDR region'
        ax.scatter(self.tx[0],self.tx[1],linewidth=0)

        ax.set_title(title)
        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        fig.colorbar(cov,cax)
        if self.show:
            plt.show()

    def showLoss(self,polarization='o'):
        """ show losses map

        Parameters
        ----------
        polarization : string 
            'o'|'p'|'both'

        Examples
        --------
        .. plot::
            :include-source:

            >>> from pylayers.antprop.coverage import *
            >>> C = Coverage()
            >>> C.cover()
            >>> C.showLoss(polarization='o')
            >>> C.showLoss(polarization='p')
        """
        fig = plt.figure()
        fig,ax=self.L.showGs(fig=fig)
        l=self.grid[0,0]
        r=self.grid[-1,0]
        b=self.grid[0,1]
        t=self.grid[-1,-1]

        if polarization=='o':
            cov = ax.imshow(self.Lwo.reshape((self.nx,self.ny)).T,
                            extent=(l,r,b,t),
                            origin='lower')
            title = ('Map of losses, orthogonal (V) polarization') 
        if polarization=='p':
            cov = ax.imshow(self.Lwp.reshape((self.nx,self.ny)).T,
                            extent=(l,r,b,t),
                            origin='lower')
            title = ('Map of losses, parallel (H) polarization') 

        ax.scatter(self.tx[0],self.tx[1],linewidth=0)
        ax.set_title(title)

        divider = make_axes_locatable(ax)
        cax = divider.append_axes("right", size="5%", pad=0.05)
        fig.colorbar(cov,cax)

        if self.show:
            plt.show()
示例#46
0
    def __init__(self, _fileini="coverage.ini"):
        """ object constructor

        Parameters
        ----------

        _fileini : string
            name of the configuration file

        Notes
        -----

        Coverage is described in an ini file.
        Default file is coverage.ini and is placed in the ini directory of the current project.

        """

        self.config = ConfigParser.ConfigParser()
        self.config.read(pyu.getlong(_fileini, pstruc["DIRSIMUL"]))

        self.layoutopt = dict(self.config.items("layout"))
        self.gridopt = dict(self.config.items("grid"))
        self.apopt = dict(self.config.items("ap"))
        self.rxopt = dict(self.config.items("rx"))
        self.showopt = dict(self.config.items("show"))

        # get the Layout
        self.L = Layout(self.layoutopt["filename"])

        # get the receiving grid
        self.nx = eval(self.gridopt["nx"])
        self.ny = eval(self.gridopt["ny"])
        self.mode = self.gridopt["mode"]
        self.boundary = eval(self.gridopt["boundary"])
        self.filespa = self.gridopt["file"]

        #
        # create grid
        #
        self.creategrid(mode=self.mode, boundary=self.boundary, _fileini=self.filespa)

        self.dap = {}
        for k in self.apopt:
            kwargs = eval(self.apopt[k])
            ap = std.AP(**kwargs)
            self.dap[eval(k)] = ap

        self.fGHz = np.array([])
        # self.fGHz = eval(self.txopt['fghz'])
        # self.tx = np.array((eval(self.txopt['x']),eval(self.txopt['y'])))
        # self.ptdbm = eval(self.txopt['ptdbm'])
        # self.framelengthbytes = eval(self.txopt['framelengthbytes'])

        # receiver section
        # self.rxsens = eval(self.rxopt['sensitivity'])

        self.temperaturek = eval(self.rxopt["temperaturek"])
        self.noisefactordb = eval(self.rxopt["noisefactordb"])

        # show section
        self.bshow = str2bool(self.showopt["show"])

        try:
            self.L.Gt.nodes()
        except:
            pass
        try:
            self.L.dumpr()
        except:
            self.L.build()
            self.L.dumpw()
示例#47
0
r"""
===========================================
8 Random Layout 
===========================================

This example display randomly N layout from 
the set of all available Layout file

The file extension is .lay

"""
from pylayers.gis.layout import Layout
import matplotlib.pyplot as plt 
import random
import warnings

warnings.filterwarnings("error")
L = Layout()
lL = L.ls()
N = 8
for tL in random.sample(lL,N):
    if 'Munich' not in tL:
        L = Layout(tL,bbuild=0,bgraphs=0)
        f,a = L.showG('s')
        plt.title(tL,fontsize=32)
        plt.show()
示例#48
0
class Simul(SimulationRT):  # Sympy 2
    """

    Attributes
    ----------

    config  : config parser instance
    sim_opt : dictionary of configuration option for simulation
    ag_opt : dictionary of configuration option for agent
    lay_opt : dictionary of  configuration option for layout
    meca_opt : dictionary of  configuration option for mecanic
    net_opt : dictionary of  configuration option for network
    loc_opt : dictionary of  configuration option for localization
    save_opt : dictionary of  configuration option for save
    sql_opt : dictionary of  configuration option for sql


    Parameters
    ----------

    self.lAg  : list of Agent(Object)
        list of agents involved in simulation
    self.L : Layout
        Layout used in simulation

    Note
    ----

    All the previous dictionnary are obtained from the chosen simulnet.ini file
    in the project directory

    """
    def __init__(self):

        SimulationRT.__init__(self)  # Sympy 2
        # sympy.RealtimeEnvironment.__init__(self)  #simpy 3
        self.initialize()

        self.config = ConfigParser.ConfigParser()
        filename = pyu.getlong('simulnet.ini', pstruc['DIRSIMUL'])

        self.config.read(filename)
        self.sim_opt = dict(self.config.items('Simulation'))
        self.lay_opt = dict(self.config.items('Layout'))
        self.meca_opt = dict(self.config.items('Mechanics'))
        self.net_opt = dict(self.config.items('Network'))
        self.loc_opt = dict(self.config.items('Localization'))
        self.save_opt = dict(self.config.items('Save'))
        self.sql_opt = dict(self.config.items('Mysql'))
        self.seed = eval(self.sim_opt['seed'])

        self.traj = Trajectories()

        self.verbose = str2bool(self.sim_opt['verbose'])
        if str2bool(self.net_opt['ipython_nb_show']):
            self.verbose = False
        self.roomlist = []

        self.finish = False
        self.create()

    def __repr__(self):

        s = 'Simulation information' + '\n----------------------'
        s = s + '\nLayout: ' + self.lay_opt['filename']
        s = s + '\nSimulation duration: ' + str(self.sim_opt['duration'])
        s = s + '\nRandom seed: ' + str(self.sim_opt['seed'])
        s = s + '\nSave simulation: ' + self.save_opt['savep']

        s = s + '\n\nUpdate times' + '\n-------------'
        s = s + '\nMechanical update: ' + \
            str(self.meca_opt['mecanic_update_time'])
        s = s + '\nNetwork update: ' + str(self.net_opt['network_update_time'])
        s = s + '\nLocalization update: ' + self.net_opt['communication_mode']

        s = s + '\n\nAgents => self.lAg[i]' + '\n------'
        s = s + '\nNumber of agents :' + str(len(self.lAg))
        s = s + '\nAgents IDs: ' + \
            str([self.lAg[i].ID for i in range(len(self.lAg))])
        s = s + '\nAgents names: ' + \
            str([self.lAg[i].name for i in range(len(self.lAg))])
        s = s + '\nDestination of chosen agents: ' + \
            self.meca_opt['choose_destination']

        s = s + '\n\nNetwork' + '\n-------'
        s = s + '\nNodes per wstd: ' + str(self.net.wstd)

        s = s + '\n\nLocalization' + '\n------------'
        s = s + '\nLocalization enable: ' + self.loc_opt['localization']
        s = s + '\nPostion estimation methods: ' + self.loc_opt['method']

        return s

    def create_layout(self):
        """ create Layout in Simpy the_world thanks to Tk backend

        """

        _filename = self.lay_opt['filename']

        self.L = Layout(_filename)
        self.L.build()
        self.L.buildGr()
        self.L.buildGw()

        self.the_world = world()

        try:
            self.L.dumpr()
            print 'Layout graphs are loaded from ' + basename + '/struc/ini'
        except:
            #self.L.sl = sl
            # self.L.loadGr(G1)
            print 'This is the first time the layout file is used\
            Layout graphs are curently being built, it may take few minutes.'

            self.L.build()
            self.L.dumpw()

        #
        # Create Layout
        #
        walls = self.L.thwall(0, 0)
        for wall in walls:
            for ii in range(0, len(wall) - 1):
                self.the_world.add_wall(wall[ii], wall[ii + 1])

    def create_agent(self):
        """ create simulation's Agents

        ..todo:: change lAg list to a dictionnary ( modification in show.py too) 

        """

        self.lAg = []
        agents = []
        Cf = ConfigParser.ConfigParser()
        Cf.read(pyu.getlong('agent.ini', 'ini'))
        agents = eval(dict(Cf.items('used_agent'))['list'])
        for i, ag in enumerate(agents):
            ag_opt = dict(Cf.items(ag))
            self.lAg.append(
                Agent(ID=ag_opt['id'],
                      name=ag_opt['name'],
                      typ=ag_opt['typ'],
                      color=eval(ag_opt['color']),
                      pdshow=str2bool(self.meca_opt['pdshow']),
                      pos=np.array(eval(ag_opt['pos'])),
                      roomId=int(ag_opt['roomid']),
                      froom=eval(ag_opt['froom']),
                      meca_updt=float(self.meca_opt['mecanic_update_time']),
                      wait=float(ag_opt['wait']),
                      cdest=eval(self.meca_opt['choose_destination']),
                      loc=str2bool(self.loc_opt['localization']),
                      loc_updt=float(self.loc_opt['localization_update_time']),
                      loc_method=eval(self.loc_opt['method']),
                      L=self.L,
                      network=str2bool(self.net_opt['network']),
                      net=self.net,
                      epwr=dict([(eval(
                          (ag_opt['wstd']))[ep], eval((ag_opt['epwr']))[ep])
                                 for ep in range(len(eval((ag_opt['wstd']))))
                                 ]),
                      sens=dict([(eval(
                          (ag_opt['wstd']))[ep], eval(
                              (ag_opt['sensitivity']))[ep])
                                 for ep in range(len(eval((ag_opt['wstd']))))
                                 ]),
                      world=self.the_world,
                      wstd=eval(ag_opt['wstd']),
                      save=eval(self.save_opt['save']),
                      gcom=self.gcom,
                      comm_mode=eval(self.net_opt['communication_mode']),
                      sim=self,
                      seed=self.seed))

    def create_EMS(self):
        """ create electromagnetic Solver object

        """
        self.EMS = EMSolver(L=self.L)

    def create_network(self):
        """ create the whole network
        """

        self.net = Network(EMS=self.EMS)
        self.gcom = Gcom(net=self.net, sim=self)

        self.create_agent()
        # create network
        if str2bool(self.net_opt['network']):
            self.net.create()

            # create All Personnal networks
            for n in self.net.nodes():
                self.net.node[n]['PN']._get_wstd()
                self.net.node[n]['PN']._get_SubNet()
            self.gcom.create()

            # create Process Network
            self.Pnet = PNetwork(net=self.net,
                                 net_updt_time=float(
                                     self.net_opt['network_update_time']),
                                 L=self.L,
                                 sim=self,
                                 show_sg=str2bool(self.net_opt['show_sg']),
                                 disp_inf=str2bool(self.net_opt['dispinfo']),
                                 save=eval(self.save_opt['save']))
            self.activate(self.Pnet, self.Pnet.run(), 0.0)

    def create_visual(self):
        """ create visual Tk process
        """

        self.visu = Updater(interval=float(self.sim_opt['show_interval']),
                            sim=self)
        self.activate(self.visu, self.visu.execute(), 0.0)

    def create(self):
        """ create the simulation
            This method is called at the end of __init__

        """
        # this is to redump the database at each simulation
        if 'mysql' in self.save_opt['save']:
            if str2bool(self.sql_opt['dumpdb']):
                os.popen(
                    'mysql -u ' + self.sql_opt['user'] + ' -p ' +
                    self.sql_opt['dbname'] +
                    '< /private/staff/t/ot/niamiot/svn2/devel/simulator/pyray/SimWHERE2.sql'
                )

        # TODO remove the hard reference
        if 'txt' in self.save_opt['save']:
            pyu.writeDetails(self)
            if os.path.isfile(os.path.join(basename, 'output', 'Nodes.txt')):
                print 'would you like to erase previous txt files ?'
                A = raw_input()
                if A == 'y':
                    for f in os.listdir(os.path.join(basename, 'output')):
                        try:
                            fi, ext = f.split('.')
                            if ext == 'txt':
                                os.remove(os.path.join(basename, 'output' + f))
                        except:
                            pass

        # Layout
        self.create_layout()
        # Electro Magnetic Simulator
        self.create_EMS()
        # Network
        self.create_network()

        if str2bool(self.sim_opt['showtk']):
            self.create_visual()
        self.create_show()

        if str2bool(self.save_opt['savep']):
            self.save = Save(L=self.L, net=self.net, sim=self)
            self.activate(self.save, self.save.run(), 0.0)

    def create_show(self):
        """ create a vizualization
        """

        plt.ion()
        fig_net = 'network'
        fig_table = 'table'

        if str2bool(self.net_opt['show']):
            if str2bool(self.net_opt['ipython_nb_show']):
                notebook = True
            else:
                notebook = False
            self.sh = ShowNet(net=self.net,
                              L=self.L,
                              sim=self,
                              fname=fig_net,
                              notebook=notebook)
            self.activate(self.sh, self.sh.run(), 1.0)

        if str2bool(self.net_opt['show_table']):
            self.sht = ShowTable(net=self.net,
                                 lAg=self.lAg,
                                 sim=self,
                                 fname=fig_table)
            self.activate(self.sht, self.sht.run(), 1.0)

    def savepandas(self):
        """ save mechanics in pandas hdf5 format
        """
        filename = pyu.getlong(eval(self.sim_opt["filename"]),
                               pstruc['DIRNETSAVE'])
        layfile = self.L._filename.split('.')[0]
        store = pd.HDFStore(filename + '_' + layfile + '.h5', 'w')
        for a in self.lAg:

            if a.typ != 'ap':
                store.put(a.ID, a.meca.df.convert_objects())

            else:  # if agent acces point, its position is saved
                store.put(a.ID, a.posdf)

            store.get_storer(a.ID).attrs.typ = a.typ
            store.get_storer(a.ID).attrs.name = a.name
            store.get_storer(a.ID).attrs.ID = a.ID
            store.get_storer(a.ID).attrs.layout = self.L._filename
        # saving metadata
        store.root._v_attrs.attributes = self.sim_opt
        store.close()
        self.traj.loadh5(
            eval(self.sim_opt["filename"]) + '_' + layfile + '.h5')

    def runsimul(self):
        """ run simulation
        """

        if not self.finish:
            # random number seed
            seed(self.seed)
            self.simulate(until=float(self.sim_opt['duration']),
                          real_time=True,
                          rel_speed=float(self.sim_opt['speedratio']))

            self.the_world._boids = {}

            # if str2bool(self.save_opt['savep']):
            # print 'Processing save results, please wait'
            # self.save.mat_export()

            if str2bool(self.save_opt['savepd']):
                self.savepandas()
            self.finish = True
        else:
            raise NameError('Reinstantiate a new simul object to run again')
示例#49
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt

#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout()
lL = L.ls()
for tL in lL:
    print  'Layout :',tL
    try:
        L=Layout(tL)
        L.save()
    except:
        print 'Layout :',tL ,' problem'

#f = plt.figure(figsize=(20,10))
#plt.axis('off')
#f,a = L.showG('s',nodes=False,fig=f)
#plt.show()
#f,a = L.showG('r',edge_color='b',linewidth=4,fig=f)
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.buildGt()
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)
示例#50
0
from pylayers.gis.layout import Layout
import networkx as nx
import matplotlib.pyplot as plt 
import doctest 

plt.ion()
#doctest.testmod(layout)
#L = Layout('TA-Office.ini')
L = Layout('WHERE1.ini')
#L= Layout('11Dbibli.ini')
#L.show()
#L = Layout('PTIN.ini')
#L = Layout('DLR.ini')
#L.build()
L.dumpr()
L.showGi(en=11)
#Ga = L.buildGr()
#L.showGs()
#nx.draw(Ga,Ga.pos)