def to_tfrecord(analysis_area,
object_file_name,
paths_file_name,
resolution=1,
antenna_number=4):
with open(object_file_name) as infile:
obj = objects.ObjectFile.from_file(infile)
interest_car_i = None
polygon_list = []
for structure_group in obj:
for structure_i, structure in enumerate(structure_group):
if structure.name == 'flowC.0':
interest_car_i = structure_i
for sub_structure in structure:
polygon_list.append(sub_structure.as_polygon())
matrix = calc_position_matrix(analysis_area, polygon_list, resolution)
#print(matrix.shape)
#matrix_plot(matrix[1])
paths = P2mPaths(paths_file_name)
rec_i = 0
departure_angle = paths.get_departure_angle_ndarray(rec_i + 1)
arrival_angle = paths.get_arrival_angle_ndarray(rec_i + 1)
p_gain = paths.get_p_gain_ndarray(rec_i + 1)
t1 = calc_rx_power(departure_angle, arrival_angle, p_gain, antenna_number)
t1 = np.abs(t1)
best_tx_rx = np.argwhere(t1 == np.max(t1))[0]
best_tx_rx = best_tx_rx.astype(np.uint8)
return matrix[interest_car_i], best_tx_rx
'ERROR: thisEpisodeNumber != ep_i. They are:',
thisEpisodeNumber, 'and', ep_i, 'file: ',
sumoOutputInfoFileName, 'read:', row)
exit(1)
break # process only first 2 rows / line AK-TODO should eliminate the loop
if simulation_info['scene_i'] != this_scene_i:
raise SceneNotInEpisodeSequenceError(
'Expecting {} found {}'.format(
this_scene_i,
simulation_info['scene_i'],
))
print(abs_paths_file_name
) # AK TODO take out this comment and use logging
paths = P2mPaths(abs_paths_file_name)
cir = P2mCir(abs_cir_file_name)
# for receiver_number in range(numTxRxPairsPerScene): #if num Tx = 1, then receiver_number is the receiver index
receiver_number = 0 # assume that each transmitter in this case has only 1 receiver associated to it
if paths.get_total_received_power(receiver_number + 1) is not None:
total_received_power = paths.get_total_received_power(
receiver_number + 1)
mean_time_of_arrival = paths.get_mean_time_of_arrival(
receiver_number + 1)
sixParameters = paths.get_6_parameters_for_all_rays(
receiver_number + 1)
numRays = sixParameters.shape[0]
areLOSChannels = paths.is_los(receiver_number + 1)
phases = cir.get_phase_ndarray(
def test_channel():
# RESULTS_DIR='/Users/psb/ownCloud/Projects/DNN Wireless/rwi-3d-modeling/restuls/run00000'
# RESULTS_DIR = 'D:/insitedata/pc128/example_working/restuls/run00000'
RESULTS_DIR = 'D:/github/5gm-rwi-simulation/example/results_new_simuls/run00003/'
antenna_number = 2
BASE_DIR = os.path.dirname(os.path.realpath(__file__))
P2MPATHS_FILE = os.path.join(RESULTS_DIR, 'study',
'model.paths.t001_01.r002.p2m')
print('Reading file', P2MPATHS_FILE)
with open(P2MPATHS_FILE, 'rb') as infile:
paths = P2mPaths(P2MPATHS_FILE)
#get info for a given receiver
rec_i = 0 #first receiver is 0 here and 1 in the database
departure_angles = paths.get_departure_angle_ndarray(rec_i + 1)
arrival_angles = paths.get_arrival_angle_ndarray(rec_i + 1)
p_gainsdB = paths.get_p_gain_ndarray(rec_i + 1)
abs_cir_file_name = P2MPATHS_FILE.replace(
"paths", "cir") # name for the impulse response (cir) file
if os.path.exists(abs_cir_file_name) == False:
print('ERROR: could not find file ', abs_cir_file_name)
print(
'Did you ask InSite to generate the impulse response (cir) file?'
)
exit(-1)
cir = P2mCir(abs_cir_file_name) #read impulse response with phases
pathPhasesInDegrees = cir.get_phase_ndarray(rec_i + 1)
if True: # enable for debugging with fixed angles
ad = (np.pi / 4) * 180 / np.pi # in degrees, as InSite provides
aa = (3 * np.pi / 2) * 180 / np.pi
g = 10
departure_angles = ad * np.ones(departure_angles.shape,
departure_angles.dtype)
arrival_angles = aa * np.ones(arrival_angles.shape,
arrival_angles.dtype)
p_gainsdB = g * np.ones(p_gainsdB.shape, p_gainsdB.dtype)
pathPhasesInDegrees = np.zeros(len(p_gainsdB))
print(arrival_angles.shape)
azimuths_tx = departure_angles[:, 1] # azimuth is 2nd column
azimuths_rx = arrival_angles[:, 1]
start = datetime.datetime.today()
t1_py = calc_rx_power(departure_angles, arrival_angles, p_gainsdB,
antenna_number)
number_Rx_antennas = antenna_number * antenna_number
number_Tx_antennas = antenna_number * antenna_number
normalizedAntDistance = 0.5
t1 = getNarrowBandUPAMIMOChannel(departure_angles,
arrival_angles,
p_gainsdB,
number_Tx_antennas,
number_Rx_antennas,
normalizedAntDistance=0.5)
t1 = np.abs(t1)
t2 = getNarrowBandULAMIMOChannel(azimuths_tx,
azimuths_rx,
p_gainsdB,
number_Tx_antennas,
number_Rx_antennas,
normalizedAntDistance=0.5,
angleWithArrayNormal=1,
pathPhases=pathPhasesInDegrees)
print('MSE 1 = ', np.mean(np.power(np.abs(t1 - t1_py), 2)))
print('MSE 2 = ', np.mean(np.power(np.abs(t1 - t2), 2)))
# print(t2)
t2 = np.abs(t2)
(bestRxIndex, bestTxIndex) = np.unravel_index(np.argmax(t2, axis=None),
t2.shape)
print('bestRxIndex: ', bestRxIndex, ' and bestTxIndex: ', bestTxIndex)
stop = datetime.datetime.today()
print(stop - start)
arrival_vec = calc_vec_i(i, arrival_omega, antenna_range)
H = H + path_gain[i] * departure_vec.conj().T * arrival_vec
t1 = wt.conj().T * H * wr
return t1
if __name__ == '__main__':
RESULTS_DIR = '/Users/psb/ownCloud/Projects/DNN Wireless/rwi-3d-modeling/restuls/run00000'
BASE_DIR = os.path.dirname(os.path.realpath(__file__))
P2MPATHS_FILE = os.path.join(RESULTS_DIR, 'study',
'model.paths.t001_01.r002.p2m')
with open(P2MPATHS_FILE, 'rb') as infile:
paths = P2mPaths(P2MPATHS_FILE)
departure_angle = paths.get_departure_angle_ndarray(1)
arrival_angle = paths.get_arrival_angle_ndarray(1)
p_gain = paths.get_p_gain_ndarray(1)
antenna_number = 4
print(arrival_angle.shape)
start = datetime.datetime.today()
t1_py = calc_rx_power(departure_angle, arrival_angle, p_gain,
antenna_number)
stop = datetime.datetime.today()
#print(np.mean(np.power(t1 - t1_py, 2)))
print(stop - start)
print(t1_py)
def calc_scene(self, object_file_name, paths_file_name):
with open(object_file_name) as infile:
obj = objects.ObjectFile.from_file(infile)
# store the polygons for which matrix will be calculated
polygons_of_interest_idx_list = []
# store the index of the receiver for each polygon in the first dimension of matrix
position_matrix_rec_map = []
l = self.n_paths_to_tfrecord
polygon_list = []
for structure_group in obj:
for structure in structure_group:
for sub_structure in structure:
if structure.name in self.cars_with_antenna:
polygons_of_interest_idx_list.append(len(polygon_list))
position_matrix_rec_map.append(
self.cars_with_antenna.index(structure.name))
polygon_list.append(sub_structure.as_polygon())
matrix = calc_position_matrix(
self.analysis_area,
polygon_list,
self.resolution,
polygons_of_interest_idx_list=polygons_of_interest_idx_list)
#print(matrix.shape)
#matrix_plot(matrix[1])
paths = P2mPaths(paths_file_name)
n_rec = len(self.cars_with_antenna)
matrix_scene = np.empty((n_rec, *matrix.shape[1:]), matrix.dtype)
matrix_scene.fill(np.nan)
best_tx_rx_scene = np.empty((n_rec, 2), np.uint8)
best_tx_rx_scene.fill(np.nan)
departure_angle_scene = np.empty((n_rec, l, 2), np.float32)
departure_angle_scene.fill(np.nan)
arrival_angle_scene = np.empty((n_rec, l, 2), np.float32)
arrival_angle_scene.fill(np.nan)
p_gain_scene = np.empty((n_rec, l), np.float32)
p_gain_scene.fill(np.nan)
t1_scene = np.empty(
(n_rec, self.n_antenna_elements, self.n_antenna_elements),
np.complex64)
t1_scene.fill(np.nan)
for rec_i, rec_name in enumerate(self.cars_with_antenna):
try:
obj_order_rec_i = position_matrix_rec_map.index(rec_i)
except ValueError:
pass
departure_angle = paths.get_departure_angle_ndarray(
obj_order_rec_i + 1).astype(np.float32)
arrival_angle = paths.get_arrival_angle_ndarray(obj_order_rec_i +
1).astype(
np.float32)
p_gain = paths.get_p_gain_ndarray(obj_order_rec_i + 1).astype(
np.float32)
if l < len(departure_angle):
logging.warning(
"Saving only {} of {} available paths for {}".format(
l, len(departure_angle), paths_file_name))
matrix_scene[rec_i, :] = matrix[obj_order_rec_i]
departure_angle_scene[
rec_i, :len(departure_angle), :] = departure_angle
arrival_angle_scene[rec_i, :len(arrival_angle), :] = arrival_angle
p_gain_scene[rec_i, :len(p_gain)] = p_gain
t1 = calc_rx_power(departure_angle, arrival_angle, p_gain, self.antenna_number, self.frequency) \
.astype(np.complex64)
t1_abs = np.abs(t1)
t1_scene[rec_i, :] = t1
best_tx_rx = np.argwhere(t1_abs == np.max(t1_abs))[0]
best_tx_rx_scene[rec_i, :] = best_tx_rx.astype(np.uint8)
#best_idx = np.argmax(p_gain)
#best_tx_rx = np.array((departure_angle[best_idx], arrival_angle[best_idx]), dtype=np.float32)
return matrix_scene, best_tx_rx_scene, departure_angle_scene, arrival_angle_scene, p_gain_scene, t1_scene