for m in range(numCandidate):
metrics = np.zeros(2)
observations = []
for j in range(2):
A = PDCCHGenerator.numInformationBits[j]
K = A + PDCCHGenerator.numCRCBits
cword = codewords[cword_offset + m + j * numCandidate]
cword = cword.astype(np.int)
bpsksymbols = 1 - 2 * cword
receive_symbols = bpsksymbols + np.random.normal(loc=0, scale=sigma, size=(1, len(cword)))
receive_symbols_llr = receive_symbols * (2 / sigma ** 2)
decoded_bits, metric = SCLOneDecoders[dec_offset + j].decode(receive_symbols_llr)
dec_information_bits = decoded_bits[:-PDCCHGenerator.numCRCBits]
dec_crc = decoded_bits[-PDCCHGenerator.numCRCBits:]
crcCheck = CRCEncoder.encode(dec_information_bits)[-PDCCHGenerator.numCRCBits:]
crcCheck[-PDCCHGenerator.numRNTIBits:] = crcCheck[-PDCCHGenerator.numRNTIBits:] ^ RNTI
metrics[j] = metric / (N - K)
observations.append(receive_symbols_llr)
if np.all(crcCheck == dec_crc):
crcPassedNoisyObservation.append(receive_symbols_llr)
crcPassedDecoderIdx.append(dec_offset + j)
crcPassedIdx.append(cword_offset + m + j * numCandidate)
# For each candidate, select the DCI format with smaller DM, this step reduce the number candidate by a half
argminDM = int(np.argmin(metrics))
DCIWinnerNoisyObservation.append(observations[argminDM])
DCIWinnerIdx.append(cword_offset + m + argminDM * numCandidate)
DCIWinnerDecoderIdx.append(dec_offset + argminDM)
frozenbitsPesedo, messagebitsPesedo, _, _ = codeConstructor.PW(N, PesodoK)
polarPesedoEncoder = PolarEnc(N, PesodoK, frozenbitsPesedo, messagebitsPesedo)
crcEnc = CRCEnc(crc_n=numCRC, crc_polynominal=crcPoly)
# Try Complete Noise / Random Codewords / Regular Polar Codes
numSimulation = 2 * 10**4
DMetricsAnother = []
DMetricsRegular = []
pbar = tqdm(range(numSimulation))
for _ in pbar:
choice = np.random.randint(low=0, high=2)
if choice == 0:
# two mode: pure random codeword / polar encoded but with different information bit length
msg = np.random.randint(low=0, high=2, size=pesedoA)
msg_crc = crcEnc.encode(msg)
cword = polarPesedoEncoder.encode(msg)
cword = cword.astype(np.int)
bpsksymbols = 1 - 2 * cword
else:
msg = np.random.randint(low=0, high=2, size=A)
msg_crc = crcEnc.encode(msg)
cword = polarEncoder.encode(msg_crc)
cword = cword.astype(np.int)
bpsksymbols = 1 - 2 * cword
receive_symbols = bpsksymbols + np.random.normal(
loc=0, scale=sigma, size=(1, N))
receive_symbols_llr = receive_symbols * (2 / sigma**2)
DMetric = DMetricCalculator.getDMetric(receive_symbols_llr)
if choice == 0:
class CandidateGenerator():
def __init__(self):
self.PWPath = os.path.join(os.getcwd(), "reliable_sequence.txt")
self.numAggregationLevel = 3
self.numCandidates = 44
self.numRNTIBits = 16
self.numCandidatePerAggregationLevel = np.array([6, 6, 10])
self.codewordLengthPerAggregationLevel = np.array([128, 256, 512])
self.maxInformationLength = 140
self.numInformationBits = np.array([16, 57])
self.numCRCBits = 24
self.crcPoly = [24, 23, 21, 20, 17, 15, 13, 12, 8, 4, 2, 1, 0]
self.polarEncoders = []
self.codeConstructor = PolarCodeConstructor(QPath=self.PWPath)
self.crcEncoder = CRCEnc(self.numCRCBits, self.crcPoly)
self.initialize_encoders()
def initialize_encoders(self):
self.frozenbits_set = []
self.messagebits_set = []
self.frozenbits_indicator_set = []
self.messagebits_indicator_set = []
for i in range(self.numAggregationLevel):
N = self.codewordLengthPerAggregationLevel[i]
encoder = []
frozenbits_set = []
messagebits_set = []
frozenbits_indicator_set = []
messagebits_indicator_set = []
for A in self.numInformationBits:
K = A + self.numCRCBits
frozenbits, messagebits, frozenbits_indicator, messagebits_indicator = self.codeConstructor.PW(
N, K)
frozenbits_set.append(frozenbits)
messagebits_set.append(messagebits)
frozenbits_indicator_set.append(frozenbits_indicator)
messagebits_indicator_set.append(messagebits_indicator)
encoder.append(PolarEnc(N, K, frozenbits, messagebits))
self.polarEncoders.append(encoder)
self.frozenbits_set.append(frozenbits_set)
self.messagebits_set.append(messagebits_set)
self.frozenbits_indicator_set.append(frozenbits_indicator_set)
self.messagebits_indicator_set.append(messagebits_indicator_set)
def generate_candidates(self, isRNTI):
codewords = []
information_bits = []
if isRNTI:
RNTIIndex = np.random.randint(low=0, high=self.numCandidates)
else:
RNTIIndex = -1
RNTI = np.random.randint(low=0,
high=2,
size=self.numRNTIBits,
dtype=np.int)
cnt = 0
for i in range(self.numAggregationLevel):
for m in range(2):
A = self.numInformationBits[m]
for j in range(self.numCandidatePerAggregationLevel[i]):
msg = np.random.randint(low=0, high=2, size=A)
msg_crc = self.crcEncoder.encode(msg)
if cnt == RNTIIndex:
msg_crc[-self.numRNTIBits:] = np.mod(
msg_crc[-self.numRNTIBits:] + RNTI, 2)
codeword = self.polarEncoders[i][m].encode(msg_crc)
codeword = codeword.astype(np.int)
codewords.append(codeword)
information_bits.append(msg)
cnt += 1
return information_bits, codewords, RNTI, RNTIIndex