556 lines
23 KiB
Matlab
556 lines
23 KiB
Matlab
classdef bcjr_pam < handle
|
||
%MLSE calculates the most probable sequence for an input signal with given/ known channel impulse response of any length
|
||
|
||
properties(Access=public)
|
||
M %PAM-M
|
||
DIR
|
||
trellis_states
|
||
duobinary_output
|
||
end
|
||
|
||
methods (Access=public)
|
||
|
||
function obj = bcjr_pam(options)
|
||
%NAME Construct an instance of this class
|
||
% Detailed explanation goes here
|
||
|
||
arguments
|
||
options.M double = 4;
|
||
options.DIR double = [1];
|
||
options.trellis_states double = [-3 -1 1 3];
|
||
options.duobinary_output logical = false;
|
||
|
||
end
|
||
|
||
%
|
||
fn = fieldnames(options);
|
||
for n = 1:numel(fn)
|
||
try
|
||
obj.(fn{n}) = options.(fn{n});
|
||
end
|
||
end
|
||
end
|
||
|
||
function [VITERBI_ESTIMATION_SYMBOLS,LLR_exact,GMI] = process(obj,data_in,data_ref,tx_bits,bit_mapping)
|
||
|
||
|
||
debug = 0;
|
||
|
||
% States should match the target states of the prev. EQ (EQ's job was to reduce the error between signal and the target)
|
||
trellis_state_mode = 2;
|
||
% 0 = use provided states (MUST provide the correct states);
|
||
% 1 = normalize to = 1 rms;
|
||
% 2 = use target symbols;
|
||
% 3 = use statistical levels
|
||
% 3 analyzes avg of rx signal levels - can help with nonlinear impairments
|
||
|
||
trellis_exclusion = 1; % PAM-6 only (only if data is NOT precoded!)
|
||
|
||
% Additional scaling between states, expected output (noiseless_received) and the noisy, filtered input signal
|
||
scale_mode = 2; % scale_mode:
|
||
% 0 = no scaling,
|
||
% 1 = use RMS to scale MODEL,
|
||
% 2 = use MMSE/time-corr to scale MODEL, -> This best to get the GMI right -> sometimes the LLP's are not centered around zero...
|
||
% 3 = use RMS to scale DATA,
|
||
% 4 = use MMSE/time-corr to scale DATA
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%%%%%% PREPARATIONS %%%%%%%%
|
||
|
||
% remove unnecessary zeros at start of impulse response to keep
|
||
% number of trellis states minimal
|
||
DIR_nonzero = find(obj.DIR ~= 0);
|
||
if DIR_nonzero(1) > 1
|
||
obj.DIR(1:DIR_nonzero(1)-1) = [];
|
||
end
|
||
|
||
if isscalar(obj.DIR)
|
||
obj.DIR = [0 obj.DIR];
|
||
end
|
||
|
||
% impulse respnse to remove from signal
|
||
obj.DIR = flip(obj.DIR); %i.e. -0.2676 -0.0478 1.0000
|
||
|
||
% Trellis States
|
||
obj.trellis_states = reshape(obj.trellis_states,1,[]);
|
||
if trellis_state_mode == 1 % Normalize the Trellis states to =1 RMS
|
||
|
||
obj.trellis_states = obj.trellis_states ./ rms(obj.trellis_states);
|
||
|
||
elseif trellis_state_mode == 2 %simply use the states from the ref signal (should be a robust option)
|
||
|
||
obj.trellis_states = reshape(unique(data_ref),size(obj.trellis_states));
|
||
|
||
elseif trellis_state_mode == 3 %use_statistical_levels
|
||
|
||
%%%% Separate the equalized signal into the respective levels based on the actually transmitted level
|
||
constellation = unique(data_ref);
|
||
|
||
% find actual levels from rx signal
|
||
symbols_for_lvl = NaN(numel(constellation),length(data_ref));
|
||
for l = 1:numel(constellation)
|
||
level_amplitude = constellation(l);
|
||
symbols_for_lvl(l,data_ref==level_amplitude) = data_in(data_ref==level_amplitude);
|
||
end
|
||
|
||
%replace the trellis states
|
||
avg_levels = mean(symbols_for_lvl,2,'omitnan');
|
||
obj.trellis_states = sort(avg_levels)';
|
||
|
||
%also replace the whole ref signal (PAM-M) levels
|
||
[~, idx] = ismember(data_ref, unique(data_ref));
|
||
data_ref = avg_levels(idx);
|
||
|
||
end
|
||
|
||
|
||
% seems to be the only way to use combvec for a flexible amount
|
||
% of vectors. 'combs' contains all trellis states
|
||
pre_comb_mat = repmat(obj.trellis_states,length(obj.DIR)-1,1);
|
||
pre_comb_cell = mat2cell(pre_comb_mat,ones(1,size(pre_comb_mat,1)),size(pre_comb_mat,2));
|
||
combs = fliplr(combvec(pre_comb_cell{:}).');
|
||
first_sym = combs(:,1); % das ist das älteste/ trailing Symbol aus der sequenz
|
||
last_sym = combs(:,end); %hiermit wird entschieden/ das ist das cursor symbol am ende der sequenz
|
||
nStates = length(last_sym);
|
||
|
||
% % Calculate all possible input symbols for the desired impulse
|
||
% % response. Row number is the index of the previous state,
|
||
% % column number is the index of the next state
|
||
% % noise free received == branch metrics
|
||
% assumes: last_sym = combs(:,end); % already defined earlier
|
||
levels = sort(unique(obj.trellis_states(:)).');
|
||
edges = [levels(1) levels(end)]; % edge levels (0 and 5 in PAM6)
|
||
|
||
noise_free_received = inf(nStates,nStates); % rows: to, cols: from
|
||
edge_edge_mask = false(nStates,nStates); % rows: to, cols: from
|
||
|
||
for from = 1:nStates
|
||
for to = 1:nStates
|
||
% valid transition if shift-register overlap holds
|
||
if all(combs(to,2:end) == combs(from,1:end-1))
|
||
% noiseless sample for the 'to' state reached from 'from'
|
||
noise_free_received(to,from) = ...
|
||
dot(combs(to,:), obj.DIR(end:-1:2)) + last_sym(from)*obj.DIR(1);
|
||
|
||
% mark edge→edge candidate (to be excluded only on even→odd steps)
|
||
edge_edge_mask(to,from) = ...
|
||
(last_sym(from)==edges(1) || last_sym(from)==edges(2)) && ...
|
||
(last_sym(to) ==edges(1) || last_sym(to) ==edges(2));
|
||
end
|
||
end
|
||
end
|
||
|
||
h = flip(obj.DIR(:)).';
|
||
data_in = data_in(:);
|
||
y_ideal = conv(data_ref(:), h, "same");
|
||
|
||
switch scale_mode
|
||
case 0
|
||
g = 1; b = 0;
|
||
case 1 % RMS: scale model to data
|
||
g = rms(data_in)/rms(y_ideal); b = mean(data_in) - g*mean(y_ideal);
|
||
case 2 % MMSE/time-corr: scale states to data
|
||
[c,lags] = xcorr(data_in(:), y_ideal, 64);
|
||
[~,ix] = max(abs(c));
|
||
lag = lags(ix);
|
||
y_ideal = circshift(y_ideal, lag);
|
||
mu_y = mean(data_in(:));
|
||
mu_i = mean(y_ideal);
|
||
y_c = data_in(:)-mu_y;
|
||
yi_c = y_ideal-mu_i;
|
||
g = (yi_c'*y_c)/(yi_c'*yi_c);
|
||
b = mu_y - g*mu_i;
|
||
case 3 % RMS flipped: scale data to model
|
||
gd = rms(y_ideal)/rms(data_in); bd = mean(y_ideal) - gd*mean(data_in);
|
||
data_in = gd*data_in + bd;
|
||
g = 1; b = 0;
|
||
case 4 % MMSE/time-corr flipped: scale data to states
|
||
[c,lags] = xcorr(data_in(:), y_ideal(:), 64);
|
||
[~,ix] = max(abs(c));
|
||
lag = lags(ix);
|
||
y_ideal = circshift(y_ideal(:), lag);
|
||
mu_y = mean(data_in(:));
|
||
mu_i = mean(y_ideal);
|
||
y_c = data_in(:) - mu_y; % data_in centered
|
||
yi_c = y_ideal - mu_i; % ideal centered
|
||
g = (y_c' * yi_c) / (y_c' * y_c);
|
||
b = mu_i - g * mu_y;
|
||
data_in = g * data_in(:) + b;
|
||
g = 1; b = 0;
|
||
end
|
||
|
||
% apply (g,b) to states/ expected values
|
||
noise_free_received = g*noise_free_received + b;
|
||
last_sym = g*last_sym + b;
|
||
|
||
% calculate noise power
|
||
sigma2 = mean(abs(data_in - (g*y_ideal + b)).^2); %noise = mean(abs((RX Signal - IDEAL Signal)))^2
|
||
inv2s2 = 1/(2*sigma2);
|
||
|
||
if debug
|
||
figure(100); clf; hold on
|
||
obj.showLevelScatter_(data_in, data_ref);
|
||
yline(noise_free_received(:), 'DisplayName','Transition States','Color','red','HandleVisibility','off');
|
||
yline(obj.trellis_states(:), 'DisplayName','Transition States','Color','green','LineWidth',2,'HandleVisibility','off')
|
||
end
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%%%%% FORWARD PASS (VITERBI -Alpha's) %%%%%
|
||
|
||
% Initialize the output vector
|
||
pm = zeros(nStates,nStates);
|
||
bm_fw = zeros(nStates,nStates,length(data_in));
|
||
|
||
% first start is evaluated without ISI/ wihout the full Impulse response
|
||
% so simply use the constellation here
|
||
bm = -(data_in(1) - last_sym).^2 * inv2s2;
|
||
pm = pm + bm;
|
||
[alpha(:,1),pm_survivor_fw_idx(:,1)] = max(pm,[],2);
|
||
pm = repmat(alpha(:,1).',nStates,1);
|
||
bm_fw(:,:,1) = pm;
|
||
|
||
% Forward Recursion (FSM Computation)
|
||
for n = 2:length(data_in)
|
||
|
||
bm = -(data_in(n) - noise_free_received).^2 * inv2s2;
|
||
|
||
% exclude edge to edge transitions only for even->odd steps && PAM-6
|
||
if mod(n,2) == 0 && obj.M == 6 && trellis_exclusion
|
||
bm(edge_edge_mask) = -Inf;
|
||
end
|
||
|
||
pm = pm + bm;
|
||
[alpha(:,n),pm_survivor_fw_idx(:,n)] = max(pm,[],2); % choose lowest path metric as new state (get min distance for all state transitions towards a new state)
|
||
pm = repmat(alpha(:,n).',nStates,1); % update pm (chosen state to 2nd dimension -> FROM state)
|
||
|
||
bm_fw(:,:,n) = bm;
|
||
|
||
end
|
||
|
||
% we can now get the best path as min
|
||
viterbi_path = NaN(1,length(data_in));
|
||
|
||
% find ideal trellis path by going through the trellis backwards
|
||
[~,viterbi_path(length(data_in))] = max(alpha(:,length(data_in)));
|
||
for n = length(data_in):-1:2
|
||
viterbi_path(n-1) = pm_survivor_fw_idx(viterbi_path(n),n);
|
||
end
|
||
|
||
|
||
if debug
|
||
alpha_ = alpha - min(alpha) + eps;
|
||
figure();hold on;
|
||
n = 10;
|
||
scatter(1:n,obj.trellis_states(repmat([1:numel(obj.trellis_states)]',1,n)),abs(alpha_(:,end-n+1:end)),'Marker','o','LineWidth',1);
|
||
scatter(1:n,obj.trellis_states(viterbi_path(end-n+1:end)),500,'Marker','x','LineWidth',1,'MarkerEdgeColor','green');
|
||
% scatter(1:n,data_ref(end-n+1:end),500,'Marker','x','LineWidth',1,'MarkerEdgeColor','red');
|
||
yticks(obj.trellis_states);
|
||
ylim([min(obj.trellis_states)-1 max(obj.trellis_states)+1]);
|
||
end
|
||
|
||
VITERBI_ESTIMATION_SYMBOLS(1:length(data_in)) = first_sym(viterbi_path);
|
||
VITERBI_ESTIMATION_SYMBOLS = reshape(VITERBI_ESTIMATION_SYMBOLS,size(data_in));
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%%%%% BACKWARD (Beta's) %%%%%
|
||
|
||
% Initialize the output vector
|
||
pm = zeros(nStates,nStates);
|
||
beta = zeros(nStates,length(data_in));
|
||
pm_survivor_bw_idx = zeros(nStates,length(data_in));
|
||
bm_bw = zeros(nStates,nStates,length(data_in));
|
||
|
||
% starting with the state that has the lowest sum path
|
||
% metric, follow the stored information about the
|
||
% predecessor
|
||
for h = length(data_in)-1:-1:1
|
||
|
||
bm = -(data_in(h+1) - noise_free_received).^2 * inv2s2;
|
||
|
||
% exclude edge to edge transitions for even->odd steps && PAM-6
|
||
if mod(h+1, 2) == 0 && obj.M == 6 && trellis_exclusion
|
||
bm(edge_edge_mask) = -Inf;
|
||
end
|
||
|
||
pm = pm + bm.';
|
||
[beta(:,h),pm_survivor_bw_idx(:,h)] = max(pm,[],2); % choose lowest path metric as new state
|
||
pm = repmat(beta(:,h).',nStates,1); % update pm (chosen state to 2nd dimension -> FROM state)
|
||
|
||
bm_bw(:,:,h) = bm;
|
||
|
||
end
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%%%%% FORWARD (Combine Alpha and Beta to yield LLP's) %%%%%
|
||
|
||
%calc the log probabilities (llp's)
|
||
|
||
for k = 1:length(data_in)
|
||
|
||
if k == 1
|
||
|
||
alpha_ = repmat(alpha(:,k)',[nStates,1])';
|
||
beta_ = beta(:,k);
|
||
|
||
LLP(:,k) = max(alpha_ + beta_,[],2);
|
||
|
||
else
|
||
|
||
alpha_ = repmat(alpha(:,k-1)',[nStates,1])';
|
||
gamma_ = bm_fw(:,:,k)';
|
||
beta_ = beta(:,k);
|
||
|
||
LLP(:,k) = max(alpha_ + gamma_,[],1) + beta_';
|
||
end
|
||
|
||
end
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%%%%% Calc LLR's %%%%%
|
||
|
||
% These are interchangeable...
|
||
nml_LLP = LLP - max(LLP); %subtract highest value for better numerical stability, LLP's are not always close to zero
|
||
expLLP = exp(nml_LLP);
|
||
state_prob = expLLP ./ sum(expLLP); % sums to one (or numerically close to one)
|
||
|
||
% compute symbol‐posteriors from LLP in the log‐domain:
|
||
amax = max(LLP,[],1);
|
||
logZ = amax + log(sum(exp(LLP - amax), 1));
|
||
logPstate = LLP - logZ; % still in log‐domain
|
||
state_prob = exp(logPstate); % exact, sums to 1
|
||
|
||
if obj.M == 6
|
||
|
||
num_bits = 5;
|
||
|
||
% all possible transitions (for now 36, including the "edges"
|
||
% of the QAM 32 constellation)
|
||
states = [-5 -3 -1 1 3 5];
|
||
pam6transitions = combvec(states,states)'; % pam6transitions =
|
||
% [-5 -5;
|
||
% -3 -5;
|
||
% -1 -5; ...
|
||
|
||
[~, idx_sym_1] = ismember(pam6transitions(:,1), states);
|
||
[~, idx_sym_2] = ismember(pam6transitions(:,2), states);
|
||
pam6ind = [idx_sym_1, idx_sym_2];
|
||
|
||
numPairs = floor(size(LLP,2)/2);
|
||
LLR_exact = zeros(numPairs,5);
|
||
LLR_maxlogmap = zeros(numPairs,5);
|
||
|
||
for k = 1:numPairs
|
||
symbol1 = 2*k-1;
|
||
symbol2 = 2*k;
|
||
|
||
LLP1 = LLP(:,symbol1);
|
||
LLP2 = LLP(:,symbol2);
|
||
prob1 = state_prob(:,symbol1);
|
||
prob2 = state_prob(:,symbol2);
|
||
|
||
% All 36 Combinations: M = LLP Symbol 1 + LLP Symbol 2
|
||
Mij = LLP1(pam6ind(:,1)) + LLP2(pam6ind(:,2));
|
||
pij = prob1(pam6ind(:,1)) .* prob2(pam6ind(:,2));
|
||
|
||
% for each of the 5 bits sum exact-probs or max-log
|
||
for b = 1:num_bits
|
||
idx_sym_1 = bit_mapping(:,b)==1;
|
||
idx_bit_1 = bit_mapping(:,b)==0;
|
||
|
||
% exact LLR from probabilities
|
||
P1 = sum(pij(idx_sym_1)); %prob that bit == 1
|
||
P0 = sum(pij(idx_bit_1));
|
||
LLR_exact(k,b) = log(P1./P0); %ratio by multiplication
|
||
|
||
% max-log:
|
||
LLR_maxlogmap(k,b) = max( Mij(idx_sym_1) ) - max( Mij(idx_bit_1) ); % ratio by subtraction
|
||
end
|
||
end
|
||
|
||
% GMI calc includes the Tx-bitstream
|
||
tx_bits_pam6_reshaped = reshape(tx_bits',5,[])'; % N x 5
|
||
MI = zeros(1, num_bits);
|
||
for k = 1:num_bits
|
||
|
||
idx_bit_1 = (tx_bits_pam6_reshaped(:,k) == 0); %wo sind die 1en
|
||
idx_sym_1 = (tx_bits_pam6_reshaped(:,k) == 1); %wo sind die 0en
|
||
|
||
%LLR's for all actually transmitted ones or zeros
|
||
llr0 = LLR_exact(idx_bit_1,k);
|
||
llr1 = LLR_exact(idx_sym_1,k);
|
||
|
||
% Calculate mutual information for bit position k
|
||
I0 = mean(log2(1 + exp(llr0))); % exp(--LLR) = exp(positive) > 1
|
||
I1 = mean(log2(1 + exp(-llr1))); % exp(-+LLR) = exp(negative) < 1
|
||
MI(k) = 1 - 0.5 * (I0 + I1);
|
||
end
|
||
|
||
GMI = sum(MI); % Total mutual information per symbol
|
||
GMI = GMI/2; % GMI per single symbol not per two symbols
|
||
|
||
else
|
||
|
||
% Number of symbols and bits per symbol
|
||
num_bits = log2(length(obj.trellis_states)); % 2 bits per symbol
|
||
|
||
% bit_mapping = PAMmapper(length(obj.trellis_states),0,"eth_style",0).showBitMapping;
|
||
|
||
% Initialize LLR storage
|
||
LLR_maxlogmap = zeros(length(data_in),num_bits);
|
||
LLR_exact = zeros(length(data_in),num_bits);
|
||
|
||
% Compute bit-wise LLRs
|
||
for bit_idx = 1:num_bits
|
||
|
||
% Find indices where bit is 0 and where it is 1
|
||
idx_bit_0 = bit_mapping(:,bit_idx) == 0;
|
||
idx_bit_1 = bit_mapping(:,bit_idx) == 1;
|
||
|
||
% Sum over log-probabilities
|
||
% Max-Log approximation uses the single max LLP value
|
||
% instead of sum over all LLP's
|
||
LLR_maxlogmap(:,bit_idx) = max(LLP(idx_bit_1,:), [], 1) - max(LLP(idx_bit_0,:), [], 1);
|
||
|
||
% Sum probabilities over states for which the bit is 1 and 0, respectively.
|
||
P0 = sum(state_prob(idx_bit_0, :),1);
|
||
P1 = sum(state_prob(idx_bit_1, :),1);
|
||
LLR_exact(:,bit_idx) = log(P1./P0); % N x num_bits
|
||
|
||
|
||
end
|
||
|
||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||
%%%%% CALC NGMI %%%%%
|
||
|
||
MI = zeros(1, num_bits);
|
||
for k = 1:num_bits
|
||
|
||
idx_bit_0 = (tx_bits(:,k) == 0); %wo sind die 1en
|
||
idx_bit_1 = (tx_bits(:,k) == 1); %wo sind die 0en
|
||
|
||
%LLR's for all actually transmitted ones or zeros
|
||
llr0 = LLR_exact(idx_bit_0,k);
|
||
llr1 = LLR_exact(idx_bit_1,k);
|
||
|
||
% mutual information for bit position k
|
||
I0 = mean(log2(1 + exp(llr0))); % exp(--LLR) = exp(positive) > 1
|
||
I1 = mean(log2(1 + exp(-llr1))); % exp(-+LLR) = exp(negative) < 1
|
||
MI(k) = 1 - 0.5 * (I0 + I1); % assumes equally distributed ones and zeros
|
||
end
|
||
|
||
GMI = sum(MI); % Total bitwise mutual information
|
||
|
||
end
|
||
|
||
|
||
if debug
|
||
%%% DEBUG PLOT LIKELIHOOD RATIOS %%%
|
||
figure(115);clf
|
||
subplot(2,1,1)
|
||
for bit = 1:num_bits
|
||
hold on;
|
||
histogram(LLR_exact(:,bit),1000,"DisplayName",sprintf('Actual LLR of Bit Pos %d',bit),'LineStyle','none','FaceAlpha',0.4);
|
||
end
|
||
legend
|
||
|
||
subplot(2,1,2)
|
||
for bit = 1:num_bits
|
||
hold on;
|
||
histogram(LLR_maxlogmap(:,bit),1000,"DisplayName",sprintf('Max Log LLR of Bit Pos %d',bit),'LineStyle','none','FaceAlpha',0.4);
|
||
end
|
||
legend
|
||
|
||
if obj.M == 6
|
||
pairs = reshape(VITERBI_ESTIMATION_SYMBOLS,2,[]).';
|
||
levels = sort(unique(VITERBI_ESTIMATION_SYMBOLS));
|
||
isedge = ismember(pairs, [levels(1) levels(end)]);
|
||
isforbidden = sum(isedge,2)==2;
|
||
fprintf('Found %d forbidden transitions (even -> odd ; edge -> edge).\n', nnz(isforbidden));
|
||
end
|
||
|
||
end
|
||
|
||
|
||
end
|
||
|
||
function [symbols_for_lvl,avg_for_lvl] = showLevelScatter_(~,eq_signal,ref_symbols)
|
||
|
||
figure()
|
||
|
||
rx_symbols = eq_signal; %./ rms(eq_signal);
|
||
correct_symbols = ref_symbols;
|
||
|
||
% col = cbrewer2('Paired',numel(unique(correct_symbols))*2);
|
||
col = ...
|
||
[0.6510 0.8078 0.8902; ...
|
||
0.1216 0.4706 0.7059; ...
|
||
0.6980 0.8745 0.5412; ...
|
||
0.2000 0.6275 0.1725; ...
|
||
0.9843 0.6039 0.6000; ...
|
||
0.8902 0.1020 0.1098; ...
|
||
0.9922 0.7490 0.4353; ...
|
||
1.0000 0.4980 0; ...
|
||
0.7922 0.6980 0.8392; ...
|
||
0.4157 0.2392 0.6039; ...
|
||
1.0000 1.0000 0.6000; ...
|
||
0.6941 0.3490 0.1569; ...
|
||
0.6510 0.8078 0.8902; ...
|
||
0.1216 0.4706 0.7059; ...
|
||
0.6980 0.8745 0.5412; ...
|
||
0.2000 0.6275 0.1725];
|
||
ccnt = -1;
|
||
|
||
levels = unique(correct_symbols);
|
||
symbols_for_lvl = NaN(numel(levels),length(correct_symbols));
|
||
start = 1;
|
||
ende = length(correct_symbols);
|
||
|
||
for l = 1:numel(levels)
|
||
ccnt = ccnt+2;
|
||
|
||
level_amplitude = levels(l);
|
||
|
||
symbols_for_lvl(l,correct_symbols==level_amplitude) = rx_symbols(correct_symbols==level_amplitude);
|
||
std_lvl(l) = std(symbols_for_lvl(l,:),'omitnan');
|
||
xax = 1:length(correct_symbols);
|
||
|
||
scatter(xax(start:ende),symbols_for_lvl(l,start:ende),10,'.','MarkerFaceAlpha',0.5,'MarkerEdgeAlpha',0.5,'MarkerEdgeColor',col(ccnt,:));
|
||
hold on;
|
||
|
||
|
||
end
|
||
|
||
std_lvl = round(std_lvl,2);
|
||
|
||
ccnt = 0;
|
||
avg_for_lvl = NaN(numel(levels),length(correct_symbols));
|
||
% Add the windowed/ smoothed curves
|
||
for l = 1:numel(levels)
|
||
ccnt = ccnt+2;
|
||
level_amplitude = levels(l);
|
||
|
||
L = 500;
|
||
movmean = 1/L .* movsum(rx_symbols(correct_symbols==level_amplitude),[L/2,L/2], 'Endpoints', 'fill');
|
||
|
||
avg_for_lvl(l,correct_symbols==level_amplitude) = movmean;
|
||
|
||
nanx = isnan(avg_for_lvl(l,:));
|
||
t = 1:numel(avg_for_lvl(l,:));
|
||
avg_for_lvl(l,nanx) = interp1(t(~nanx), avg_for_lvl(l,~nanx), t(nanx));
|
||
|
||
plot(xax(start:ende),avg_for_lvl(l,start:ende),'Color',col(ccnt,:));
|
||
|
||
hold on
|
||
end
|
||
|
||
% yline(levels);
|
||
xlabel('Samples');
|
||
ylabel('Amplitude');
|
||
ylim([-3 3]);
|
||
|
||
end
|
||
|
||
|
||
end
|
||
end
|