コード例 #1
0
def do_gen(content, decision):
    SER_S = np.empty((tau_range.shape[0], phi_range.shape[0]))
    SER_U = np.empty((tau_range.shape[0], phi_range.shape[0]))

    for tau_idx, tau in enumerate(tau_range):
        print("tau = %.2f" % (tau))

        # symbols of (synch"ed, unsynch"ed) sender
        if content in ("same",):
            tmp_syms = np.random.randint(16, size=nsyms + 2)
            send_syms = [tmp_syms, tmp_syms]
        else:
            send_syms = np.random.randint(16, size=2 * (nsyms + 2)).reshape(2, nsyms + 2)

        send_syms_s, send_syms_u = send_syms[0][1:-1], send_syms[1][1:-1]
        send_chips = pt.map_chips(*send_syms)

        RECV_CHIPS_I = pt.detect_i(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)
        RECV_CHIPS_Q = pt.detect_q(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)

        for phi_idx in range(len(phi_range)):
            recv_chips = np.empty(2 * RECV_CHIPS_I.shape[0])
            recv_chips[::2] = RECV_CHIPS_I[:, phi_idx]
            recv_chips[1::2] = RECV_CHIPS_Q[:, phi_idx]

            # slice bits to simulate hard decision decoder
            if decision in ("hard",):
                recv_chips = np.sign(recv_chips)

            recv_syms = pt.detect_syms_corr(recv_chips)[1:-1]

            SER_S[tau_idx, phi_idx] = sum(recv_syms != send_syms_s) / (1.0 * len(recv_syms))
            SER_U[tau_idx, phi_idx] = sum(recv_syms != send_syms_u) / (1.0 * len(recv_syms))

    np.savez_compressed("data/ser_Au%.2f_%s_%s_v2.npz" % (Au, content, decision), SER_S=SER_S, SER_U=SER_U, **settings)
コード例 #2
0
def do_gen(part, content, wide, numthreads):
	start_time = time.time()

	tau_range  = (tau_range_wide if wide else tau_range_g)
	Au_range   = (Au_range_wide  if wide else Au_range_g)

	tau_range = np.split(tau_range, numthreads)[part]

	PRR_S = np.zeros((tau_range.shape[0], Au_range.shape[0]))
	PRR_U = np.zeros((tau_range.shape[0], Au_range.shape[0]))

	for tau_idx, tau in enumerate(tau_range):
		if content in ('same',):
			send_chips = np.array([2*np.random.randint(2, size=2*nbits)-1]).reshape((2, nbits))
			send_chips = np.vstack((send_chips, send_chips))
		else:
			send_chips = np.array([2*np.random.randint(2, size=4*nbits)-1]).reshape((4, nbits))

		for Au_idx, Au in enumerate(Au_range):
			ber_u_phi = np.zeros(phi_range.shape[0])
			ber_s_phi = np.zeros(phi_range.shape[0])

			print('%s: tau=%7.3f, tau_step=(%3i/%3i), Au=%7.3f, Au_step=(%3i/%3i), runtime: %5.2f secs' %\
				(sys.argv[0], tau, tau_idx+1, tau_range.shape[0], Au, Au_idx+1, Au_range.shape[0], time.time() - start_time))

			start_time = time.time()

			RECV_CHIPS_I = pt.detect_i(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)
			RECV_CHIPS_Q = pt.detect_q(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)

			for phi_idx, phi in enumerate(phi_range):
				recv_chips       = np.zeros(2*RECV_CHIPS_I.shape[0])
				recv_chips[::2]  = np.sign(RECV_CHIPS_I[:,phi_idx])
				recv_chips[1::2] = np.sign(RECV_CHIPS_Q[:,phi_idx])

				usync_chips       = np.zeros(2*send_chips.shape[1])
				usync_chips[::2]  = send_chips[2]
				usync_chips[1::2] = send_chips[3]

				sync_chips       = np.zeros(2*send_chips.shape[1])
				sync_chips[::2]  = send_chips[0]
				sync_chips[1::2] = send_chips[1]

				# ignore chips that are only partially affected here
				ber_s_phi[phi_idx] = np.sum(recv_chips[2:-2] != sync_chips[2:-2])  / (1.0*len(recv_chips[2:-2]))
				ber_u_phi[phi_idx] = np.sum(recv_chips[2:-2] != usync_chips[2:-2]) / (1.0*len(recv_chips[2:-2]))

			PRR_S[tau_idx, Au_idx] = np.mean((1-ber_s_phi)**pktlen)
			PRR_U[tau_idx, Au_idx] = np.mean((1-ber_u_phi)**pktlen)

	np.savez_compressed('data/prr_AsAu_%s%s_part%i.npz'%(content, wide, part), PRR_S=PRR_S, PRR_U=PRR_U,
		tau_range=tau_range, As=As, Au_range=Au_range, phi_range=phi_range,
		pktlen=pktlen, nsteps=nsteps, nbits=nbits)
コード例 #3
0
def do_gen(content):
	start_time = time.time()

	BER_U = np.zeros((tau_range.shape[0], phi_range.shape[0]))
	BER_S = np.zeros((tau_range.shape[0], phi_range.shape[0]))

	for tau_idx in range(len(tau_range)):
		tau = tau_range[tau_idx]

		print("Step time for tau = %.3f: %.3fs"% (tau, time.time() - start_time))
		start_time = time.time()

		if content in ("same", ):
			send_chips = np.array([2*np.random.randint(2, size=2*nbits)-1]).reshape((2, nbits))
			send_chips = np.vstack((send_chips, send_chips))
		else:
			send_chips = np.array([2*np.random.randint(2, size=4*nbits)-1]).reshape((4, nbits))

		RECV_CHIPS_I = pt.detect_i(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)
		RECV_CHIPS_Q = pt.detect_q(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)

		for phi_idx in range(len(phi_range)):
			recv_chips       = np.empty(2*RECV_CHIPS_I.shape[0])
			recv_chips[ ::2] = np.sign(RECV_CHIPS_I[:,phi_idx])
			recv_chips[1::2] = np.sign(RECV_CHIPS_Q[:,phi_idx])

			sync_chips       = np.empty(2*send_chips.shape[1])
			sync_chips[ ::2] = send_chips[0]
			sync_chips[1::2] = send_chips[1]

			usync_chips       = np.empty(2*send_chips.shape[1])
			usync_chips[ ::2] = send_chips[2]
			usync_chips[1::2] = send_chips[3]

			# ignore chips that are only partially affected here (the outermost two chips)
			BER_U[tau_idx, phi_idx] = np.sum(recv_chips[2:-2] != usync_chips[2:-2]) / (1.0*len(recv_chips[2:-2]))
			BER_S[tau_idx, phi_idx] = np.sum(recv_chips[2:-2] != sync_chips[2:-2])  / (1.0*len(recv_chips[2:-2]))

	np.savez_compressed("data/ber_Au%.2f_%s.npz"%(Au, content), BER_S=BER_S, BER_U=BER_U, **settings)
コード例 #4
0
def do_gen(part, content, decision, wide, numthreads):
	if wide == "_uwide":
		tau_range = tau_range_uwide
		Au_range  = Au_range_uwide
	elif wide == "_wide":
		tau_range = tau_range_wide
		Au_range  = Au_range_wide
	else:
		tau_range = tau_range_norm
		Au_range  = Au_range_norm


	start_time = time.time()

	tau_range = np.split(tau_range, numthreads)[part]

	PRR_S = np.zeros((tau_range.shape[0], Au_range.shape[0]))
	PRR_U = np.zeros((tau_range.shape[0], Au_range.shape[0]))

	SER_S_PHI = np.zeros((tau_range.shape[0], phi_range.shape[0]))
	SER_U_PHI = np.zeros((tau_range.shape[0], phi_range.shape[0]))

	for tau_idx, tau in enumerate(tau_range):
		# symbols of (synch"ed, unsynch"ed) sender
		if content in ("same",):
			tmp_syms= np.random.randint(16, size=nsyms+2)
			send_syms = np.vstack((tmp_syms, tmp_syms))
		else:
			send_syms = np.random.randint(16, size=2*(nsyms+2)).reshape(2, nsyms+2)

		send_syms_s, send_syms_u = send_syms[0][1:-1], send_syms[1][1:-1]
		send_chips = pt.map_chips(*send_syms)

		#RECV_CHIPS_I_A = pt.detect_i(send_chips[:2], send_chips[2:], phi_range, tau, As, Au_range)
		#RECV_CHIPS_Q_A = pt.detect_q(send_chips[:2], send_chips[2:], phi_range, tau, As, Au_range)

		for Au_idx, Au in enumerate(Au_range):
			print("%s: tau=%7.3f, tau_step=(%3i/%3i), Au=%7.3f, Au_step=(%3i/%3i), runtime: %5.2f secs" %\
				(sys.argv[0], tau, tau_idx+1, tau_range.shape[0], Au, Au_idx+1, Au_range.shape[0], time.time() - start_time))
			start_time = time.time()

			RECV_CHIPS_I = pt.detect_i(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)
			RECV_CHIPS_Q = pt.detect_q(send_chips[:2], send_chips[2:], phi_range, tau, As, Au)

			for phi_idx, phi in enumerate(phi_range):
				# Interleave the I and Q phase (this is faster than np.ravel)
				recv_chips       = np.zeros(2*RECV_CHIPS_I.shape[0])
				recv_chips[ ::2] = RECV_CHIPS_I[:,phi_idx]
				recv_chips[1::2] = RECV_CHIPS_Q[:,phi_idx]

				if decision in ("hard",):
					recv_chips = np.sign(recv_chips)

				recv_syms = pt.detect_syms_corr(recv_chips)[1:-1]

				SER_S_PHI[tau_idx, phi_idx] = np.sum(recv_syms != send_syms_s) / (1.0*len(recv_syms))
				SER_U_PHI[tau_idx, phi_idx] = np.sum(recv_syms != send_syms_u) / (1.0*len(recv_syms))

			PRR_S[tau_idx, Au_idx] = np.mean((1.0-SER_S_PHI[tau_idx,:])**pktlen)
			PRR_U[tau_idx, Au_idx] = np.mean((1.0-SER_U_PHI[tau_idx,:])**pktlen)

	np.savez_compressed("data/prr_AsAu_%s_%s%s_part%i.npz"%(content, decision, wide, part),
						PRR_S=PRR_S, PRR_U=PRR_U, **settings)