def Clipping_vs_PAPR():
print("------ Running Clipping vs PAPR Simulation -------")
params = {}
params['N'] = 512
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
params['useClipping'] = True
# nBits = 2**20
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/ece.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
BERSets = []
snrRange = np.arange(-10, 20, 1)
clippingFactor = [1.0, 0.9, 0.75, 0.5]
for C in clippingFactor:
params['clippingPercent'] = C
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
BER = []
for snr in snrRange:
# applying channel with fading
avgOFDMSymbolPower = np.mean(np.mean(np.power(np.abs(sig), 2),axis=-1))
channel = SISOFlatChannel(fading_param=( polar2rect(0.9,10.0), 0.19))
channel.set_SNR_dB(snr, Es=avgOFDMSymbolPower)
noisySig = channel.propagate(sig.flatten())
# decoding
rbitStream = rx.receive(noisySig)
BER.append(np.sum(np.logical_xor(rbitStream, bitStream)) /(1.0 * len(bitStream)))
print(" C = {:<3.1f} Max PAPR (dB) = {:<5.3} SNR(db) = {:<4} BER = {:<5.3}".format(float(C*100.0), np.max(paprDb[-1]), snr, BER[-1]))
BERSets.append(BER)
legend = ['Clipping = {:3.1f} %% of Max'.format(float(val*100.0)) for val in clippingFactor]
legend[0] = 'No Clipping'
plotCCDF(paprDb, savePath='Clipping_vs_PAPR_L-{}.png'.format(params['upsampleFactor']), show=False,
steps=0.25, legend=legend,
title='Complementary Cumulative Distribution Function (CCDF) for PAPR\nApplying Clipping for N = {} and L = {}'.format(params['N'], params['upsampleFactor']))
plotBER(BERSets, snrRange, xlabel='SNR (dB)', savePath='Clipping_vs_BER_L-{}.png'.format(params['upsampleFactor']), show=False, semilog=True,
title='Bit Error Rate in Rician Channel\nRelationship with Clipping OFDM Signal', legend=legend)
print("".join(["-"]*60), "\n\n")
def N_vs_BER():
print("------ Running # of Sub Carrier vs BER Simulation -------")
params = {}
params['N'] = 64
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
# nBits = 2**16
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/ece.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
BERSets = []
Nrange = [64, 128, 256, 512, 1024, 2048]
snrRange = np.arange(-10,40,1)
for N in Nrange:
params['N'] = N
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
BER = []
for snr in snrRange:
# applying channel with fading
avgOFDMSymbolPower = np.mean(np.mean(np.power(np.abs(sig), 2),axis=-1))
channel = SISOFlatChannel(fading_param=( polar2rect(0.9,15.0), 0.19))
channel.set_SNR_dB(snr, Es=avgOFDMSymbolPower)
noisySig = channel.propagate(sig.flatten())
# decoding
rbitStream = rx.receive(noisySig)
BER.append(np.sum(np.logical_xor(rbitStream, bitStream)) / (1.0 * len(bitStream)))
print(" N = {:<6} SNR (dB) = {:<4} BER = {:<5.3}".format(N, snr, BER[-1]))
BERSets.append(BER)
legend = ['N = {}'.format(val) for val in Nrange]
plotBER(BERSets, snrRange, xlabel='SNR (dB)', savePath='N_vs_BER.png', show=False, semilog=True,
title='Bit Error Rate in Rician Channel\nRelationship with Number of Sub Carriers', legend=legend)
print("".join(["-"]*60), "\n\n")
def SLM_vs_PAPR():
print("------ Running SLM Candidates vs PAPR Simulation -------")
params = {}
params['N'] = 512
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
params['useSLM'] = True
# nBits = 2**20
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/ece.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
phaseCandidates = [0, 8, 16, 32, 64]
for C in phaseCandidates:
params['SLMCandidates'] = C
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rx.SLMPhaseVectorIdx = tx.SLMPhaseVectorIdx
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) /(1.0 * len(bitStream))
print(" C = {:<3} Max PAPR (dB) = {:<5.3} BER = {:<5.3}".format(
C, np.max(paprDb[-1]), BER))
legend = ['Candidates = {}'.format(val) for val in phaseCandidates]
legend[0] = 'No SLM'
plotCCDF(paprDb, savePath='SLM-C_vs_PAPR_L-{}.png'.format(params['upsampleFactor']), show=False,
legend=legend,
title='Complementary Cumulative Distribution Function (CCDF) for PAPR\nApplying Selective Mapping for N = {} and L = {}'.format(params['N'], params['upsampleFactor']))
print("".join(["-"]*60), "\n\n")
def ConvCoding_vs_PAPR():
print("------ Running Conv Coding vs PAPR Simulation -------")
params = {}
params['N'] = 512
params['modType'] = 'qam'
params['M'] = 4
params['useConvCode'] = True
# nBits = 2**14
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/ece.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
legend = []
ConvCodeGenerators = [[], [0o5, 0o7], [0o5, 0o7, 0o3], [0o5, 0o7, 0o3, 0o06]] # generator polynomial connections
for G in ConvCodeGenerators:
params['convCodeGMatrix'] = np.array(G)
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.trellis = tx.trellis
rx.padBits = tx.padBits
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) /(1.0 * len(bitStream))
legend.append('Rate = {}'.format(tx.codeRate))
print(" CodeRate = {} Max PAPR (dB) = {:<5.3} BER = {:<5.3}".format(tx.codeRate, np.max(paprDb[-1]), BER))
legend[0] = 'No Conv Coding'
plotCCDF(paprDb, savePath='ConvCoding_vs_PAPR.png', show=False, steps=0.25,
legend=legend,
title='Complementary Cumulative Distribution Function (CCDF) for PAPR\nApplying Convolutional Coding')
print("".join(["-"]*60), "\n\n")
def N_vs_PAPR():
print("------ Running # of Sub Carrier vs PAPR Simulation -------")
params = {}
params['N'] = 64
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
# nBits = 2**20
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/ece.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
Nrange = [64, 128, 256, 512, 1024, 2048]
for N in Nrange:
params['N'] = N
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) /(1.0 * len(bitStream))
print(" N = {:<3} Max PAPR (dB) = {:<5.3} BER = {:<5.3}".format(
N, np.max(paprDb[-1]), BER))
legend = ['N = {}'.format(val) for val in Nrange]
plotCCDF(paprDb, savePath='N_vs_PAPR.png', show=False, steps=0.25,
title='Complementary Cumulative Distribution Function (CCDF) for PAPR\nRelationship with Number of Sub Carriers', legend=legend)
print("".join(["-"]*60), "\n\n")
def main():
params = {}
params['N'] = 512
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
params['dumpModChunks'] = True
imagePaths = sorted(glob.glob('../sample_data/*.jpg'))
modChunks = []
for imgp in imagePaths:
img = cv2.imread(imgp)
bitStream, imgShape = img2bits(img)
tx = OFDMTransmitter(**params)
modChunks.append(tx.transmit(bitStream))
# print(modChunks[0].shape)
modChunks = np.concatenate(modChunks, axis=0)
print(modChunks.shape)
np.savez('modChunks.npz', data=modChunks)
from PAPRNet import papr_encoder, papr_decoder, papr_net, tf_papr
from keras.callbacks import ReduceLROnPlateau, CSVLogger, EarlyStopping
from keras.optimizers import adam
from initialize.params import bit_allocation, coef
params = dict()
params['BitAllocation'] = bit_allocation
params['Coef'] = coef
train_num = 10000
test_num = 100
symbol_num = train_num + test_num
bits_per_symbol = sum(params['BitAllocation'])
bit_send = np.random.randint(0, 2, bits_per_symbol * symbol_num)
tx = OFDMTransmitter(**params)
ofdm_chunks = tx.get_qammod(bit_send)
ofdm_chunks = np.concatenate(
[np.expand_dims(ofdm_chunks.real, 1),
np.expand_dims(ofdm_chunks.imag, 1)],
axis=1)
ofdm_train = ofdm_chunks[0:train_num, :, 0:-1]
ofdm_test = ofdm_chunks[train_num:, :, 0:-1]
sig_train = np.zeros(train_num)
sig_test = np.zeros(test_num)
n = tx.SubCarrierNum
encoder = papr_encoder((2, n - 1), 2 * (n - 1), 2 * (n - 1), n - 1)
decoder = papr_decoder((2, n - 1), 2 * (n - 1), 2 * (n - 1), n - 1)
net = papr_net(encoder, decoder)
def SLM_vs_NN():
print("------ Running SLM vs NN Simulation -------")
params = {}
params['N'] = 512
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
# nBits = 2**20
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/wild.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
legend = []
# Normal OFDM ------------------------------------------
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) / (1.0 * len(bitStream))
legend.append("Normal OFDM")
# OFDM with SLM 32 ------------------------------------------
params['useSLM'] = True
params['SLMCandidates'] = 32
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rx.SLMPhaseVectorIdx = tx.SLMPhaseVectorIdx
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) / (1.0 * len(bitStream))
print("SLM 32 : BER = {:<5.2}".format(BER))
legend.append("OFDM + SLM-32")
# OFDM with SLM 64 ------------------------------------------
params['useSLM'] = True
params['SLMCandidates'] = 64
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rx.SLMPhaseVectorIdx = tx.SLMPhaseVectorIdx
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) / (1.0 * len(bitStream))
print("SLM 64 : BER = {:<5.2}".format(BER))
legend.append("OFDM + SLM-64")
# OFDM with SLM 64 and Clipping ------------------------------------------
params['useSLM'] = True
params['SLMCandidates'] = 64
params['useClipping'] = True
params['clippingPercent'] = 0.75
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rx.SLMPhaseVectorIdx = tx.SLMPhaseVectorIdx
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) / (1.0 * len(bitStream))
print("SLM 64 and Clipping : BER = {:<5.2}".format(BER))
legend.append("OFDM + SLM-64 + Clipping")
# OFDM with PAPRnet ------------------------------------------
params['useSLM'] = False
params['useClipping'] = False
params['usePAPRnet'] = True
params['PAPRnetEncoder'] = load_model('./trained_models/PAPRnet01/encoder.hdf5')
params['PAPRnetDecoder'] = load_model('./trained_models/PAPRnet01/decoder.hdf5')
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rbitStream = rx.receive(sig.flatten())
BER = np.sum(np.logical_xor(rbitStream, bitStream)) / (1.0 * len(bitStream))
print("PARPnet : BER = {:<5.2}".format(BER))
legend.append("OFDM + PAPRnet")
plotCCDF(paprDb, savePath='SLM_vs_PAPRnet.png', show=True, legend=legend,
title='Complementary Cumulative Distribution Function (CCDF) for PAPR\nComparision between PAPRnet and Conventional techniques')
print("".join(["-"]*60), "\n\n")
def ClippingSLM_vs_PAPR():
print("------ Running Clipping vs PAPR Simulation -------")
params = {}
params['N'] = 512
params['cyclicPrefix'] = int(0.25 * params['N'])
params['modType'] = 'qam'
params['M'] = 4
params['upsampleFactor'] = 1
params['useClipping'] = True
params['clippingPercent'] = 0.75
params['useSLM'] = True
params['SLMCandidates'] = 32
# nBits = 2**20
# bitStream = np.random.randint(0, 2, nBits, dtype=np.uint8)
img = cv2.imread('sample_data/ece.jpg')
bitStream, imgShape = img2bits(img)
paprDb = []
BERSets = []
legend = []
snrRange = np.arange(-10, 40, 1)
for useClipping, useSLM in zip([False, True, False, True], [False, False, True, True]) :
params['useSLM'] = useSLM
params['useClipping'] = useClipping
legend.append('Clipping = {} SLM = {}'.format(useClipping, useSLM))
tx = OFDMTransmitter(**params)
sig = tx.transmit(bitStream)
paprDb.append(calcPAPR(sig))
rx = OFDMReceiver(**params)
rx.padBits = tx.padBits
rx.SLMPhaseVectorIdx = tx.SLMPhaseVectorIdx
BER = []
for snr in snrRange:
# applying channel with fading
avgOFDMSymbolPower = np.mean(np.mean(np.power(np.abs(sig), 2),axis=-1))
channel = SISOFlatChannel(fading_param=( polar2rect(0.9,10.0), 0.19))
channel.set_SNR_dB(snr, Es=avgOFDMSymbolPower)
noisySig = channel.propagate(sig.flatten())
# decoding
rbitStream = rx.receive(noisySig)
BER.append(np.sum(np.logical_xor(rbitStream, bitStream)) /(1.0 * len(bitStream)))
print(" SLM = {} Clipping = {} Max PAPR (dB) = {:<5.3} SNR(db) = {:<4} BER = {:<5.3}".format(useSLM, useClipping, np.max(paprDb[-1]), snr, BER[-1]))
BERSets.append(BER)
legend[0] = 'No SLM or Clipping'
plotCCDF(paprDb, savePath='ClippingSLM_vs_PAPR.png', show=False,
steps=0.25, legend=legend,
title='Complementary Cumulative Distribution Function (CCDF) for PAPR\nUsing Clipping and SLM')
plotBER(BERSets, snrRange, xlabel='SNR (dB)', savePath='ClippingSLM_vs_BER.png', show=False, semilog=True,
title='Bit Error Rate in Rician Channel\nRelationship with Clipping OFDM Signal', legend=legend)
print("".join(["-"]*60), "\n\n")
import matplotlib.pyplot as plt
from ofdm import OFDMTransmitter, OFDMReceiver
from initialize.params import channel, h, bit_allocation, coef
from signals import awgn
params = dict()
params['BitAllocation'] = bit_allocation
params['Coef'] = coef
params['OverSampleRate'] = 4
params['CPLength'] = 100
symbol_num = 1000
bits_per_symbol = sum(params['BitAllocation'])
bit_send = np.random.randint(0, 2, bits_per_symbol * symbol_num)
tx = OFDMTransmitter(**params)
rx = OFDMReceiver(**params)
encoder_list = [
None,
'training/encoder_3.hdf5',
'training/encoder_5.hdf5',
'training/encoder_10.hdf5',
'training/encoder_30.hdf5',
]
decoder_list = [
None,
'training/decoder_3.hdf5',
'training/decoder_5.hdf5',
'training/decoder_10.hdf5',