add v0.1.3 to github.

Author: jschaul

CHANGES.txt

@@ -0,0 +1,8 @@
+
+v0.1.3, 26th February 2014 -- added project on github. No changes to the code.
+
+v0.1.3, 26th September 2011 -- added advanced documentation, which is now completed - source code remained the same. 
+v0.1.2, 29th August 2011 -- added more documentation, and a starting example, fixed some console output. 
+v0.1.1b,  29th August 2011 -- removed matplotlib from the install_requires package - please install matplotlib separately.
+v0.1.1, 28th August 2011 -- setup.py dependency bug fix.
+v0.1.0, 28th August 2011 -- Initial release after part-time development since October 2010. 

ComplexNetworkSim/__init__.py

@@ -0,0 +1,4 @@
+from agents import NetworkAgent
+from simulation import NetworkSimulation, Sim
+from plotting import PlotCreator
+from animation import AnimationCreator

ComplexNetworkSim/agents.py

@@ -0,0 +1,123 @@
+'''
+Module for the NetworkAgent class that can be subclassed by agents.
+
+@author: Joe Schaul <joe.schaul@gmail.com>
+'''
+
+from SimPy import Simulation as Sim
+import networkx as nx
+import random
+
+SEED = 123456789
+
+ADD_EDGE = "add edge"
+REMOVE_EDGE = "remove edge"
+ADD_NODE = "add node"
+REMOVE_NODE = "remove node"
+
+
+class NetworkAgent(Sim.Process):
+    '''NetworkAgent class that can be subclassed by agents. '''
+    
+    #class variables, shared between all instances of this class
+    r = random.Random(SEED)
+    TIMESTEP_DEFAULT = 1.0
+
+    def __init__(self, state, initialiser, stateVector=[], name='network_process', **stateParameters):
+        Sim.Process.__init__(self, name)
+        self.state = state
+        self.stateVector = stateVector
+        self.stateParameters = stateParameters
+        self.initialize(*initialiser)
+        
+        
+    def initialize(self, id, sim, globalTopo, globalParams):
+        ''' this gets called automatically '''        
+        self.id = id
+        self.sim = sim
+        self.globalTopology = globalTopo
+        self.globalSharedParameters = globalParams
+        
+    def getAllNodes(self):
+        return self.globalTopology.nodes()
+    
+    def getAllAgents(self, state=None):
+        neighs = self.getAllNodes()
+        if state is not None:
+            return [self.globalTopology.node[n]['agent'] for n in neighs 
+                      if self.globalTopology.node[n]['agent'].state == state]
+        else:
+            return [self.globalTopology.node[n]['agent'] for n in neighs]
+        
+        
+        
+    def getNeighbouringAgents(self, state=None):
+        ''' returns list of neighbours, but as agents, not nodes.
+        so e.g. one can set result[0].state = INFECTED '''
+        neighs = self.globalTopology.neighbors(self.id)
+        if state is not None:
+            return [self.globalTopology.node[n]['agent'] for n in neighs 
+                      if self.globalTopology.node[n]['agent'].state == state]
+        else:
+            return [self.globalTopology.node[n]['agent'] for n in neighs]
+        
+    def getNeighbouringAgentsIter(self, state=None):
+        '''same as getNeighbouringAgents, but returns generator expression, 
+        not list.
+        '''
+        neighs = self.globalTopology.neighbors(self.id)
+        if state is not None:
+            return (self.globalTopology.node[n]['agent'] for n in neighs 
+                      if self.globalTopology.node[n]['agent'].state == state)
+        else:
+            return (self.globalTopology.node[n]['agent'] for n in neighs)
+    
+    def getNeighbouringNodes(self):
+        ''' returns list of neighbours as nodes. 
+        Call self.getAgent() on one of them to get the agent.'''
+        return self.globalTopology.neighbors(self.id)
+    
+    def getAgent(self, id):
+        '''returns agent of specified ID.'''   
+        return self.globalTopology.node[id]['agent']
+        
+    def addNewNode(self, state):
+        #add & activate new agent
+        return self.sim.addNewNode(state) 
+        
+        #add a random edge
+        #u = NetworkAgent.r.choice(self.globalTopology.nodes())
+        #self.globalTopology.add_edge(u, id)
+        
+    def die(self):
+        self.removeNode(self.id)        
+        
+    def removeNode(self, id):
+#        cancel ? self.getAgent(id)
+        self.globalTopology.remove_node(id)
+        
+    def removeEdge(self, node1, node2):
+        
+        self.globalTopology.remove_edge(self.id, self.currentSupernodeID)
+        self.logTopoChange(REMOVE_EDGE, node1, node2)
+        
+        
+    def addEdge(self, node1, node2):        
+        self.globalTopology.add_edge(self.id, self.currentSupernodeID)
+        self.logTopoChange(ADD_EDGE, node1, node2)
+        
+        
+    def logTopoChange(self, action, node, node2=None):
+        #TODO: test, add this to netlogger...
+        print action, node, node2
+        
+        
+    
+    
+    
+    
+    
+    
+        
+        
+    

ComplexNetworkSim/animation.py

@@ -0,0 +1,86 @@
+'''
+Module for the generation of visualisations of processes over complex networks
+Generates PNG images for each timestep and (if ImageMagick is available) a gif animation file.
+
+@author: Joe Schaul <joe.schaul@gmail.com>
+'''
+
+import utils
+from matplotlib import pyplot
+import networkx as nx
+import os    
+#dependency: ImageMagick for gif creation. Works without too then only creates PNGs
+    
+class AnimationCreator(object):
+    
+    def __init__(self, dir, name, title, mapping, trial=0, delay=100):
+        self.name = name
+        self.dir = os.path.abspath(dir)
+        self.delay = delay
+        self.mapping = mapping
+        self.trial = trial
+        self.title = title
+        self.G = nx.Graph()
+    
+    def create_gif(self, verbose=True):
+        if verbose: print "Creating PNGs ...",
+        self.createPNGs()        
+        
+        input = os.path.join(self.dir, self.name + "*.png")
+        output = os.path.join(self.dir, self.name + ".gif")
+        
+        if verbose: print "attempting gif creation ...",
+        
+        failure = os.system("convert -delay %i -loop 0 \"%s\" \"%s\"" % (self.delay, input, output))
+        if failure:
+            print "Problem: Could not create gif. \nMaybe ImageMagick not installed correctly, or its 'convert' executable is not on your system path? \nPNG Image files are generated in any case." 
+        else:
+            print "success! \nAnimation at %s " % str(output)
+            
+            
+    def createPNGs(self):        
+        
+        states, topos, vector = utils.retrieveTrial(self.dir, self.trial)
+                     
+        init_topo = topos[0][1]
+        if topos[0][0] != 0:
+            print "problem - first topology not starting at 0!"
+        self.G = init_topo
+        self.layout = nx.layout.fruchterman_reingold_layout(self.G)
+        self.nodesToDraw = self.G.nodes()
+        self.edgesToDraw = self.G.edges()
+        self.nodesToDraw.sort()
+        self.edgesToDraw.sort()
+        i = 1 
+        j = 0
+        
+        
+        pyplot.figure()
+        for t, s in states:
+            
+            # start with initial topology, and check the topology tuples
+            # each time to make sure to have an up-to-date graph topology
+            if len(topos) > i and t == topos[i][0]:                
+                self.G = topos[i][1]
+                fixednodes = [node for node in self.nodesToDraw if node in self.G.nodes()]                
+                self.layout = nx.layout.fruchterman_reingold_layout(self.G, pos=self.layout, fixed=fixednodes)
+                i += 1
+                
+            #convert states to colours and draw a figure
+            colours = utils.states_to_colourString(s, self.mapping)            
+            pyplot.clf()
+            self.nodesToDraw = self.G.nodes()
+            self.nodesToDraw.sort()
+            self.edgesToDraw = self.G.edges()
+            self.edgesToDraw.sort()
+        
+            nx.draw_networkx_nodes(self.G, nodelist=self.nodesToDraw, pos=self.layout, node_color=colours, with_labels=False)
+            nx.draw_networkx_edges(self.G, edgelist=self.edgesToDraw, pos=self.layout, with_labels=False)
+            
+            pyplot.suptitle("%s\ntime = %i" % (self.title, t))
+            pyplot.axis('off')
+            
+            pyplot.savefig(os.path.join(self.dir, self.name + "%02d.png" % j))
+            j += 1
+            
+            

ComplexNetworkSim/customexceptions.py

@@ -0,0 +1,20 @@
+'''
+Custom exceptions when handling files to be more precise about the error
+that occurred. 
+
+@author: Joe Schaul <joe.schaul@gmail.com>
+'''
+
+class LogOpeningError(Exception):   
+    """Error happening when trying to open multiple simulation logs"""
+    
+    
+    def __init__(self, value, logs):
+        self.value = value
+        self.logs = logs
+        
+    def __str__(self):
+        return repr(self.value)
+    
+    
+        

ComplexNetworkSim/logging.py

@@ -0,0 +1,55 @@
+'''
+Special agent automatically initialised by the simulation that logs network
+states and topologies at every defined timestep.
+
+@author: Joe Schaul <joe.schaul@gmail.com>
+'''
+
+import networkx as nx
+from SimPy import Simulation as Sim
+
+import utils
+
+class NetworkLogger(Sim.Process):
+        
+    def __init__(self, sim, directory, logging_interval):
+        Sim.Process.__init__(self, sim=sim)
+        self.sim = sim
+        self.directory = directory
+        self.interval = logging_interval
+        self.stateTuples = []
+        self.stateVectorTuples = []
+        self.topology = nx.Graph()
+        self.topoTuples = []  
+        
+    def Run(self):
+        while True:
+            self.logCurrentState()
+            yield Sim.hold, self, self.interval
+            
+    def logCurrentState(self):
+        
+        nodes = self.sim.G.nodes(data=True)
+        states = [node[1]['agent'].state for node in nodes]
+        stateVectors = [node[1]['agent'].stateVector for node in nodes]
+        
+        #log states
+        self.stateTuples.append((self.sim.now(), states))
+        self.stateVectorTuples.append((self.sim.now(), stateVectors))
+
+        #log new topology if it changed.
+        if not nx.fast_could_be_isomorphic(self.topology, nx.Graph(self.sim.G)):
+            self.topology = utils.create_copy_without_data(self.sim.G)
+            self.topoTuples.append((self.sim.now(), self.topology))
+            
+
+    def logTrialToFiles(self, id): 
+        if not self.topoTuples:
+            self.topoTuples.append((0, self.topology))
+        #write states, topologies, and state vectors to file       
+        utils.logAllToFile(self.stateTuples, self.topoTuples, 
+                           self.stateVectorTuples, self.directory, id)
+        
+        
+        
+        

ComplexNetworkSim/plotting.py

@@ -0,0 +1,66 @@
+'''
+Module for the generation of plots of system states.
+
+@author: Joe Schaul <joe.schaul@gmail.com>
+'''
+
+import utils
+import statistics
+import os
+
+
+from matplotlib import pyplot
+
+class PlotCreator(object):
+    '''Constructor - set examples=1 to get plot lines of first trial as well as the average'''
+    def __init__(self, directory, name, title, statesToMonitor, colours, labels, examples=0):
+        self.directory = os.path.abspath(directory)
+        self.name = name
+        self.statesToMonitor = statesToMonitor
+        self.colours = colours
+        self.labels = labels
+        self.examples = examples
+        self.title = title        
+    
+    def plotSimulation(self, ret=False, show=False, verbose=True):
+        '''plots a simulation, time on x axis, nodes on y.
+        Set ret=True for return of lines and no image creation. '''
+        
+        states, topologies, vectors = utils.retrieveAllTrialsInDirectory(self.directory)
+        stats = statistics.TrialStats(states, topologies)
+        av = stats.trialAverage
+        
+        pyplot.figure()
+        lines = []        
+        for i in range(len(self.statesToMonitor)):
+            if self.examples > 0:
+                t0 = stats.trialstates[0]
+                pyplot.plot(t0.times, t0.stateCounterForStateX[self.statesToMonitor[i]], "k", alpha=0.5)
+            
+            try:
+                pyplot.plot(av.times, av.stateCounterForStateX[self.statesToMonitor[i]], self.colours[i], label=self.labels[i])
+                lines.append((av.times, av.stateCounterForStateX[self.statesToMonitor[i]], self.colours[i]))
+            except KeyError:
+                try:
+                    print "Plotting warning: skipping state = %s, colour = %s, label = %s, %s" \
+                            % (str(self.statesToMonitor[i]), str(self.colours[i]), str(self.labels[i]), 
+                               "because no node is ever in this state in this trial")
+                except KeyError:
+                    print "Plotting error: one of 'colours' or 'labels' has fewer elements",
+                    " than 'statesToMonitor'. Skipping this state."
+            
+        pyplot.legend(loc=0)
+        pyplot.title(self.title)
+        pyplot.xlabel("Time")
+        pyplot.ylabel("Nodes")
+        if ret:
+            return lines
+        else:        
+            output_path = os.path.join(self.directory, "plot_" + self.name + ".png")
+            pyplot.savefig(output_path)
+            if verbose: 
+                print "Plot at", output_path
+            
+            if show:
+                pyplot.show()
+