Ejemplo n.º 1
0
def get_s_integration(net,
                      p=None,
                      Tmin=None,
                      Tmax=None,
                      k=None,
                      tol=None,
                      to_ser=False):
    """
    """
    if p is not None:
        net.update_optimizable_vars(p)

    if Tmin is None:
        Tmin = TMIN
    if Tmax is None:
        Tmax = TMAX
    if k is None:
        k = K
    if tol is None:
        tol = TOL_SS

    nsp = len(net.dynamicVars)
    tmin, tmax = 0, Tmin
    x0 = net.x0.copy()
    constants = net.constantVarValues

    while tmax <= Tmax:
        # yp0 helps integration stability
        yp0 = Dynamics.find_ics(net.x0, net.x0, tmin,
                                net._dynamic_var_algebraic, [1e-6] * nsp,
                                [1e-6] * nsp, constants, net)[1]
        # using daskr to save computational overhead
        out = daskr.daeint(res=net.res_function,
                           t=[tmin, tmax],
                           y0=x0,
                           yp0=yp0,
                           atol=[1e-6] * nsp,
                           rtol=[1e-6] * nsp,
                           intermediate_output=False,
                           rpar=constants,
                           max_steps=100000.0,
                           max_timepoints=100000.0,
                           jac=net.ddaskr_jac)
        xt = out[0][-1]
        dxdt = net.res_function(tmax, xt, [0] * nsp, constants)
        if np.max(np.abs(dxdt)) < tol:
            net.updateVariablesFromDynamicVars(xt, tmax)
            net.t = tmax
            if to_ser:
                return butil.Series(xt, net.xids)
            else:
                return xt
        else:
            tmin, tmax = tmax, tmax * k
            x0 = xt
    raise Exception("Cannot reach steady state for p=%s" % p)
Ejemplo n.º 2
0
def get_s(net,
          p=None,
          method=None,
          Tmin=None,
          Tmax=None,
          k=None,
          x0=None,
          tol=None,
          to_ser=False,
          **kwargs_rootfinding):
    """
    Input:
        method:
        Tmin, Tmax, k:
        x0: 
        
    """
    if p is not None:
        net.update_optimizable_vars(p)

    if method is None:
        method = METHOD
    if Tmin is None:
        Tmin = TMIN

    if method == 'integration':
        return get_s_integration(net,
                                 Tmin=Tmin,
                                 Tmax=Tmax,
                                 k=k,
                                 tol=tol,
                                 to_ser=to_ser)
    elif method == 'rootfinding':
        return get_s_rootfinding(net,
                                 x0=x0,
                                 tol=tol,
                                 to_ser=to_ser,
                                 **kwargs_rootfinding)
    elif method == 'mixed':
        nsp = len(net.dynamicVars)
        constants = net.constantVarValues
        yp0 = Dynamics.find_ics(net.x0, net.x0, 0, net._dynamic_var_algebraic,
                                [1e-6] * nsp, [1e-6] * nsp, constants, net)[1]
        out = daskr.daeint(res=net.res_function,
                           t=[0, Tmin],
                           y0=net.x0.copy(),
                           yp0=yp0,
                           atol=[1e-6] * nsp,
                           rtol=[1e-6] * nsp,
                           intermediate_output=False,
                           rpar=constants,
                           max_steps=100000.0,
                           max_timepoints=100000.0,
                           jac=net.ddaskr_jac)
        xt = out[0][-1]
        return get_s_rootfinding(net,
                                 x0=xt,
                                 tol=tol,
                                 to_ser=to_ser,
                                 **kwargs_rootfinding)
    else:
        raise ValueError("Unrecognized value for method: %s" % method)