DetailedModel.m

classdef DetailedModel < Greedy.User.FVDetailedModelDefault
  % IDetailedModel implementation for a two phase flow system
  %
  % This is a detailed model for a problem of this type
  %
  %

  properties(Constant)
    % This constant is used for a consistency check of the model descr with
    % help of DetailedModelBaseIf.struct_check()
    %
    % This check is only executed if we use a Newton scheme
    newton_checks = struct(...
      'newton_steps',                 {{@isscalar}},...
      'newton_epsilon',               {{@isscalar}}...
    );
  end

  properties (Dependent)
    % current time instance
    t;

    % current time step
    tstep;
  end

  properties
    % boolean flag indicating whether conditions of system matrices shall be computed.
    compute_conditions = false;
  end

  methods
    function dm = DetailedModel(descr)
    % function dm = DetailedModel(descr)
    % constructor
    %
    % This checks and stores the model description structure
    %
    % Required fields of descr:
    %   newton_solver:  boolean flag indicating whether we are using a Newton
    %                   scheme for the discretization.
      dm = dm@Greedy.User.FVDetailedModelDefault(descr);
      if ~IDetailedModel.struct_check(descr, TwoPhaseFlow.DetailedModel.newton_checks)
        error('Consistency check of description for Newton solver problems failed!');
      end
    end

    sim_data   = detailed_simulation(model, model_data);

    sim_data   = detailed_simulation_galerkin(model, detailed_data);

    sim_data   = detailed_simulation_impes(model, model_data);

    model_data = gen_model_data(model);

    p          = plot_sim_data(dmodel, model_data, sim_data, plot_params);

    function plot_error_sequence(dmodel, errs)
      if length(errs.S) == dmodel.descr.nt+1
        times = 0:dmodel.descr.dt:dmodel.descr.T;
      else
        times = 1:length(errs.S);
      end
      plot(times, errs.S, 'k-', times, errs.U, 'b:', times, errs.P, 'r-.');
      legend('S', 'U', 'P');
    end
  end

  methods (Static)

    function U = get_dofs_from_sim_data(sim_data)

      if isfield(sim_data, 'Stemp');
        U.S = [sim_data.S, sim_data.Stemp];
        U.P = [sim_data.P, sim_data.Ptemp];
        U.U = [sim_data.U, sim_data.Utemp];
      else
        U = sim_data;
      end


    end

    function snapshot = get_dofs_at_time(sim_data, time_index)

      snapshot.S = sim_data.S(:,time_index);
      snapshot.U = sim_data.U(:,time_index);
      snapshot.P = sim_data.P(:,time_index);
    end

  end

  methods
    function t = get.t(this)
      t = this.descr.t;
    end

    function set.t(this, t)
      this.descr.t = t;
    end

    function tstep = get.tstep(this)
      tstep = this.descr.tstep;
    end

    function set.tstep(this, tstep)
      this.descr.tstep = tstep;
    end
  end

  methods(Static)
    function errs = l2_error_sequence_algorithm(U, Uapprox, model_data)
      if size(U, 1) == model_data.grid.nelements
        A = model_data.W;
      else
        A = model_data.diamondWinv;
      end
      errs = fv_l2_error(U, Uapprox, A);
    end

    function errs = l2_error_sequence_complete(U, Uapprox, model_data)
      errs.S = fv_l2_error(U.S, Uapprox.S, model_data.W);
      errs.U = fv_l2_error(U.U, Uapprox.U, model_data.diamondWinv);
      errs.P = fv_l2_error(U.P, Uapprox.P, model_data.W);
    end

    function errs = linfty_error_sequence_complete(U, Uapprox, model_data)
      errs.S = fv_linfty_error(U.S, Uapprox.S, model_data.W);
      errs.U = fv_linfty_error(U.U, Uapprox.U, model_data.diamondWinv);
      errs.P = fv_linfty_error(U.P, Uapprox.P, model_data.W);
    end
  end

end