function [inputs] = initializeInputs(opts_param)
    %% Default values for opts
    opts = struct('setpoint', false, ...
                  'Dw',       false, ...
                  'ty',       false, ...
                  'ry',       false, ...
                  'Rz',       false, ...
                  'u_hexa',   false, ...
                  'mass',     false, ...
                  'n_hexa',   false  ...
    );

    %% Populate opts with input parameters
    if exist('opts_param','var')
        for opt = fieldnames(opts_param)'
            opts.(opt{1}) = opts_param.(opt{1});
        end
    end

    %% Load Sampling Time and Simulation Time
    load('./mat/sim_conf.mat', 'sim_conf');

    %% Define the time vector
    time_vector = 0:sim_conf.Ts:sim_conf.Tsim;

    %% Create the input Structure that will contain all the inputs
    inputs = struct();

    %% Ground motion
    if islogical(opts.Dw) && opts.Dw == true
        load('./mat/weight_Wxg.mat', 'Wxg');
        Dw = 1/sqrt(2)*100*random('norm', 0, 1, length(time_vector), 3);
        Dw(:, 1) = lsim(Wxg, Dw(:, 1), time_vector);
        Dw(:, 2) = lsim(Wxg, Dw(:, 2), time_vector);
        Dw(:, 3) = lsim(Wxg, Dw(:, 3), time_vector);
    elseif islogical(opts.Dw) && opts.Dw == false
        Dw = zeros(length(time_vector), 3);
    else
        Dw = opts.Dw;
    end

    inputs.Dw = timeseries(Dw, time_vector);

    %% Translation stage [m]
    if islogical(opts.ty) && opts.ty == true
        ty = zeros(length(time_vector), 1);
    elseif islogical(opts.ty) && opts.ty == false
        ty = zeros(length(time_vector), 1);
    else
        ty = opts.ty;
    end

    inputs.ty = timeseries(ty, time_vector);

    %% Tilt Stage [rad]
    if islogical(opts.ry) && opts.ry == true
        ry = 3*(2*pi/360)*sin(2*pi*0.2*time_vector);
    elseif islogical(opts.ry) && opts.ry == false
        ry = zeros(length(time_vector), 1);
    else
        ry = opts.ry;
    end

    inputs.ry = timeseries(ry, time_vector);

    %% Spindle [rad]
    if islogical(opts.Rz) && opts.Rz == true
        Rz = 2*pi*0.5*time_vector;
    elseif islogical(opts.Rz) && opts.Rz == false
        Rz = zeros(length(time_vector), 1);
    elseif isnumeric(opts.Rz) && length(opts.Rz) == 1
        Rz = 2*pi*(opts.Rz/60)*time_vector;
    else
        Rz = opts.Rz;
    end

    inputs.Rz = timeseries(Rz, time_vector);

    %% Micro Hexapod
    if islogical(opts.u_hexa) && opts.setpoint == true
        u_hexa = zeros(length(time_vector), 6);
    elseif islogical(opts.u_hexa) && opts.setpoint == false
        u_hexa = zeros(length(time_vector), 6);
    else
        u_hexa = opts.u_hexa;
    end

    inputs.micro_hexapod = timeseries(u_hexa, time_vector);

    %% Center of gravity compensation
    if islogical(opts.mass) && opts.setpoint == true
        Rm = zeros(length(time_vector), 2);
    elseif islogical(opts.mass) && opts.setpoint == false
        Rm = zeros(length(time_vector), 2);
        Rm(:, 2) = pi*ones(length(time_vector), 1);
    else
        Rm = opts.mass;
    end

    inputs.Rm = timeseries(Rm, time_vector);

    %% Nano Hexapod
    if islogical(opts.n_hexa) && opts.setpoint == true
        n_hexa = zeros(length(time_vector), 6);
    elseif islogical(opts.n_hexa) && opts.setpoint == false
        n_hexa = zeros(length(time_vector), 6);
    else
        n_hexa = opts.n_hexa;
    end

    inputs.nano_hexapod = timeseries(n_hexa, time_vector);

    %% Set point [m, rad]
    if islogical(opts.setpoint) && opts.setpoint == true
        setpoint = zeros(length(time_vector), 6);
    elseif islogical(opts.setpoint) && opts.setpoint == false
        setpoint = zeros(length(time_vector), 6);
    else
        setpoint = opts.setpoint;
    end

    inputs.setpoint = timeseries(setpoint, time_vector);

    %% Save
    save('./mat/inputs.mat', 'inputs');
end