def run_example(): def residual(t,y,yd): res_0 = yd[0]-y[2] res_1 = yd[1]-y[3] res_2 = yd[2]+y[4]*y[0] res_3 = yd[3]+y[4]*y[1]+9.82 res_4 = y[2]**2+y[3]**2-y[4]*(y[0]**2+y[1]**2)-y[1]*9.82 return np.array([res_0,res_1,res_2,res_3,res_4]) #The initial conditons t0 = 0.0 #Initial time y0 = [1.0, 0.0, 0.0, 0.0, 0.0] #Initial conditions yd0 = [0.0, 0.0, 0.0, -9.82, 0.0] #Initial conditions print (residual(t0,y0,yd0)) model = Implicit_Problem(residual, y0, yd0, t0) #Create an Assimulo problem model.name = 'Pendulum' #Specifies the name of problem (optional) sim = IDA(model) #Create the IDA solver tfinal = 10.0 #Specify the final time ncp = 500 #Number of communcation points (number of return points) t,y,yd = sim.simulate(tfinal, ncp) #Use the .simulate method to simulate and provide the final time and ncp (optional) sim.plot()
def simulate(self, Tend, nIntervals, gridWidth): problem = Implicit_Problem(self.rhs, self.y0, self.yd0) problem.name = 'IDA' # solver.rhs = self.right_hand_side problem.handle_result = self.handle_result problem.state_events = self.state_events problem.handle_event = self.handle_event problem.time_events = self.time_events problem.finalize = self.finalize # Create IDA object and set additional parameters simulation = IDA(problem) simulation.atol = self.atol simulation.rtol = self.rtol simulation.verbosity = self.verbosity if hasattr(simulation, 'continuous_output'): simulation.continuous_output = False # default 0, if one step approach should be used elif hasattr(simulation, 'report_continuously'): simulation.report_continuously = False # default 0, if one step approach should be used simulation.tout1 = self.tout1 simulation.lsoff = self.lsoff # Calculate nOutputIntervals: if gridWidth <> None: nOutputIntervals = int((Tend - self.t0) / gridWidth) else: nOutputIntervals = nIntervals # Check for feasible input parameters if nOutputIntervals == 0: print 'Error: gridWidth too high or nIntervals set to 0! Continue with nIntervals=1' nOutputIntervals = 1 # Perform simulation simulation.simulate(Tend, nOutputIntervals) # to get the values: t_new, y_new, yd_new = simulation.simulate
def run_example(): #initial values t0 = 0 y0 = np.array([0., -0.10344, -0.65, 0., 0. , 0., -0.628993, 0.047088]) #|phi_s| <= 0.1034 rad, |phi_b| <= 0.12 rad yd0 = np.array([0., 0., 0., 0., 0., 0., 0., 0.]) sw = [False, True, False] #problem model = Implicit_Problem(pecker, y0, yd0, t0, sw0=sw) model.state_events = state_events #from woodpecker.py model.handle_event = handle_event #from woodpecker.py model.name = 'Woodpeckermodel' sim = IDA(model) #create IDA solver tfinal = 2.0 #final time ncp = 500 #number control points sim.suppress_alg = True sim.rtol=1.e-6 sim.atol[6:8] = 1e6 sim.algvar[6:8] = 0 t, y, yd = sim.simulate(tfinal, ncp) #simulate #plot fig, ax = P.subplots() ax.plot(t, y[:, 0], label='z') legend = ax.legend(loc='upper center', shadow=True) P.grid() P.figure(1) fig2, ax2 = P.subplots() ax2.plot(t, y[:, 1], label='phi_s') ax2.plot(t, y[:, 2], label='phi_b') legend = ax2.legend(loc='upper center', shadow=True) P.grid() P.figure(2) fig3, ax3 = P.subplots() ax3.plot(t, y[:, 4], label='phi_sp') ax3.plot(t, y[:, 5], label='phi_bp') legend = ax3.legend(loc='upper center', shadow=True) P.grid() P.figure(3) fig4, ax4 = P.subplots() ax4.plot(t, y[:, 6], label='lambda_1') ax4.plot(t, y[:, 7], label='lambda_2') legend = ax4.legend(loc='upper right', shadow=True) P.grid() #event data sim.print_event_data() #show plots P.show() print("...") P.show()
def run_example(with_plots=True): #Define the residual def f(t,y,yd): eps = 1.e-6 my = 1./eps yd_0 = y[1] yd_1 = my*((1.-y[0]**2)*y[1]-y[0]) res_0 = yd[0]-yd_0 res_1 = yd[1]-yd_1 return N.array([res_0,res_1]) y0 = [2.0,-0.6] #Initial conditions yd0 = [-.6,-200000.] #Define an Assimulo problem imp_mod = Implicit_Problem(f,y0,yd0) imp_mod.name = 'Van der Pol (implicit)' #Define an explicit solver imp_sim = Radau5DAE(imp_mod) #Create a Radau5 solver #Sets the parameters imp_sim.atol = 1e-4 #Default 1e-6 imp_sim.rtol = 1e-4 #Default 1e-6 imp_sim.inith = 1.e-4 #Initial step-size #Simulate t, y, yd = imp_sim.simulate(2.) #Simulate 2 seconds #Plot if with_plots: P.plot(t,y[:,0], marker='o') P.show() #Basic test x1 = y[:,0] assert N.abs(x1[-1]-1.706168035) < 1e-3 #For test purpose
def run_example(with_plots=True): #Define the residual def f(t, y, yd): eps = 1.e-6 my = 1. / eps yd_0 = y[1] yd_1 = my * ((1. - y[0]**2) * y[1] - y[0]) res_0 = yd[0] - yd_0 res_1 = yd[1] - yd_1 return N.array([res_0, res_1]) y0 = [2.0, -0.6] #Initial conditions yd0 = [-.6, -200000.] #Define an Assimulo problem imp_mod = Implicit_Problem(f, y0, yd0) imp_mod.name = 'Van der Pol (implicit)' #Define an explicit solver imp_sim = Radau5DAE(imp_mod) #Create a Radau5 solver #Sets the parameters imp_sim.atol = 1e-4 #Default 1e-6 imp_sim.rtol = 1e-4 #Default 1e-6 imp_sim.inith = 1.e-4 #Initial step-size #Simulate t, y, yd = imp_sim.simulate(2.) #Simulate 2 seconds #Plot if with_plots: P.plot(t, y[:, 0], marker='o') P.show() #Basic test x1 = y[:, 0] assert N.abs(x1[-1] - 1.706168035) < 1e-3 #For test purpose
resid12 = -lambda_2 - g * m - lambda_3(z1 - z2) resid13 = (x1 * du[6] + x1_dot**2) + (y1 * du[7] + y1_dot**2) - du[8] resid14 = (x1 * du[9] + x1_dot**2) + (y1 * du[10] + y1_dot**2) - du[11] resid15 = (x1 - x2) * (du[6] - du[9]) + (x1_dot - x2_dot) * (x1_dot - x2_dot) resid16 = (y1 - y2) * (du[7] - du[10]) + (y1_dot - y2_dot) * (y1_dot - y2_dot) resid17 = (z1 - z2) * (du[8] - du[11]) + (z1_dot - z2_dot) * (z1_dot - z2_dot) return np.array([ resid1, resid2, resid3, resid4, resid5, resid6, resid7, resid8, resid9, resid10, resid11, resid12, resid13, resid14, resid15, resid16, resid17 ]) #initial conditions t0 = 0.0 u0 = [1.0, 1.0, 1.0, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0, 0, 0] du0 = [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0, 0, 0] model = Implicit_Problem(residual, u0, du0, t0) model.name = 'masses linked on surface' sim = IDA(model) tfinal = 10.0 #Specify the final time ncp = 500 #Number of communication points (number of return points) t, y, yd = sim.simulate(tfinal, ncp) sim.plot()
np.real(ux_x_min), \ np.imag(ux_x_min), \ np.real(b_par_x_min), \ np.imag(b_par_x_min), \ np.real(u_perp_x_min), \ np.imag(u_perp_x_min) )) dU_x_min = np.concatenate(( \ np.real(dux_x_min), \ np.imag(dux_x_min), \ np.real(db_par_x_min), \ np.imag(db_par_x_min), \ np.real(du_perp_x_min), \ np.imag(du_perp_x_min) )) model = Implicit_Problem(residual, U_x_min, dU_x_min, x_min) model.name = 'Pendulum' sim = IDA(model) # x,U,dU = sim.simulate(x_max, nx) # sim.plot() fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x, vA(x, 0)) fig = plt.figure() ax = fig.add_subplot(111) ax.plot(x, np.real(ux_ana(x, 0))) ax.plot(x, np.imag(ux_ana(x, 0)))
def run_example(with_plots=True): #Defines the residual def f(t,y,yd): res_0 = yd[0]-y[2] res_1 = yd[1]-y[3] res_2 = yd[2]+y[4]*y[0] res_3 = yd[3]+y[4]*y[1]+9.82 #res_4 = y[0]**2+y[1]**2-1 res_4 = y[2]**2+y[3]**2-y[4]*(y[0]**2+y[1]**2)-y[1]*9.82 return N.array([res_0,res_1,res_2,res_3,res_4]) #Defines the jacobian def jac(c,t,y,yd): jacobian = N.zeros([len(y),len(y)]) #Derivative jacobian[0,0] = 1*c jacobian[1,1] = 1*c jacobian[2,2] = 1*c jacobian[3,3] = 1*c #Differentiated jacobian[0,2] = -1 jacobian[1,3] = -1 jacobian[2,0] = y[4] jacobian[3,1] = y[4] jacobian[4,0] = y[0]*2*y[4]*-1 jacobian[4,1] = y[1]*2*y[4]*-1-9.82 jacobian[4,2] = y[2]*2 jacobian[4,3] = y[3]*2 #Algebraic jacobian[2,4] = y[0] jacobian[3,4] = y[1] jacobian[4,4] = -(y[0]**2+y[1]**2) return jacobian #The initial conditons y0 = [1.0,0.0,0.0,0.0,5] #Initial conditions yd0 = [0.0,0.0,0.0,-9.82,0.0] #Initial conditions #Create an Assimulo implicit problem imp_mod = Implicit_Problem(f,y0,yd0) #Sets the options to the problem imp_mod.jac = jac #Sets the jacobian imp_mod.algvar = [1.0,1.0,1.0,1.0,0.0] #Set the algebraic components imp_mod.name = 'Test Jacobian' #Create an Assimulo implicit solver (IDA) imp_sim = IDA(imp_mod) #Create a IDA solver #Sets the paramters imp_sim.atol = 1e-6 #Default 1e-6 imp_sim.rtol = 1e-6 #Default 1e-6 imp_sim.suppress_alg = True #Suppres the algebraic variables on the error test #Let Sundials find consistent initial conditions by use of 'IDA_YA_YDP_INIT' imp_sim.make_consistent('IDA_YA_YDP_INIT') #Simulate t, y, yd = imp_sim.simulate(5,1000) #Simulate 5 seconds with 1000 communication points #Basic tests nose.tools.assert_almost_equal(y[-1][0],0.9401995, places=4) nose.tools.assert_almost_equal(y[-1][1],-0.34095124, places=4) nose.tools.assert_almost_equal(yd[-1][0], -0.88198927, places=4) nose.tools.assert_almost_equal(yd[-1][1], -2.43227069, places=4) #Plot if with_plots: P.plot(t,y) P.show()
y0 = numpy.array([0.5, 0,0, -0, 0, 0.5,-1e-4,0]) yd0 = numpy.array([-0, 0, 0.5,-g, 1e-12, 0, 0, 0]) w0 = -0.91 y0 = numpy.array([0.5, 0,0, -0, w0, w0,-1e-4,0]) yd0 = numpy.array([-0, w0, w0,-g, 1e-12, 0, 0, 0]) #y0 = numpy.array([4.83617428e-01, -3.00000000e-02, -2.16050178e-01, 1.67315232e-16, -5.39725367e-14, -1.31300925e+01, -7.20313572e-02, -6.20545138e-02]) #yd0 = numpy.array([1.55140566e-17, -5.00453439e-15, -1.31302838e+01, 6.62087352e-13, -2.13577297e-10, 2.21484026e+02, -4.67637454e+00, -2.89824658e+00]) #startsw = [0,1, 0, 0] problem = Implicit_Problem(res, y0, yd0, t0, sw0=startsw) problem.state_events = state_events problem.handle_event = handle_event problem.name = 'Woodpecker' phipIndex = [4, 5] lambdaIndex = [6, 7] sim = IDA(problem) sim.rtol = 1e-6 sim.atol[phipIndex] = 1e8 sim.algvar[phipIndex] = 1 sim.atol[lambdaIndex] = 1e8 sim.algvar[lambdaIndex] = 1 sim.suppress_alg = True ncp = 500 tfinal = 2
import numpay as np import pylab as P from assimulo.problem import Implicit_Problem from assimulo.solvers import IDA y0 = np.array([0 0 0 0 0 0 0]) yp0 = np.array([0 0 0 0 0 0 0]) t0 = 0.0 model = Implicit_Problem(squeezer, y0, yp0, t0) model.name = 'Squeezer' solver = IDA(model)
from scipy import * from assimulo.problem import Implicit_Problem from assimulo.solvers import IDA from Project_2 import squeezer as sq from Project_2 import squeezer2 as sq2 import matplotlib.pyplot as plt t0 = 0 tfinal = 0.03 # Model 1, squeezer with index 3 constraints y0_1,yp0_1 = sq.init_squeezer() ncp_1 = 100 model_1 = Implicit_Problem(sq.squeezer, y0_1, yp0_1, t0) model_1.name = 'Squeezer index 3 constraints' sim_1 = IDA(model_1) sim_1.suppress_alg = True sim_1.algvar = array([1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0]) sim_1.atol = ones(20,) for i in range(size(sim_1.atol)): if 0 <= i <= 6: sim_1.atol[i] = pow(10,-6) else: sim_1.atol[i] = pow(10,5) t, y, yd = sim_1.simulate(tfinal, ncp_1) plt.plot(t,y[:,14:shape(y)[1]]) # Plots the Lagrange multipliers plt.show() plt.plot(t,(y[:,0:7]+pi)%(2*pi)-pi) # Plots the position variables i.e beta,gamma etc, modulo 2pi. plt.show() # Model 2, squeezer with index 2 constraints
sim.atol[lambdaIndex] = 1e-1 sim.atol[velocityIndex] = 1e-5 elif indexNumber == 2: problem = Implicit_Problem(squeezer2, y0, yd0, t0) algvar[lambdaIndex] = 0 algvar[velocityIndex] = 1 sim = IDA(problem) sim.atol = numpy.ones(numpy.size(y0))*1e-7 sim.atol[lambdaIndex] = 1e-5 sim.atol[velocityIndex] = 1e-5 elif indexNumber == 1: problem = Explicit_Problem(squeezer1, y0[0:14], t0) sim = RungeKutta34(problem) sim.atol = numpy.ones(14)*1e-7 problem.name = 'Squeezer' sim.rtol = 1e-8 tfinal = 0.03 ncp = 5000 if indexNumber == 2 or indexNumber == 3: sim.algvar = algvar sim.suppress_alg = True t, y, yd = sim.simulate(tfinal, ncp) elif indexNumber == 1: t, y, = sim.simulate(tfinal, ncp)
np.real(ux_x_min), \ np.imag(ux_x_min), \ np.real(b_par_x_min), \ np.imag(b_par_x_min), \ np.real(u_perp_x_min), \ np.imag(u_perp_x_min) ]) dU_x_min = np.array([ \ np.real(dux_x_min), \ np.imag(dux_x_min), \ np.real(db_par_x_min), \ np.imag(db_par_x_min), \ np.real(du_perp_x_min), \ np.imag(du_perp_x_min) ]) model = Implicit_Problem(residual, U_x_min, dU_x_min, x_min) model.name = 'Resonant absorption' sim = IDA(model) x, U, dU = sim.simulate(x_max, nx) x = np.array(x) ux_r = U[:, 0] ux_i = U[:, 1] b_par_r = U[:, 2] b_par_i = U[:, 3] u_perp_r = U[:, 4] u_perp_i = U[:, 5] fig = plt.figure()
def dae_solver(residual, y0, yd0, t0, p0=None, jac=None, name='DAE', solver='IDA', algvar=None, atol=1e-6, backward=False, display_progress=True, pbar=None, report_continuously=False, rtol=1e-6, sensmethod='STAGGERED', suppress_alg=False, suppress_sens=False, usejac=False, usesens=False, verbosity=30, tfinal=10., ncp=500): ''' DAE solver. Parameters ---------- residual: function Implicit DAE model. y0: List[float] Initial model state. yd0: List[float] Initial model state derivatives. t0: float Initial simulation time. p0: List[float] Parameters for which sensitivites are to be calculated. jac: function Model jacobian. name: string Model name. solver: string DAE solver. algvar: List[bool] A list for defining which variables are differential and which are algebraic. The value True(1.0) indicates a differential variable and the value False(0.0) indicates an algebraic variable. atol: float Absolute tolerance. backward: bool Specifies if the simulation is done in reverse time. display_progress: bool Actives output during the integration in terms of that the current integration is periodically printed to the stdout. Report_continuously needs to be activated. pbar: List[float] An array of positive floats equal to the number of parameters. Default absolute values of the parameters. Specifies the order of magnitude for the parameters. Useful if IDAS is to estimate tolerances for the sensitivity solution vectors. report_continuously: bool Specifies if the solver should report the solution continuously after steps. rtol: float Relative tolerance. sensmethod: string Specifies the sensitivity solution method. Can be either ‘SIMULTANEOUS’ or ‘STAGGERED’. Default is 'STAGGERED'. suppress_alg: bool Indicates that the error-tests are suppressed on algebraic variables. suppress_sens: bool Indicates that the error-tests are suppressed on the sensitivity variables. usejac: bool Sets the option to use the user defined jacobian. usesens: bool Aactivates or deactivates the sensitivity calculations. verbosity: int Determines the level of the output. QUIET = 50 WHISPER = 40 NORMAL = 30 LOUD = 20 SCREAM = 10 tfinal: float Simulation final time. ncp: int Number of communication points (number of return points). Returns ------- sol: solution [time, model states], List[float] ''' if usesens is True: # parameter sensitivity model = Implicit_Problem(residual, y0, yd0, t0, p0=p0) else: model = Implicit_Problem(residual, y0, yd0, t0) model.name = name if usejac is True: # jacobian model.jac = jac if algvar is not None: # differential or algebraic variables model.algvar = algvar if solver == 'IDA': # solver from assimulo.solvers import IDA sim = IDA(model) sim.atol = atol sim.rtol = rtol sim.backward = backward # backward in time sim.report_continuously = report_continuously sim.display_progress = display_progress sim.suppress_alg = suppress_alg sim.verbosity = verbosity if usesens is True: # sensitivity sim.sensmethod = sensmethod sim.pbar = np.abs(p0) sim.suppress_sens = suppress_sens # Simulation # t, y, yd = sim.simulate(tfinal, ncp=(ncp - 1)) ncp_list = np.linspace(t0, tfinal, num=ncp, endpoint=True) t, y, yd = sim.simulate(tfinal, ncp=0, ncp_list=ncp_list) # Plot # sim.plot() # plt.figure() # plt.subplot(221) # plt.plot(t, y[:, 0], 'b.-') # plt.legend([r'$\lambda$']) # plt.subplot(222) # plt.plot(t, y[:, 1], 'r.-') # plt.legend([r'$\dot{\lambda}$']) # plt.subplot(223) # plt.plot(t, y[:, 2], 'k.-') # plt.legend([r'$\eta$']) # plt.subplot(224) # plt.plot(t, y[:, 3], 'm.-') # plt.legend([r'$\dot{\eta}$']) # plt.figure() # plt.subplot(221) # plt.plot(t, yd[:, 0], 'b.-') # plt.legend([r'$\dot{\lambda}$']) # plt.subplot(222) # plt.plot(t, yd[:, 1], 'r.-') # plt.legend([r'$\ddot{\lambda}$']) # plt.subplot(223) # plt.plot(t, yd[:, 2], 'k.-') # plt.legend([r'$\dot{\eta}$']) # plt.subplot(224) # plt.plot(t, yd[:, 3], 'm.-') # plt.legend([r'$\ddot{\eta}$']) # plt.figure() # plt.subplot(121) # plt.plot(y[:, 0], y[:, 1]) # plt.xlabel(r'$\lambda$') # plt.ylabel(r'$\dot{\lambda}$') # plt.subplot(122) # plt.plot(y[:, 2], y[:, 3]) # plt.xlabel(r'$\eta$') # plt.ylabel(r'$\dot{\eta}$') # plt.figure() # plt.subplot(121) # plt.plot(yd[:, 0], yd[:, 1]) # plt.xlabel(r'$\dot{\lambda}$') # plt.ylabel(r'$\ddot{\lambda}$') # plt.subplot(122) # plt.plot(yd[:, 2], yd[:, 3]) # plt.xlabel(r'$\dot{\eta}$') # plt.ylabel(r'$\ddot{\eta}$') # plt.figure() # plt.subplot(121) # plt.plot(y[:, 0], y[:, 2]) # plt.xlabel(r'$\lambda$') # plt.ylabel(r'$\eta$') # plt.subplot(122) # plt.plot(y[:, 1], y[:, 3]) # plt.xlabel(r'$\dot{\lambda}$') # plt.ylabel(r'$\dot{\eta}$') # plt.figure() # plt.subplot(121) # plt.plot(yd[:, 0], yd[:, 2]) # plt.xlabel(r'$\dot{\lambda}$') # plt.ylabel(r'$\dot{\eta}$') # plt.subplot(122) # plt.plot(yd[:, 1], yd[:, 3]) # plt.xlabel(r'$\ddot{\lambda}$') # plt.ylabel(r'$\ddot{\eta}$') # plt.show() sol = [t, y, yd] return sol
def run_example(with_plots=True): r""" Example for the use of Radau5DAE to solve Van der Pol's equation .. math:: \dot y_1 &= y_2 \\ \dot y_2 &= \mu ((1.-y_1^2) y_2-y_1) with :math:`\mu= 10^6`. on return: - :dfn:`imp_mod` problem instance - :dfn:`imp_sim` solver instance """ #Define the residual def f(t, y, yd): eps = 1.e-6 my = 1. / eps yd_0 = y[1] yd_1 = my * ((1. - y[0]**2) * y[1] - y[0]) res_0 = yd[0] - yd_0 res_1 = yd[1] - yd_1 return N.array([res_0, res_1]) y0 = [2.0, -0.6] #Initial conditions yd0 = [-.6, -200000.] #Define an Assimulo problem imp_mod = Implicit_Problem(f, y0, yd0) imp_mod.name = 'Van der Pol (implicit)' #Define an explicit solver imp_sim = Radau5DAE(imp_mod) #Create a Radau5 solver #Sets the parameters imp_sim.atol = 1e-4 #Default 1e-6 imp_sim.rtol = 1e-4 #Default 1e-6 imp_sim.inith = 1.e-4 #Initial step-size #Simulate t, y, yd = imp_sim.simulate(2.) #Simulate 2 seconds #Plot if with_plots: P.subplot(211) P.plot(t, y[:, 0]) #, marker='o') P.xlabel('Time') P.ylabel('State') P.subplot(212) P.plot(t, yd[:, 0] * 1.e-5) #, marker='o') P.xlabel('Time') P.ylabel('State derivatives scaled with $10^{-5}$') P.suptitle(imp_mod.name) P.show() #Basic test x1 = y[:, 0] assert N.abs(x1[-1] - 1.706168035) < 1e-3 #For test purpose return imp_mod, imp_sim
res = np.zeros(6 * ct.nz) res[0:ct.nz] = np.real(dux + 1j * ct.omega * b_par + nabla_perp_u_perp) res[ct.nz:2 * ct.nz] = np.imag(dux + 1j * ct.omega * b_par + nabla_perp_u_perp) res[2 * ct.nz:3 * ct.nz] = np.real(db_par + 1j / ct.omega * L_ux) res[3 * ct.nz:4 * ct.nz] = np.imag(db_par + 1j / ct.omega * L_ux) res[4 * ct.nz:5 * ct.nz] = np.real(L_u_perp - 1j * ct.omega * nabla_perp_b_par) res[5 * ct.nz:] = np.imag(L_u_perp - 1j * ct.omega * nabla_perp_b_par) return res model = Implicit_Problem(residual, ct.U_x_min, ct.dU_x_min, ct.x_min) model.name = 'Resonant abosprotion' sim = IDA(model) x, U, dU = sim.simulate(ct.x_max, ct.nx) # sim.plot() # fig = plt.figure() # ax = fig.add_subplot(111) # ax.plot(ct.z, ct.dU_perp_x_min[0:ct.nz]) # ax.plot(ct.z, np.real(ct.du_perp_ana(ct.x_min,ct.z))) # fig = plt.figure() # ax = fig.add_subplot(111) # ax.plot(ct.z, ct.dU_perp_x_min[ct.nz:])
def run_example(with_plots=True): #Defines the residual def f(t, y, yd): res_0 = yd[0] - y[2] res_1 = yd[1] - y[3] res_2 = yd[2] + y[4] * y[0] res_3 = yd[3] + y[4] * y[1] + 9.82 #res_4 = y[0]**2+y[1]**2-1 res_4 = y[2]**2 + y[3]**2 - y[4] * (y[0]**2 + y[1]**2) - y[1] * 9.82 return N.array([res_0, res_1, res_2, res_3, res_4]) #Defines the jacobian def jac(c, t, y, yd): jacobian = N.zeros([len(y), len(y)]) #Derivative jacobian[0, 0] = 1 * c jacobian[1, 1] = 1 * c jacobian[2, 2] = 1 * c jacobian[3, 3] = 1 * c #Differentiated jacobian[0, 2] = -1 jacobian[1, 3] = -1 jacobian[2, 0] = y[4] jacobian[3, 1] = y[4] jacobian[4, 0] = y[0] * 2 * y[4] * -1 jacobian[4, 1] = y[1] * 2 * y[4] * -1 - 9.82 jacobian[4, 2] = y[2] * 2 jacobian[4, 3] = y[3] * 2 #Algebraic jacobian[2, 4] = y[0] jacobian[3, 4] = y[1] jacobian[4, 4] = -(y[0]**2 + y[1]**2) return jacobian #The initial conditons y0 = [1.0, 0.0, 0.0, 0.0, 5] #Initial conditions yd0 = [0.0, 0.0, 0.0, -9.82, 0.0] #Initial conditions #Create an Assimulo implicit problem imp_mod = Implicit_Problem(f, y0, yd0) #Sets the options to the problem imp_mod.jac = jac #Sets the jacobian imp_mod.algvar = [1.0, 1.0, 1.0, 1.0, 0.0] #Set the algebraic components imp_mod.name = 'Test Jacobian' #Create an Assimulo implicit solver (IDA) imp_sim = IDA(imp_mod) #Create a IDA solver #Sets the paramters imp_sim.atol = 1e-6 #Default 1e-6 imp_sim.rtol = 1e-6 #Default 1e-6 imp_sim.suppress_alg = True #Suppres the algebraic variables on the error test #Let Sundials find consistent initial conditions by use of 'IDA_YA_YDP_INIT' imp_sim.make_consistent('IDA_YA_YDP_INIT') #Simulate t, y, yd = imp_sim.simulate( 5, 1000) #Simulate 5 seconds with 1000 communication points #Basic tests nose.tools.assert_almost_equal(y[-1][0], 0.9401995, places=4) nose.tools.assert_almost_equal(y[-1][1], -0.34095124, places=4) nose.tools.assert_almost_equal(yd[-1][0], -0.88198927, places=4) nose.tools.assert_almost_equal(yd[-1][1], -2.43227069, places=4) #Plot if with_plots: P.plot(t, y) P.show()