effect of inter-凯发k8网页登录

nframes = 4;               % number of frames
eqmethod = 'mmse_irc';     % mmse, mmse_irc

sinr = 0.8;        % sinr in db
dip2 = -1.73;      % dip in db for cell 2
dip3 = -8.66;      % dip in db for cell 3
noc = -98;         % dbm/15khz average power spectral density

% set the random number generator seed
rng('default');
% set cell 1 enodeb configuration according to r.47
simulationparameters = struct;
simulationparameters.ndlrb = 50;
simulationparameters.cellrefp = 2;
simulationparameters.ncellid = 0;
simulationparameters.cfi = 2;
simulationparameters.duplexmode = 'fdd';
simulationparameters.totsubframes = 1; % this is not the total number of
% subframes used in the simulation, just the number of subframes we
% generate per call to the waveform generator.
% specify pdsch configuration substructure
simulationparameters.pdsch.txscheme = 'spatialmux';
simulationparameters.pdsch.modulation = {'16qam'};
simulationparameters.pdsch.nlayers = 1;
simulationparameters.pdsch.rho = -3;
simulationparameters.pdsch.prbset = (0:49)';
% table a.3.3.2.1-2, ts 36.101
simulationparameters.pdsch.trblksizes = [8760 8760 8760 8760 8760 0 8760 8760 8760 8760];
% table a.3.3.2.1-2, ts 36.101
simulationparameters.pdsch.codedtrblksizes = [24768 26400 26400 26400 26400 0 26400 26400 26400 26400];
simulationparameters.pdsch.csimode = 'pucch 1-1';
simulationparameters.pdsch.pmimode = 'wideband';
simulationparameters.pdsch.csi = 'on';
simulationparameters.pdsch.w = [];
simulationparameters.pdsch.codebooksubset = '1111';
% specify pdsch ocng configuration
simulationparameters.ocngpdschenable = 'on';             % enable ocng fill
simulationparameters.ocngpdschpower = -3;                % ocng power same as pdsch rho
simulationparameters.ocngpdsch.rnti = 0;                 % virtual ue rnti
simulationparameters.ocngpdsch.modulation = 'qpsk';      % ocng symbol modulation
simulationparameters.ocngpdsch.txscheme = 'txdiversity'; % ocng transmission mode 2

enb1 = ltermcdl(simulationparameters);

% cell 2
enb2 = enb1;
enb2.ncellid = 1;
enb2.ocngpdschenable = 'off';
% cell 3
enb3 = enb1;
enb3.ncellid = 2;
enb3.ocngpdschenable = 'off';

% enodeb1 to ue propagation channel
channel1 = struct;                    % channel config structure
channel1.seed = 20;                   % channel seed
channel1.nrxants = 2;                 % 2 receive antennas
channel1.delayprofile ='eva';         % delay profile
channel1.dopplerfreq = 5;             % doppler frequency
channel1.mimocorrelation = 'low';     % multi-antenna correlation
channel1.nterms = 16;                 % oscillators used in fading model
channel1.modeltype = 'gmeds';         % rayleigh fading model type
channel1.initphase = 'random';        % random initial phases
channel1.normalizepathgains = 'on';   % normalize delay profile power
channel1.normalizetxants = 'on';      % normalize for transmit antennas

ofdminfo = lteofdminfo(enb1);
channel1.samplingrate = ofdminfo.samplingrate;
% enodeb2 (interference) to ue propagation channel
channel2 = channel1;
channel2.seed = 122;                  % channel seed
% enodeb3 (interference) to ue propagation channel
channel3 = channel1;
channel3.seed = 36;                   % channel seed

% channel estimator behavior
perfectchanestimator = true;
% the channel estimator configuration structure is defined below. the
% frequency and time averaging window sizes are chosen to span a relatively
% large number of resource elements. the large window sizes are chosen to
% average as much as possible noise and interference in the resource
% elements. note that too large an averaging window in time and/or frequency
% will cause loss of information due to averaging out the channel variations.
% this produces an increasingly imperfect channel estimate which can affect
% the performance of the equalizer.
cec = struct;                        % channel estimation config structure
cec.pilotaverage = 'userdefined';    % type of pilot symbol averaging
cec.freqwindow = 31;                 % frequency window size
cec.timewindow = 23;                 % time window size
cec.interptype = 'cubic';            % 2d interpolation type
cec.interpwindow = 'centered';       % interpolation window type
cec.interpwinsize = 1;               % interpolation window size

% channel noise setup
noclin = 10.^(noc/10)*(1e-3); % linear  in watts
% take into account fft (ofdm) scaling
no = sqrt(noclin/(2*double(ofdminfo.nfft)));
% signal and interference amplitude scaling factors calculation
[k1, k2, k3] = henbscalingfactors(dip2, dip3, noc, sinr, enb1, enb2, enb3);

% initialize state of all harq processes
harqprocesses = hnewharqprocess(enb1);
% initialize harq process ids to 1 as the first non-zero transport
% block will always be transmitted using the first harq process. this
% will be updated with the full sequence output by ltermcdltool after
% the first call to the function
harqprocesssequence = 1;
% set up variables for the main loop
lastoffset = 0;       % initialize frame timing offset from previous frame
frameoffset = 0;      % initialize frame timing offset
npmi = 0;             % initialize the number of precoder matrix indication
                      % (pmi) set calculated
blkcrc = [];          % block crc for all considered subframes
bittput = [];         % number of successfully received bits per subframe
txedtrblksizes = [];  % number of transmitted bits per subframes
% vector of total number of bits transmitted, calculated for each subframe.
runningmaxthput = [];
% vector storing the number of successfully received bits, calculated for
% each subframe.
runningsimthput = [];
% obtain the number of transmit antennas.
dims = ltedlresourcegridsize(enb1);
p = dims(3);
% assign the redundancy version sequence for each codeword and transport
% block sizes for each subframe
rvsequence = enb1.pdsch.rvseq;
trblksizes = enb1.pdsch.trblksizes;
% set the pmi delay for the closed-loop spatial multiplexing
pmidelay = 8; % as specified in ts 36.101, table 8.2.1.4.1b-1
% initialize pmis for the first 'pmidelay' subframes
pmidims = ltepmiinfo(enb1,enb1.pdsch);
txpmis = zeros(pmidims.nsubbands, pmidelay);
% flag to indicate if a valid pmi feedback is available from the ue
pmiready = false;

fprintf('\nsimulating %d frame(s)\n',nframes);
% main for loop: for all subframes
for subframeno = 0:(nframes*10-1)
    % reinitialize channel seed for each subframe to increase variability
    channel1.seed = 1 subframeno;
    channel2.seed = 1 subframeno (nframes*10);
    channel3.seed = 1 subframeno 2*(nframes*10);
    % update subframe number
    enb1.nsubframe = subframeno;
    enb2.nsubframe = subframeno;
    enb3.nsubframe = subframeno;
    duplexinfo = lteduplexinginfo(enb1);
    if  duplexinfo.nsymbolsdl ~= 0 % target only downlink subframes
        % get harq process id for the subframe from harq process sequence
        harqid = harqprocesssequence(mod(subframeno, length(harqprocesssequence)) 1);
        % if there is a transport block scheduled in the current subframe
        % (indicated by non-zero 'harqid'), perform transmission and
        % reception. otherwise, continue to the next subframe.
        if harqid == 0
            continue;
        end
        % update current harq process
        harqprocesses(harqid) = hharqscheduling( ...
            harqprocesses(harqid), subframeno, rvsequence);
        % extract the current subframe transport block size(s)
        trblk = trblksizes(:, mod(subframeno, 10) 1).';
        % update the pdsch transmission config with harq process state
        enb1.pdsch.rvseq = harqprocesses(harqid).txconfig.rvseq;
        enb1.pdsch.rv = harqprocesses(harqid).txconfig.rv;
        dlschtransportblk = harqprocesses(harqid).data;
        % set the pmi to the appropriate value in the delay queue
        if strcmpi(enb1.pdsch.txscheme,'spatialmux')
            pmiidx = mod(subframeno, pmidelay);      % pmi index in delay queue
            enb1.pdsch.pmiset = txpmis(:, pmiidx 1); % set pmi
        end
        % create transmit waveform
        [tx,~,enbout] = ltermcdltool(enb1, dlschtransportblk);
        % pad 25 samples to cover the range of delays expected from channel
        % modeling (a combination of implementation delay and channel delay
        % spread)
        txwaveform1 = [tx; zeros(25, p)];
        % get the harq id sequence from 'enbout' for harq processing
        harqprocesssequence = enbout.pdsch.harqprocesssequence;
        % generate interferer model as per as per ts 36.101, b.5.3. the
        % function htm4interfmodel generates the interferer transmit signal.
        txwaveform2 = [htm4interfmodel(enb2); zeros(25,p)];
        txwaveform3 = [htm4interfmodel(enb3); zeros(25,p)];
        % specify channel time for the present subframe
        channel1.inittime = subframeno/1000;
        channel2.inittime = channel1.inittime;
        channel3.inittime = channel1.inittime;
        % pass data through the channel
        rxwaveform1 = ltefadingchannel(channel1,txwaveform1);
        rxwaveform2 = ltefadingchannel(channel2,txwaveform2);
        rxwaveform3 = ltefadingchannel(channel3,txwaveform3);
        % generate noise
        noise = no*complex(randn(size(rxwaveform1)), ...
            randn(size(rxwaveform1)));
        % add awgn to the received time domain waveform
        rxwaveform = k1*rxwaveform1   k2*rxwaveform2   k3*rxwaveform3   noise;
        % receiver
        % once every frame, on subframe 0, calculate a new synchronization
        % offset
        if (mod(subframeno,10) == 0)
            frameoffset = ltedlframeoffset(enb1, rxwaveform);
            if (frameoffset > 25)
                frameoffset = lastoffset;
            end
            lastoffset = frameoffset;
        end
        % synchronize the received waveform
        rxwaveform = rxwaveform(1 frameoffset:end, :);
        % scale rxwaveform by 1/k1 to avoid numerical issues with
        % channel decoding stages
        rxwaveform = rxwaveform/k1;
        % perform ofdm demodulation on the received data to obtain the
        % resource grid
        rxsubframe = lteofdmdemodulate(enb1, rxwaveform);
        % perform channel estimation
        if(perfectchanestimator)
            estchannelgrid = ltedlperfectchannelestimate(enb1, channel1, frameoffset);
            noiseinterf = k2*rxwaveform2   k3*rxwaveform3   noise;
            noiseinterf = noiseinterf/k1;
            noisegrid = lteofdmdemodulate(enb1, noiseinterf(1 frameoffset:end ,:));
            noiseest = var(noisegrid(:));
        else
            [estchannelgrid, noiseest] = ltedlchannelestimate( ...
                enb1, enb1.pdsch, cec, rxsubframe);
        end
        % get pdsch indices
        pdschindices = ltepdschindices(enb1,enb1.pdsch,enb1.pdsch.prbset);
        % get pdsch resource elements. scale the received subframe by
        % the pdsch power factor rho.
        [pdschrx, pdschhest] = lteextractresources(pdschindices, ...
            rxsubframe*(10^(-enb1.pdsch.rho/20)), estchannelgrid);
        % perform equalization and deprecoding
        if strcmp(eqmethod,'mmse')
            % mimo equalization and deprecoding (mmse based)
            [rxdeprecoded,csi] = lteequalizemimo(enb1,enb1.pdsch,...
                pdschrx,pdschhest,noiseest);
        else
            % mimo equalization and deprecoding (mmse-irc based)
            [rxdeprecoded,csi] = hequalizemmseirc(enb1,enb1.pdsch,...
                rxsubframe,estchannelgrid,noiseest);
        end
        % perform layer demapping, demodulation and descrambling
        cws = ltepdschdecode(enb1,setfield(enb1.pdsch,'txscheme',...
            'port7-14'),rxdeprecoded); % the pdsch transmission scheme is
        % modified into port7-14, in order to skip the deprecoding operation
        % scaling llrs by csi
        cws = hcsiscaling(enb1.pdsch,cws,csi);
        % decode dl-sch
        [decbits, harqprocesses(harqid).blkerr,harqprocesses(harqid).decstate] = ...
            ltedlschdecode(enb1, enb1.pdsch, trblk, cws, ...
            harqprocesses(harqid).decstate);
        % store values to calculate throughput
        % only for subframes with data and valid pmi feedback
        if any(trblk) && pmiready
            blkcrc = [blkcrc harqprocesses(harqid).blkerr];
            txedtrblksizes =  [txedtrblksizes trblk];
            bittput = [bittput trblk.*(1-harqprocesses(harqid).blkerr)];
        end
        runningsimthput = [runningsimthput sum(bittput,2)];
        runningmaxthput = [runningmaxthput sum(txedtrblksizes,2)];
        % provide pmi feedback to the enodeb
        if strcmpi(enb1.pdsch.txscheme,'spatialmux')
            pmi = ltepmiselect(enb1, enb1.pdsch, estchannelgrid, noiseest);
            txpmis(:, pmiidx 1) = pmi;
            npmi = npmi 1;
            if npmi>=pmidelay
                pmiready = true;
            end
        end
    end
end

maxthroughput = sum(txedtrblksizes); % maximum possible throughput
simthroughput = sum(bittput,2);      % simulated throughput
% display achieved throughput percentage
disp(['achieved throughput ' num2str(simthroughput*100/maxthroughput) '%'])
% plot running throughput
figure;plot(runningsimthput*100./runningmaxthput)
ylabel('throughput (%)');
xlabel('simulated subframe');
title('throughput');