├── Main_Overhead.m
├── ULAdictionaryGeneralize.m
├── README.md
├── vec.m
├── Muturalance_correlance.m
├── CS_MMV_SOMP.m
├── ChannelGenralize.m
├── CSMUSIC_AOD_Estimation.m
├── RIS_SequenceOptimization.m
├── SMJCE.m
└── SMJCE_iteration.m


/Main_Overhead.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/jayJieChen/ChannelEstimation-RIS-MUmmWAVe-MIMO-Systems/HEAD/Main_Overhead.m


--------------------------------------------------------------------------------
/ULAdictionaryGeneralize.m:
--------------------------------------------------------------------------------
1 | function Dictionary=ULAdictionaryGeneralize(Dimension,NumResolu)
2 | Dictionary=zeros(Dimension,NumResolu);  
3 | for ite=1:1:NumResolu
4 |     Dictionary(:,ite)=(sqrt(1/Dimension)*exp(-1j*2*pi*(-0.5+(ite-1)/NumResolu)*[0:Dimension-1])).';
5 | end 
6 | end


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # ChannelEstimation-RIS-MUmmWAVe-MIMO-Systems
2 | This repository contains the main source codes of the proposed algorithm (S-MJCE) in the paper ``Channel Estimation for Reconfigurable Intelligent
3 | Surface Aided Multi-User mmWave MIMO Systems'' published in IEEE Transactions on Wireless Communications.
4 | 


--------------------------------------------------------------------------------
/vec.m:
--------------------------------------------------------------------------------
 1 | function v = vec( x )
 2 | 
 3 | % VEC   Vectorize.
 4 | %    VEC(X), where X is a vector, matrix, or N-D array, returns a column vector
 5 | %    containing all of the elements of X; i.e., VEC(X)=X(:).
 6 | 
 7 | v = reshape( x, numel( x ), 1 );
 8 | 
 9 | % Copyright 2005-2016 CVX Research, Inc.
10 | % See the file LICENSE.txt for full copyright information.
11 | % The command 'cvx_where' will show where this file is located.
12 | 


--------------------------------------------------------------------------------
/Muturalance_correlance.m:
--------------------------------------------------------------------------------
 1 | function  [Number_random,MeanC,varC]=Muturalance_correlance(Gr,V,Dr,xbins1)
 2 | ind=1:1:Gr;
 3 |         ind=(ind-1)*Gr+ind;
 4 |         Dic=V'*Dr; 
 5 |         for ite=1:1:Gr
 6 |         Dic(:,ite)=Dic(:,ite)./norm(Dic(:,ite));
 7 |         end 
 8 |         Grammatrix=(Dic'*Dic);
 9 |         vecGrammatrix=abs(vec(Grammatrix));
10 |         vecGrammatrix(ind)=[];
11 |       % yy2=dsort(vecGrammatrix);
12 |         [Number_random,~]=hist(vecGrammatrix,xbins1);
13 |         MeanC=mean(vecGrammatrix);
14 |         varC=var(vecGrammatrix);
15 | end


--------------------------------------------------------------------------------
/CS_MMV_SOMP.m:
--------------------------------------------------------------------------------
 1 | function  Inedxk=CS_MMV_SOMP(z_bk2,Dmatrixo,yita)
 2 | 
 3 | [length01,length2]=size(Dmatrixo);
 4 |  
 5 | Rk=z_bk2;
 6 | AMplitude=zeros(length2,1);
 7 | 
 8 | Dmatrix=Dmatrixo;
 9 | for ii=1:1:length2
10 |     AMplitude(ii)=sqrt(real(Dmatrixo(:,ii)'*Dmatrixo(:,ii)));%            norm(D_matxo(:,ii),2);
11 |     if AMplitude(ii)<=1e-12
12 |         AMplitude(ii)=1;
13 |     else
14 |         Dmatrix(:,ii)=Dmatrixo(:,ii)/AMplitude(ii);
15 |     end
16 | end
17 | 
18 | IdentiMatrix=diag(ones(length01,1));
19 | InedxOmega_k=zeros(1,length2);
20 | for iteSup=1:1:length2
21 |     erv=sum(abs(Dmatrix'*Rk).^2,2);
22 |     [~,jmax]=max(erv);
23 |     InedxOmega_k(1,jmax(1))=1;
24 |     Inedxk=find(InedxOmega_k(1,:)==1);
25 |     it=0;
26 |     while rank(Dmatrix(:,Inedxk))<length(Inedxk)&&it<20 %yita/;%yita%norm(vecRk,2)^2
27 |         InedxOmega_k(1,jmax(1))=0;
28 |         erv(erv==jmax)=0; 
29 |         [~,jmax]=max(erv);
30 |         InedxOmega_k(1,jmax(1))=1;
31 |         Inedxk=find(InedxOmega_k(1,:)==1);
32 |         it=it+1;
33 |     end
34 |     P_omega=Dmatrix(:,Inedxk)*(Dmatrix(:,Inedxk)'*Dmatrix(:,Inedxk))^(-1)*Dmatrix(:,Inedxk)'; 
35 |     Rk=(IdentiMatrix-P_omega)*z_bk2;
36 |     if real(trace(Rk'*Rk))<=yita %yita/;%yita%norm(vecRk,2)^2
37 |         break;
38 |     end
39 | end
40 | 
41 | end


--------------------------------------------------------------------------------
/ChannelGenralize.m:
--------------------------------------------------------------------------------
 1 | function  [F,H,GenieaidedAoA,GenieaidedAoD]=ChannelGenralize(System) ; 
 2 |  
 3 | NL=System.NL;
 4 | NM=System.NM;
 5 | Nf=System.Nf;
 6 | Nhk=System.Nhk;
 7 | K=System.K; 
 8 | AoAF=zeros(NL,Nf) ;
 9 | GenieaidedAoD=zeros(NM,Nf);
10 | AoDHk=zeros(NL,Nhk,K);
11 | GenieaidedAoA=zeros(NL,Nhk*Nf,K); 
12 | % BS-RIS Channel
13 | F=zeros(NL,NM);
14 | theta_nmAOA= ((rand(1,Nf)*pi)-pi/2); 
15 | theta_nmAOD=((rand(1,Nf)*pi)-pi/2); 
16 | for iteaoa=1:1:length(theta_nmAOA)
17 |     AoAF(:,iteaoa)=(exp(-1j*pi*sin(theta_nmAOA(iteaoa))*[0:NL-1])).';
18 |     GenieaidedAoD(:,iteaoa)=(exp(-1j*pi*sin(theta_nmAOD(iteaoa))*[0:NM-1])).';
19 |     F=F+sqrt(0.5)*(normrnd(0,1,1,1) + 1j*normrnd(0,1,1,1)).*(AoAF(:,iteaoa)* GenieaidedAoD(:,iteaoa)');%*exp(1j*rand(1,1) * 2 * pi); ()
20 | end
21 | F=sqrt(1/Nf).*F;
22 | 
23 | % RIS-User Channel
24 | H=zeros(NL,K);
25 | for itek=1:1:K
26 |     theta_User=(rand(K,Nhk)*pi)-pi/2;%[10 30 ]';
27 |     H(:,itek)=zeros(NL,1);
28 |     for iteuaoa=1:1:Nhk
29 |         AoDHk(:,iteuaoa,itek)=((exp(-1j*pi*sin(theta_User(itek,iteuaoa))*[0:NL-1])).');
30 |         GenieaidedAoA(:,(iteuaoa-1)*length(theta_nmAOA)+1:(iteuaoa)*length(theta_nmAOA),itek)=diag(AoDHk(:,iteuaoa,itek)')*AoAF;
31 |         H(:,itek)= H(:,itek)+sqrt(0.5)*(normrnd(0,1,1,1) + 1j*normrnd(0,1,1,1)).*AoDHk(:,iteuaoa,itek);
32 |     end
33 |     H(:,itek)= sqrt(1/(Nhk)).*H(:,itek);
34 | end
35 | end


--------------------------------------------------------------------------------
/CSMUSIC_AOD_Estimation.m:
--------------------------------------------------------------------------------
 1 | function [R_reduce,ChannelSubpace]=CSMUSIC_AOD_Estimation(N_bpilot,Yk,YkHermite, System)
 2 |  
 3 | z_bktilde=YkHermite;
 4 | z_bk=Yk;
 5 | 
 6 | 
 7 | NM=System.NM; % The number of antennas at the BS 
 8 | K=System.K;  % The numer of users
 9 |   
10 | 
11 | CovarianceZ=zeros(NM,NM);
12 | for ite=1:1:K
13 |     CovarianceZ=CovarianceZ+z_bk(:,:,ite)*z_bktilde(:,:,ite)./K;
14 | end
15 | [S_CovarianceZ,CovarianceZ_eigvalue,~]=eig(CovarianceZ);
16 | [CovarianceZ_eigvalue_Trans, idexmaxtomin]=dsort(diag(CovarianceZ_eigvalue));
17 | S_CovarianceZ_Trans=S_CovarianceZ;
18 | for itej=1:1:length((idexmaxtomin))
19 |     S_CovarianceZ_Trans(:,itej)=S_CovarianceZ(:,idexmaxtomin(itej));
20 | end
21 | CovarianceZ_eigvalue_Trans=abs(CovarianceZ_eigvalue_Trans);
22 | %method 2
23 | %p=Nb;
24 | %N=observations:
25 | MDLp=NM;
26 | MDLN=K*N_bpilot;
27 | MDL_value_cur=inf;
28 | for MDLk=1:1:NM
29 |     MDL_value_bef=MDL_value_cur;
30 |     Term1=prod(CovarianceZ_eigvalue_Trans(MDLk+1:MDLp).^(1/(MDLp-MDLk)));
31 |     Term2=sum(CovarianceZ_eigvalue_Trans(MDLk+1:MDLp))./((MDLp-MDLk));
32 |     MDL_value_cur=-((MDLp-MDLk)*MDLN)*log((Term1/Term2))+0.5*MDLk*(2*MDLp-MDLk)*log(MDLN);
33 |     if MDL_value_cur>MDL_value_bef
34 |         break
35 |     end
36 | end
37 | 
38 | 
39 | r=min(min(MDLk-1,NM),N_bpilot);%===!!===
40 | ChannelSubpace=S_CovarianceZ_Trans(:,1:r);
41 | R_reduce=sum(CovarianceZ_eigvalue_Trans(r+1:end)); 
42 | end


--------------------------------------------------------------------------------
/RIS_SequenceOptimization.m:
--------------------------------------------------------------------------------
 1 | 
 2 | function LISpilotO=RIS_SequenceOptimization(System,N_bpilot)
 3 | Gr=System.Gr;
 4 | Dr=System.Dr;
 5 | NL=System.NL; 
 6 | xbins1=0:0.01:0.09;
 7 | LISpilot=sqrt(0.5)*(normrnd(0,1,NL,N_bpilot) + 1j*normrnd(0,1,NL,N_bpilot));%1-ny-nsignalzeros(n_signal,1);%
 8 | while rank(LISpilot)<N_bpilot
 9 |     LISpilot=sqrt(0.5)*(normrnd(0,1,NL,N_bpilot) + 1j*normrnd(0,1,NL,N_bpilot));%1-ny-nsignalzeros(n_signal,1);%
10 | end
11 | LISpilot=LISpilot./abs(LISpilot);
12 |  
13 | 
14 | LISpilotO=LISpilot;
15 | [CA1,CA0]=size(LISpilot);
16 | A=Dr*Dr';
17 | [Sx,Vx,Dx]=eig(A); %
18 | [valuemaxtoimin, idexmaxtomin]=dsort(diag(Vx));
19 | Sxtrans=Sx;
20 | for itej=1:1:length((idexmaxtomin))
21 |     Sxtrans(:,itej)=Sx(:,idexmaxtomin(itej));
22 | end
23 | CA2=length(valuemaxtoimin(valuemaxtoimin>0));
24 | cur=inf;
25 | for ite=1:1:1
26 |     cuf=cur;
27 |     for jj=1:1:CA0
28 |         Tamma=Sxtrans'*LISpilot;
29 |         VV=diag(valuemaxtoimin)*Tamma;
30 |         Ej=CA0.*diag(valuemaxtoimin)-VV*VV'+VV(:,jj)*VV(:,jj)';
31 |         [Sj,Vj,~]=eig(Ej); %
32 |         [c1,~]=find(real(Vj)==(max(max(real(Vj)))));
33 |         temvec=LISpilot(:,jj);
34 |         for ii=1:1:CA2
35 |             temvec(ii)=Sj(ii,c1(1))*sqrt(Vj(c1(1),c1(1)))/valuemaxtoimin(ii);
36 |         end
37 |         LISpilot(:,jj)=Sxtrans*temvec;
38 |         LISpilot(:,jj)= LISpilot(:,jj)./abs(LISpilot(:,jj));
39 |     end
40 |     [~,cur,~]=Muturalance_correlance(Gr,LISpilot,Dr,xbins1); 
41 |     if cur<cuf
42 |         LISpilotO=LISpilot;
43 |     else
44 |         break
45 |     end
46 | end 
47 | LISpilotO=LISpilotO./abs(LISpilotO); 
48 | end
49 | 


--------------------------------------------------------------------------------
/SMJCE.m:
--------------------------------------------------------------------------------
 1 | function [NMSE_SMJCE,NMSE_SMMV]=SMJCE(Yk,YkHermite,V,G,System,N_bpilot) % Algorithm 2  
 2 |  
 3 | NMSE_SMMV=0;
 4 | NMSE_SMJCE=0;
 5 | NM=System.NM;  
 6 | NL=System.NL;  
 7 | K=System.K;   
 8 | SNR=System.SNR;
 9 | Gr=System.Gr; 
10 | N_npilot=System.N_npilot;
11 | Dr=System.Dr;  
12 | 
13 | %%  Channelsubpace Estimation and Projection========================================
14 | [~,Subpace]=CSMUSIC_AOD_Estimation( N_bpilot, Yk, YkHermite,System); % Subspace Estimation eq(26)
15 | [~,length_ind]=size(Subpace);
16 | YkProjected=zeros(N_bpilot,length_ind,K);
17 | for ite=1:1:K
18 |     YkProjected(:,:,ite)= YkHermite(:,:,ite)*Subpace*(Subpace'*Subpace)^(-1); %eq(28)
19 | end 
20 | noisecovariance= N_bpilot*trace((Subpace'*Subpace)^(-1))/(SNR)/(N_npilot);
21 | G_hatall= zeros(NL,NM,K);
22 | for itekkk=1:1:K
23 |     Inedxk=CS_MMV_SOMP(YkProjected(:,:,itekkk),V'*Dr,noisecovariance);
24 |     leftinverse=((V'*Dr(:,Inedxk))'*V'*Dr(:,Inedxk))^(-1)*(V'*Dr(:,Inedxk))';
25 |     Xk=leftinverse*YkProjected(:,:,itekkk);
26 |     if itekkk==1 
27 |         X_curini= zeros(Gr,length_ind);
28 |         X_curini(Inedxk,:)=Xk;
29 |     end
30 |     G_hat=Dr(:,Inedxk)*Xk*Subpace';
31 |     G_hatall(:,:,itekkk)=G_hat;
32 |     NMSE_SMMV=NMSE_SMMV+trace((G_hat-G(:,:,itekkk))'*(G_hat-G(:,:,itekkk)))/trace((G(:,:,itekkk))'*(G(:,:,itekkk)))/K; 
33 | end 
34 | %% MJCE
35 |  [Alphaalll,Xall]=SMJCE_iteration(N_bpilot,V,G_hatall,X_curini,System,YkProjected,Subpace);
36 | for itek=1:1:K
37 |     G_hat=(Alphaalll((itek-1)*NL+1:(itek*NL),:))*Dr*Xall*Subpace';
38 |     NMSE_SMJCE=NMSE_SMJCE+trace((G_hat-G(:,:,itek))'*(G_hat-G(:,:,itek)))/trace((G(:,:,itek))'*(G(:,:,itek)))/K;
39 | end 
40 | end


--------------------------------------------------------------------------------
/SMJCE_iteration.m:
--------------------------------------------------------------------------------
  1 | function   [alphaAll,Xall]=SMJCE_iteration(N_bpilot,V,G_hatall,X_curini,System,YkProjected,Subpace);
  2 | NM=System.NM; % The number of antennas at the BS
  3 | NL=System.NL;  % The numer of reflective elements at the RIS
  4 | K=System.K;  % The numer of users
  5 | SNR=System.SNR;
  6 | Gr=System.Gr; 
  7 | N_npilot=System.N_npilot;
  8 | Dr=System.Dr;  
  9 | 
 10 | [~,length_ind]=size(Subpace);
 11 | lambdaD=0.1;
 12 | noisecovariance2=1/(SNR(1))/(N_npilot);
 13 | itemaxgra_Gradientsearch=4;
 14 | threshold_eps=1e-9;
 15 | %% First Estimated/ Joint Optimized 
 16 | Hestimated_cur=ones(NL,K);
 17 | for itek=1:1:K
 18 |     for itel=1:1:NL
 19 |         Hestimated_cur(itel,itek) =sum(G_hatall(itel,:,itek)./G_hatall(itel,:,1))./NM;
 20 |     end
 21 | end
 22 | Z_all_her=zeros(K*N_bpilot,length_ind);
 23 | V_all_her=zeros(K*N_bpilot,K*NL);
 24 | A_all=zeros(K*NL,NL);
 25 | for ite=1:1:K
 26 |     Z_all_her((ite-1)*N_bpilot+1:ite*N_bpilot,:)= YkProjected(:,:,ite);
 27 |     V_all_her((ite-1)*N_bpilot+1:ite*N_bpilot,(ite-1)*NL+1:ite*NL)=V';
 28 |     A_all((ite-1)*NL+1:ite*NL,:)= diag(Hestimated_cur(:,ite));
 29 | end
 30 | Z_all=Z_all_her';
 31 | V_all=V_all_her'; 
 32 | A_all_ini=A_all; 
 33 | lambda_ini=lambdaD/(log(Gr)*noisecovariance2);
 34 | lambda_all=diag(ones(1,K*N_bpilot));
 35 | for itee=1:1:K
 36 |     lambda_all((itee-1)*N_bpilot+1:itee*N_bpilot,(itee-1)*N_bpilot+1:itee*N_bpilot)=diag(lambda_ini.*ones(1,N_bpilot));  %/trace(noise(:,:,itee)'*noise(:,:,itee));%((trace((z_bktilde(:,:,itee)-V'*diag(Hestimated(:,itee)')*Dr*X_cur)'*(z_bktilde(:,:,itee)-V'*diag(Hestimated(:,itee)')*Dr*X_cur))));
 37 | end 
 38 | Xall= ones(Gr,length_ind);
 39 | obj_curout=sum(log(real(diag(Xall*Xall'))+threshold_eps))+trace((Z_all'-V_all'*A_all*Dr*Xall)'*lambda_all*(Z_all'-V_all'*A_all*Dr*Xall));
 40 | 
 41 | ind=1:1:NL;
 42 | ind=ind+NL*(ind-1);
 43 | for ite_sca=1:1:500
 44 |     obj_befout=obj_curout ;
 45 |     Abef_all=A_all;
 46 |     %% Compite X_cur
 47 |     obj_curinner=obj_befout;
 48 |     conver1=1e-6;
 49 |     for ite_scag=1:1:10000
 50 |         obj_befinner=obj_curinner;
 51 |         DiagnolaValue=diag(1./(real(diag(Xall*Xall'))+threshold_eps));
 52 |         Midterm1=(DiagnolaValue+(Dr'*A_all'*V_all*lambda_all*V_all'*A_all*Dr))^(-1);
 53 |         Xall=Midterm1*(Dr'*A_all'*V_all*lambda_all*Z_all');
 54 |         DiagnolaValue=diag(1./(real(diag(Xall*Xall'))+threshold_eps));
 55 |         Xall=(DiagnolaValue+Dr'*A_all'*V_all*lambda_all*V_all'*A_all*Dr)^(-1)*(Dr'*A_all'*V_all*lambda_all*Z_all');
 56 |         obj_curinner=real(sum(log(real(diag(Xall*Xall'))+threshold_eps))+trace((Z_all'-V_all'*A_all*Dr*Xall)'*lambda_all*(Z_all'-V_all'*A_all*Dr*Xall)));
 57 |         if (obj_befinner-obj_curinner)<conver1*1e-1
 58 |             break
 59 |         end
 60 |     end
 61 |     obj_curout=obj_curinner;
 62 |     
 63 |     %% Computde Derivate of A_ll
 64 |     for itegradient=1:1:itemaxgra_Gradientsearch
 65 |         if K==1
 66 |             flag=1;
 67 |             break;
 68 |         end
 69 |         
 70 |         for iteg=2:1:K
 71 |             vecZk=vec(YkProjected(:,:,iteg));
 72 |             Dmatrix11=kron((Dr*Xall).',V');
 73 |             Dmatrix11_ind=Dmatrix11(:,ind);
 74 |             flag=0;
 75 |             if rank(Dmatrix11_ind,1e-8)<NL
 76 |                 flag=1;
 77 |                 for itenu=1:1:NL
 78 |                     Abef_all((iteg-1)*NL+itenu,itenu)=A_all((iteg-1)*NL+itenu,itenu);%-DerivateA((iteg-1)*Nu+itenu,itenu)*(1e-4/(itegradient)/ite_sca^2)*abs(A_all_ini((iteg-1)*Nu+itenu,itenu)) ;%(1e-7/(itegradient)/ite_sca^2)*DerivateA((iteg-1)*Nu+itenu,itenu);
 79 |                 end
 80 |             else
 81 |                 Abef_all((iteg-1)*NL+1: iteg*NL,:)=diag( (Dmatrix11_ind'*Dmatrix11_ind)^(-1)*Dmatrix11_ind'*vecZk);
 82 |             end
 83 |             if  flag==1
 84 |                 break
 85 |             end
 86 |         end
 87 |         obj_cur0=sum(log(real(diag(Xall*Xall'))+threshold_eps))+trace((Z_all'-V_all'*Abef_all*Dr*Xall)'*lambda_all*(Z_all'-V_all'*Abef_all*Dr*Xall));
 88 |         if obj_curout-obj_cur0>=0%real(trace(X_cur*X_cur'*DiagnolaValue))>real(trace(CovarianceZ_est'*((Dt_opt*DiagnolaValue_inv*Dt_opt')^(-1))*CovarianceZ_est))
 89 |             break
 90 |         end
 91 |         if  flag==1
 92 |             break
 93 |         end
 94 |     end
 95 |     
 96 |     if  flag==1
 97 |         break
 98 |     end
 99 |     
100 |     if itegradient<itemaxgra_Gradientsearch
101 |         A_all=Abef_all;
102 |     end
103 |     
104 |     if abs(obj_curout-obj_cur0)<conver1
105 |         break
106 |     end
107 |     obj_curout=obj_cur0;
108 | end
109 | alphaAll=A_all;
110 | G_hat1=0;
111 | G_hatini=0;
112 | for itek=1:1:K
113 |     G_hat1=sum(sum(abs((alphaAll((itek-1)*NL+1:(itek*NL),:))*Dr*Xall*Subpace').^2))+G_hat1;
114 |     G_hatini=G_hatini+sum(sum(abs((A_all_ini((itek-1)*NL+1:(itek*NL),:))*Dr*X_curini*Subpace').^2));
115 | end
116 | 
117 | if G_hat1>1.7*G_hatini %heuristically
118 |     alphaAll=A_all_ini;
119 |     Xall=X_curini;
120 | end
121 | end
122 | 
123 | 
124 | 
125 | 
126 | 


--------------------------------------------------------------------------------