Distributed_Surface_Code/result_one_point_nn.py at master · evalvarez12/Distributed_Surface_Code · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
"""
Simple simulation to test the surface code simulation is working
without looking at plots.

Run this code using mpi4py:
mpiexec python result_one_point_nn.py topology=toric distance=8 iterations=500 cycles=8 protocol=BASIC p=0.07 ignore=0.0 method=single_rounds_rev
created-on: 09/12/17
@author: eduardo
"""
import sys
import numpy as np
from os.path import dirname, realpath
from mpi4py import MPI
import surface_code
import layers
import matching


def get_file_name(params):
    protocol = "protocol=" + params["protocol"]
    topology = "topology=" + params["topology"]
    distance = "distance=" + params["distance"]
    iterations = "iterations=" + params["iterations"]
    cycles = "cycles=" + params["cycles"]
    p = "p=" + params["p"]

    param_names = [protocol, topology, distance, iterations, cycles, p]
    file_name = "_".join(param_names)
    return file_name

# Start the comm for mpi4py
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()

# Get the arguments
pythonfile = sys.argv[0]
args = dict(arg.split('=') for arg in sys.argv[1:])

# Set random seed
# np.random.seed(45678 + rank)

# Parameters for noisy measurement
eta = 0.0
a0 = 0.0
a1 = 0.0
theta = 0.0

# Set parameters
distance = int(args["distance"])
topology = args["topology"]
iterations = int(args["iterations"])
p = float(args["p"])
cycles = int(args["cycles"])
protocol = args["protocol"]
p_not_complete = float(args["ignore"])
method = args["method"]
# Initialize fail rate
fail_rate = 0

# Paramters
ps = 0.0
pm = 0.0005
pg = 0.001

p_not_complete = 0.0
eta = p

# Initialize objects
sc = surface_code.SurfaceCode(distance, topology)
lc = layers.Layers(sc)
sc.init_error_obj(topology, ps, pm, pg, eta, a0, a1, theta, protocol)

# Choose a measurement protocol
sc.select_measurement_protocol(0.0, 0.0, method, p_not_complete)

# Perform measurements
for i in range(iterations):

    # Noisy measurements
    for t in range(cycles):
        sc.noisy_measurement_cycle()
        lc.add()
    sc.measure_all_stabilizers()
    lc.add()

    # Decode and apply corrections
    lc.decode()

    # Measure logical qubit
    logical = sc.measure_logical()

    if -1 in logical[0] or -1 in logical[1]:
        fail_rate += 1

    lc.reset()
    sc.reset()

fail_rate = fail_rate/float(iterations)

# print(rank, fail_rate)
# Initializing variables. mpi4py requires that we pass numpy objects.
f_rate = np.zeros(1)
total = np.zeros(1)

f_rate[0] = fail_rate

# Communication: root node receives results with a collective "reduce"
comm.Reduce(f_rate, total, op=MPI.SUM, root=0)

# Root process saves the results
if rank == 0:
        total = total / float(size)
        # total = total / float(cycles)
        print(size, method, distance, cycles, "p=", p, "incomplete=",p_not_complete, ":", round(total[0], 7), ":", round(total[0], 7)/float(cycles))

        # print("size: ", size)
        # print("id: ", rank)
        # args_str = get_file_name(args)
        # script_path = dirname(realpath(__file__))
        # file_name = (script_path + "/results/" + args_str)
        # np.save(file_name, total)
        # print("TOTAL FAIL RATE: ", total)