def save_graph(graph, n, p):
#initialze Figure
plt.figure(num=None, figsize=(20, 20), dpi=80)
plt.axis('off')
fig = plt.figure(figsize=(50, 40))
pos = nx.circular_layout(graph)
nx.draw_networkx_nodes(graph, pos)
nx.draw_networkx_edges(graph, pos)
nx.draw_networkx_labels(graph, pos)
file_name = 'Q8_Assets/SmallWorld_N_' + str(n) + '_P_' + str(p) + '.pdf'
plt.savefig(file_name, bbox_inches="tight")
plt.close(fig)
del fig
def draw_graph(self, node_type='', layout=''):
if layout == 'spring':
pos = nx.spring_layout(self.scgraph.code_graph)
if layout == 'spectral':
pos = nx.spectral_layout(self.scgraph.code_graph)
if layout == 'planar':
pos = nx.planar_layout(self.scgraph.code_graph)
if layout == 'shell':
pos = nx.shell_layout(self.scgraph.code_graph)
if layout == 'circular':
pos = nx.circular_layout(self.scgraph.code_graph)
if layout == 'spiral':
pos = nx.spiral_layout(self.scgraph.code_graph)
if layout == 'random':
pos = nx.random_layout(self.scgraph.code_graph)
if node_type == 'cycles':
self.scgraph.draw('cycles', layout)
if node_type == 'dict':
self.scgraph.draw('dict', layout)
def AllocateSmallGroups(G, n, teamCount, m, showAnimation, peopleNumbers,
peopleUnvisited):
# Setup graph animation window
# Display all nodes in a circular layout with labels
pos = nx.circular_layout(G)
if showAnimation:
pylab.show()
nx.draw_circular(G, with_labels=True)
# Determine the number of edges will present in the clique
# by taking the number of teams and multiplying it by
# one less of itself
cliqueEdges = teamCount * (teamCount - 1)
# Determine the likely number of groups that will be allocated
# for each night by doing integer division with n divided by m
# Sometimes, there will be less groups due to edge cases where a
# group would only have had one person
numGroups = n // m
# Create a list to contain the lists of each group for each night
superList = []
# Start a counter for the number of nights
nightNum = 0
# Create a list of the teams that were hosts the last night
previousHosts = []
# While there are still teams who have not visited a different team
# (Alternatively, if there are still edges missing to form a clique)
while len(sum(list(peopleUnvisited.values()), [])) > 0:
# Make a deep copy of the peopleUnvisited map as it currently is
people = deepcopy(peopleUnvisited)
# Create a list to hold the groups for this night
# Create a list within this that will hold the number of individuals
# assigned to each group of this night
night = [[]]
# Create a list of the teams that are hosts for this night
hostNames = []
# Create the expected number of groups
for i in range(numGroups):
# Retrieve the list of unassigned teams
peopleList = list(people.keys())
peopleNum = len(peopleList)
# If there is only one unassigned team, do not create a new
# group, but let the remainingGuests list allocate
# this team to an existing group
if peopleNum == 1:
break
# Create a map for teams that could be a host for this group
potentialHosts = {}
# Populate the map with unassigned teams that
# were not hosts last night
for person in Difference(peopleList, previousHosts):
potentialHosts[person] = people[person]
# If there are potential hosts for this group
if len(potentialHosts) > 0:
# Select the host that has been visited least, which
# is the same as host with most unvisited teams
# (Alternatively, node of smallest degree)
host = max(potentialHosts,
key=lambda k: len(potentialHosts[k]))
# Find the unassigned teams that were hosts last night, but
# are not hosts for this night
previousHostOptions = Intersection(
peopleList, Difference(previousHosts, hostNames))
if len(previousHostOptions) > 0:
# Reset the map to store possible hosts from last night
potentialHosts = {}
for person in previousHostOptions:
potentialHosts[person] = peopleUnvisited[person]
# Find the host that has been visited least, which
# was a host last night, but not tonight
prevHost = max(potentialHosts,
key=lambda k: len(potentialHosts[k]))
# If the host from last night has been visited less
# than the host selected at the moment, then
# select the host from last night instead
if (len(peopleUnvisited[host]) < len(
peopleUnvisited[prevHost])):
host = prevHost
# Otherwise, if there are no unassigned teams that
# that were not hosts last night
else:
# Find the unassigned teams that were hosts last night, but
# are not hosts for this night
previousHostOptions = Intersection(
peopleList, Difference(previousHosts, hostNames))
if len(previousHostOptions) > 0:
# Reset the map to store possible hosts from last night
potentialHosts = {}
for person in previousHostOptions:
potentialHosts[person] = peopleUnvisited[person]
# Select the host that has been visited least, which
# was a host last night, but not tonight
host = max(potentialHosts,
key=lambda k: len(potentialHosts[k]))
# Otherwise, if there is no unassigned teams that could
# be hosts for this night, then do not create
# a group and just add any unassigned people
# using remainingGuests
else:
break
# Create a list for a new group for this night,
# starting with the selected host
group = [host]
# Initialize the initial list of the night list
# by setting the current size of this group
# to the number of individuals the host
night[0].append(peopleNumbers[host])
hostNames.append(host)
# Since the host has been assigned to a group, remove them from map
del people[host]
# If the host already fills up the group
if peopleNumbers[host] >= m:
# Find any unassigned guests who have not yet visited this host
potentialGuests = Intersection(peopleUnvisited[host],
list(people.keys()))
if len(potentialGuests) > 0:
# Add a guest anyway to this group, so that
# this edge case is resolved by allowing teams
# to visit this host, even though group is filled
guestToAdd = potentialGuests[0]
group.append(guestToAdd)
if showAnimation:
AnimateEdge(G, pos, guestToAdd, host)
# Increment group size by number of individuals of guest
night[0][i] += peopleNumbers[guestToAdd]
# Denote guest as assigned by removing from map
del people[guestToAdd]
# Remove guest from univisited list of host
peopleUnvisited[host].remove(guestToAdd)
# While this group is not filled and there are unassigned guests
while night[0][i] < m and len(list(people.keys())) > 0:
guestToAdd = None
peopleList = list(people.keys())
peopleNum = len(peopleList)
# Find any unassigned guests who have not yet visited this host
potentialGuests = Intersection(peopleUnvisited[host],
peopleList)
potentialNum = len(potentialGuests)
# If adding any guest at any point will overflow for this host
if peopleNumbers[host] + 2 > m:
# Then add a guest anyway with preference toward unvisited
if potentialNum > 0:
guestToAdd = potentialGuests[0]
else:
guestToAdd = peopleList[0]
# If there are potential guests but still no guest selected
if potentialNum > 0 and guestToAdd is None:
# If a couple can fit
if night[0][i] + 2 <= m:
# Then add a couple, if one is available
for guest in potentialGuests:
if peopleNumbers[guest] == 2:
guestToAdd = guest
break
# Otherwise, if still no guest selected and
# if a single can fit
if guestToAdd is None and night[0][i] + 1 <= m:
for guest in potentialGuests:
# Then add a single, if one is available
if peopleNumbers[guest] == 1:
guestToAdd = guest
break
# Otherwise, stop attempting to add guests to this group and
# simply allow the remainingGuests list to fill this group
if guestToAdd is None:
break
# Otherwise, if there are, in fact, no potential guests and
# still no guest selected but there are unassigned guests
elif potentialNum == 0 and guestToAdd is None and peopleNum > 0:
# Then add a guest anyway
guestToAdd = peopleList[0]
potentialIndex = 1
# Try the next guest if the current one will not fit
while (potentialIndex < peopleNum
and peopleNumbers[guestToAdd] + night[0][i] > m):
guestToAdd = peopleList[potentialIndex]
potentialIndex += 1
# If there is a guest selected
if guestToAdd is not None:
# Add the guest to this group
group.append(guestToAdd)
if showAnimation:
AnimateEdge(G, pos, guestToAdd, host)
# Increment group size by number of individuals of guest
night[0][i] += peopleNumbers[guestToAdd]
# Denote guest as assigned by removing from map
del people[guestToAdd]
# Remove guest from univisited list of host, if the
# guest is still in that list
if guestToAdd in peopleUnvisited[host]:
peopleUnvisited[host].remove(guestToAdd)
# Add this group to the current night
night.append(group)
# As a catch-all, compile a list of any guests that were not assigned
# in the current night
remainingGuests = list(people.keys())
# If there were any extra unassigned guests
if len(remainingGuests) > 0:
# Sort them with couples at the beginning
sortedRemainingGuests = []
for guest in remainingGuests:
if peopleNumbers[guest] == 2:
sortedRemainingGuests.insert(0, guest)
else:
sortedRemainingGuests.append(guest)
# Add each guest to the smallest group
for guest in sortedRemainingGuests:
# Find the group with least number of individuals
smallestGroupIndex = night[0].index(min(night[0]))
# Find who the host is for that group
host = night[smallestGroupIndex + 1][0]
# Add the guest to that group
night[smallestGroupIndex + 1].append(guest)
if showAnimation:
AnimateEdge(G, pos, guest, host)
# Increment group size by number of individuals of extra guest
night[0][smallestGroupIndex] += peopleNumbers[guest]
# Remove guest from univisited list of host, if the
# guest is still in that list
if guest in peopleUnvisited[host]:
peopleUnvisited[host].remove(guest)
# Add this filled night list to the list of lists
superList.append(night)
# Set the list of current hosts as the previous hosts for the next night
previousHosts = hostNames
# Increment the night counter
nightNum += 1
# Print out the details for the night, including the
# size of each group and the groups themselves
print("Night #", nightNum)
print("Group sizes are =", night[0])
for j, group in enumerate(night[1:], start=1):
print("Group #", j, "=", night[j])
# Determine how much progress has been made on forming a clique
if showAnimation:
edges = G.number_of_edges()
else:
edges = cliqueEdges - len(sum(list(peopleUnvisited.values()), []))
# Print out progress of algorithm as a percentage, which is
# how many edges have been added so far divided by
# the total number of edges required to form a clique
print("Clique is", int(100 * (edges / cliqueEdges)),
"% complete (" + str(edges), "of",
str(cliqueEdges) + " edges).\n")
return superList
w = 3
h = 3
G = nx.from_numpy_array(allSC[0])
# pos = nx.spring_layout(G,scale=9)
# pos = nx.circular_layout(G)
pos = nx.fruchterman_reingold_layout(G)
# pos = nx.random_layout(G)
# pos = nx.spectral_layout(G)
# pos = nx.shell_layout(G)
# pos = nx.layout(G)
bestCount = 400
best_i = 0
th_best = -1
pos = nx.circular_layout(G)
# pos = nx.kamada_kawai_layout(G)
list = []
mul = 1
# mul = 2.5
# for i in listL2:
for i in range(allSC.shape[0]):
for th in [0.05]: # for L2 FC
# for th in [0.03]: # for full corr FC
sc = getNormalizedMatrix_np(allSC[i])
# sc = getNormalizedMatrix_np(allSC[i])
sc[sc < th] = 0
tfc = getNormalizedMatrix_np(np.copy(trueFC[i]))
# tfc = np.copy(trueFC[i])
# tfc[tfc!=0]=1
def draw(self, node_type='', layout=''):
"""
Draw graph with vertices, edges, and faces labeled by colored nodes and their integer indices
corresponding to the qubit indices for the surface code
"""
if not node_type in ['cycles', 'dict']:
raise ValueError('node_type can be "cycles" or "dict"')
if layout == 'spring':
pos = nx.spring_layout(self.code_graph)
if layout == 'spectral':
pos = nx.spectral_layout(self.code_graph)
if layout == 'planar':
pos = nx.planar_layout(self.code_graph)
if layout == 'shell':
pos = nx.shell_layout(self.code_graph)
if layout == 'circular':
pos = nx.circular_layout(self.code_graph)
if layout == 'spiral':
pos = nx.spiral_layout(self.code_graph)
if layout == 'random':
pos = nx.random_layout(self.code_graph)
# white nodes
nx.draw_networkx_nodes(self.code_graph,
pos,
nodelist=list(self.alpha),
node_color='c',
node_size=500,
alpha=0.3)
# vertex nodes
nx.draw_networkx_nodes(self.code_graph,
pos,
nodelist=list(self.sigma),
node_color='b',
node_size=500,
alpha=0.6)
# face nodes
nx.draw_networkx_nodes(self.code_graph,
pos,
nodelist=list(self.phi),
node_color='r',
node_size=500,
alpha=0.6)
# edges
nx.draw_networkx_edges(self.code_graph, pos, width=1.0, alpha=0.5)
labels = {}
if node_type == 'cycles':
'''
label nodes the cycles of sigma, alpha, and phi
'''
for node in self.alpha_dict:
# stuff = self.alpha_dict[node]
labels[node] = f'$e$({node})'
for node in self.sigma_dict:
# something = self.sigma_dict[node]
labels[node] = f'$v$({node})'
for node in self.phi_dict:
# something2 = self.phi_dict[node]
labels[node] = f'$f$({node})'
nx.draw_networkx_labels(self.code_graph, pos, labels, font_size=12)
if node_type == 'dict':
'''
label nodes with v, e, f and indices given by node_dict corresponding to
qubit indices of surface code
'''
for node in self.alpha_dict:
# stuff = self.alpha_dict[node]
labels[node] = f'$e$({self.alpha_dict[node]})'
for node in self.sigma_dict:
# something = self.sigma_dict[node]
labels[node] = f'$v$({self.sigma_dict[node]})'
for node in self.phi_dict:
# something2 = self.phi_dict[node]
labels[node] = f'$f$({self.phi_dict[node]})'
nx.draw_networkx_labels(self.code_graph, pos, labels, font_size=12)
# plt.axis('off')
# plt.savefig("labels_and_colors.png") # save as png
plt.show() # display
