mmWave Adaptive Channel Estimation

Algorithm Description

The proposed adaptive beam-training procedure enables the Base Station (BS) and Mobile Station (MS) to jointly identify the optimal transmit–receive beam pair from predefined codebooks. The algorithm operates over multiple stages, where each stage progressively narrows the search space. This hierarchical refinement significantly reduces training overhead compared to exhaustive beam scanning.

1. Initialization

Both BS and MS are assumed to know the total number of angular directions N, the hierarchical resolution parameter K, and the codebooks F (for BS beams) and W (for MS beams).

The initial codebook subset indices are:

k₁^BS = 1,    k₁^MS = 1.

The total number of adaptive stages is:

S = log_K(N)

ensuring that the search space is reduced by a factor of K in each stage.

2. Stage-wise Beam Training

For each stage s = 1,…,S, both BS and MS test K beam candidates.

2.1 BS Transmission

For each BS beam index m_BS = 1,…,K, the BS transmits using the beam:

F_{(s, ks^BS)}[:, m_BS].

2.2 MS Reception

For each BS beam, the MS cycles through its own beam candidates m_MS = 1,…,K, applying:

W_{(s, ks^MS)}[:, m_MS].

2.3 Measurement Collection

The MS records the received signal corresponding to each transmit–receive beam pair:

y_mBS = √P_s · W^H · H · F + n_mBS.

The MS stores all measurements in:

Y(s) = [y₁, y₂, …, y_K].

3. Beam Pair Selection

The strongest beam pair is identified by maximizing the magnitude of the collected measurements:

(m^*_BS, m^*_MS) = arg max_{mBS, mMS} |Y(s) ⊙ Y(s)*|.

This pair represents the best-performing combination in the current stage.

4. Subset Update

The indices of the selected beam subsets for the next stage are updated using:

k_s+1^BS = K(m^*_BS − 1) + 1,
k_s+1^MS = K(m^*_MS − 1) + 1.

This selects the sub-region of the angular domain containing the strongest path.

5. Final Parameter Estimation

After completing all stages, the estimated angle parameters are:

φ̂ = φ̄_kS+1^BS,    θ̂ = θ̄_kS+1^MS.

The corresponding path gain is estimated as:

α̂ = √(ρ/P_s) · G(S)[Y(s)]_{mMS*, mBS*}.

MATLAB Code

% Example Usage:

N = 64;           % Total angles

K = 4;            % Beams per stage

S = log(N)/log(K);

% Build dummy hierarchical codebooks:

for s = 1:S

    for k = 1:N

        F{s, k} = exp(1j * 2*pi*(0:15)' * rand(1,K)); 

        W{s, k} = exp(1j * 2*pi*(0:15)' * rand(1,K));

    end

end

% Example channel

H = randn(16,16) + 1j*randn(16,16);

% Example power allocation

P = ones(S,1);

% Angle grids

phi_grid = linspace(-pi/2, pi/2, N);

theta_grid = linspace(-pi/2, pi/2, N);

% Run algorithm

[phi_hat, theta_hat, alpha_hat] = adaptive_beam_training(F, W, H, N, K, P, phi_grid, theta_grid);

function [phi_hat, theta_hat, alpha_hat] = adaptive_beam_training(F, W, H, N, K, P, phi_grid, theta_grid)

% -----------------------------------------------------------

% Adaptive Beam Training Algorithm

% -----------------------------------------------------------

% Inputs:

%  F          : BS codebook (cell array or 3-D matrix)

%  W          : MS codebook (cell array or 3-D matrix)

%  H          : Channel matrix

%  N          : Total number of angular bins

%  K          : Number of beams per stage

%  P          : Transmit power at each stage

%  phi_grid   : BS angle grid (vector)

%  theta_grid : MS angle grid (vector)

%

% Outputs:

%  phi_hat    : Estimated BS angle

%  theta_hat  : Estimated MS angle

%  alpha_hat  : Estimated path gain

%

% -----------------------------------------------------------

% ---------- Initialization ----------

k_bs = 1;     % BS codebook subset index

k_ms = 1;     % MS codebook subset index

S = log(N) / log(K);   % Number of adaptive stages

% ---------- Adaptive Stages ----------

for s = 1:S

    

    Y = zeros(K, K);  % Storage for received measurements

    

    % Sweep through all K × K beam combinations

    for mBS = 1:K

        

        f_bs = F{s, k_bs}(:, mBS);     % BS beam for stage s

        

        for mMS = 1:K

            

            w_ms = W{s, k_ms}(:, mMS); % MS beam for stage s

            

            % Measurement at MS:

            y = sqrt(P(s)) * (w_ms' * H * f_bs) + (randn + 1j*randn) * 0.01;

            

            Y(mMS, mBS) = abs(y);      % Magnitude for detection

            

        end

    end

    

    % ----- Select strongest beam pair -----

    [~, idx] = max(Y(:));

    [mMS_star, mBS_star] = ind2sub(size(Y), idx);

    

    % ----- Update subset indices -----

    k_bs = K*(mBS_star - 1) + 1;

    k_ms = K*(mMS_star - 1) + 1;

end

% ---------- Final Estimates ----------

phi_hat   = phi_grid(k_bs);

theta_hat = theta_grid(k_ms);

% Estimate gain using last measurement

alpha_hat = Y(mMS_star, mBS_star) / sqrt(P(end));

end

Hierarchical Beam Training Logic

Suppose:

• N = 64 → total finest-resolution beams
• K = 4 → number of beams tested per stage

Stage 1 (coarse search)

• You divide the 64 total beams into 64 / 4 = 16 blocks, each block contains 4 beams.
• You only test 1 beam per block, so at stage 1 you test K = 4 beams (one from each candidate block).
• Goal: pick the block containing the strongest beam.

Stage 2 (intermediate search)

• You now focus on the block selected in stage 1.
• That block has 4 beams, divide it again into 4 sub-blocks, pick 1 beam per sub-block.
• You test K = 4 beams in this stage again.
• Goal: narrow down further.

Stage 3 (fine search)

• The selected sub-block now contains the final 4 beams.
• Test these 4 beams, pick the best one.

Key Points

• At each stage, you only test K beams, not all N beams.
• The algorithm zooms in progressively.
• After S = log₄(64) = 3 stages, you have identified 1 beam out of 64.

Stage Summary

Stage	Beams tested (K)	Candidate beams in block	Notes
1	4	64	Coarse search
2	4	16	Focused search
3	4	4	Fine search

At stage 1, you test 4 beams to choose one block of 16 beams.
At stage 2, you test 4 beams to choose one block of 4 beams.
At stage 3, you test 4 beams to pick the final beam.

If desired, a diagram can be drawn to show the 64 → 16 → 4 → 1 zoom-in process visually.

Summary

The algorithm carries out a multi-stage hierarchical search over the BS and MS codebooks. In every stage, it evaluates K × K beam pairs, selects the best combination, and restricts the next stage to a narrower sub-region. After S = log_K(N) stages, the optimal beam pair is identified with dramatically reduced training overhead.

Further Reading

1.