classdef EML
    %EML External Modulated Laser
    %   Detailed explanation goes here
    
    properties
        %class input objms
        mode
        fsimu %in Hz
        lambda %in nm
        power %in dBm
        linewidth %in Hz
        ampl_imbal 
        pha_imbal
        bias 
        u_pi

        %on instance creation
        field
        noisefactor
        phase %eigentlich nur wichtig wenn man mehrere blöcke durchsimuliert...
        real_factor
        imag_factor

        %during simulation
        signal_len

    end
    
    methods
        function obj = EML(options)
            %EML Construct an instance of this class
            %   Detailed explanation goes here
            arguments
                options.mode;
                options.fsimu;
                options.lambda;
                options.power;
                options.linewidth = 0;
                options.ampl_imbal = 0;
                options.pha_imbal = 0;
                options.bias;
                options.u_pi;
            end
            
            obj.mode = options.mode;
            obj.fsimu = options.fsimu;
            obj.lambda = options.lambda;
            obj.power = options.power;
            obj.linewidth = options.linewidth;
            obj.ampl_imbal = options.ampl_imbal;
            obj.pha_imbal = options.pha_imbal;
            obj.bias = options.bias;
            obj.u_pi = options.u_pi;

            obj.field=sqrt(10^(obj.power/10-3)); %dbm to sqrt(mw)
            
            obj.noisefactor=sqrt(2*pi*obj.linewidth/obj.fsimu);
            obj.phase=0;

            if obj.mode==4 || obj.mode==5
                obj.real_factor=(1+obj.ampl_imbal/2)*exp(1i*obj.pha_imbal/2);
                obj.imag_factor=(1-obj.ampl_imbal/2)*exp(1i*(pi/2-obj.pha_imbal/2));
            end

        end
        
        function [opt_out,obj] = process(obj,elec_in)
            %METHOD1 Summary of this method goes here
            %   Detailed explanation goes here

            %needed later
            obj.signal_len = length(elec_in);

            % generate phase noise of laser
            % scale with signal energy in sqrt(mw)
            if obj.linewidth ~= 0
                ph_noi = obj.createPhaseNoise;
                laserfield = obj.field.*exp(1i*ph_noi);
            else
                laserfield = obj.field;
            end
            
            %modulate the laserfield with the electrical signal
            opt_out = obj.externalmodulation(laserfield,elec_in);

            %remember phase (! you need to receive the altered eml object in you sim program !)
            obj.phase = ph_noi(end); 

        end

        function noi = createPhaseNoise(obj)
            %create random vector
            noi = randn(obj.signal_len,1);
            %scale with noisefactor
            noi = noi * obj.noisefactor;
            %cumsum to accumulate noise over time vector
            noi = cumsum(noi);
            %add phase from previous block/ loop of simulation
            noi = noi + obj.phase;
        end

        function modulated_laserfield = externalmodulation(obj,laserfield,electrical_in)

            switch obj.mode

                case   1 % linear IM
                    modulated_laserfield = laserfield.*sqrt(real(electrical_in + obj.bias)/obj.u_pi);

                case 2   % IM with hMZM function
                    modulated_laserfield = laserfield.*cos(pi/2*(real(electrical_in)+obj.bias)/obj.u_pi);

                case 3 % PMsi
                    modulated_laserfield = laserfield.*exp(1i*pi*real(electrical_in)/obj.u_pi);

                case 4 % linear IQ-Modulator
                    if obj.ampl_imbal ==0 && obj.pha_imbal  == 0
                        % No IQ Imbalance
                        modulated_laserfield=laserfield.*electrical_in/obj.u_pi;
                    else
                        % with IQ Imbalance
                        modulated_laserfield = laserfield.*(real(electrical_in)*obj.real_factor/obj.u_pi...
                            +imag(electrical_in)*obj.imag_factor/obj.u_pi);
                    end

                case 5 % IQ-Modulator with cosine function
                    modulated_laserfield = laserfield/sqrt(2).*(cos(pi/2*(real(electrical_in)+obj.bias)/obj.u_pi)*obj.real_factor...
                        +cos(pi/2*(imag(electrical_in)+obj.bias)/obj.u_pi)*obj.imag_factor);

            end

        end

    end
end