Ejemplo n.º 1
0
def Problem2():
	nerr = 0
	reltol = cvodes.realtype(0)
	abstol = cvodes.realtype(1.0e-6)
	t = cvodes.realtype(0)

	print "\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 \n"
	
	cvode_mem = cvodes.CVodeCreate(cvodes.CV_ADAMS, cvodes.CV_FUNCTIONAL)
	
	for miter in ["FUNC", "DIAG", "BAND_USER", "BAND_DQ"]:
		ero = 0
		y = cvodes.NVector([0]*P2_NEQ)
		y[0] = 1.0
		
		if miter == "FUNC":
			cvodes.CVodeMalloc(cvode_mem, f2, P2_T0, y, cvodes.CV_SS, reltol, abstol)
		else:
			cvodes.CVodeSetIterType(cvode_mem, cvodes.CV_NEWTON)
			cvodes.CVodeReInit(cvode_mem, f2, P2_T0, y, cvodes.CV_SS, reltol, abstol)
		
		PrepareNextRun(cvode_mem, cvodes.CV_ADAMS, miter, P2_MU, P2_ML)
		
		print "\n      t        max.err      qu     hu "
		
		iout = 1
		tout = P2_T1
		while iout <= 5:
			flag = cvodes.CVode(cvode_mem, tout, y, ctypes.byref(t), cvodes.CV_NORMAL)
			erm = MaxError(y, t)
			qu = cvodes.CVodeGetLastOrder(cvode_mem)
			hu = cvodes.CVodeGetLastStep(cvode_mem)
			print "%10.3F  %12.4e   %2i   %12.4e"%(t.value, erm, qu, hu)
			if flag != cvodes.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 = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_FUNCTIONAL)
	
	for miter in ["FUNC", "DIAG", "BAND_USER", "BAND_DQ"]:
		ero = 0
		y[0] = 1.0
		
		if miter == "FUNC":
			cvodes.CVodeMalloc(cvode_mem, f2, P2_T0, y, cvodes.CV_SS, reltol, abstol)
		else:
			cvodes.CVodeSetIterType(cvode_mem, cvodes.CV_NEWTON)
			cvodes.CVodeReInit(cvode_mem, f2, P2_T0, y, cvodes.CV_SS, reltol, abstol)
		
		PrepareNextRun(cvode_mem, cvodes.CV_BDF, miter, P2_MU, P2_ML)
		
		print "\n      t        max.err      qu     hu "
		
		iout = 1
		tout = P2_T1
		while iout <= 5:
			flag = cvodes.CVode(cvode_mem, tout, y, ctypes.byref(t), cvodes.CV_NORMAL)
			erm = MaxError(y, t)
			qu = cvodes.CVodeGetLastOrder(cvode_mem)
			hu = cvodes.CVodeGetLastStep(cvode_mem)
			print "%10.3F  %12.4e   %2i   %12.4e"%(t.value, erm, qu, hu)
			if flag != cvodes.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
Ejemplo n.º 2
0
	print "\nFinal Statistics\n"
	print "nst     = %5ld\n"%(nst)
	print "nfe     = %5ld"%(nfe)
	print "netf    = %5ld    nsetups  = %5ld"%(netf, nsetups)
	print "nni     = %5ld    ncfn     = %5ld\n"%(nni, ncfn)

	if sensi:
		print "nfSe    = %5ld    nfeS     = %5ld"%(nfSe, nfeS)
		print "netfs   = %5ld    nsetupsS = %5ld"%(netfS, nsetupsS)
		print "nniS    = %5ld    ncfnS    = %5ld"%(nniS, ncfnS)

sensi = False
sensi_meth = -1
err_con = False
t = cvodes.realtype(0)

if len(sys.argv) < 2:
	WrongArgs(sys.argv[0])

if sys.argv[1] == "-nosensi":
	sensi = False
elif sys.argv[1] == "-sensi":
	sensi = True
else:
	WrongArgs(sys.argv[0])

if (sensi):
	if len(sys.argv) != 4:
		WrongArgs(sys.argv[0])
Ejemplo n.º 3
0
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):
			cvodes.denGETRS(data.P[jx][jy], NUM_SPECIES, data.pivot[jx][jy], z.ptrto(jx*NUM_SPECIES + jy*NSMX))

	return 0

u = cvodes.NVector([0.0]*(NEQ))

#Allocate and initialise user data
t = cvodes.realtype(0)
data = UserData()
for jx in range(MX):
	for jy in range(MY):
		data.P[jx][jy] = cvodes.denalloc(NUM_SPECIES, NUM_SPECIES)
		data.Jbd[jx][jy] = cvodes.denalloc(NUM_SPECIES, NUM_SPECIES)
		data.pivot[jx][jy] = cvodes.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)
Ejemplo n.º 4
0
def Problem1():
	nerr = 0
	reltol = cvodes.realtype(0)
	abstol = cvodes.realtype(1.0e-6)
	t = cvodes.realtype(0)

	y = cvodes.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 = cvodes.CVodeCreate(cvodes.CV_ADAMS, cvodes.CV_FUNCTIONAL)
	
	for miter in ["FUNC", "DENSE_USER", "DENSE_DQ", "DIAG"]:
		ero = 0
		y[0] = 2.0
		y[1] = 0
	
		if miter == "FUNC": 
			cvodes.CVodeMalloc(cvode_mem, f1, 0, y, cvodes.CV_SS, reltol, abstol)
		else:
			cvodes.CVodeSetIterType(cvode_mem, cvodes.CV_NEWTON)
			cvodes.CVodeReInit(cvode_mem, f1, 0, y, cvodes.CV_SS, reltol, abstol)
		
		PrepareNextRun(cvode_mem, cvodes.CV_ADAMS, miter, 0, 0)
	
		print "\n     t           x              xdot         qu     hu "
	
		iout = 1
		tout = P1_T1
		while iout <= 4:
			flag = cvodes.CVode(cvode_mem, tout, y, ctypes.byref(t), cvodes.CV_NORMAL)
			qu = cvodes.CVodeGetLastOrder(cvode_mem)
			hu = cvodes.CVodeGetLastStep(cvode_mem)
			print "%10.6g    %12.5e   %12.5e   %2i    %6.4e"%(t.value, y[0], y[1], qu, hu)
			if flag != cvodes.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 = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_FUNCTIONAL)
	
	for miter in ["FUNC", "DENSE_USER", "DENSE_DQ", "DIAG"]:
		ero = 0
		y[0] = 2.0
		y[1] = 0
	
		if miter == "FUNC": 
			cvodes.CVodeMalloc(cvode_mem, f1, 0, y, cvodes.CV_SS, reltol, abstol)
		else:
			cvodes.CVodeSetIterType(cvode_mem, cvodes.CV_NEWTON)
			cvodes.CVodeReInit(cvode_mem, f1, 0, y, cvodes.CV_SS, reltol, abstol)
			
		PrepareNextRun(cvode_mem, cvodes.CV_BDF, miter, 0, 0)
		
		print "\n     t           x              xdot         qu     hu "
			
		iout = 1
		tout = P1_T1
		while iout <= 4:
			flag = cvodes.CVode(cvode_mem, tout, y, ctypes.byref(t), cvodes.CV_NORMAL)
			qu = cvodes.CVodeGetLastOrder(cvode_mem)
			hu = cvodes.CVodeGetLastStep(cvode_mem)
			print "%10.6g    %12.5e   %12.5e   %2i    %6.4e"%(t.value, y[0], y[1], qu, hu)
			if flag != cvodes.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
Ejemplo n.º 5
0
	
	GSIter(-gamma, z, vtemp, wdata)
	
	iv = 0
	for jy in range(wdata.my):
		igy = wdata.jigy[jy]
		for jx in range(wdata.mx):
			igx = wdata.jigx[jx]
			ig = igx + igy*wdata.ngx
			cvodes.denGETRS(wdata.P[ig], wdata.mp, wdata.pivot[ig], z.ptrto(iv))
			iv += wdata.mp
	
	return 0

tnext = 1e-08
t = cvodes.realtype(T0)
ncheck = ctypes.c_int(0)
rewt = cvodes.NVector([0]*NEQ)
wdata = WebData()
for i in range(NGRP):
	wdata.P[i] = cvodes.denalloc(NS,NS)
	wdata.pivot[i] = cvodes.denallocpiv(NS)
wdata.rewt = rewt.data
InitUserData(wdata)

c = cvodes.NVector([0]*(NEQ))
CInit(c, wdata)

print "\nCreate and allocate CVODES memory for forward run"
cvode_mem = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_NEWTON)
wdata.cvode_memF = cvode_mem.obj
Ejemplo n.º 6
0
	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 = cvodes.NVector([1.0, 0.0, 0.0])
abstol = cvodes.NVector([1.0e-8, 1.0e-14, 1.0e-6])
reltol = cvodes.realtype(1.0e-4)

cvode_mem = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_NEWTON)
cvodes.CVodeMalloc(cvode_mem, f, 0.0, y, cvodes.CV_SV, reltol, abstol)
cvodes.CVodeRootInit(cvode_mem, 2, g, None)
cvodes.CVDense(cvode_mem, 3)
cvodes.CVDenseSetJacFn(cvode_mem, Jac, None)

print " \n3-species kinetics problem\n"

iout = 0
tout = 0.4
t = cvodes.realtype(0.0)

while True:
	flag = cvodes.CVode(cvode_mem, tout, y, ctypes.byref(t), cvodes.CV_NORMAL)
Ejemplo n.º 7
0
    def run(self):
        """Do the actual simulation.
        
        The input is set using setters/constructor.
        The solution can be retrieved using self.get_solution()
        """
        return_last = self.get_return_last()
        sensi = self.get_sensitivity_analysis()
        time_step = self.get_time_step()
        start_time = self.get_start_time()
        end_time = self.get_final_time()
        verbose = self.get_verbosity()
        model = self.get_model()

        if verbose >= self.WHISPER:
            print "Running simulation with interval (%s, %s)." \
                    % (start_time, end_time)
        if verbose >= self.NORMAL:
            print "Input before integration:", model.u
            print "States:", model.x
            print start_time, "to", end_time

        class UserData:
            """ctypes structure used to move data in (and out of?) the callback
               functions.
            """
            def __init__(self):
                self.parameters = None
                self.model = None
                self.ignore_p = None
                self.t_sim_start = None
                self.t_sim_end = None
                self.t_sim_duration = None

            __slots__ = [
                'parameters',  # parameters
                'model',  # The evaluation model
                # (RHS if you will).
                'ignore_p',  # Whether p should be ignored or
                # not used to reduce unnecessary
                # copying.
                't_sim_start',  # Start time for simulation.
                't_sim_end',  # End time for simulation.
                't_sim_duration',  # Time duration for simulation.
            ]

        # initial y (copying just in case)
        y = cvodes.NVector(model.x.copy())

        # converting tolerances to C types
        abstol = cvodes.realtype(self.abstol)
        reltol = cvodes.realtype(self.reltol)

        t0 = cvodes.realtype(start_time)

        cvode_mem = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_NEWTON)
        cvodes.CVodeMalloc(cvode_mem, self._sundials_f, t0, y, cvodes.CV_SS,
                           reltol, abstol)

        cvodes.CVDense(cvode_mem, len(model.x))

        # Set f_data
        data = UserData()
        data.model = model
        data.t_sim_start = start_time
        data.t_sim_end = end_time
        data.t_sim_duration = data.t_sim_end - data.t_sim_start
        if sensi:
            # Sensitivity indices used by sundials_f(...)
            data.parameters = self.get_sensitivity_indices()
            data.ignore_p = 0
        else:
            data.ignore_p = 1
            parameters = None  # Needed for correct return

        self._data = data

        if sensi:
            NP = len(model.pi)  # number of model parameters
            NU = len(model.u)  # number of control signals/inputs
            NI = len(model.x)  # number of initial states from
            # which sensitivity is calculated
            NS = NP + NI + NU  # number of sensitivities to be calculated
            NEQ = len(model.x)
            assert NEQ == NI, "yS must be modified below to handle the" \
                              " inequality NEQ != NI"
            err_con = False  # Use sensisitity for error control
            yS = nvecserial.NVectorArray([[0] * NEQ] * NP +
                                         N.eye(NI).tolist() + [[0] * NEQ] * NU)

            cvodes.CVodeSensMalloc(cvode_mem, NS, cvodes.CV_STAGGERED1, yS)
            cvodes.CVodeSetSensErrCon(cvode_mem, err_con)
            cvodes.CVodeSetSensDQMethod(cvode_mem, cvodes.CV_CENTERED, 0)

            model_parameters = model.pi
            cvodes.CVodeSetSensParams(cvode_mem, data.parameters.params, None,
                                      None)

        tout = start_time + time_step
        if tout > end_time:
            tout = end_time

        # initial time
        t = cvodes.realtype(t0.value)

        # used for collecting the y's for plotting
        if return_last == False:
            num_samples = int(math.ceil(
                (end_time - start_time) / time_step)) + 1
            T = N.zeros(num_samples, dtype=pyjmi.c_jmi_real_t)
            ylist = N.zeros((num_samples, len(model.x)),
                            dtype=pyjmi.c_jmi_real_t)
            ylist[0] = model.x.copy()
            T[0] = t0.value
            i = 1

        while True:
            # run ODE solver
            flag = cvodes.CVode(cvode_mem, tout, y, ctypes.byref(t),
                                cvodes.CV_NORMAL)

            if verbose >= self.SCREAM:
                print "At t = %-14.4e  y =" % t.value, \
                      ("  %-11.6e  "*len(y)) % tuple(y)
            """Used for return."""
            if return_last == False:
                T[i] = t.value
                ylist[i] = N.array(y)
                i = i + 1

            if N.abs(tout - end_time) <= 1e-6:
                break

            if flag == cvodes.CV_SUCCESS:
                tout += time_step

            if tout > end_time:
                tout = end_time

        if return_last == False:
            assert i <= num_samples, "Allocated a too small array." \
                                     " (%s > %s)" % (i, num_samples)
            num_samples = i
            ylist = ylist[:num_samples]
            T = T[:num_samples]

        if sensi:
            cvodes.CVodeGetSens(cvode_mem, t, yS)

        if verbose >= self.LOUD:
            # collecting lots of information about the execution and present it
            nst = cvodes.CVodeGetNumSteps(cvode_mem)
            nfe = cvodes.CVodeGetNumRhsEvals(cvode_mem)
            nsetups = cvodes.CVodeGetNumLinSolvSetups(cvode_mem)
            netf = cvodes.CVodeGetNumErrTestFails(cvode_mem)
            nni = cvodes.CVodeGetNumNonlinSolvIters(cvode_mem)
            ncfn = cvodes.CVodeGetNumNonlinSolvConvFails(cvode_mem)
            nje = cvodes.CVDenseGetNumJacEvals(cvode_mem)
            nfeLS = cvodes.CVDenseGetNumRhsEvals(cvode_mem)
            nge = cvodes.CVodeGetNumGEvals(cvode_mem)
            print "\nFinal Statistics:"
            print "nst = %-6i nfe  = %-6i nsetups = %-6i nfeLS = %-6i nje = %i" % \
                  (nst, nfe, nsetups, nfeLS, nje)
            print "nni = %-6ld ncfn = %-6ld netf = %-6ld nge = %ld\n " % \
                  (nni, ncfn, netf, nge)

        if return_last:
            ylist = N.array(y).copy()
            T = t.value
        else:
            ylist = N.array(ylist)
            T = N.array(T)

        if sensi:
            self._set_sensitivities(N.array(yS))
        else:
            self._set_sensitivities(None)

        self._set_solution(T, ylist)
Ejemplo n.º 8
0
			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 = cvodes.realtype(0)
u = cvodes.NVector([0]*NEQ)
data = UserData()
InitUserData(data)
SetInitialProfiles(u, data.dx, data.dy)
abstol = cvodes.realtype(ATOL)
reltol = RTOL

cvode_mem = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_NEWTON)
cvodes.CVodeSetFdata(cvode_mem, ctypes.pointer(data))
cvodes.CVodeMalloc(cvode_mem, f, T0, u, cvodes.CV_SS, reltol, abstol)
ml = mu = 2
bpdata = cvodes.CVBandPrecAlloc(cvode_mem, NEQ, mu, ml)
cvodes.CVBPSpgmr(cvode_mem, cvodes.PREC_LEFT, 0, bpdata)
PrintIntro(mu, ml)
Ejemplo n.º 9
0
print "     dy2/dt =  p1*y1 - p2*y2*y3 - p3*(y2)^2"
print "     dy3/dt =  p3*(y2)^2\n"
print "Find dG/dp for"
print "     G = int_t0^tB0 g(t,p,y) dt"
print "     g(t,p,y) = y3\n\n"

data = UserData()
data.p[0] = 0.04
data.p[1] = 1.0e4
data.p[2] = 3.0e7

y = cvodes.NVector([1.0, 0.0, 0.0])

q = cvodes.NVector([0.0])

reltolQ = cvodes.realtype(1.0e-6)
abstolQ = cvodes.realtype(1.0e-6)

print "Create and allocate CVODES memory for forward runs"

cvode_mem = cvodes.CVodeCreate(cvodes.CV_BDF, cvodes.CV_NEWTON)
cvodes.CVodeMalloc(cvode_mem, f, 0.0, y, cvodes.CV_WF, 0.0, None)

cvodes.CVodeSetEwtFn(cvode_mem, ewt, None)
cvodes.CVodeSetFdata(cvode_mem, ctypes.pointer(data))
cvodes.CVDense(cvode_mem, 3)
cvodes.CVDenseSetJacFn(cvode_mem, Jac, ctypes.pointer(data))

cvodes.CVodeQuadMalloc(cvode_mem, fQ, q)
cvodes.CVodeSetQuadFdata(cvode_mem, ctypes.pointer(data))
cvodes.CVodeSetQuadErrCon(cvode_mem, True, cvodes.CV_SS, reltolQ, abstolQ)