Dear Kamal,

You can find the code in Matlab. There are different type of this code.

However I didn't work with this model and I'm not sure the following one is good for you or not, but you can try by Matlab.

Best wishes,

Marziyeh.

Dear Kamal,

You can use Python to easily program epidemic models like SIR (Susceptible-Infected-Recovered). See for example the link attached, where you can find an implementation of the SIR model in Python.

http://computationallegalstudies.com/2009/10/11/programming-dynamic-models-in-python/

Hi Kamal,

I believe ​you must somehow got source code for SIR model. I too work on same problem "finding spreader on social network". It would be great if you could share me the source code and give me few hints about it.

###############################

import numpy as np

def SIR(g, N, beta, seed):

random.seed(seed)

sigma=dict()

for node_g in g.nodes():

print node_g

x=[]; l=0

for itrs in range(0, N):

l=percolation(g, beta, node_g)

x.append(l)

sigma[node_g]=round(np.mean(x), 4)

return(sigma)

###############################

Here, argument (1) g is the graph on which you want to perform SIR contagion spread, e.g., Zebra

(2) N is the number of iteration say 1000

(3) beta is rate of infection set just above the epidemic threshold.

(4) seed, fix this number say 2018 so that the sequence of random number generated can be repeated and simulation results become reproducible.

If you get some other source help me too.

Regards

Kushal Kanwar

PS: Any question is welcome.

what is the difference between the SIR model in single layer and multilayer network? it can be said that in a multilayer network, first the SIR value is calculated for each layer and then I get the average for all layer.

I'm not sure if it's relevant to what you're working on or not. Anyhow, I am this code i am using for any type of complex networks.

# -*- coding: utf-8 -*-

"""

Created on Thu Nov 03 20:42:45 2016

@author: Sarah

"""

import numpy as np

import random

from scipy import stats

from operator import itemgetter

def main():

readdata(sourcepath)

print("SIR model:...")

calImportance()

# for undricted network

def readdata(sourcepath):

data1 = open(sourcepath1,'w')

data = open(sourcepath,'r')

data.readline()

data.readline()

data.readline()

data.readline()

for line in data:

string = line.split("\t")

node1 = hashID(int(string[0]))

node2 = hashID(int(string[1]))

data1.write(str(node1)+'\t'+str(node2)+'\n')

linkinformation[node1].append(node2)

linkinformation[node2].append(node1) #directed

# clear multiple neighbor

for neighbor in range(len(linkinformation)):

linkinformation[neighbor] = list(set(linkinformation[neighbor]))

degrees[neighbor] = len(linkinformation[neighbor])

data.close()

data1.close()

print("data read over")

#used to map the uncontinunes node id to continues

def hashID(x):

global idx

if hash_map.has_key(x):

return hash_map.get(x)

else:

hash_map[x] = idx

idx += 1

return idx-1

def calImportance():

global values, degrees

filedata = open(targetpath, 'w')

for nodetest in range(N):

if nodetest%100 == 0:

print(nodetest)

value = 0.0

for rnum in range(100):

value = value + SIRSimulation(nodetest)

values[nodetest] = value/100

filedata.write(str(nodetest)+'\t'+str(len(linkinformation[nodetest]))+"\t"+str(value)+'\n')

filedata.close()

correlation = calKendalltau()

print(correlation)

def calKendalltau():

snum = 0

ninum = 0

for i in range(N-1):

for j in range(i+1,N):

if ((values[i]-values[j]) * (degrees[i]-degrees[j])) > 0:

snum += 1

if ((values[i]-values[j]) * (degrees[i]-degrees[j])) < 0:

ninum += 1

return float(2*(snum-ninum))/(N*(N-1))

def SIRSimulation(targetnode):

importance = 0

state = np.zeros(N) # 0 for susceptible; 1 for infective; -1 for recovery

state[targetnode] = 1

infectnodes = set()

infectnodes.add(targetnode)

infectnumber = 1

while infectnumber > 0: # only if existed infected nodes, the process should continues

node = infectnodes.pop()

state[node] = -1

importance += 1

infectnumber -= 1

# consider the current infective node used to infective its neighbors

neighbors = linkinformation[node]

neighbors_num = len(neighbors)

for nnum in range(neighbors_num):

if state[neighbors[nnum]] == 0:

p = random.uniform(0,1)

if p