def _setup_sim(self, **kwargs): """ Create a simulation interface to Assimulo using CVODE, given a problem definition """ # Create Assimulo interface sim = CVode(self.prob) sim.discr = 'BDF' sim.maxord = 5 # Setup some default arguments for the ODE solver, or override # if available. This is very hackish, but it's fine for now while # the number of anticipated tuning knobs is small. if 'maxh' in kwargs: sim.maxh = kwargs['maxh'] else: sim.maxh = np.min([0.1, self.output_dt]) if 'minh' in kwargs: sim.minh = kwargs['minh'] # else: sim.minh = 0.001 if "iter" in kwargs: sim.iter = kwargs['iter'] else: sim.iter = 'Newton' if "linear_solver" in kwargs: sim.linear_solver = kwargs['linear_solver'] if "max_steps" in kwargs: # DIFFERENT NAME!!!! sim.maxsteps = kwargs['max_steps'] else: sim.maxsteps = 1000 if "time_limit" in kwargs: sim.time_limit = kwargs['time_limit'] sim.report_continuously = True else: sim.time_limit = 0.0 # Don't save the [t_-, t_+] around events sim.store_event_points = False # Setup tolerances nr = self.args[0] sim.rtol = state_rtol sim.atol = state_atol + [1e-12] * nr if not self.console: sim.verbosity = 50 else: sim.verbosity = 40 # sim.report_continuously = False # Save the Assimulo interface return sim
def _setup_sim(self, **kwargs): """ Create a simulation interface to Assimulo using CVODE, given a problem definition """ # Create Assimulo interface sim = CVode(self.prob) sim.discr = 'BDF' sim.maxord = 5 # Setup some default arguments for the ODE solver, or override # if available. This is very hackish, but it's fine for now while # the number of anticipated tuning knobs is small. if 'maxh' in kwargs: sim.maxh = kwargs['maxh'] else: sim.maxh = np.min([0.1, self.output_dt]) if 'minh' in kwargs: sim.minh = kwargs['minh'] # else: sim.minh = 0.001 if "iter" in kwargs: sim.iter = kwargs['iter'] else: sim.iter = 'Newton' if "linear_solver" in kwargs: sim.linear_solver = kwargs['linear_solver'] if "max_steps" in kwargs: # DIFFERENT NAME!!!! sim.maxsteps = kwargs['max_steps'] else: sim.maxsteps = 1000 if "time_limit" in kwargs: sim.time_limit = kwargs['time_limit'] sim.report_continuously = True else: sim.time_limit = 0.0 # Don't save the [t_-, t_+] around events sim.store_event_points = False # Setup tolerances nr = self.args[0] sim.rtol = state_rtol sim.atol = state_atol + [1e-12]*nr if not self.console: sim.verbosity = 50 else: sim.verbosity = 40 # sim.report_continuously = False # Save the Assimulo interface return sim
def run_example(with_plots=True): #Defines the rhs def f(t, y): yd_0 = y[1] yd_1 = -9.82 return N.array([yd_0, yd_1]) #Defines the jacobian*vector product def jacv(t, y, fy, v): j = N.array([[0, 1.], [0, 0]]) return N.dot(j, v) y0 = [1.0, 0.0] #Initial conditions #Defines an Assimulo explicit problem exp_mod = Explicit_Problem(f, y0) exp_mod.jacv = jacv #Sets the jacobian exp_mod.name = 'Example using the Jacobian Vector product' exp_sim = CVode(exp_mod) #Create a CVode solver #Set the parameters exp_sim.iter = 'Newton' #Default 'FixedPoint' exp_sim.discr = 'BDF' #Default 'Adams' exp_sim.atol = 1e-5 #Default 1e-6 exp_sim.rtol = 1e-5 #Default 1e-6 exp_sim.linear_solver = 'SPGMR' #Change linear solver #exp_sim.options["usejac"] = False #Simulate t, y = exp_sim.simulate( 5, 1000) #Simulate 5 seconds with 1000 communication points #Basic tests nose.tools.assert_almost_equal(y[-1][0], -121.75000000, 4) nose.tools.assert_almost_equal(y[-1][1], -49.100000000) #Plot if with_plots: P.plot(t, y) P.show()
def run_example(with_plots=True): #Defines the rhs def f(t,y): yd_0 = y[1] yd_1 = -9.82 return N.array([yd_0,yd_1]) #Defines the jacobian*vector product def jacv(t,y,fy,v): j = N.array([[0,1.],[0,0]]) return N.dot(j,v) y0 = [1.0,0.0] #Initial conditions #Defines an Assimulo explicit problem exp_mod = Explicit_Problem(f,y0) exp_mod.jacv = jacv #Sets the jacobian exp_mod.name = 'Example using the Jacobian Vector product' exp_sim = CVode(exp_mod) #Create a CVode solver #Set the parameters exp_sim.iter = 'Newton' #Default 'FixedPoint' exp_sim.discr = 'BDF' #Default 'Adams' exp_sim.atol = 1e-5 #Default 1e-6 exp_sim.rtol = 1e-5 #Default 1e-6 exp_sim.linear_solver = 'SPGMR' #Change linear solver #exp_sim.options["usejac"] = False #Simulate t, y = exp_sim.simulate(5, 1000) #Simulate 5 seconds with 1000 communication points #Basic tests nose.tools.assert_almost_equal(y[-1][0],-121.75000000,4) nose.tools.assert_almost_equal(y[-1][1],-49.100000000) #Plot if with_plots: P.plot(t,y) P.show()
def integration_assimulo(self, **kwargs): """ Perform time integration for ODEs with the assimulo package """ assert self.set_time_setting == 1, 'Time discretization must be specified first' if self.tclose > 0: close = True else: close = False # Control vector self.U = interpolate(self.boundary_cntrl_space, self.Vb).vector()[self.bndr_i_b] if self.discontinous_boundary_values == 1: self.U[self.Corner_indices] = self.U[self.Corner_indices]/2 # Definition of the sparse solver for the ODE rhs function to # be defined next #my_solver = factorized(csc_matrix(self.M)) my_solver = factorized(self.M) #my_jac_o = csr_matrix(my_solver(self.J @ self.Q)) #my_jac_c = csr_matrix(my_solver((self.J - self.R) @ self.Q)) # Definition of the rhs function required in assimulo def rhs(t,y): """ Definition of the rhs function required in the ODE part of assimulo """ if close: if t < self.tclose: z = self.my_mult(self.J, self.my_mult(self.Q,y)) + self.my_mult(self.Bext,self.U* self.boundary_cntrl_time(t,self.tclose)) else: z = self.my_mult((self.J - self.R), self.my_mult(self.Q,y)) else: z = self.my_mult(self.J, self.my_mult(self.Q,y)) + self.my_mult(self.Bext,self.U* self.boundary_cntrl_time(t,self.tclose)) return my_solver(z) def jacobian(t,y): """ Jacobian related to the ODE formulation """ if close: if t < self.tclose: my_jac = my_jac_o else: my_jac = my_jac_c else: my_jac = my_jac_o return my_jac def jacv(t,y,fy,v): """ Jacobian matrix-vector product related to the ODE formulation """ if close: if t < self.tclose: z = self.my_mult(self.J, self.my_mult(self.Q,v) ) else: z = self.my_mult((self.J - self.R), self.my_mult(self.Q,v)) else: z = self.my_mult(self.J, self.my_mult(self.Q,v)) return my_solver(z) print('ODE Integration using assimulo built-in functions:') # # https://jmodelica.org/assimulo/_modules/assimulo/examples/cvode_with_preconditioning.html#run_example # model = Explicit_Problem(rhs,self.A0,self.tinit) #model.jac = jacobian model.jacv = jacv sim = CVode(model,**kwargs) sim.atol = 1e-3 sim.rtol = 1e-3 sim.linear_solver = 'SPGMR' sim.maxord = 3 #sim.usejac = True #sim = RungeKutta34(model,**kwargs) time_span, ODE_solution = sim.simulate(self.tfinal) A_ode = ODE_solution.transpose() # Hamiltonian self.Nt = A_ode.shape[1] self.tspan = np.array(time_span) Ham_ode = np.zeros(self.Nt) for k in range(self.Nt): #Ham_ode[k] = 1/2 * A_ode[:,k] @ self.M @ self.Q @ A_ode[:,k] Ham_ode[k] = 1/2 * self.my_mult(A_ode[:,k].T, \ self.my_mult(self.M, self.my_mult(self.Q, A_ode[:,k]))) # Get q variables Aq_ode = A_ode[:self.Nq,:] # Get p variables Ap_ode = A_ode[self.Nq:,:] # Get Deformation Rho = np.zeros(self.Np) for i in range(self.Np): Rho[i] = self.rho(self.coord_p[i]) W_ode = np.zeros((self.Np,self.Nt)) theta = .5 for k in range(self.Nt-1): W_ode[:,k+1] = W_ode[:,k] + self.dt * 1/Rho[:] * ( theta * Ap_ode[:,k+1] + (1-theta) * Ap_ode[:,k] ) self.Ham_ode = Ham_ode return Aq_ode, Ap_ode, Ham_ode, W_ode, np.array(time_span)
def integration_assimulo(self, **kwargs): """ Perform time integration for ODEs with the assimulo package """ assert self.set_time_setting == 1, 'Time discretization must be specified first' if self.tclose > 0: close = True else: close = False # Control vector self.U = interpolate(self.boundary_cntrl_space, self.Vb).vector()[self.bndr_i_b] if self.discontinous_boundary_values == 1: self.U[self.Corner_indices] = self.U[self.Corner_indices]/2 # Definition of the sparse solver for the ODE rhs function to # be defined next my_solver = factorized(csc_matrix(self.Mp_rho_Cv)) C = self.A if self.sparse == 1: my_jac_o = csr_matrix(my_solver(C.toarray())) else: my_jac_o = my_solver(C) # Definition of the rhs function required in assimulo def rhs(t,y): """ Definition of the rhs function required in the ODE part of assimulo """ z = self.my_mult(self.A, y) + self.my_mult(self.Bext,self.U* self.boundary_cntrl_time(t,self.tclose)) return my_solver(z) #z = np.zeros(shape=y.shape[:]) #z[0:self.Np] = self.my_mult(self.Mp, yd[0:self.Np]) - self.my_mult(D, y[self.Np+self.Nq:self.Np+2*self.Nq]) #z[self.Np:self.Np+self.Nq] = self.my_mult(self.Mq, y[self.Np:self.Np+self.Nq]) + self.my_mult(D.T, y[0:self.Np]) - self.my_mult(self.Bp, self.U* self.boundary_cntrl_time(t,self.tclose)) #z[self.Np+self.Nq:self.Np+2*self.Nq] = self.my_mult(self.Mq, y[self.Np+self.Nq:self.Np+2*self.Nq]) - self.my_mult(self.L,y[self.Np:self.Np+self.Nq]) #return z def jacobian(t,y): """ Jacobian related to the ODE formulation """ my_jac = my_jac_o return my_jac def jacv(t,y,fy,v): """ Jacobian matrix-vector product related to the ODE formulation """ return None print('ODE Integration using assimulo built-in functions:') # # https://jmodelica.org/assimulo/_modules/assimulo/examples/cvode_with_preconditioning.html#run_example # model = Explicit_Problem(rhs,self.Tp0,self.tinit) sim = CVode(model,**kwargs) sim.atol = 1e-3 sim.rtol = 1e-3 sim.linear_solver = 'SPGMR' sim.maxord = 3 #sim.usejac = True #sim = RungeKutta34(model,**kwargs) time_span, ODE_solution = sim.simulate(self.tfinal) A_ode = ODE_solution.transpose() # Hamiltonian self.Nt = A_ode.shape[1] self.tspan = np.array(time_span) Ham_ode = np.zeros(self.Nt) for k in range(self.Nt): Ham_ode[k] = 1/2 * self.my_mult(A_ode[:,k].T, \ self.my_mult(self.Mp_rho_Cv, A_ode[:,k])) self.Ham_ode = Ham_ode return Ham_ode, np.array(time_span)