function output =  imddmodel(sir,winlen,linewidth)

for realiz = 1:3

    rng(realiz);
    
    %% Set Simulation Variables
    
    sir = sir;
    
    delay = 50; %mpi delay in meter
    
    fiblen = 0; %main link in km
    
    laser_linewidth = linewidth;
    
    O = 17; %order of prbs
    N = 2^(O-1); %length of prbs
    [~,seed] = prbs(O,1); %initialize first seed of prbs
    
    % Modulation
    M = 4; %PAM-M
    bitpattern = zeros(N,log2(M));
    
    % Symbol Rate
    fsym = 112e9;
    
    % DAC Rate
    fdac = 120e9;
    
    % Simulation oversampling rate "k";
    kover = 16;
    
    % ADC Rate
    fadc = 256e9;
    
    % Simulation frequency in "analog domain"
    fsimu = kover * fdac ;
    
    
    %% CONSTRUCT ALL CLASSES
    
    digimod     = PAMmapper(M,0);
    
    pulseform   = Pulseformer("pulseform","rrc","fdac",fdac,"fsym",fsym,"pulselength",32,"rrcalpha",0.1);
    
    awg         = AWG('fdac',fdac,'kover',kover,'lpf_active',1,'f_cutoff',56e9,'lpf_type',filtertypes.gaussian,'bit_resolution',5.5);
    
    lp_laser    = Filter('filtdegree',1,"f_cutoff",50e9,"fsamp",fdac*kover,"filterType",filtertypes.bessel_inp);
    
    u_pi = 3.5;
    vbias = (0.5*u_pi)-u_pi;
    extmodlaser = EML("mode",eml_mode.im_cosinus,"power",15,"fsimu",fsimu,"lambda",1550,"bias",vbias,"u_pi",u_pi,"linewidth",laser_linewidth);
    
    fib         = Fiber("fsimu",fdac*kover,"fiber_length",fiblen,"alpha",0.2,"D",16,"lambda0",thz2nm(193.1),"gamma",0);
    
    reflectionpoint  = Amplifier("amp_mode","ideal_no_noise","gain_mode","gain","amplification_db",sir);
    reflectionprop   = Fiber("fsimu",fdac*kover,"fiber_length",2*delay/1000,"alpha",0.2,"D",16,"lambda0",1550,"gamma",0);
    
    
    opticatten  = Amplifier("amp_mode","ideal_no_noise","gain_mode","output_power","amplification_db",0);
    
    edfaamp     = Amplifier("amp_mode","edfa_increase_nase","gain_mode","output_power","amplification_db",0,"nase_mode","generate_ase","noifig",10.5);
    
    phdiode     = Photodiode("fsimu",fdac*kover,"dark_current",2e-08,"responsivity",1,"temperature",20);
    
    lp_diode    = Filter('filtdegree',1,"f_cutoff",50e9,"fsamp",fdac*kover,"filterType",filtertypes.bessel_inp);
    
    scp         = Scope("fsimu",fdac*kover,"fadc",fadc,...
        "delay",0,"fixed_delay",0,"lpf_bw",113e9,"filtertype",filtertypes.butterworth,...
        "samplingdelay",0,"rand_samplingdelay",0,"freq_offset",0,"samp_jitter",0,...
        "adcresolution",6,"quantbuffer",0.1,'block_dc',1);
    
    eq          = EQ("K",2,"plottrain",0,"plotfinal",0,...
        "training_length",1024,"training_loops",5,...
        "Ne",[50,0,0],"Nb",[0,0,0],...
        "DCmu",0,"DDmu",[0.0004 0.0004 0.0004 0.0004 ],"DFEmu",0.005,"FFEmu",0.00,...
        "dd_loops",2,"epsilon",[10 100 1000 ],"M",4,...
        "thres",[0.005 0.004 0.0005 ],"l1act",0,"delay",1,"rho",0.0005,"ideal_dfe",0,"DB_aim",0);
    
    
    %% PROCESS
    
    % PRBS Generation
    for i = 1:log2(M)
        [bitpattern(:,i),seed] = prbs(O,N,seed);
    end
    bitpattern = [bitpattern ; flip(bitpattern)];
    %bitpattern = prms_out';
    
    % Build Inf. signal class
    bits        = Informationsignal(bitpattern);
    
    % Digi Mod
    mod_out     = digimod.map(bits);
    
    % merken für EQ training
    reference   = mod_out;
    
    % shape shape
    X       = pulseform.process(mod_out);
    
    % AWG -> ELECTRICAL DOMAIN
    awg_out     = awg.process(X);
    
    X           = lp_laser.process(awg_out);
    X           = lp_laser.process(X);
    
    X           = X.normalize("mode","oneone");
    X.signal    = X.signal .* 1.3800;
    
    % Laser; Modulation ->  OPTICAL DOMAIN
    X           = extmodlaser.process(X);
    
    % Fiber Propagation
    X           = fib.process(X);
    
    %% Reflect with attenuation
    R = reflectionpoint.process(X);
    
    % Propagate
    R = reflectionprop.process(R);
    
    % disp(['SIR ',num2str(10*log10(X.power/R.power))]);
    
    % Delay
    R = R.delay("delay_meter",delay);
    
    % Add together
    X = X+R;
    
    %%
    X           = opticatten.process(X);
    % X           = edfaamp.process(X);
    
    % Photo Diode -> ELECTRICAL DOMAIN
    X           = phdiode.process(X);
    X           = lp_diode.process(X);
    
    
    % Oscilloscope (Sampling to f_adc; Quantization; Bandwidth Limitation)
    X           = scp.process(X);
    
    % Resample to Symbol Rate
    X           = X.resample("fs_out",2*fsym,"fs_in",fadc);
    
    % Normalize
    Eq_in           = X.normalize("mode","rms");
    
    % Equalizer
    Eq_out           = eq.process(Eq_in,reference);
    
    %% MPI reduction DC removal
    wl = winlen; % symbols
    yk_dcsm = Eq_out;
    yk_dcsm.signal = Eq_out.signal - 1/wl .* movsum( Eq_out.signal,[wl/2,wl/2]);
    
    %% MPI reduction Level wise error removal
    yk_lvsm = Eq_out;
    yk_lvlp = Eq_out;
    pre_decision_level_uni  = digimod.decide_pamlevel(Eq_out);
    pre_decision_level_bi   = ( pre_decision_level_uni*2-3 ) .* 1/sqrt(5);
    
    e = Eq_out.signal - pre_decision_level_bi;
    
    lp_mpi = Filter('filtdegree',1,"f_cutoff",max(10*linewidth,1e6),"fsamp",fsym,"filterType",filtertypes.bessel_inp);
    
    filtered = lp_mpi.process(e);
    
    wl = winlen; % symbols
    smoothed = ( 1/wl .* movsum(e,[wl/2,wl/2])  );
    
    % remove interference
    for level = 0:3
        yk_lvsm.signal(pre_decision_level_uni==level) = yk_lvsm.signal(pre_decision_level_uni==level) - smoothed(pre_decision_level_uni==level);
        yk_lvlp.signal(pre_decision_level_uni==level) = yk_lvlp.signal(pre_decision_level_uni==level) - filtered(pre_decision_level_uni==level);
    end
    
    %% EVM
    [evm_bm(realiz,:),std_bm(realiz,:)]   = calc_evm(Eq_out.signal, pre_decision_level_bi);
    [evm_dcsm(realiz,:),std_dcsm(realiz,:)] = calc_evm(yk_dcsm.signal, pre_decision_level_bi);
    [evm_lsm(realiz,:),std_lsm(realiz,:)]  = calc_evm(yk_lvsm.signal, pre_decision_level_bi);
    [evm_llp(realiz,:),std_llp(realiz,:)]  = calc_evm(yk_lvlp.signal, pre_decision_level_bi);
    
    %% Digi Demod
    d_bm         = digimod.demap(Eq_out);
    d_dcsm       = digimod.demap(yk_dcsm);
    d_lvsm       = digimod.demap(yk_lvsm);
    d_lvlp       = digimod.demap(yk_lvlp);
    
    %% BER
    dbit =  length(d_bm.signal)-length(bitpattern);
    
    [~,errors_bm,ber_bm(realiz)]     = calc_ber(d_bm.signal(1:end-dbit,:)    ,bitpattern(1:end,:),10000);
    [~,errors_dcsm,ber_dcsm(realiz)] = calc_ber(d_dcsm.signal(1:end-dbit,:)  ,bitpattern(1:end,:),10000);
    [~,errors_lvsm,ber_lvsm(realiz)] = calc_ber(d_lvsm.signal(1:end-dbit,:)  ,bitpattern(1:end,:),10000);
    [~,errors_lvlp,ber_lvlp(realiz)] = calc_ber(d_lvlp.signal(1:end-dbit,:)  ,bitpattern(1:end,:),10000);
    
%     disp(['BER benchmark: ', sprintf('%2E',ber_bm),   ' ERRORS: ' ,num2str(sum(errors_bm))]);
%     disp(['BER dc smooth: ', sprintf('%2E',ber_dcsm), ' ERRORS: ' ,num2str(sum(errors_dcsm))]);
%     disp(['BER lv smooth: ', sprintf('%2E',ber_lvsm), ' ERRORS: ' ,num2str(sum(errors_lvsm))]);
%     disp(['BER lv lowpas: ', sprintf('%2E',ber_lvlp), ' ERRORS: ' ,num2str(sum(errors_lvlp))]);



end

output.ber_bm   = mean(ber_bm);
output.ber_dcsm = mean(ber_dcsm);
output.ber_lvsm = mean(ber_lvsm);
output.ber_lvlp = mean(ber_lvlp);

output.evm_bm   = mean(evm_bm);
output.evm_dcsm = mean(evm_dcsm);
output.evm_lsm = mean(evm_lsm);
output.evm_llp = mean(evm_llp);

output.std_bm  = mean(std_bm);
output.std_dcsm = mean(std_dcsm);
output.std_lsm = mean(std_lsm);
output.std_llp = mean(std_llp);


end