def simulation(flame=1000, user=4, user_antenna=1, BS=1, BS_antenna=4, select_user=4, Nc=128, CP=1, path=1, Ps=1.0, data_symbol=128, M=4, conv_type='soft', code_rate=1/2, zad_len=16, zad_num=1, zad_shift=0, channel_type='Rayleigh', last_snr=30): code_symbol = int(data_symbol * 1/code_rate) bit_rate = Bitrate(M).count_bit_rate() selection = Selection(user, user_antenna, BS, BS_antenna, select_user) channel = Channel(user, user_antenna, BS_antenna, Nc, path, CP, Ps, code_symbol) convcode = Convcode(select_user, user_antenna, BS_antenna, data_symbol, bit_rate, code_rate, conv_type) modulation = Modulation(M, code_symbol, data_symbol, bit_rate, select_user, user_antenna, BS_antenna) equalization = Equalization(code_symbol, select_user, user_antenna, BS_anntena, Nc) for SNRdB in range(0,31): SNR = 10 ** (SNRdB / 10) No = 1 / SNR sigma = math.sqrt(No/2) true = Result(flame, user, BS, data_symbol, Nc) for count in tqdm(range(flame)): # Create channel true_channel = channel.create_rayleigh_channel() # User selection seleced_channel = selection.selection(true_channel) # Randomly create send bit with 0 and 1 send_data = np.random.randint(0,2, select_user * user_antenna * data_symbol * bit_rate) # Serial to Parallel send_bit = Serial2Parallel(send_data, select_user, user_antenna, bit_rate, data_symbol).create_parallel() # Conv coding encode_bit = convcode.encoding(send_bit) # Modulation mod_signal = modulation.modulation(encode_bit) # Channel multiplication receive_signal = channel.channel_multiplication(seleced_channel, mod_signal) # Create noise noise = Noise().create_noise(code_symbol, sigma, BS_anntena) # Add noise receive_signal += noise # ZF equalization receive_weight_signal = equalization.MMSE(receive_signal, seleced_channel, SNR) # Demodulation demod_bit = modulation.demodulation(receive_weight_signal, conv_type, sigma) # Conv decoding decode_bit = convcode.decoding(demod_bit) # Parallel to Serial receive_data = Parallel2Serial(decode_bit).create_serial() # BER & NMSE & TRP true.calculate(count, send_data, receive_data, mod_signal, noise, SNR, M, bit_rate, code_rate)
def simulation(flame=1000, user=16, BS=1, Nc=128, CP=1, path=1, Ps=1.0, BW=1/6, data_symbol=128, conv_type='soft', total_bit=8, zad_len=16, zad_num=1, zad_shift=0, channel_type='Rayleigh', last_snr=30): convcode = Convcode(user, BS, data_symbol, conv_type) modulation = Modulation(user, BS) channel = Channel(user, BS, Nc, path, CP, Ps) weight = Weight(user, BS) for SNR in range(0,31): sigma = math.sqrt( Ps / (2 * math.pow(10.0, SNR/10))) true = Result(flame, user, BS, data_symbol, Nc) for count in tqdm(range(flame)): # Create channel true_channel = channel.create_rayleigh_channel() # Bit allocation & Send power control num_stream, bit_rate, send_power, code_rate = BERControl(user, BS, true_channel, sigma, Ps, total_bit).bit_allocation() # Randomly create send bit with 0 and 1 send_data = np.random.randint(0,2,data_symbol*total_bit) # Serial to Parallel send_bit = Serial2Parallel(send_data, bit_rate, data_symbol).create_parallel() # Conv coding encode_bit, code_symbol = convcode.encoding(send_bit, num_stream, bit_rate, code_rate) # Modulation send_signal = modulation.modulation(encode_bit, num_stream, bit_rate, code_symbol) # Send weight multiplication send_weight_signal = weight.send_weight_multiplication(send_signal, true_channel, num_stream, send_power) # Channel multiplication receive_signal = channel.channel_multiplication(send_weight_signal, code_symbol) # Create noise noise = Noise().create_noise(code_symbol, sigma, BS) # Add noise receive_signal += noise # receive weight multiplication receive_weight_signal = weight.receive_weight_multiplication(receive_signal) # Demodulation demod_bit = modulation.demodulation(receive_weight_signal, conv_type, sigma) # Conv decoding decode_bit = convcode.decoding(demod_bit) # Parallel to Serial receive_data = Parallel2Serial(decode_bit, bit_rate, data_symbol).create_serial() # BER true.calculate(count, send_data, receive_data, send_weight_signal, noise, SNR, total_bit)
def createDownloadDirectory(self, channel: Channel) -> Path: channelDirectory = Path(self.__downloadDirectory / channel.getTitle()) if channelDirectory.exists(): raise IOError('Channel "' + channel.getTitle() + '" already has a directory. ' 'Move or remove directory and try again.') channelDirectory.mkdir() return channelDirectory
def create_train(self): for sample in range(self.flame): self.channel = Channel(self.symbol, self.user, self.BS, 1, self.path, self.CP, self.Ps).create_rayleigh_channel() estimated_channel, receive_pilot_signal = Estimate( self.pilot_signal, self.channel, self.user, self.BS, self.path, self.sigma, 1).least_square_estimate() self.file_writing(sample, estimated_channel.reshape(1, self.user), receive_pilot_signal.reshape(1, self.pilot_len), self.channel.reshape(1, self.user))
def parse(self, url: str, feedContent: str) -> Iterator[Episode]: tree = cElementTree.fromstring(feedContent) channel = Channel(self.getChannelTitle(tree), url) for episode in tree.iter('item'): yield self.parseEpisode(episode, channel)
fig = plt.figure() ax = fig.add_subplot(1, 1, 1) for i in range(user): ax.plot(x, cumulative_matrix[i], linestyle='-', color='k') plt.gca().xaxis.set_tick_params(direction='in') plt.gca().yaxis.set_tick_params(direction='in') ax.set_xlabel('eigenvalue [dB]', fontsize=12) ax.set_ylabel('Cumulative probability', fontsize=12) plt.grid(which="both") plt.savefig('Image/CDF/user{}_BS{}.pdf'.format(user, BS)) #-----------NMSE-------- symbol = 128 user = 4 BS = 4 Nc = 128 path = 1 CP = 1 Ps = 1 channel = Channel(symbol, user, BS, Nc, path, CP, Ps) cumulative_probability(channel, user, BS)
select_user = math.floor(BS_antenna / user_antenna) # 選択されたユーザ数 Nc = 72 # 搬送波数 CP = 1 # CP数 path = 1 # パス数 Ps = 1.0 # 総送信電力 SNRdB = 10 SNR = 10**(SNRdB / 10) symbol = 72 frame = 100 channel = Channel(user, user_antenna, BS_antenna, Nc, path, CP, Ps, symbol) selection = Selection(user, user_antenna, BS, BS_antenna, select_user) CDUS = [] RAND = [] ALL = [] for SNRdB in tqdm(range(0, 31)): SNR = 10**(SNRdB / 10) cdus = 0 rand = 0 all = 0 for _ in range(frame): true_channel = channel.create_rayleigh_channel()
from Model.Channel import Channel from Model.Estimate import Estimate user = 19 BS = 2 path = 1 pilot_len = 9 size = 19 symbol = 128 Nc = 128 CP = 1 Ps = 1.0 EbN0 = 30 sigma = math.sqrt(0.5 * math.pow(10.0, (-1) * EbN0 * 0.1)) channel = Channel(symbol, user, BS, Nc, path, CP, Ps) true_channel = channel.create_rayleigh_channel() dft_pilot = DFTSequence(user, path, pilot_len, size).create_pilot() frame_pilot = Frame(user, pilot_len).create_frame_matrix() for r in range(BS): tmp_channel = np.zeros((user * path, 1), dtype=np.complex) for s in range(user): for p in range(path): tmp_channel[s * path + p, 0] = true_channel[p, user * r + s] tmp_receive = np.dot(frame_pilot, tmp_channel) A_ = np.linalg.pinv(frame_pilot)
path = 1 CP = 1 Ps = 1 total_bit = user * 2 code_rates = [1 / 2, 2 / 3, 3 / 4] frame = 2 conv_type = 'soft' BW = 1 / 6 bit_dict = [] convcode = Convcode(user, BS, data_symbol, conv_type) modulation = Modulation(user, BS) channel = Channel(user, BS, Nc, path, CP, Ps) weight = Weight(user, BS) for cnt in tqdm(range(count)): if is_random == True: SNRdB = random.randint(20, 25) SNR = 10**(SNRdB / 10) No = 1 / SNR sigma = math.sqrt(No / 2) true_channel = channel.create_rayleigh_channel() H = np.zeros((BS, user), dtype=np.complex) for r in range(BS): for s in range(user): H[r][s] = true_channel[0][BS * r + s]
def simulation(flame=1000, user=16, BS=1, Nc=128, CP=1, path=1, Ps=1.0, BW=80, data_symbol=100, Ms=4, code_rates=1 / 2, conv_type='hard', zad_len=4, zad_num=0, zad_shift=1, channel_type='Rayleigh', csv_column=False, last_snr=30): for SNR in range(0, last_snr): sigma = math.sqrt(Ps / (2 * math.pow(10.0, SNR / 10))) zadoff_pilot = ZadoffSequence(user, path, zad_len, zad_num, zad_shift).create_pilot() zadoff_estimate = Estimate(zadoff_pilot, user, BS, path, sigma, Nc) # dft_pilot = DFTSequence(user, path, pilot_len, size).create_pilot() # frame_pilot = Frame(user, pilot_len).create_frame_matrix() true = Result(flame, user, BS, BW, data_symbol, Nc, conv_type, channel_type, csv_column, last_snr) zadoff = Result(flame, user, BS, BW, data_symbol, Nc, conv_type, channel_type, csv_column, last_snr) for code_rate in code_rates: for M in Ms: code_symbol = int(data_symbol * 1 / code_rate) bit_rate = Bitrate(M).count_bit_rate() convcode = Convcode(user, BS, data_symbol, bit_rate, code_rate, conv_type) modulation = Modulation(M, code_symbol, data_symbol, bit_rate, user, BS) channel = Channel(code_symbol, user, BS, Nc, path, CP, Ps, channel_type) equalization = Equalization(code_symbol, user, BS, Nc) for count in tqdm(range(flame)): # Randomly create send bit with 0 and 1 send_data = np.random.randint( 0, 2, user * data_symbol * bit_rate) # Serial to Parallel send_bit = Serial2Parallel(send_data, user, bit_rate, data_symbol).create_parallel() # Conv coding encode_bit = convcode.encoding(send_bit) # Modulation mod_signal = modulation.modulation(encode_bit) # Create channel true_channel = channel.create_channel() # Channel multiplication receive_signal = channel.channel_multiplication(mod_signal) # Create noise noise = Noise().create_noise(code_symbol, sigma, BS) # Add noise receive_signal += noise # ZF equalization receive_weight_signal = equalization.ZF( receive_signal, true_channel) # Demodulation demod_bit = modulation.demodulation( receive_weight_signal, conv_type, sigma) # Conv decoding decode_bit = convcode.decoding(demod_bit) # Parallel to Serial receive_data = Parallel2Serial(decode_bit).create_serial() # BER & NMSE & TRP true.calculate(count, send_data, receive_data, mod_signal, noise, SNR, M, bit_rate, code_rate) #---------------------------- zadoff ------------------------------------- # channel estimate zadoff_channel = zadoff_estimate.least_square_estimate( true_channel) # Frequency domain equalization zadoff_signal = equalization.ZF(receive_signal, zadoff_channel) # Demodulation zadoff_demod_bit = modulation.demodulation( zadoff_signal, conv_type, sigma) # Conv decoding zadoff_decode_bit = convcode.decoding(zadoff_demod_bit) # Parallel to Serial zadoff_receive_data = Parallel2Serial( zadoff_decode_bit).create_serial() # BER & NMSE & TRP zadoff.calculate(count, send_data, zadoff_receive_data, mod_signal, noise, SNR, M, bit_rate, code_rate, true_channel, zadoff_channel)
class Train: def __init__(self, flame=10500, symbol=128, user=16, BS=1, CP=1, path=1, Ps=1.0, EbN0=20, pilot_len=16, size=16, type=None): self.flame = flame self.symbol = symbol self.user = user self.BS = BS self.CP = CP self.path = path self.Ps = Ps self.EbN0 = EbN0 self.sigma = math.sqrt(0.5 * math.pow(10.0, (-1) * EbN0 * 0.1)) self.pilot_len = pilot_len self.size = size self.type = type if self.type == 'DFT': self.pilot_signal = DFTSequence(user, path, pilot_len, size).create_pilot() if self.type == 'frame': self.pilot_signal = Frame(user, pilot_len).create_frame_matrix() def create_train(self): for sample in range(self.flame): self.channel = Channel(self.symbol, self.user, self.BS, 1, self.path, self.CP, self.Ps).create_rayleigh_channel() estimated_channel, receive_pilot_signal = Estimate( self.pilot_signal, self.channel, self.user, self.BS, self.path, self.sigma, 1).least_square_estimate() self.file_writing(sample, estimated_channel.reshape(1, self.user), receive_pilot_signal.reshape(1, self.pilot_len), self.channel.reshape(1, self.user)) def file_writing(self, sample, estimated_channel, receive_pilot_signal, channel): dir = "Data/train_data/{}".format(self.type) if not os.path.exists(dir): os.makedirs(dir) ls_dir = "{}/ls".format(dir) if not os.path.exists(ls_dir): os.makedirs(ls_dir) ls_file = "{}/size{}_pilot{}_user{}.csv".format( ls_dir, self.size, self.pilot_len, self.user) if not os.path.exists(ls_file): pathlib.Path(ls_file).touch() if sample == 0: with open(ls_file, 'w') as f: writer = csv.writer(f, lineterminator='\n') writer.writerows( np.concatenate([ np.real(estimated_channel), np.imag(estimated_channel) ], 1)) else: with open(ls_file, 'a') as f: writer = csv.writer(f, lineterminator='\n') writer.writerows( np.concatenate([ np.real(estimated_channel), np.imag(estimated_channel) ], 1)) receive_dir = "{}/receive".format(dir) if not os.path.exists(receive_dir): os.makedirs(receive_dir) receive_file = "{}/size{}_pilot{}_user{}.csv".format( receive_dir, self.size, self.pilot_len, self.user) if not os.path.exists(receive_file): pathlib.Path(receive_file).touch() if sample == 0: with open(receive_file, 'w') as f: writer = csv.writer(f, lineterminator='\n') writer.writerows( np.concatenate([ np.real(receive_pilot_signal), np.imag(receive_pilot_signal) ], 1)) else: with open(receive_file, 'a') as f: writer = csv.writer(f, lineterminator='\n') writer.writerows( np.concatenate([ np.real(receive_pilot_signal), np.imag(receive_pilot_signal) ], 1)) true_dir = "{}/true".format(dir) if not os.path.exists(true_dir): os.makedirs(true_dir) true_file = "{}/size{}_pilot{}_user{}.csv".format( true_dir, self.size, self.pilot_len, self.user) if not os.path.exists(true_file): pathlib.Path(true_file).touch() if sample == 0: with open(true_file, 'w') as f: writer = csv.writer(f, lineterminator='\n') writer.writerows( np.concatenate( [np.real(channel), np.imag(channel)], 1)) else: with open(true_file, 'a') as f: writer = csv.writer(f, lineterminator='\n') writer.writerows( np.concatenate( [np.real(channel), np.imag(channel)], 1))