mctc_mapdec.m

OFDMA 物理层开发的matlab 源码.飞思卡尔提供.对物理层开发的工程师有帮助!

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%  Property of Freescale
%  Freescale Confidential Proprietary
%  Freescale Copyright (C) 2005 All rights reserved
%  ----------------------------------------------------------------------------
%  $RCSfile: mCTC_MAPDec.m.rca $
%  $Revision: 1.1 $
%  $Date: Mon Jan 22 11:01:17 2007 $
%  Target: Matlab
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% Optimisation of Alpha, Beta :
%   * grouping of Alpha 1-5,2-6,3-7,4-8, Beta 1-2,3-4,5-6,7_8)
%   * gamma saved in a matrix
%
% Perf : 67.4s pour 10e6, param : 192
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% This module implements Max-Log-MAP decoder algorithm
% for double binary circular turbo code
% Outputs:
% L_00      => Posteriori info. for data couple 00
% L_01      => Posteriori info. for data couple 01
% L_10      => Posteriori info. for data couple 10
% L_11      => Posteriori info. for data couple 11
% ln_p00    => Extrinsic info. for data couple 00
% ln_p01    => Extrinsic info. for data couple 01
% ln_p10    => Extrinsic info. for data couple 10
% ln_p11    => Extrinsic info. for data couple 11
% Alpha_out => Initial Alpha value for next iteration
% Beta_out  => Initial Beta value for next iteration
%
% Inputs:
% rec_s     => Received signal.
% g         => Generator polynomial.
% L_a_p00   => Priori info. for data couple 00
% L_a_p01   => Priori info. for data couple 01
% L_a_p10   => Priori info. for data couple 10
% L_a_p11   => Priori info. for data couple 11
% Alpha_in  => Initial Alpha
% Beta_in   => Initial Beta
%


function [L_00, L_01, L_10, L_11, ln_p00, ln_p01, ln_p10, ln_p11, Alpha_out, Beta_out] = ...
    mCTC_MAPDec (rec_s, g, L_a_p00, L_a_p01, L_a_p10, L_a_p11, Alpha_in, Beta_in)

L_total = length(rec_s)/4;

[n,K] = size(g);
m = K - 1;

% number of states in the trellis
nstates = 2^m;
[next_out, next_state, last_out, last_state] = mFastTrellis ;
%temp_alpha_max = zeros(1,L_total+1);
gamma00 = zeros(8,L_total); gamma01 = zeros(8,L_total); gamma10 = zeros(8,L_total); gamma11 = zeros(8,L_total);

% Initialization of Alpha & Beta
Alpha(1,:) = Alpha_in;
Beta(L_total+1,:) = Beta_in;

% Trace forward, compute Alpha in each trellis stage
for k = 2:L_total+1
    for state2 = 1:4
        gamma00(state2,k-1) = rec_s(4*k-7)*last_out(state2,1) + rec_s(4*k-6)*last_out(state2,2) + ...
            rec_s(4*k-5)*last_out(state2,3) + rec_s(4*k-4)*last_out(state2,4) + ...
            L_a_p00(k-1);

        gamma01(state2,k-1) = rec_s(4*k-7)*last_out(state2,5) + rec_s(4*k-6)*last_out(state2,6) + ...
            rec_s(4*k-5)*last_out(state2,7) + rec_s(4*k-4)*last_out(state2,8) + ...
            L_a_p01(k-1);

        gamma10(state2,k-1) = rec_s(4*k-7)*last_out(state2,9) + rec_s(4*k-6)*last_out(state2,10) + ...
            rec_s(4*k-5)*last_out(state2,11) + rec_s(4*k-4)*last_out(state2,12) + ...
            L_a_p10(k-1);

        gamma11(state2,k-1) = rec_s(4*k-7)*last_out(state2,13) + rec_s(4*k-6)*last_out(state2,14) + ...
            rec_s(4*k-5)*last_out(state2,15) + rec_s(4*k-4)*last_out(state2,16) + ...
            L_a_p11(k-1);

        temp1=gamma00(state2,k-1)+Alpha(k-1,last_state(state2,1));
        temp2=gamma01(state2,k-1)+Alpha(k-1,last_state(state2,2));
        temp3=gamma10(state2,k-1)+Alpha(k-1,last_state(state2,3));
        temp4=gamma11(state2,k-1)+Alpha(k-1,last_state(state2,4));

        temp_1=gamma00(state2,k-1)+Alpha(k-1,last_state(state2+4,1));
        temp_2=gamma01(state2,k-1)+Alpha(k-1,last_state(state2+4,2));
        temp_3=gamma10(state2,k-1)+Alpha(k-1,last_state(state2+4,3));
        temp_4=gamma11(state2,k-1)+Alpha(k-1,last_state(state2+4,4));

        Alpha(k,state2) = max(max(temp1,temp2),max(temp3,temp4));
        Alpha(k,state2+4) = max(max(temp_1,temp_2),max(temp_3,temp_4));
    end

    % Normalization
    Alpha(k,:) = Alpha(k,:) - max(Alpha(k,:)) ;
end

gamma00(5,:) = gamma00(1,:);
gamma00(8,:) = gamma00(4,:);
gamma00(6,:) = gamma00(2,:);
gamma00(7,:) = gamma00(3,:);

gamma01(5,:) = gamma01(1,:);
gamma01(8,:) = gamma01(4,:);
gamma01(6,:) = gamma01(2,:);
gamma01(7,:) = gamma01(3,:);

gamma10(5,:) = gamma10(1,:);
gamma10(8,:) = gamma10(4,:);
gamma10(6,:) = gamma10(2,:);
gamma10(7,:) = gamma10(3,:);

gamma11(5,:) = gamma11(1,:);
gamma11(8,:) = gamma11(4,:);
gamma11(6,:) = gamma11(2,:);
gamma11(7,:) = gamma11(3,:);

%Updata Alpha_ini
Alpha_out = Alpha(L_total+1,:);

% Trace backward, compute Beta
for k = L_total:-1:1
    for state1 = 1:2:7
        gamma00_ = rec_s(4*k-3)*next_out(state1,1) + rec_s(4*k-2)*next_out(state1,2) + ...
            rec_s(4*k-1)*next_out(state1,3) + rec_s(4*k)*next_out(state1,4) + ...
            L_a_p00(k);

        gamma01_ = rec_s(4*k-3)*next_out(state1,5) + rec_s(4*k-2)*next_out(state1,6) + ...
            rec_s(4*k-1)*next_out(state1,7) + rec_s(4*k)*next_out(state1,8) + ...
            L_a_p01(k);

        gamma10_ = rec_s(4*k-3)*next_out(state1,9) + rec_s(4*k-2)*next_out(state1,10) + ...
            rec_s(4*k-1)*next_out(state1,11) + rec_s(4*k)*next_out(state1,12) + ...
            L_a_p10(k);

        gamma11_ = rec_s(4*k-3)*next_out(state1,13) + rec_s(4*k-2)*next_out(state1,14) + ...
            rec_s(4*k-1)*next_out(state1,15) + rec_s(4*k)*next_out(state1,16) + ...
            L_a_p11(k);

        temp1=gamma00_ +Beta(k+1,next_state(state1,1));
        temp2=gamma01_ +Beta(k+1,next_state(state1,2));
        temp3=gamma10_ +Beta(k+1,next_state(state1,3));
        temp4=gamma11_ +Beta(k+1,next_state(state1,4));

        temp_1=gamma00_ +Beta(k+1,next_state(state1+1,1));
        temp_2=gamma01_ +Beta(k+1,next_state(state1+1,2));
        temp_3=gamma10_ +Beta(k+1,next_state(state1+1,3));
        temp_4=gamma11_ +Beta(k+1,next_state(state1+1,4));

        Beta(k,state1) = max(max(temp1,temp2),max(temp3,temp4));
        Beta(k,state1+1) = max(max(temp_1,temp_2),max(temp_3,temp_4));
    end

    % Normalization
    Beta(k,:) = Beta(k,:) - max(Beta(k,:));

end

%Update Beta_ini
Beta_out = Beta(1,:);

% Compute the soft output
for k = 1:L_total

    for state2 = 1:nstates
        temp00(state2) = (gamma00(state2,k) + Alpha(k,last_state(state2,1)) + Beta(k+1,state2));
        temp01(state2) = (gamma01(state2,k) + Alpha(k,last_state(state2,2)) + Beta(k+1,state2));
        temp10(state2) = (gamma10(state2,k) + Alpha(k,last_state(state2,3)) + Beta(k+1,state2));
        temp11(state2) = (gamma11(state2,k) + Alpha(k,last_state(state2,4)) + Beta(k+1,state2));
    end

    L_00(k) = max(temp00); %posteriori probability of symbol 00
    L_01(k) = max(temp01); %posteriori probability of symbol 01
    L_10(k) = max(temp10); %posteriori probability of symbol 10
    L_11(k) = max(temp11); %posteriori probability of symbol 11

    ln_p00(k) = L_00(k)- (rec_s(4*k-3)*(1)+ rec_s(4*k-2)*(1)) - L_a_p00(k);
    ln_p01(k) = L_01(k)- (rec_s(4*k-3)*(1)+ rec_s(4*k-2)*(-1)) - L_a_p01(k);
    ln_p10(k) = L_10(k)- (rec_s(4*k-3)*(-1)+ rec_s(4*k-2)*(1)) - L_a_p10(k);
    ln_p11(k) = L_11(k)- (rec_s(4*k-3)*(-1)+ rec_s(4*k-2)*(-1)) - L_a_p11(k);

end