def run(self, f, jac, y0, t0, t1, f_params, jac_params): if self.first_step: # copy initial state from input ndarray y0 to our nvector y self.y[:] = y0[:] # reinitialize cvode, now that we have func and t0, and actual values for y0 _cvode.CVodeReInit(self.cvode_mem, cvode_rhs_func, t0, self.y, _cvode.CV_SS, self.rtol, self.atol) # tell cvode about our rhs function's user data f_data = ctypes.cast(ctypes.pointer(ctypes.py_object((f, f_params))), ctypes.c_void_p) _cvode.CVodeSetFdata(self.cvode_mem, f_data) tret = _cvode.realtype() flag = _cvode.CVode(self.cvode_mem, t1, self.y, tret, _cvode.CV_NORMAL) if flag < 0: self.success = 0 print("cvodes error: %d (see SUNDIALS manual for more information)" % flag) return (self.y, t1)
def run(self, f, jac, y0, t0, t1, f_params, jac_params): if self.first_step: # copy initial state from input ndarray y0 to our nvector y self.y[:] = y0[:] # reinitialize cvode, now that we have func and t0, and actual values for y0 _cvode.CVodeReInit(self.cvode_mem, cvode_rhs_func, t0, self.y, _cvode.CV_SS, self.rtol, self.atol) # tell cvode about our rhs function's user data f_data = ctypes.cast( ctypes.pointer(ctypes.py_object((f, f_params))), ctypes.c_void_p) _cvode.CVodeSetFdata(self.cvode_mem, f_data) tret = _cvode.realtype() flag = _cvode.CVode(self.cvode_mem, t1, self.y, tret, _cvode.CV_NORMAL) if flag < 0: self.success = 0 print "cvodes error: %d (see SUNDIALS manual for more information)" % flag return (self.y, t1)
def __init__(self, f_ode, t, y, reltol=1e-8, abstol=1e-8, nrtfn=None, g_rtfn=None, f_data=None, g_data=None, chunksize=2000, maxsteps=1e4, mupper=None, mlower=None): # Ensure that t and y can be indexed t = np.array(t, dtype=float, ndmin=1) try: y = np.array(y, dtype=float, ndmin=1) except ValueError: raise ValueError("State vector y not interpretable as float: %s" % y) # Ensure that f_ode assigns a value to all elements of the rate vector assert_assigns_all(f_ode, y, f_data) # Ensure that the function returns 0 on success and <0 on exception. # (CVODE's convention is # 0 = OK, >0 = recoverable error, <0 = unrecoverable error.) # If not, decorate as if with @cvodefun. self.f_ode = f_ode # store this for use in __repr__ etc. success_value = f_ode(t[0], nv(y), nv(y), f_data) # probably 0 or None try: error_value = f_ode(None, None, None, None) # <0 or raise exception except StandardError: error_value = None try: f_ode.traceback = "" except AttributeError: pass if (success_value == 0) and (error_value < 0): self.my_f_ode = f_ode else: self.my_f_ode = cvodefun(f_ode) # Variables y, tret, abstol are written by CVode functions, and their # pointers must remain constant. They are assigned here; later # assignments will copy values into the existing variables, like so: # self.tret.value = ... (cvode.realtype) # self.y[:] = ... (cvode.NVector) self.y = nv(y) # state vector (read/write) self.tret = cvode.realtype(0.0) # actual time of return from solver if type(abstol) is cvode.realtype: self.abstol = abstol # copy of abstol, used for ReInit elif np.isscalar(abstol): self.abstol = cvode.realtype(abstol) else: self.abstol = nv(abstol) self.t = t self.t0 = cvode.realtype(t[0]) # initial time self.tstop = t[-1] # end time self.n = len(y) # number of state variables self.reltol = reltol # copy of reltol, used for ReInit self.itol = cvode.CV_SV if (type(self.abstol) is nv) else cvode.CV_SS self.f_data = f_data # user data for right-hand-side of ODE self.g_data = g_data # user data for rootfinding function self.chunksize = chunksize self.maxsteps = maxsteps self.last_flag = None # CVODE solver object self.cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_NEWTON) cvode.CVodeMalloc(self.cvode_mem, self.my_f_ode, self.t0, self.y, self.itol, self.reltol, self.abstol) # allocate & initialize memory if f_data is not None: cvode.CVodeSetFdata(self.cvode_mem, np.ctypeslib.as_ctypes(self.f_data)) cvode.CVodeSetStopTime(self.cvode_mem, self.tstop) # set stop time # Specify how the Jacobian should be approximated if mupper is None: cvode.CVDense(self.cvode_mem, self.n) else: cvode.CVBand(self.cvode_mem, self.n, mupper, mlower) self.RootInit(nrtfn, g_rtfn, g_data)
def annlodesolve(model, tfinal, envlist, params, useparams=None, tinit = 0.0, ic=True): ''' the ODE equation solver tailored to work with the annealing algorithm model: the model object envlist: the list returned from annlinit params: the list of parameters that are being optimized with annealing useparams: the parameter number to which params[i] corresponds tinit: initial time reltol: relative tolerance abstol: absolute tolerance ic: reinitialize initial conditions to a value in params or useparams ''' (f, rhs_exprs, y, odesize, data, xout, yout, nsteps, cvode_mem, yzero, reltol, abstol) = envlist #set the initial values and params in each run #all parameters are used in annealing. initial conditions are not, here if useparams is None: for i in range(len(params)): data.p[i] = params[i] else: #only a subset of parameters are used for annealing for i in range(len(useparams)): #print("changing parameter", model.parameters[useparams[i]],"data.p", data.p[useparams[i]],"to", params[i]) data.p[useparams[i]] = params[i] # update yzero if initial conditions are being modified as part of the parameters # did it this way b/c yzero and data.p may not always want to be modified at the same time # if ic is True: for cplxptrn, ic_param in model.initial_conditions: speci = model.get_species_index(cplxptrn) yzero[speci] = ic_param.value #reset initial concentrations y = cvode.NVector(yzero) # Reinitialize the memory allocations, DOES NOT REALLOCATE cvode.CVodeReInit(cvode_mem, f, 0.0, y, cvode.CV_SS, reltol, abstol) tadd = tfinal/nsteps t = cvode.realtype(tinit) tout = tinit + tadd for step in range(1, nsteps): ret = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) if ret !=0: print("CVODE ERROR %i"%(ret)) break xout[step]= tout for i in range(0, odesize): yout[step][i] = y[i] # increase the time counter tout += tadd #print("Integration finished") #now deal with observables obs_names = [name for name, rp in model.observable_patterns] yobs = numpy.zeros([len(obs_names), nsteps]) #sum up the correct entities for i, name in enumerate(obs_names): factors, species = zip(*model.observable_groups[name]) yobs[i] = (yout[:, species] * factors).sum(axis = 1) #merge the x and y arrays for easy visualization xyobs = numpy.vstack((xout, yobs)) return (xyobs,xout,yout, yobs)
c = cvode.NVector([0]*NEQ) rewt = cvode.NVector([0]*NEQ) wdata = WebData() for i in range(NGRP): wdata.P[i] = cvode.denalloc(NS,NS) wdata.pivot[i] = cvode.denallocpiv(NS) wdata.rewt = rewt.data InitUserData(wdata) ns = wdata.ns mxns = wdata.mxns PrintIntro() for jpre in range(cvode.PREC_LEFT, cvode.PREC_RIGHT+1): for gstype in range(cvode.MODIFIED_GS,cvode.CLASSICAL_GS+1): t = cvode.realtype(T0) CInit(c, wdata) PrintHeader(jpre, gstype) firstrun = (jpre == cvode.PREC_LEFT and gstype == cvode.MODIFIED_GS) if firstrun: cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_NEWTON) wdata.cvode_mem = cvode_mem.obj cvode.CVodeSetFdata(cvode_mem, ctypes.pointer(wdata)) cvode.CVodeMalloc(cvode_mem, f, t.value, c, cvode.CV_SS, RTOL, ATOL) cvode.CVSpgmr(cvode_mem, jpre, MAXL) cvode.CVSpilsSetGSType(cvode_mem, gstype) cvode.CVSpilsSetDelt(cvode_mem, DELT) cvode.CVSpilsSetPreconditioner(cvode_mem, Precond, PSolve, ctypes.pointer(wdata)) PrintAllSpecies(c, ns, mxns, t)
def odesolve(model, tfinal, envlist, params, useparams=None, tinit=0.0, ic=True): ''' the ODE equation solver tailored to work with the annealing algorithm model: the model object envlist: the list returned from annlinit params: the list of parameters that are being optimized with annealing useparams: the parameter number to which params[i] corresponds tinit: initial time reltol: relative tolerance abstol: absolute tolerance ic: reinitialize initial conditions to a value in params or useparams ''' (f, rhs_exprs, y, odesize, data, xout, yout, nsteps, cvode_mem, yzero, reltol, abstol) = envlist #set the initial values and params in each run #all parameters are used in annealing. initial conditions are not, here if useparams is None: for i in range(len(params)): data.p[i] = params[i] else: #only a subset of parameters are used for annealing for i in range(len(useparams)): #print "changing parameter", model.parameters[useparams[i]],"data.p", data.p[useparams[i]],"to", params[i] data.p[useparams[i]] = params[i] # FIXME: # update yzero if initial conditions are being modified as part of the parameters # did it this way b/c yzero and data.p may not always be modified at the same time # the params list should NOT contain the initial conditions if they are not # to be used in the annealing... so this is a hack based on the fact that the # initial conditions are contained as part of the model.parameters list. # if ic is True: for cplxptrn, ic_param in model.initial_conditions: speci = model.get_species_index(cplxptrn) yzero[speci] = ic_param.value #reset initial concentrations y = cvode.NVector(yzero) # Reinitialize the memory allocations, DOES NOT REALLOCATE cvode.CVodeReInit(cvode_mem, f, 0.0, y, cvode.CV_SS, reltol, abstol) tadd = tfinal / nsteps t = cvode.realtype(tinit) tout = tinit + tadd #print "Beginning integration" #print "TINIT:", tinit, "TFINAL:", tfinal, "TADD:", tadd, "ODESIZE:", odesize #print "Integrating Parameters:\n", params #print "y0:", yzero for step in range(1, nsteps): ret = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) if ret != 0: print "CVODE ERROR %i" % (ret) break xout[step] = tout for i in range(0, odesize): yout[step][i] = y[i] # increase the time counter tout += tadd #print "Integration finished" #now deal with observables #obs_names = [name for name, rp in model.observable_patterns] yobs = numpy.zeros([len(model.observables), nsteps]) #sum up the correct entities for i, obs in enumerate(model.observables): coeffs = obs.coefficients specs = obs.species yobs[i] = (yout[:, specs] * coeffs).sum(1) #merge the x and y arrays for easy analysis xyobs = numpy.vstack((xout, yobs)) return (xyobs, xout, yout, yobs)
def Problem2(): nerr = 0 reltol = cvode.realtype(0) abstol = cvode.realtype(1.0e-6) t = cvode.realtype(0) print "\n\n-------------------------------------------------------------" print "-------------------------------------------------------------" print "\nProblem 2: ydot = A * y, where A is a banded lower" print "triangular matrix derived from 2-D advection PDE\n" print " neq = %i, ml = %i, mu = %i"%(P2_NEQ, P2_ML, P2_MU) print " itol = %s, reltol = %.2g, abstol = %.2g"%("CV_SS", 0, 1.0e-6) print " t max.err qu hu " cvode_mem = cvode.CVodeCreate(cvode.CV_ADAMS, cvode.CV_FUNCTIONAL) for miter in ["FUNC", "DIAG", "BAND_USER", "BAND_DQ"]: ero = 0 y = cvode.NVector([0]*P2_NEQ) y[0] = 1.0 if miter == "FUNC": cvode.CVodeMalloc(cvode_mem, f2, P2_T0, y, cvode.CV_SS, reltol, abstol) else: cvode.CVodeSetIterType(cvode_mem, cvode.CV_NEWTON) cvode.CVodeReInit(cvode_mem, f2, P2_T0, y, cvode.CV_SS, reltol, abstol) PrepareNextRun(cvode_mem, cvode.CV_ADAMS, miter, P2_MU, P2_ML) print "\n t max.err qu hu " iout = 1 tout = P2_T1 while iout <= 5: flag = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) erm = MaxError(y, t) qu = cvode.CVodeGetLastOrder(cvode_mem) hu = cvode.CVodeGetLastStep(cvode_mem) print "%10.3F %12.4e %2i %12.4e"%(t.value, erm, qu, hu) if flag != cvode.CV_SUCCESS: nerr += 1 break er = erm / abstol.value if er > ero: ero = er if er > P2_TOL_FACTOR: nerr += 1 PrintErrOutput(P2_TOL_FACTOR) iout += 1 tout *= P2_TOUT_MULT PrintFinalStats(cvode_mem, miter, ero) cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_FUNCTIONAL) for miter in ["FUNC", "DIAG", "BAND_USER", "BAND_DQ"]: ero = 0 y[0] = 1.0 if miter == "FUNC": cvode.CVodeMalloc(cvode_mem, f2, P2_T0, y, cvode.CV_SS, reltol, abstol) else: cvode.CVodeSetIterType(cvode_mem, cvode.CV_NEWTON) cvode.CVodeReInit(cvode_mem, f2, P2_T0, y, cvode.CV_SS, reltol, abstol) PrepareNextRun(cvode_mem, cvode.CV_BDF, miter, P2_MU, P2_ML) print "\n t max.err qu hu " iout = 1 tout = P2_T1 while iout <= 5: flag = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) erm = MaxError(y, t) qu = cvode.CVodeGetLastOrder(cvode_mem) hu = cvode.CVodeGetLastStep(cvode_mem) print "%10.3F %12.4e %2i %12.4e"%(t.value, erm, qu, hu) if flag != cvode.CV_SUCCESS: nerr += 1 break er = erm / abstol.value if er > ero: ero = er if er > P2_TOL_FACTOR: nerr += 1 PrintErrOutput(P2_TOL_FACTOR) iout += 1 tout *= P2_TOUT_MULT PrintFinalStats(cvode_mem, miter, ero) return nerr
def Problem1(): nerr = 0 reltol = cvode.realtype(0) abstol = cvode.realtype(1.0e-6) t = cvode.realtype(0) y = cvode.NVector([0, 0]) print "Demonstration program for CVODE package - direct linear solvers\n\n" print "Problem 1: Van der Pol oscillator" print " xdotdot - 3*(1 - x^2)*xdot + x = 0, x(0) = 2, xdot(0) = 0" print " neq = %i, itol = %s, reltol = %.2g, abstol = %.2g"%(2, "CV_SS", 0, 1.0e-6), cvode_mem = cvode.CVodeCreate(cvode.CV_ADAMS, cvode.CV_FUNCTIONAL) for miter in ["FUNC", "DENSE_USER", "DENSE_DQ", "DIAG"]: ero = 0 y[0] = 2.0 y[1] = 0 if miter == "FUNC": cvode.CVodeMalloc(cvode_mem, f1, 0, y, cvode.CV_SS, reltol, abstol) else: cvode.CVodeSetIterType(cvode_mem, cvode.CV_NEWTON) cvode.CVodeReInit(cvode_mem, f1, 0, y, cvode.CV_SS, reltol, abstol) PrepareNextRun(cvode_mem, cvode.CV_ADAMS, miter, 0, 0) print "\n t x xdot qu hu " iout = 1 tout = P1_T1 while iout <= 4: flag = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) qu = cvode.CVodeGetLastOrder(cvode_mem) hu = cvode.CVodeGetLastStep(cvode_mem) print "%10.6g %14.5e %14.5e %2i %6.4e"%(t.value, y[0], y[1], qu, hu) if flag != cvode.CV_SUCCESS: nerr += 1 break if iout%2 == 0: er = abs(y[0])/abstol.value if er > ero: ero = er if er > P1_TOL_FACTOR: nerr += 1 PrintErrOutput(P1_TOL_FACTOR) iout += 1 tout += P1_DTOUT PrintFinalStats(cvode_mem, miter, ero) cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_FUNCTIONAL) for miter in ["FUNC", "DENSE_USER", "DENSE_DQ", "DIAG"]: ero = 0 y[0] = 2.0 y[1] = 0 if miter == "FUNC": cvode.CVodeMalloc(cvode_mem, f1, 0, y, cvode.CV_SS, reltol, abstol) else: cvode.CVodeSetIterType(cvode_mem, cvode.CV_NEWTON) cvode.CVodeReInit(cvode_mem, f1, 0, y, cvode.CV_SS, reltol, abstol) PrepareNextRun(cvode_mem, cvode.CV_BDF, miter, 0, 0) print "\n t x xdot qu hu " iout = 1 tout = P1_T1 while iout <= 4: flag = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) qu = cvode.CVodeGetLastOrder(cvode_mem) hu = cvode.CVodeGetLastStep(cvode_mem) print "%10.6g %14.5e %14.5e %2i %6.4e"%(t.value, y[0], y[1], qu, hu) if flag != cvode.CV_SUCCESS: nerr += 1 break if iout%2 == 0: er = abs(y[0])/abstol.value if er > ero: ero = er if er > P1_TOL_FACTOR: nerr += 1 PrintErrOutput(P1_TOL_FACTOR) iout += 1 tout += P1_DTOUT PrintFinalStats(cvode_mem, miter, ero) return nerr
def annlodesolve(model, tfinal, envlist, params, tinit = 0.0, ic=True): ''' the ODE equation solver tailored to work with the annealing algorithm model: the model object envlist: the list returned from annlinit params: the list of parameters that are being optimized with annealing tinit: initial time reltol: relative tolerance abstol: absolute tolerance ic: reinitialize initial conditions to a value in params ''' (f, rhs_exprs, y, odesize, data, xout, yout, nsteps, cvode_mem, yzero, reltol, abstol) = envlist #set the initial values and params in each run #all parameters are used in annealing. for i in range(len(params)): data.p[i] = params[i] # update yzero if initial conditions are being modified as part of the parameters # did it this way b/c yzero and data.p may not always want to be modified at the same time # FIXME: this is not the best way to do this. # the params list should NOT contain the initial conditions if they are not # to be used in the annealing... so this is a hack based on the fact that the # initial conditions are contained as part of the model.parameters list. # FIXME # if ic is True: for cplxptrn, ic_param in model.initial_conditions: speci = model.get_species_index(cplxptrn) yzero[speci] = ic_param.value #reset initial concentrations y = cvode.NVector(yzero) # Reinitialize the memory allocations, DOES NOT REALLOCATE cvode.CVodeReInit(cvode_mem, f, 0.0, y, cvode.CV_SS, reltol, abstol) tadd = tfinal/nsteps t = cvode.realtype(tinit) tout = tinit + tadd #print "Beginning integration" #print "TINIT:", tinit, "TFINAL:", tfinal, "TADD:", tadd, "ODESIZE:", odesize #print "Integrating Parameters:\n", params #print "y0:", yzero for step in range(1, nsteps): ret = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL) if ret !=0: print "CVODE ERROR %i"%(ret) break xout[step]= tout for i in range(0, odesize): yout[step][i] = y[i] # increase the time counter tout += tadd #print "Integration finished" #now deal with observables yobs = numpy.zeros([len(model.observables), nsteps]) #sum up the correct entities for i, obs in enumerate(model.observables): coeffs = obs.coefficients specs = obs.species yobs[i] = (yout[:, specs] * coeffs).sum(1) #merge the x and y arrays for easy analysis xyobs = numpy.vstack((xout, yobs)) return (xyobs,xout,yout, yobs)
def PSolve(tn, u, fu, r, z, gamma, delta, lr, P_data, vtemp): data = ctypes.cast(P_data, PUserData).contents z[:] = r for jx in range(MX): for jy in range(MY): cvode.denGETRS(data.P[jx][jy], NUM_SPECIES, data.pivot[jx][jy], z.ptrto(jx*NUM_SPECIES + jy*NSMX)) return 0 u = cvode.NVector([0.0]*(NEQ)) #Allocate and initialise user data t = cvode.realtype(0) data = UserData() for jx in range(MX): for jy in range(MY): data.P[jx][jy] = cvode.denalloc(NUM_SPECIES, NUM_SPECIES) data.Jbd[jx][jy] = cvode.denalloc(NUM_SPECIES, NUM_SPECIES) data.pivot[jx][jy] = cvode.denallocpiv(NUM_SPECIES) data.om = PI/HALFDAY data.dx = (XMAX-XMIN)/(MX-1) data.dy = (YMAX-YMIN)/(MY-1) data.hdco = KH/(data.dx**2) data.haco = VEL/(2.0*data.dx) data.vdco = (1.0/(data.dy**2))*KV0 pdata = ctypes.pointer(data)
data.vdcoef = 1.0/(data.dy**2) cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_NEWTON); cvode.CVodeMalloc(cvode_mem, f, 0.0, u, cvode.CV_SS, reltol, abstol) cvode.CVodeSetFdata(cvode_mem, ctypes.pointer(data)); cvode.CVBand(cvode_mem, 50, 5, 5); cvode.CVBandSetJacFn(cvode_mem, Jac, ctypes.pointer(data)); umax = max(abs(u)) print "\n2-D Advection-Diffusion Equation" print "Mesh dimensions = %d X %d"%(10,5) print "Total system size = %d"%(50) print "Tolerance parameters: reltol = %lg abstol = %lg\n"%(reltol, abstol) print "At t = %lg max.norm(u) =%14.6le"%(0.0, umax) t = cvode.realtype(0) iout = 1 tout = 0.1 while iout <= 10: cvode.CVode(cvode_mem, tout, u, ctypes.byref(t), cvode.CV_NORMAL) umax = max(abs(u)) nst = cvode.CVodeGetNumSteps(cvode_mem) print "At t = %4.2f max.norm(u) =%14.6le nst = %4ld"%(t.value, umax, nst) iout +=1 tout += 0.1 nst = cvode.CVodeGetNumSteps(cvode_mem) nfe = cvode.CVodeGetNumRhsEvals(cvode_mem) nsetups = cvode.CVodeGetNumLinSolvSetups(cvode_mem) netf = cvode.CVodeGetNumErrTestFails(cvode_mem) nni = cvode.CVodeGetNumNonlinSolvIters(cvode_mem)
gout[1] = y[2] - 0.01 return 0 def Jac(N, J, t, y, fy, jac_data, tmp1, tmp2, tmp3): J[0][0] = -0.04 J[0][1] = 1.0e4*y[2] J[0][2] = 1.0e4*y[1] J[1][0] = 0.04 J[1][1] = -1.0e4*y[2]-6.0e7*y[1] J[1][2] = -1.0e4*y[1] J[2][1] = 6.0e7*y[1] return 0 y = cvode.NVector([1.0, 0.0, 0.0]) abstol = cvode.NVector([1.0e-8, 1.0e-14, 1.0e-6]) reltol = cvode.realtype(1.0e-4) cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_NEWTON) cvode.CVodeMalloc(cvode_mem, f, 0.0, y, cvode.CV_SV, reltol, abstol) cvode.CVodeRootInit(cvode_mem, 2, g, None) cvode.CVDense(cvode_mem, 3) cvode.CVDenseSetJacFn(cvode_mem, Jac, None) print " \n3-species kinetics problem\n" iout = 0 tout = 0.4 t = cvode.realtype(0.0) while True: flag = cvode.CVode(cvode_mem, tout, y, ctypes.byref(t), cvode.CV_NORMAL)
else: iright = 1 c1lt = u[1-1 + (jx+ileft)*NUM_SPECIES + (jy)*NSMX] c2lt = u[2-1 + (jx+ileft)*NUM_SPECIES + (jy)*NSMX] c1rt = u[1-1 + (jx+iright)*NUM_SPECIES + (jy)*NSMX] c2rt = u[2-1 + (jx+iright)*NUM_SPECIES + (jy)*NSMX] hord1 = hordco*(c1rt - 1.0*c1 + c1lt) hord2 = hordco*(c2rt - 1.0*c2 + c2lt) horad1 = horaco*(c1rt - c1lt) horad2 = horaco*(c2rt - c2lt) udot[ 1-1 + ( jx)*NUM_SPECIES + ( jy)*NSMX] = vertd1 + hord1 + horad1 + rkin1 udot[ 2-1 + ( jx)*NUM_SPECIES + ( jy)*NSMX] = vertd2 + hord2 + horad2 + rkin2 return 0 t = cvode.realtype(0) u = cvode.NVector([0]*NEQ) data = UserData() InitUserData(data) SetInitialProfiles(u, data.dx, data.dy) abstol = cvode.realtype(ATOL) reltol = RTOL cvode_mem = cvode.CVodeCreate(cvode.CV_BDF, cvode.CV_NEWTON) cvode.CVodeSetFdata(cvode_mem, ctypes.pointer(data)) cvode.CVodeMalloc(cvode_mem, f, T0, u, cvode.CV_SS, reltol, abstol) ml = mu = 2 bpdata = cvode.CVBandPrecAlloc(cvode_mem, NEQ, mu, ml) cvode.CVBPSpgmr(cvode_mem, cvode.PREC_LEFT, 0, bpdata) PrintIntro(mu, ml)