コード例 #1
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")
コード例 #2
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")
コード例 #3
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")
コード例 #4
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")
コード例 #5
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")
コード例 #6
0
ファイル: genTrainData.py プロジェクト: shahruk10/PAPRnet
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)
コード例 #7
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")
コード例 #8
0
ファイル: main.py プロジェクト: shahruk10/PAPRnet
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")