1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use super::*;

impl<P, LS, NLS, TolC> Ida<P, LS, NLS, TolC>
where
    P: IdaProblem,
    LS: linear::LSolver<P::Scalar>,
    NLS: nonlinear::NLSolver<P>,
    TolC: TolControl<P::Scalar>,
{
    /// Return a view of the y vector
    pub fn get_yy(&self) -> ndarray::ArrayView1<P::Scalar> {
        self.nlp.ida_yy.view()
    }

    /// Return a view of the y' vector
    pub fn get_yp(&self) -> ndarray::ArrayView1<P::Scalar> {
        self.nlp.ida_yp.view()
    }

    /// returns the integration method order used during the last internal step.
    pub fn get_last_order(&self) -> usize {
        self.ida_kused
    }

    /// returns the integration method order to be used on the next internal step.
    pub fn get_current_order(&self) -> usize {
        self.ida_kk
    }

    /// returns the value of the integration step size used on the first step.
    pub fn get_actual_init_step(&self) -> P::Scalar {
        self.ida_h0u
    }

    /// returns the integration step size taken on the last internal step (if from `solve()`), or
    /// the last value of the artificial step size h (if from `calc_ic()`).
    pub fn get_last_step(&self) -> P::Scalar {
        self.ida_hused
    }

    /// returns the integration step size to be attempted on the next internal step.
    pub fn get_current_setp(&self) -> P::Scalar {
        self.ida_hh
    }

    /// returns the current internal time reached by the solver.
    pub fn get_current_time(&self) -> P::Scalar {
        self.nlp.ida_tn
    }

    /// returns a suggested factor by which the user’s tolerances should be scaled when too much
    /// accuracy has been requested for some internal step.
    pub fn get_tol_scale_factor(&self) -> P::Scalar {
        self.ida_tolsf
    }

    /// returns the cumulative number of internal steps taken by the solver (total so far).
    pub fn get_num_steps(&self) -> usize {
        self.counters.ida_nst
    }

    /// returns the number of calls to the user’s residual evaluation function.
    /// Note: does not account for calls made to res from a linear solver or preconditioner module
    pub fn get_num_res_evals(&self) -> usize {
        self.nlp.ida_nre
    }

    /// returns the cumulative number of calls made to the linear solver’s setup function (total so
    /// far).
    pub fn get_num_lin_solv_setups(&self) -> usize {
        self.nlp.ida_nsetups
    }

    ///  returns the cumulative number of local error test failures that have occurred (total so far).
    pub fn get_num_err_test_fails(&self) -> usize {
        self.counters.ida_netf
    }

    /// returns the cumulative number of calls to the idals Jacobian approximation function.
    pub fn get_num_jac_evals(&self) -> usize {
        self.nlp.lp.nje
    }

    pub fn get_num_nonlin_solv_iters(&self) -> usize {
        /* get number of iterations for IC calc */
        /* get number of iterations from the NLS */
        self.counters.ida_nni + self.nls.get_num_iters()
    }

    /// returns the number of calls to the DAE residual needed for the DQ Jacobian approximation or
    /// J*v product approximation
    pub fn get_num_lin_res_evals(&self) -> usize {
        self.nlp.lp.nre_dq
    }

    /// returns the cumulative number of linear iterations.
    pub fn get_num_lin_iters(&self) -> usize {
        //self.nlp.lp.nli
        0
    }

    /// returns the cumulative number of linear convergence failures.
    pub fn get_num_nonlin_solv_conv_fails(&self) -> usize {
        self.counters.ida_ncfn
    }

    /// returns the cumulative number of calls to the user root function.
    pub fn get_num_g_evals(&self) -> usize {
        self.ida_nge
    }

    /// returns an array showing which functions were found to have a root.
    /// 
    /// Note that, for the components gi for which a root was found, the sign of rootsfound[i] indicates the direction of zero-crossing. A value of +1 indicates that gi is increasing, while a value of −1 indicates a decreasing gi.
    pub fn get_root_info(&self) -> ndarray::ArrayView1<P::Scalar> {
        self.ida_iroots.view()
    }
}