def create_output_transducer(scheme_1, scheme_2, k):
# Функция генерации входного преобразователя и добавления его в СФК на основе кодирования в трехбитном пространстве
# Хэмминга
# scheme_1 - основная комбинационная схема
# scheme_2 - СФК на основе кодирования в трехбитном пространстве Хэмминга без выходных преобразователей
# Создание словаря соединений
con = dict()
# Создание пустой подсхемы выходного преобразователя out_transducer
out_transducer = sch.scheme_alt()
# Генерация входов выходного преобразователя out_transducer
out_transducer.__inputs__ = [
'_{}_'.format(k), '_{}_'.format(k + 1), '_{}_'.format(k + 2)
]
# Генерация выхода выходного преобразователя out_transducer
out_transducer.__outputs__ = ['y']
# Генерация элементов выходного преобразователя out_transducer
out_transducer.__elements__ = {
'_{}_'.format(k + 4): ('OR', ['_{}_'.format(k), '_{}_'.format(k + 1)]),
'_{}_'.format(k + 5):
('NAND', ['_{}_'.format(k), '_{}_'.format(k + 1)]),
'_{}_'.format(k + 6):
('NAND', ['_{}_'.format(k + 4), '_{}_'.format(k + 2)]),
'y': ('NAND', ['_{}_'.format(k + 5), '_{}_'.format(k + 6)])
}
# Копирование выходных преобразователей out_transducer по числу выходов основной схемы
out_transducer = sch.merge_schemes([out_transducer] *
int(scheme_2.outputs() / 3))
# Генерация словаря соединений
for i in range(scheme_1.outputs()):
con[(0, scheme_2.__outputs__[i])] = ([
(1, out_transducer.__inputs__[3 * i])
])
con[(0, scheme_2.__outputs__[scheme_1.outputs() + i])] = ([
(1, out_transducer.__inputs__[3 * i + 1])
])
con[(0, scheme_2.__outputs__[2 * scheme_1.outputs() + i])] = ([
(1, out_transducer.__inputs__[3 * i + 2])
])
# Генерация выходов объединенной схемы
out = [(1, i) for i in out_transducer.__outputs__]
# Объединение СФК и выходного преобразователя out_transducer
scheme_2 = sch.merge_schemes([scheme_2, out_transducer], con, out)
# Приведение выхода результирующей схемы к общему виду
del scheme_2.__elements__['y']
scheme_2.__elements__['y_0'] = ('NAND', [
'_{}_'.format(k + 5), '_{}_'.format(k + 6)
])
scheme_2.__outputs__[0] = 'y_0'
return scheme_2
def patch_merger(patches):
patchlist = []
for target in patches:
patchlist.append(patches[target][0])
all_inps = []
all_outs = []
for patch in patchlist:
all_inps += patch.__inputs__
all_outs += patch.__outputs__
all_inps = list(set(all_inps))
all_outs = list(set(all_outs))
final_patch = sc.merge_schemes(patchlist, [], [])
final_patch.__inputs__ = all_inps
final_patch.__outputs__ = all_outs
return final_patch
def create_ced_for_group(scheme, group, num):
k = scheme.outputs()
m = k
p = submatrix_p(k, m)
coder = sch.replicate(scheme, 1)
coder = create_coder(coder, p, k + m, num)
renamed = {i: '{}_out'.format(i) for i in scheme.__outputs__}
coder.rename_labels(renamed)
coder.__outputs__ = ['{}_out'.format(i) for i in scheme.__outputs__] + coder.__outputs__
hx = hx_with_elements(coder.__outputs__, np.hstack([p, np.eye(k, k, dtype=int)]), 2 * k, k)
d1 = {i: [] for i in scheme.__outputs__}
for i in range(k):
for hx_str in hx:
if coder.__outputs__[i] in hx_str: d1[scheme.__outputs__[i]] += hx_str
for i in scheme.__outputs__:
check_eq = d1[i]
ind_0 = scheme.__outputs__.index(i)
for j in range(2):
index = check_eq.index(coder.__outputs__[ind_0])
check_eq.remove(check_eq[index])
inputs = [d1[i] for i in d1]
for i in range(k): inputs[i] = [scheme.__outputs__[i]] + inputs[i]
decoder = sch.scheme_alt()
decoder.__outputs__ = ['out_ced_{}'.format(i) for i in group]
decoder.__inputs__ = list(sorted(set([n3 for n2 in range(k) for n3 in inputs[n2]])))
n = 1
for i in range(k): decoder, n = create_decoder(decoder, inputs[i], decoder.__outputs__[i], num, n)
decoder.__inputs__ = scheme.__outputs__ + coder.__outputs__
conn = {(0, i): [(1, i)] for i in coder.__outputs__}
out = [(1, i) for i in decoder.__outputs__] + [(0, '{}_out'.format(i)) for i in scheme.__outputs__]
ced = sch.merge_schemes([coder, decoder], conn, out)
return ced, coder, decoder
def create_ced(scheme, groups):
n_groups = len(groups) # число разложений (групп)
schemes = list()
coders = list()
decoders = list()
d1 = {(0, i): [] for i in scheme.__inputs__}
d2 = {}
out = []
for num in range(n_groups):
outputs = [scheme.__outputs__[groups[num][i] - 1] for i in range(len(groups[num]))]
scheme_1 = scheme.subscheme_by_outputs(outputs)
scheme_2, coder, decoder = create_ced_for_group(scheme_1, groups[num], num)
schemes.append(scheme_2)
coders.append(coder)
decoders.append(decoder)
for i in scheme_1.__inputs__: d1[(0, i)].append((num + 1, scheme_2.__inputs__[scheme_1.__inputs__.index(i)]))
d2.update({(0, i): [(num + 1, i)] for i in scheme_1.__outputs__})
out += [(num + 1, i) for i in scheme_2.__outputs__]
conn = {}
conn.update(d1)
conn.update(d2)
renamed = {}
n = 1
for i in scheme.__elements__.keys():
if i not in scheme.__outputs__:
renamed[i] = 'wire_{}'.format(n)
n += 1
scheme.rename_labels(renamed)
ldpc_ced = sch.merge_schemes([scheme] + schemes, conn, out)
ldpc_ced.__outputs__ = ['out_ced_{}'.format(i + 1) for i in range(scheme.outputs())]
ldpc_ced.__outputs__ += scheme.__outputs__ + ['{}_out'.format(i) for i in scheme.__outputs__]
return ldpc_ced, coders, decoders
def create_input_transducer(scheme_1, scheme_2):
# Функция генерации вх. преобразователя и добавления его в СФК на основе кодирования в 3битном пространстве Хэмминга
# scheme_1 - основная комбинационная схема
# scheme_2 - схема, в которой ЛЭ были заменены на сбоеустойчивые аналоги в 3битном пространстве Хэмминга
# Создание словаря соединений
con = dict()
# Создание списка выходов объединенной схемы scheme_2
out = list()
# Создание пустой подсхемы входного преобразователя inp_transducer
inp_transducer = sch.scheme_alt()
# Добавление входов для подсхемы входного преобразователя inp_transducer
inp_transducer.__inputs__ = ['x_0']
for i in range(scheme_1.inputs() - 1):
inp_transducer.__inputs__.append('x_{}'.format(i + 1))
# Добавление выходов для подсхемы входного преобразователя inp_transducer
inp_transducer.__outputs__ = inp_transducer.__inputs__
# Генерация словаря соединений
# Например:
# {(1,'x_1'): [(0, 'a'), (0, 'a_1'), (0, 'a_2')]}, где 'x_1' - вход преобразователя,
# 'a','a_1','a_2' - входы схемы
for i in range(scheme_1.inputs()):
con[(1, 'x_{}'.format(i))] = [(0, scheme_1.__inputs__[i]),
(0, scheme_1.__inputs__[i] + '_1'),
(0, scheme_1.__inputs__[i] + '_2')]
# Генерация выходов объединенной схемы
for i in range(scheme_2.outputs()):
out.append((0, scheme_2.__outputs__[i]))
# Объединение схемы hemming_scheme и подсхемы входного преобразователя inp_transducer
scheme_2 = sch.merge_schemes([scheme_2, inp_transducer], con, out)
return scheme_2
def create_ced_for_group(scheme, group, cone=None, n=0):
if cone is None: cone = []
spectral_ced = sch.scheme_alt()
if scheme.outputs() != 1:
# Вычисление основных параметров спектрального R-кода
k = scheme.outputs()
m = int(np.ceil(np.log2(k)))+1
gx = matrix_gx(k, m-1)
gx_elements = gx_with_elements(scheme, gx, k, m)
gx_count_one = gx_with_count_one(gx)
outputs = []
for i in range(scheme.outputs()): outputs.append(scheme.__outputs__[i])
# Создание копии основной схемы для кодера
scheme_1 = sch.replicate(scheme, 1)
# Генерирование подсхемы кодера для СФК на основе спектрального R-кода
coder, n = create_coder(scheme_1, gx_elements, gx_count_one, m, n)
# Минимизирование подсхемы кодера для СФК на основе спектрального R-кода с помощью Yosys
# coder_min = create_circuit_external_yosys(coder)
# Генерирование подсхемы декодера для СФК на основе спектрального R-кода
decoder, n = create_decoder(scheme, gx_elements, outputs, gx_count_one, m, k, n)
# Минимизирование подсхемы декодера для СФК на основе спектрального R-кода с помощью Yosys
# decoder_min = create_circuit_external_yosys(decoder)
# n_decoder_out = len(decoder_min.__outputs__)
n_decoder_out = len(decoder.__outputs__)
# Генерирование подсхемы мультиплексора для СФК на основе спектрального R-кода
# mux_inputs = decoder_min.__outputs__[:(n_decoder_out-1)]
mux_inputs = decoder.__outputs__[:(n_decoder_out - 1)]
mux, n = create_mux(mux_inputs, scheme.__outputs__, k, n, group)
# cone += mux.__elements__
# Объединение подсхем декодера и мультиплексора
conn = dict()
out = list()
# for n1 in range(k): conn[(0, decoder_min.__outputs__[n1])] = [(1, decoder_min.__outputs__[n1])]
for n1 in range(k): conn[(0, decoder.__outputs__[n1])] = [(1, decoder.__outputs__[n1])]
for n2 in range(k): conn[(0, scheme.__outputs__[n2])] = [(1, scheme.__outputs__[n2])]
conn[(0, '_s0')] = [(1, '_s0')]
conn[(0, 'n_s0')] = [(1, 'n_s0')]
for n3 in range(k): out.append((1, mux.__outputs__[n3]))
out.append((0, '_s0'))
out.append((0, 'flag'))
# scheme_2 = sch.merge_schemes([decoder_min, mux], conn, out)
scheme_2 = sch.merge_schemes([decoder, mux], conn, out)
# Объединение подсхем кодера и scheme_2
conn = dict()
out = list()
# for n4 in range(m): conn[(0, coder_min.__outputs__[n4])] = [(1, scheme_2.__inputs__[k+n4])]
# for n5 in range(scheme_2.outputs()): out.append((1, scheme_2.__outputs__[n5]))
# spectral_ced = sch.merge_schemes([coder_min, scheme_2], conn, out)
for n4 in range(m): conn[(0, coder.__outputs__[n4])] = [(1, scheme_2.__inputs__[k+n4])]
for n5 in range(scheme_2.outputs()): out.append((1, scheme_2.__outputs__[n5]))
spectral_ced = sch.merge_schemes([coder, scheme_2], conn, out)
return spectral_ced, cone, n, coder, decoder
def create_spec_circuit(scheme, n_pass):
# Функция генерации СФК на основе спектрального R кода с учетом применения алгоритма кластеризации
if n_pass == 0:
groups = [[i+1 for i in range(scheme.outputs())]]
# Q = 0
else:
clusters, groups = clusterization(scheme, n_pass)
scheme_3 = list()
coders = list()
decoders = list()
cone = list()
l3 = list()
n = 1
for i in range(len(groups)):
outputs = []
for j in range(len(groups[i])): outputs.append(scheme.__outputs__[groups[i][j] - 1])
scheme_1 = scheme.subscheme_by_outputs(outputs)
scheme_2, cone, n, coder, decoder = create_ced_for_group(scheme_1, groups[i], cone, n)
scheme_3.append(scheme_2)
coders.append(coder)
decoders.append(decoder)
conn = dict()
out = list()
for n0 in range(scheme.inputs()):
l1 = list()
l2 = list()
for n1 in range(len(groups)):
if scheme_3[n1].__inputs__.count(scheme.__inputs__[n0]) != 0: l1.append(n1)
for n2 in range(len(l1)): l2.append((l1[n2] + 1, scheme.__inputs__[n0]))
conn[(0, scheme.__inputs__[n0])] = l2
for n3 in range(len(groups)):
n_out = scheme_3[n3].outputs() - 2
inp_1 = scheme_3[n3].__inputs__[(-n_out):]
for n4 in range(len(inp_1)): conn[(0, scheme.__outputs__[groups[n3][n4] - 1])] = [(n3 + 1, inp_1[n4])]
cir = [scheme]
for n5 in range(len(groups)): cir.append(scheme_3[n5])
for n6 in range(len(scheme_3)):
for n7 in range(scheme_3[n6].outputs()): out.append((n6 + 1, scheme_3[n6].__outputs__[n7]))
result = sch.merge_schemes(cir, conn, out)
t_cone = result.subscheme_by_outputs(['_s0'])
for n8 in range(scheme.elements()):
if list(t_cone.__elements__).count(list(scheme.__elements__)[n8]) > 0:
del t_cone.__elements__[list(scheme.__elements__)[n8]]
l3 += list(t_cone.__elements__.keys())
for n7 in range(len(groups) - 1):
t_cone = result.subscheme_by_outputs(['_s0_{}'.format(n7 + 1)])
for n8 in range(scheme.elements()):
if list(t_cone.__elements__).count(list(scheme.__elements__)[n8]) > 0:
del t_cone.__elements__[list(scheme.__elements__)[n8]]
l3 += list(t_cone.__elements__.keys())
cone += l3
if n_pass != 0:
old_out = sorted(result.__outputs__)
n_or = len(groups) - 1
for i in range(n_or): result.__elements__['bit_{}'.format(i + 1)] = ('OR', [old_out[i], old_out[i + 1]])
bit = 'bit_{}'.format(n_or)
old_out = old_out[len(groups):]
for i in range(n_or): result.__elements__['flag_error_{}'.format(i + 1)] = ('OR', [old_out[i], old_out[i + 1]])
flag = 'flag_error_{}'.format(n_or)
old_out = old_out[len(groups):]
result.__outputs__ = ['out_{}'.format(i + 1) for i in range(len(old_out))]
result.__outputs__ += [bit, flag]
return result, cone, coders, decoders
def create_hemming_circuit(scheme):
# Функция переименования узлов схемы
renamed_scheme = sch.replicate(scheme, 1)
n = renamed_elements_in_scheme(renamed_scheme, 'inp_', 'wire_', 0)
# "Утроение" основной схемы
scheme_2 = sch.merge_schemes([renamed_scheme] * 3)
scheme_3 = sch.scheme_alt()
inputs = list()
# Вычисление числа ЛЭ основной схемы
k = scheme.elements()
# Для каждого ЛЭ основной схемы создается сбоеустойчивый аналог данного ЛЭ в базисе 3битоного пространства Хэмминга
# Определение выходов сбоеустойчивого аналога ЛЭ
for element in sorted(renamed_scheme.__elements__.keys()):
outputs = [element, element + '_1', element + '_2']
# Определение входов аналога, если ЛЭ основной схемы является двувходовым
if len(renamed_scheme.__elements__[element][1]) == 2:
inputs = [
renamed_scheme.__elements__[element][1][0],
renamed_scheme.__elements__[element][1][0] + '_1',
renamed_scheme.__elements__[element][1][0] + '_2',
renamed_scheme.__elements__[element][1][1],
renamed_scheme.__elements__[element][1][1] + '_1',
renamed_scheme.__elements__[element][1][1] + '_2'
]
# Если ЛЭ основной схемы - одновходовой
elif len(renamed_scheme.__elements__[element][1]) == 1:
inputs = [
renamed_scheme.__elements__[element][1][0],
renamed_scheme.__elements__[element][1][0] + '_1',
renamed_scheme.__elements__[element][1][0] + '_2'
]
# Определение типа (выполняемой функции) ЛЭ основной схемы
node_type = renamed_scheme.__elements__[element][0]
# Генерация подсхемы subscheme сбоеустойчивого аналога ЛЭ основной схемы
if node_type == 'INV':
subscheme, k = create_ft_analog_inv(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ INV
elif node_type == 'BUF':
subscheme, k = create_ft_analog_buf(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ BUF
elif node_type == 'AND':
subscheme, k = create_ft_analog_and2(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ AND2
elif node_type == 'OR':
subscheme, k = create_ft_analog_or2(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ OR2
elif node_type == 'XOR':
subscheme, k = create_ft_analog_xor2(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ XOR2
elif node_type == 'NAND':
subscheme, k = create_ft_analog_nand2(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ NAND2
elif node_type == 'NOR':
subscheme, k = create_ft_analog_nor2(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ NOR2
elif node_type == 'XNOR':
subscheme, k = create_ft_analog_xnor2(
inputs, outputs, k) # Сбоеустойчивый аналог ЛЭ XNOR2
elif node_type == 'GND':
subscheme = {element: renamed_scheme.__elements__[element]} # GND
else:
subscheme = 0
if node_type == 'GND': scheme_3.__elements__.update(subscheme)
else: scheme_3.__elements__.update(subscheme.__elements__)
scheme_3.__inputs__ = scheme_2.__inputs__
scheme_3.__outputs__ = scheme_2.__outputs__
# Добавление подсхемы входного преобразователя
scheme_4 = create_input_transducer(renamed_scheme, scheme_3)
# Добавление подсхемы выходного преобразователя
hem_ced = create_output_transducer(renamed_scheme, scheme_4, k)
return hem_ced
def create_ced(scheme, count):
#ОСНОВНАЯ ФУНКЦИЯ ГЕНЕРАЦИИ СФК НА ОСНОВЕ МОДИФИЦИРОВАННОГО КОДА ХЭММИНГА
SWC_ced = sch.scheme_alt()
# ВЫЧИСЛЕНИЕ ОСНОВНЫХ ПАРАМЕТРОВ СХЕМЫ
k = scheme.outputs() # КОЛ-ВО ИНФОРМАЦИОННЫХ РАЗРЯДОВ/ВЫХОДОВ СХЕМЫ
n = int(np.ceil(np.log2(k + 1))) # КОЛ-ВО ПРОВЕРОЧНЫХ РАЗРЯДОВ
gx = matrix_gx(n, k) # ГЕНЕРАЦИЯ ПОРОЖДАЮЩЕЙ МАТРИЦЫ
gx_elements = gx_with_elements(
scheme, gx, k, n) # СПИСОК ЭЛ-ОВ, ДЛЯ ВЫЧИСЛЕНИЯ ПРОВЕРОЧНЫХ РАЗРЯДОВ
gx_one_line = np.sum(
gx, 1) # КОЛ-ВО ЭЛ-ОВ, ДЛЯ ВЫЧИСЛЕНИЯ ПРОВЕРОЧНЫХ РАЗРЯДОВ
scheme_1 = sch.replicate(scheme, 1) # КОПИЯ О.С. ДЛЯ ФОРМИРОВАНИЯ КОДЕРА
coder, count = create_coder(scheme_1, gx_elements, gx_one_line, n,
count) # ФОРМИРОВАНИЕ ПОДСХЕМЫ КОДЕРА
#coder_min = create_circuit_external_yosys(coder) # МИНИМИЗАЦИЯ КОДЕРА С ПОМОЩЬЮ YOSYS
decoder, count = create_decoder(scheme, gx_elements, gx_one_line, n, k,
count) # ФОРМИРОВАНИЕ ПОДСХЕМЫ ДЕКОДЕРА
#decoder_min = create_circuit_external_yosys(decoder) # МИНИМИЗАЦИЯ ДЭКОДЕРА С ПОМОЩЬЮ YOSYS
# ОБЪЕДИНЕНИЕ ОСНОВНОЙ СХЕМЫ И ПОДСХЕМЫ КОДЕРА
conn = dict() # СОЕДИНЕНИЯ ОС И КОДЕРА
conn_min = dict() # СОЕДИНЕНИЯ ОС И МИНИМИЗИРОВАННОГО КОДЕРА
out = list() # ВЫХОДЫ ОС И КОДЕРА
out_min = list() # ВЫХОДЫ ОС И МИН. КОДЕРА
for i in range(scheme.inputs()): # ЗАПОЛНЕНИЕ СЛОВОРЕЙ СОЕДИНЕНИЙ
conn[(0, scheme.__inputs__[i])] = [(1, coder.__inputs__[i])]
#conn_min[(0, scheme.__inputs__[i])] = [(1, coder_min.__inputs__[i])]
for j in range(scheme.outputs()): # ЗАПОЛНЕНИЕ СПИСКА ВЫХОДОВ
out.append((0, scheme.__outputs__[j]))
out_min.append((0, scheme.__outputs__[j]))
for i in range(coder.outputs()):
out.append((1, coder.__outputs__[i]))
# for i in range(coder_min.outputs()):
# out_min.append((1, coder_min.__outputs__[i]))
scheme_2 = sch.merge_schemes([scheme, coder], conn,
out) # ОБЪЕДИНЕНИЕ ОС И КОДЕРА
#scheme_3 = sch.merge_schemes([scheme, coder_min], conn_min, out_min) # ОБЪЕДИНЕНИЕ ОС И МИН. КОДЕРА
# ОБЪЕДИНЕНИЕ scheme_3/scheme_3 И ДЕКОДЕРА
conn = dict() # СОЕДИНЕНИЯ scheme_3/scheme_3 И ДЕКОДЕРА
conn_min = dict() # СОЕДИНЕНИЯ scheme_3/scheme_3 И МИН. ДЕКОДЕРА
out = list() # ВЫХОДЫ scheme_3/scheme_3 И ДЕКОДЕРА
out_min = list() # ВЫХОДЫ scheme_3/scheme_3 И МИН. ДЕКОДЕРА
for i in range(decoder.inputs()): # ЗАПОЛНЕНИЕ СЛОВОРЕЙ СОЕДИНЕНИЙ
conn[(0, scheme_2.__outputs__[i])] = [(1, decoder.__inputs__[i])]
# for i in range(decoder_min.inputs()):
# conn_min[(0, scheme_2.__outputs__[i])] = [(1, decoder_min.__inputs__[i])]
for j in range(scheme.outputs()): # ЗАПОЛНЕНИЕ СПИСКА ВЫХОДОВ
out.append((0, scheme_2.__outputs__[j]))
out_min.append((0, scheme_2.__outputs__[j]))
for i in range(decoder.outputs()):
out.append((1, decoder.__outputs__[i]))
# for i in range(decoder_min.outputs()):
# out_min.append((1, decoder_min.__outputs__[i]))
SWC_ced = sch.merge_schemes([scheme_2, decoder], conn,
out) # ФОРМИРОВАНИЕ СФК
#SWC_ced = sch.merge_schemes([scheme_2, decoder_min], conn, out) # ФОРМИРОВАНИЕ СФК С МИН. ДЕКОДЕРОМ
#SWC_ced = sch.merge_schemes([scheme_3, decoder], conn, out) # ФОРМИРОВАНИЕ СФК С МИН. КОДЕРОМ
#SWC_ced = sch.merge_schemes([scheme_3, decoder_min], conn_min, out_min) # ФОРМИР СФК С МИН. КОДЕРОМ И МИН. ДЕКОДЕРОМ
return SWC_ced
