Example #1
0
    def neighbors(self):
        """Return neighbor agents within the communication range."""
        cache = self.scheduler.zone_cache
        if not cache:
            die("update_zone() must have been called for zone caching.")

        p = self.mobility.current
        i, j = self.zone()
        neighbors = []
        # check nine zones including/surrounding the current one
        for dj in [-1, 0, 1]:
            if j + dj < 0:
                continue
            for di in [-1, 0, 1]:
                if i + di < 0:
                    continue
                if not cache.get(j + dj, None):
                    continue
                if not cache[j + dj].get(i + di, None):
                    continue
                for agent in self.scheduler.zone_cache[j + dj][i + di]:
                    if agent == self:
                        continue
                    q = agent.mobility.current
                    if abs(p[0] - q[0]) > self.range_:
                        continue
                    if abs(p[1] - q[1]) > self.range_:
                        continue
                    if math.sqrt((p[0] - q[0])**2 +
                                 (p[1] - q[1])**2) > self.range_:
                        continue
                    neighbors.append(agent)
        return neighbors
Example #2
0
    def create_random_graph(self, N=10, E=20, no_multiedge=False):
        if E < N:
            die('Too small number of edges')

        for v in range(1, N + 1):
            self.add_vertices(v)

        # add first (N - 1) edges for making sure connectivity
        for i in range(1, N):
            u = i + 1
            v = random.randrange(1, u)
            if random.uniform(0, 1) >= 0.5:
                self.add_edge(u, v)
            else:
                self.add_edge(v, u)

        # randomly add remaining (E - (N - 1)) edges
        for i in range(1, E - (N - 1) + 1):
            # FIXME: avoid cycle edges, but this may take log time
            ntries = 1
            while ntries < MAX_RETRIES:
                u = random.randrange(1, N + 1)
                v = random.randrange(1, N + 1)
                if not no_multiedge and u != v:
                    break
                if no_multiedge and u != v and not self.has_edge(u, v):
                    break
            self.add_edge(u, v)
        return self
Example #3
0
 def __init__(self, scheduler=None):
     if scheduler is None:
         die("Scheduler class must be specified.")
     self.scheduler = scheduler
     self.tx_total = 0
     self.rx_total = 0
     self.dup_total = 0
     self.uniq_total = 0
     self.delivered_total = 0
     self.uniq_delivered_total = 0
Example #4
0
 def __init__(self, path=None, *args, **kwargs):
     super().__init__(*args, **kwargs)
     if not path:
         die("Underlying path class must be specified.")
     if not path.graph:
         die("Path class doesn't return a valid graph via path.graph.")
     self.path = path
     self.current_edge = None
     self.current_offset = None
     self.wait = True
     # choose a random point on a graph
     self.move_to_point(*self.random_point())
Example #5
0
    def __init__(self,
                 id_=None,
                 scheduler=None,
                 mobility=None,
                 monitor=None,
                 range_=50):
        if id_ is None:
            id_ = len(scheduler.agents) + 1
        if not scheduler:
            die("Scheduler class must be specified.")
        if not mobility:
            die("Mobility class must be specified.")
        if not monitor:
            die("Monitor class must be specified.")
        if range_ > MAX_RANGE:
            die(f"range cannot exceed MAX_RANGE ({MAX_RANGE})")
        self.id_ = id_
        self.scheduler = scheduler
        self.mobility = mobility
        self.monitor = monitor
        self.range_ = range_

        self.last_neighbors = []
        self.received = defaultdict(int)
        self.receive_queue = defaultdict(int)
        self.delivered = defaultdict(int)
        self.tx_count = 0
        self.rx_count = 0
        self.dup_count = 0

        self.scheduler.add_agent(self)
Example #6
0
 def usage():
     prog = os.path.basename(sys.argv[0])
     die(f"""
 usage: {prog} [-v] [-s #] [-n #] [-r range] [-I id[,id]...] [-m mobility] [-p path] [-a agent] [-M monitor]
   -v            verbose mode
   -s #          seed of random number generator
   -n #          number of agents
   -r range      communication range [m]
   -I id[,id...] initial infected nodes
   -m mobility   name of mobility class (Fixed/FullMixed/LevyWalk/LimitedRandomWaypoint/RandomWalk/RandomWaypoint/graph.Fixed/graph.Sequential/graph.RandomWalk/grpah.CRWP)
   -p path       name of path class (NONE/Line/Grid/Voronoi)
   -a agent      name of agent class (CarryOnly/Random/Epidemic/P_BCAST/SA_BCAST/HP_BCAST/ProPHET)
   -M monitor    name of monitor class (Null/Log/Cell)
 """)
Example #7
0
 def __init__(self,
              id_=None,
              scheduler=None,
              mobility=None,
              monitor=None,
              pydtnsim=None,
              range_=50):
     super().__init__(
         id_=id_,
         scheduler=scheduler,
         mobility=mobility,
         monitor=monitor,
         range_=range_)
     if not pydtnsim:
         die("class pydtnsim is must be specified.")
     self.pydtnsim=pydtnsim
Example #8
0
 def import_dot(self, lines):
     buf = ''
     for line in lines:
         # remove C++-style comment
         pos = line.find('//')
         if pos >= 0:
             line = line[pos:]
         line = line.strip()
         buf += line
     # remove C-style comment
     buf = re.sub(r'/\*.*?\*/', '', buf)
     m = re.search(r'graph\s+(\S+)\s*{(.*)}', buf)
     if not m:
         die('Invalid graph format (missing dot graph header)')
     body = m.group(2)
     return self._import_dot_body(body)
Example #9
0
 def export_graph(self, fmt, *args):
     name = EXPORT_SUBP.get(fmt, None)
     method = getattr(self, name, None)
     if not name or not method:
         die(f"No export support for graph format `{fmt}'")
     return method(*args)
Example #10
0
 def expect_multiedged(self):
     if not self.multiedged():
         die('multiedged graph expected')
Example #11
0
 def expect_directed(self):
     if not self.directed():
         die('directed graph expected')
Example #12
0
 def expect_undirected(self):
     if not self.undirected():
         die('undirected graph expected')