% Advanced 4x4 MIMO Wireless Propagation Evaluation

% Operating Frequency: 14 GHz

% Environments: Rural, Urban, Suburban
% Features: Polarization, Mobility, Modulation/Coding
% Correspondence: Dr A. Rahimian (rahimian@ieee.org)

clear;
close all;
clc;

% Define the environments to be analyzed

environments = {'rural', 'urban', 'suburban'};
all_results = struct();

% Perform analysis for each environment

for i = 1:length(environments)
% Define system parameters for each environment
params = define_system_parameters(environments{i});

% Generate MIMO channel matrix

H = generate_mimo_channel(params);

% Perform MIMO system analysis

results = analyze_mimo_system(H, params);

% Store results
all_results.(environments{i}) = results;
end

% Display and plot results

display_comparative_results(all_results, environments);

% Section 1: Define System Parameters

% This function defines and returns system parameters based on the environment
function params = define_system_parameters(environment)
% Common parameters for all environments
params.freq = 14e9; % Operating frequency (14 GHz)
params.c = 3e8; % Speed of light (m/s)
params.lambda = params.c / params.freq; % Wavelength (m)
params.num_tx = 4; % Number of transmit antennas
params.num_rx = 4; % Number of receive antennas
params.snr_db = 20; % Signal-to-Noise Ratio in dB
params.num_subcarriers = 64; % Number of OFDM subcarriers
params.num_realizations = 1000; % Number of channel realizations for Monte Carlo
simulation
params.distance = 1000; % Distance between transmitter and receiver (m)
params.antenna_spacing = 0.5 * params.lambda; % Antenna spacing (uniform linear array)
params.transmit_power = 1; % Transmit power in watts
params.environment = environment; % Environment type
params.target_rate = 10; % Target rate for outage probability (bits/s/Hz)

% Enhanced parameters for the analysis

params.polarization = 'dual'; % 'single' or 'dual' polarization
params.modulation = '16QAM'; % 'BPSK', 'QPSK', '16QAM', or '64QAM'
params.coding_rate = 1/2; % Rate for convolutional coding

% Environment-specific parameters
switch environment
case 'urban'
params.path_loss_exp = 3.5;
params.angle_spread = 35;
params.corr_factor = 0.7;
params.velocity = 3; % 3 m/s (walking speed)
case 'suburban'
params.path_loss_exp = 3.0;
 params.angle_spread = 25;
params.corr_factor = 0.5;
params.velocity = 10; % 10 m/s (vehicular speed)
otherwise % rural
params.path_loss_exp = 2.8;
params.angle_spread = 15;
params.corr_factor = 0.2;
params.velocity = 20; % 20 m/s (high-speed vehicular)
end

% Calculate maximum Doppler shift

params.max_doppler = params.velocity * params.freq / params.c;
end

% Section 2: Generate MIMO Channel Matrix

% This function generates the MIMO channel matrix incorporating path loss,
% antenna spacing effects, environment-specific effects, polarization, and Doppler spread.
function H = generate_mimo_channel(params)
% Generate random MIMO channel matrix
H = (randn(params.num_rx, params.num_tx, params.num_subcarriers) + ...
1i * randn(params.num_rx, params.num_tx, params.num_subcarriers)) / sqrt(2);

% Apply path loss

path_loss = 10^(-compute_path_loss(params)/10); % Convert dB to linear scale
H = H * sqrt(path_loss);

% Apply antenna spacing effects

for i = 1:params.num_tx
for j = 1:params.num_rx
phase = 2 * pi * params.antenna_spacing * (i-1) * sin(pi/6) / params.lambda;
H(j,i,:) = H(j,i,:) * exp(1i * phase);
end
end

% Apply environment-specific correlation

corr_matrix = eye(params.num_rx) + params.corr_factor * (ones(params.num_rx) -
eye(params.num_rx));
H = reshape(corr_matrix * reshape(H, params.num_rx, []), params.num_rx, params.num_tx,
params.num_subcarriers);

% Apply polarization effects

H = apply_polarization(H, params.polarization);

% Apply Doppler spread

H = apply_doppler_spread(H, params);
end

% Section 3: Apply Polarization Effects

% This function applies polarization effects to the channel matrix
function H = apply_polarization(H, polarization)
if strcmp(polarization, 'dual')
% For dual polarization, split the antennas into two polarization states
H_pol = zeros(size(H));
for i = 1:size(H, 3)
H_pol(:,:,i) = [H(1:2,1:2,i), 0.7*H(1:2,3:4,i); ...
0.7*H(3:4,1:2,i), H(3:4,3:4,i)];
end
H = H_pol;
end
% For single polarization, keep H as is
end

% Section 4: Apply Doppler Spread

% This function applies Doppler spread to the channel matrix
function H = apply_doppler_spread(H, params)
 num_subcarriers = params.num_subcarriers;
doppler_shift = params.max_doppler * cos(2*pi*rand(params.num_rx, params.num_tx));
time_variation = exp(1i * 2*pi * doppler_shift .* reshape(0:num_subcarriers-1, 1, 1, [])
/ num_subcarriers);

% Ensure time_variation dimensions match H dimensions

for k = 1:num_subcarriers
H(:,:,k) = H(:,:,k) .* time_variation(:,:,k);
end
end

% Section 5: Analyze MIMO System

% This function performs various analyses on the MIMO system
function results = analyze_mimo_system(H, params)
results = struct();

% 1. Channel Capacity
results.capacity = zeros(params.num_subcarriers, 1);
for k = 1:params.num_subcarriers
results.capacity(k) = compute_channel_capacity(H(:,:,k), params.transmit_power);
end
results.avg_capacity = mean(results.capacity);

% 2. Singular Value Decomposition (SVD)

results.svd_gains = zeros(params.num_rx, params.num_subcarriers);
for k = 1:params.num_subcarriers
[~, S, ~] = svd(H(:,:,k));
results.svd_gains(:,k) = diag(S);
end

% 3. Condition Number
results.condition_number = zeros(params.num_subcarriers, 1);
for k = 1:params.num_subcarriers
results.condition_number(k) = cond(H(:,:,k));
end
results.avg_condition_number = mean(results.condition_number);

% 4. Path Loss
results.path_loss_db = compute_path_loss(params);

% 5. BER Analysis
results.SNR_dB = 0:5:30; % SNR range in dB
results.ber = compute_ber(H(:,:,1), results.SNR_dB, params);

% 6. Spatial Correlation
[results.R_tx, results.R_rx] = compute_spatial_correlation(params);

% 7. Ergodic Capacity
results.ergodic_capacity = compute_ergodic_capacity(H, params, results.R_tx,
results.R_rx);

% 8. Outage Probability
results.outage_prob = sum(results.ergodic_capacity < params.target_rate) /
params.num_realizations;

% 9. Channel Rank
results.rank_channel = rank(H(:,:,1));

% 10. Channel Gain

results.channel_gain = norm(H(:,:,1), 'fro');

% 11. Diversity Order

results.diversity_order = compute_diversity_order(H(:,:,1));

% 12. Eigenvalue Analysis

 results.correlation_matrix = compute_correlation_matrix(H(:,:,1));
results.eigenvalues = eig(results.correlation_matrix);
end

% Section 6: Compute Channel Capacity

% This function computes the channel capacity using the Shannon-Hartley theorem
function channel_capacity = compute_channel_capacity(H, transmit_power)
noise_power_dBm = -174; % Assume thermal noise at room temperature
noise_power = 10^(noise_power_dBm / 10) / 1000; % Convert to watts
SNR = transmit_power / noise_power;
channel_capacity = log2(real(det(eye(size(H, 1)) + (SNR / size(H, 2)) * (H * H'))));
end

% Section 7: Compute Path Loss

% This function computes path loss using the selected model
function path_loss_db = compute_path_loss(params)
path_loss_db = 20*log10(4*pi*params.distance/params.lambda) + ...
10*params.path_loss_exp*log10(params.distance/1000);
end

% Section 8: Compute Bit Error Rate (BER)

% This function computes the bit error rate (BER) for different SNR values
function ber = compute_ber(H, SNR_dB, params)
[num_rx, num_tx, ~] = size(H);
ber = zeros(size(SNR_dB));
num_bits = 1e6; % Number of bits to simulate

for i = 1:length(SNR_dB)
SNR_linear = 10^(SNR_dB(i) / 10);
noise_variance = 1 / SNR_linear;

% Generate random bits

bits = randi([0 1], num_tx, num_bits);

% Apply channel coding

coded_bits = apply_channel_coding(bits, params.coding_rate);

% Modulate
symbols = modulate(coded_bits, params.modulation);

% Pass through channel (reshape symbols to match H dimensions)

symbols = reshape(symbols, num_tx, []);
received = H(:,:,1) * symbols + sqrt(noise_variance/2) * (randn(num_rx, size(symbols,
2)) + 1i * randn(num_rx, size(symbols, 2)));

% Equalize and demodulate

equalized = pinv(H(:,:,1)) * received;
demodulated = demodulate(equalized, params.modulation);

% Apply channel decoding

decoded_bits = apply_channel_decoding(demodulated, params.coding_rate);

% Compute BER
ber(i) = sum(sum(decoded_bits(:, 1:num_bits) ~= bits)) / (num_tx * num_bits);
end
end

% Section 9: Apply Channel Coding

% This function applies simple convolutional coding (rate 1/2)
function coded_bits = apply_channel_coding(bits, ~)
trellis = poly2trellis(7, [171 133]);
coded_bits = convenc(bits(:), trellis);
coded_bits = reshape(coded_bits, size(bits, 1), []);
end
% Section 10: Apply Channel Decoding
% This function applies Viterbi decoding
function decoded_bits = apply_channel_decoding(soft_bits, ~)
trellis = poly2trellis(7, [171 133]);
decoded_bits = vitdec(soft_bits(:), trellis, 5, 'trunc', 'soft', 3);
decoded_bits = reshape(decoded_bits, size(soft_bits, 1), []);
end

% Section 11: Modulate Bits

% This function modulates bits based on the specified modulation type
function symbols = modulate(bits, modulation_type)
switch modulation_type
case 'BPSK'
symbols = 2 * bits - 1;
case 'QPSK'
symbols = (1-2*bits(1:2:end)) + 1i*(1-2*bits(2:2:end));
symbols = symbols / sqrt(2);
case '16QAM'
symbols = qammod(bi2de(reshape(bits, 4, []).'), 16, 'gray', 'UnitAveragePower',
true);
case '64QAM'
symbols = qammod(bi2de(reshape(bits, 6, []).'), 64, 'gray', 'UnitAveragePower',
true);
otherwise
error('Unsupported modulation type');
end
end

% Section 12: Demodulate Symbols

% This function demodulates symbols based on the specified modulation type
function bits = demodulate(symbols, modulation_type)
switch modulation_type
case 'BPSK'
bits = real(symbols) > 0;
case 'QPSK'
bits = [real(symbols) > 0; imag(symbols) > 0];
bits = bits(:).';
case '16QAM'
demod = qamdemod(symbols, 16, 'gray', 'UnitAveragePower', true);
bits = reshape(de2bi(demod, 4), 1, []);
case '64QAM'
demod = qamdemod(symbols, 64, 'gray', 'UnitAveragePower', true);
bits = reshape(de2bi(demod, 6), 1, []);
otherwise
error('Unsupported modulation type');
end
end

% Section 13: Compute Spatial Correlation

% This function computes spatial correlation matrices
function [R_tx, R_rx] = compute_spatial_correlation(params)
theta = deg2rad(linspace(-params.angle_spread/2, params.angle_spread/2, 100));
R_tx = zeros(params.num_tx);
R_rx = zeros(params.num_rx);

for m = 1:params.num_tx
for n = 1:params.num_tx
R_tx(m,n) = mean(exp(-1i*2*pi*params.antenna_spacing*(m-n)*sin(theta)));
end
end

for m = 1:params.num_rx
for n = 1:params.num_rx
R_rx(m,n) = mean(exp(-1i*2*pi*params.antenna_spacing*(m-n)*sin(theta)));
end
 end
end

% Section 14: Compute Ergodic Capacity

% This function computes ergodic capacity considering spatial correlation
function ergodic_capacity = compute_ergodic_capacity(H, params, R_tx, R_rx)
ergodic_capacity = zeros(params.num_realizations, 1);
for i = 1:params.num_realizations
H_corr = sqrt(R_rx) * H(:,:,1) * sqrt(R_tx);
ergodic_capacity(i) = compute_channel_capacity(H_corr, params.transmit_power);
end
end

% Section 15: Compute Diversity Order

% This function computes the diversity order of the channel
function diversity_order = compute_diversity_order(H)
singular_values = svd(H);
tolerance = max(size(H)) * eps(norm(H));
diversity_order = sum(singular_values > tolerance);
end

% Section 16: Compute Correlation Matrix

% This function computes the correlation matrix of the channel
function correlation_matrix = compute_correlation_matrix(H)
correlation_matrix = (H * H') / size(H, 2);
end

% Section 17: Display Comparative Results

% This function displays and plots the comparative results for all environments
function display_comparative_results(all_results, environments)
% Plot comparative channel capacity
figure;
hold on;
for i = 1:length(environments)
plot(1:length(all_results.(environments{i}).capacity),
all_results.(environments{i}).capacity);
end
title('Channel Capacity across Subcarriers');
xlabel('Subcarrier Index');
ylabel('Capacity (bits/s/Hz)');
legend(environments);
hold off;

% Plot comparative singular values

figure;
hold on;
for i = 1:length(environments)
plot(1:size(all_results.(environments{i}).svd_gains, 2),
all_results.(environments{i}).svd_gains);
end
title('Singular Values across Subcarriers');
xlabel('Subcarrier Index');
ylabel('Singular Value Magnitude');
legend(environments);
hold off;

% Plot comparative BER vs SNR

figure;
hold on;
for i = 1:length(environments)
semilogy(all_results.(environments{i}).SNR_dB, all_results.(environments{i}).ber, 'o-
');
end
xlabel('SNR (dB)');
ylabel('Bit Error Rate (BER)');
 title('BER vs SNR');
legend(environments);
grid on;
hold off;

% Plot comparative spatial correlation

for i = 1:length(environments)
figure;
subplot(1,2,1);
imagesc(abs(all_results.(environments{i}).R_tx));
title(['Transmit Spatial Correlation - ' environments{i}]);
colorbar;
subplot(1,2,2);
imagesc(abs(all_results.(environments{i}).R_rx));
title(['Receive Spatial Correlation - ' environments{i}]);
colorbar;
end

% Plot comparative eigenvalues of the correlation matrix

figure;
hold on;
for i = 1:length(environments)
plot(sort(all_results.(environments{i}).eigenvalues, 'descend'), 'o-');
end
xlabel('Eigenvalue Index');
ylabel('Eigenvalue');
title('Eigenvalues of the Correlation Matrix');
legend(environments);
hold off;

% Display comparative results in a table

results_table = table('Size', [length(environments), 7], ...
'VariableTypes', {'string', 'double', 'double', 'double', 'double',
'double', 'double'}, ...
'VariableNames', {'Environment', 'AvgCapacity', 'PathLoss',
'AvgConditionNumber', 'OutageProbability', 'ChannelRank', 'DiversityOrder'});

for i = 1:length(environments)
results_table.Environment(i) = environments{i};
results_table.AvgCapacity(i) = all_results.(environments{i}).avg_capacity;
results_table.PathLoss(i) = all_results.(environments{i}).path_loss_db;
results_table.AvgConditionNumber(i) =
all_results.(environments{i}).avg_condition_number;
results_table.OutageProbability(i) = all_results.(environments{i}).outage_prob;
results_table.ChannelRank(i) = all_results.(environments{i}).rank_channel;
results_table.DiversityOrder(i) = all_results.(environments{i}).diversity_order;
end

disp(results_table);
end