def __init__(self, problem, tag, *args, **kwargs):
self.problem = problem
self.tag = tag
opts = PETSc.Options()
# Timestepping solver
self.ts = PETSc.TS().create()
self.ts_its = 0
ts = self.ts
ts.setIFunction(problem.evalFunction, problem.b_petsc)
ts.setIJacobian(problem.evalJacobian, problem.A_petsc)
ts.setSolution(problem.xx)
ts.computeIFunction(0.0, problem.xx, problem.xxdot, problem.b_petsc)
ts.computeIJacobian(0.0, problem.xx, problem.xxdot, 1.0,
problem.A_petsc)
ts.setMonitor(TSMonitor(self))
# Nonlinear solver
self.snes = ts.getSNES()
self.snes_its = 0
self.snes.setMonitor(SNESMonitor(self))
# Linear solver
self.ksp = self.snes.getKSP()
self.ksp_its = 0
self.ksp.setMonitor(KSPMonitor(self))
# and preconditioner
self.pc = self.ksp.getPC()
def run_test(nx, ny, nz, samples, plot=False):
ts = PETSc.TS().create()
ts.setType('theta')
ts.setTheta(1.0)
ts.setTimeStep(0.01)
ts.setTime(0.0)
ts.setMaxTime(1.0)
ts.setMaxSteps(10)
eft = PETSc.TS.ExactFinalTime.STEPOVER
ts.setExactFinalTime(eft)
x = PETSc.Vec().createSeq(nx * ny * nz)
ts.setSolution(x)
app = AppCtx(nx, ny, nz)
f = PETSc.Vec().createSeq(nx * ny * nz)
ts.setIFunction(app.formFunction, f)
ts.snes.setUseMF(1)
ts.snes.ksp.setType('cg')
ts.setFromOptions()
ts.setUp()
wt = 1e300
for i in range(samples):
app.formInitial(0, x)
t1 = PETSc.Log.getTime()
ts.solve(x)
t2 = PETSc.Log.getTime()
wt = min(wt, t2 - t1)
if plot and pylab:
app.plot(ts.time, x)
return wt
def setUp(self):
self.ts = PETSc.TS()
self.ts.createPython(MyTS(), comm=PETSc.COMM_SELF)
ctx = self.ts.getPythonContext()
self.assertEqual(getrefcount(ctx), 3)
self.assertEqual(ctx.log['create'], 1)
self.nsolve = 0
def setUp(self):
self.ts = PETSc.TS().create(PETSc.COMM_SELF)
ptype = PETSc.TS.ProblemType.NONLINEAR
self.ts.setProblemType(ptype)
self.ts.setType(self.TYPE)
if PETSc.ScalarType().dtype.char in 'fF':
snes = self.ts.getSNES()
snes.setTolerances(rtol=1e-6)
def help(args=None):
import sys, shlex
# program name
try:
prog = sys.argv[0]
except Exception:
prog = getattr(sys, 'executable', 'python')
# arguments
if args is None:
args = sys.argv[1:]
elif isinstance(args, str):
args = shlex.split(args)
else:
args = [str(a) for a in args]
# import and initialize
import petsc4py
petsc4py.init([prog, '-help'] + args)
from petsc4py import PETSc
# help dispatcher
COMM = PETSc.COMM_SELF
if 'vec' in args:
vec = PETSc.Vec().create(comm=COMM)
vec.setSizes(0)
vec.setFromOptions()
vec.destroy()
if 'mat' in args:
mat = PETSc.Mat().create(comm=COMM)
mat.setSizes([0, 0])
mat.setFromOptions()
mat.destroy()
if 'pc' in args:
pc = PETSc.PC().create(comm=COMM)
pc.setFromOptions()
pc.destroy()
if 'ksp' in args:
ksp = PETSc.KSP().create(comm=COMM)
ksp.setFromOptions()
ksp.destroy()
if 'snes' in args:
snes = PETSc.SNES().create(comm=COMM)
snes.setFromOptions()
snes.destroy()
if 'ts' in args:
ts = PETSc.TS().create(comm=COMM)
ts.setFromOptions()
ts.destroy()
if 'tao' in args:
tao = PETSc.TAO().create(comm=COMM)
tao.setFromOptions()
tao.destroy()
if 'dmda' in args:
dmda = PETSc.DMDA().create(comm=COMM)
dmda.setFromOptions()
dmda.destroy()
if 'dmplex' in args:
dmplex = PETSc.DMPlex().create(comm=COMM)
dmplex.setFromOptions()
dmplex.destroy()
def setUp(self):
self.ts = PETSc.TS()
self.ts.createPython(MyTS(), comm=PETSc.COMM_SELF)
eft = PETSc.TS.ExactFinalTime.STEPOVER
self.ts.setExactFinalTime(eft)
ctx = self.ts.getPythonContext()
self.assertEqual(getrefcount(ctx), 3)
self.assertEqual(ctx.log['create'], 1)
self.nsolve = 0
def __init__(self,
problem,
solution,
solution_dot,
solution_dot_dot=None):
self.problem = problem
self.solution = solution
self.solution_dot = solution_dot
self.solution_dot_dot = solution_dot_dot
# Create PETSc's TS object
self.ts = PETSc.TS().create(wrapping.get_mpi_comm(solution))
# ... and associate residual and jacobian
assert problem.time_order in (1, 2)
if problem.time_order == 1:
self.ts.setIFunction(
problem.residual_vector_eval,
wrapping.to_petsc4py(problem.residual_vector))
self.ts.setIJacobian(
problem.jacobian_matrix_eval,
wrapping.to_petsc4py(problem.jacobian_matrix))
elif problem.time_order == 2:
self.ts.setI2Function(
problem.residual_vector_eval,
wrapping.to_petsc4py(problem.residual_vector))
self.ts.setI2Jacobian(
problem.jacobian_matrix_eval,
wrapping.to_petsc4py(problem.jacobian_matrix))
else:
raise ValueError(
"Invalid time order in PETScTSIntegrator.__init__().")
# ... and monitor
self.ts.setMonitor(problem.monitor)
# Set sensible default values to parameters
default_parameters = {
"exact_final_time": "stepover",
"integrator_type": "beuler",
"problem_type": "linear",
"report": True
}
self.set_parameters(default_parameters)
# TODO since PETSc 3.8 TSAlpha2 is not working properly in the linear case without attaching a fake monitor
if self.problem.time_order == 2:
def monitor(snes, it, fgnorm):
pass
self.ts.getSNES().setMonitor(monitor)
def help(args=None):
import sys, shlex
# program name
try:
prog = sys.argv[0]
except Exception:
prog = getattr(sys, 'executable', 'python')
if args is None:
args = sys.argv[1:]
elif isinstance(args, str):
args = shlex.split(args)
else:
args = [str(a) for a in args]
import petsc4py
petsc4py.init([prog, '-help'] + args)
from petsc4py import PETSc
COMM = PETSc.COMM_SELF
if 'vec' in args:
vec = PETSc.Vec().create(comm=COMM)
vec.setSizes(0)
vec.setFromOptions()
del vec
if 'mat' in args:
mat = PETSc.Mat().create(comm=COMM)
mat.setSizes([0, 0])
mat.setFromOptions()
del mat
if 'ksp' in args:
ksp = PETSc.KSP().create(comm=COMM)
ksp.setFromOptions()
del ksp
if 'pc' in args:
pc = PETSc.PC().create(comm=COMM)
pc.setFromOptions()
del pc
if 'snes' in args:
snes = PETSc.SNES().create(comm=COMM)
snes.setFromOptions()
del snes
if 'ts' in args:
ts = PETSc.TS().create(comm=COMM)
ts.setFromOptions()
del ts
if 'da' in args:
da = PETSc.DA().create(comm=COMM)
da.setFromOptions()
del da
def __init__(self, problem, solution, solution_dot):
self.solution = solution
self.solution_dot = solution_dot
# Create PETSc's TS object
self.ts = PETSc.TS().create(wrapping.get_mpi_comm(solution))
# ... and associate residual and jacobian
self.ts.setIFunction(problem.residual_vector_eval, wrapping.to_petsc4py(problem.residual_vector))
self.ts.setIJacobian(problem.jacobian_matrix_eval, wrapping.to_petsc4py(problem.jacobian_matrix))
self.monitor = _Monitor(self.ts)
self.ts.setMonitor(self.monitor)
# Set sensible default values to parameters
default_parameters = {
"exact_final_time": "stepover",
"integrator_type": "beuler",
"problem_type": "linear",
"report": True
}
self.set_parameters(default_parameters)
def __init__(self, problem, solution, solution_dot):
self.solution = solution
self.solution_dot = solution_dot
# Create PETSc's TS object
self.ts = PETSc.TS().create(
solution.block_function_space().mesh().mpi_comm())
# ... and associate residual and jacobian
self.ts.setIFunction(problem.residual_vector_eval,
as_backend_type(problem.residual_vector).vec())
self.ts.setIJacobian(problem.jacobian_matrix_eval,
as_backend_type(problem.jacobian_matrix).mat())
self.monitor = _Monitor(self.ts)
self.ts.setMonitor(self.monitor)
# Set sensible default values to parameters
default_parameters = {
"exact_final_time": "stepover",
"integrator_type": "beuler",
"problem_type": "linear",
"report": True
}
self.set_parameters(default_parameters)
def acoustics(kernel_language='Python',
petscPlot=False,
iplot=False,
htmlplot=False,
myplot=False,
outdir='./_output',
sclaw=False,
**kwargs):
import numpy as np
"""
1D acoustics example.
"""
from petclaw.patch import Patch
from petclaw.patch import Dimension
from pyclaw.solution import Solution
from pyclaw.controller import Controller
from petclaw import plot
petscts = kwargs.get('petscts', False)
# Initialize patch and solution
xmin = 0.0
xmax = 1.0
ncells = kwargs.get('ncells', 100)
x = Dimension('x', xmin, xmax, ncells, bc_lower=2, bc_upper=2)
patch = Patch(x)
rho = 1.0
bulk = 1.0
patch.problem_data['rho'] = rho
patch.problem_data['bulk'] = bulk
patch.problem_data['zz'] = np.sqrt(rho * bulk)
patch.problem_data['cc'] = np.sqrt(rho / bulk)
from classic1 import cparam
for key, value in patch.problem_data.iteritems():
setattr(cparam, key, value)
patch.num_eqn = 2
if sclaw:
patch.num_ghost = 3
patch.t = 0.0
# init_q_petsc_structures must be called
# before patch.x.centers and such can be accessed.
patch.init_q_petsc_structures()
xc = patch.x.centers
q = np.zeros([patch.num_eqn, len(xc)], order='F')
beta = 100
gamma = 0
x0 = 0.75
q[0, :] = np.exp(-beta * (xc - x0)**2) * np.cos(gamma * (xc - x0))
q[1, :] = 0.
patch.q = q
init_solution = Solution(patch)
if sclaw:
from petclaw.sharpclaw import SharpClawSolver1D
solver = SharpClawSolver1D()
solver.lim_type = kwargs.get('lim_type', 2)
solver.time_integrator = 'SSP33'
solver.num_waves = 2
solver.char_decomp = 0
else:
from petclaw.clawpack import ClawSolver1D
solver = ClawSolver1D()
solver.num_waves = 2
from pyclaw import limiters
solver.mthlim = limiters.tvd.MC
if kernel_language == 'Python': solver.set_riemann_solver('acoustics')
solver.dt = patch.delta[0] / patch.problem_data['cc'] * 0.1
solver.kernel_language = kernel_language
claw = Controller()
#claw.output_style = 3
claw.keep_copy = True
claw.num_output_times = 5
# The output format MUST be set to petsc!
claw.output_format = 'ascii'
claw.outdir = outdir
claw.tfinal = 1.0
claw.solution = init_solution
claw.solver = solver
# Solve
if petscts:
# Uses PETSc time integrator. Needs sclaw=1 to get semidiscrete form. Examples:
# ./acoustics.py sclaw=1 petscts=1 -ts_monitor_solution -ts_type theta -snes_mf_operator -ts_dt 0.02 -ts_max_steps 50 -ts_max_time 10 -draw_pause 0.05
# ./acoustics.py sclaw=1 petscts=1 -ts_monitor_solution -ts_type ssp -ts_ssp_type rk104
x = patch.q_da.createGlobalVector()
f = x.duplicate()
ts = PETSc.TS().create(PETSc.COMM_WORLD)
ts.setDM(patch.q_da)
ts.setProblemType(PETSc.TS.ProblemType.NONLINEAR)
ts.setType(ts.Type.THETA)
eqn = AcousticEquation(patch, solver)
x[:] = patch.q
ts.setRHSFunction(eqn.rhsfunction, f)
ts.setIFunction(eqn.ifunction, f)
ts.setIJacobian(eqn.ijacobian, patch.q_da.createMat())
ts.setTimeStep(solver.dt)
ts.setDuration(claw.tfinal, max_steps=1000)
ts.setFromOptions()
q0 = x[:].copy()
ts.solve(x)
qfinal = x[:].copy()
dx = patch.delta[0]
else:
status = claw.run()
#This test is set up so that the waves pass through the domain
#exactly once, and the final solution should be equal to the
#initial condition. Here we output the 1-norm of their difference.
q0 = claw.frames[0].patch.gqVec.getArray().reshape([-1])
qfinal = claw.frames[
claw.num_output_times].patch.gqVec.getArray().reshape([-1])
dx = claw.frames[0].patch.delta[0]
if htmlplot: plot.html_plot(outdir=outdir, format=output_format)
if iplot: plot.interactive_plot(outdir=outdir, format=output_format)
if petscPlot: plot.plotPetsc(output_object)
print 'Max error:', np.max(qfinal - q0)
return dx * np.sum(np.abs(qfinal - q0))
x = numpy.arange(self.N) / self.N
for i,t,u in self.history:
pylab.plot(x, u, label='step=%d t=%8.2g'%(i,t))
pylab.xlabel('$x$')
pylab.ylabel('$u$')
pylab.legend(loc='upper right')
pylab.savefig('heat-history.png')
#pylab.show()
OptDB = PETSc.Options()
ode = Heat(MPI.COMM_WORLD, OptDB.getInt('n',100))
x = ode.gvec.duplicate()
f = ode.gvec.duplicate()
ts = PETSc.TS().create(comm=ode.comm)
ts.setType(ts.Type.ROSW) # Rosenbrock-W. ARKIMEX is a nonlinearly implicit alternative.
ts.setIFunction(ode.evalFunction, ode.gvec)
ts.setIJacobian(ode.evalJacobian, ode.mat)
ts.setMonitor(ode.monitor)
ts.setTime(0.0)
ts.setTimeStep(ode.h**2)
ts.setMaxTime(1)
ts.setMaxSteps(100)
ts.setExactFinalTime(PETSc.TS.ExactFinalTime.INTERPOLATE)
ts.setMaxSNESFailures(-1) # allow an unlimited number of failures (step will be rejected and retried)
snes = ts.getSNES() # Nonlinear solver
P.setValues([mx - 1], [mx - 1], 1.0 / hx)
lxe -= 1
for i in range(lxs, lxe):
P.setValues([i], [i - 1, i, i + 1], [
-1.0 / hx, 2.0 / hx - hx * math.exp(xx[i - gxs]) + shift,
-1.0 / hx
])
P.assemble()
return True # same_nz
M = PETSc.Options().getInt('M', 9)
da = PETSc.DA().create([M], comm=PETSc.COMM_WORLD)
f = da.createGlobalVector()
x = f.duplicate()
J = da.getMatrix(PETSc.Mat.Type.AIJ)
ts = PETSc.TS().create(PETSc.COMM_WORLD)
ts.setProblemType(PETSc.TS.ProblemType.NONLINEAR)
ts.setType(ts.Type.GL)
ode = MyODE(da)
ts.setIFunction(ode.function, f)
ts.setIJacobian(ode.jacobian, J)
ts.setTimeStep(0.1)
ts.setDuration(10, 1.0)
ts.setFromOptions()
x.set(1.0)
ts.solve(x)
xa[i] = (1 + (2**(self.nu / 2.0) - 1) *
np.exp(-self.nu / 2.0 * sig1 *
(-50 +
(i + 1) * self.dx + 2 * lam1 * t)))**(-2.0 /
self.nu)
da = PETSc.DMDA().create([2049], dof=1, stencil_width=1)
OptDB = PETSc.Options()
ode = Fisher_split(da=da)
x = ode.gvec.duplicate()
f = ode.gvec.duplicate()
ts = PETSc.TS().create(comm=MPI.COMM_WORLD)
ts.setType(ts.Type.ARKIMEXARS443
) # Rosenbrock-W. ARKIMEX is a nonlinearly implicit alternative.
# ts.setRKType('3bs')
ts.setIFunction(ode.formFunction, ode.gvec)
ts.setIJacobian(ode.formJacobian, ode.mat)
ts.setRHSFunction(ode.formRHS, ode.rhs)
# ts.setMonitor(ode.monitor)
ts.setTime(0.0)
ts.setTimeStep(0.25)
ts.setMaxTime(1.0)
ts.setMaxSteps(100)
ts.setExactFinalTime(PETSc.TS.ExactFinalTime.INTERPOLATE)
opt = {'M': MBlock, 'm': 4, 'd': 3}
surface = Sphere()
band = Band(surface, comm, opt)
la, lv, gv, wv = band.createGLVectors()
v = band.getCoordinates()
vv = sp.array([[1, 0, 0], [-1, 0, 0], [0, 1, 0], [0, -1, 0], [0, 0, 1],
[0, 0, -1]])
weights = sp.array([1, 1, 1, 1, 1, 1]) * (1 / band.dx**2)
L = band.createAnyMat(vv, weights, (7, 3))
PETSc.Sys.Print('Laplacian')
M = band.createExtensionMat()
PETSc.Sys.Print('ExtensionMat built')
ts = PETSc.TS().create(comm=comm)
ts.setProblemType(ts.ProblemType.LINEAR)
ts.setType(ts.Type.BEULER)
PETSc.Sys.Print('ML creating')
LM = M.matMult(L)
I = PETSc.Mat().create(comm=comm)
I.setSizes((gv.sizes, gv.sizes))
I.setFromOptions()
I.setPreallocationNNZ(1)
wv.set(1)
I.setDiagonal(wv)
I.assemble()
m = OptDB.getInt('m', PETSc.DECIDE)
n = OptDB.getInt('n', PETSc.DECIDE)
p = OptDB.getInt('p', PETSc.DECIDE)
dm = PETSc.DMDA().create(dim=3, sizes=(M, N, P), proc_sizes=(m, n, p),
boundary_type=(bx, by, bz), stencil_type=stype,
stencil_width=1, dof=1, comm=comm, setup=False)
dm.setFromOptions()
dm.setUp()
convdiff_problem = convection_diffusion(dm, {"dx": 0.1, "dy": 0.1, "dz": 0.1})
# prepare the initial conditions
rhs = dm.createGlobalVector()
# go do fun things with Poisson
# set up the SNES context
ts = PETSc.TS().create()
ts.setDM(dm)
ts.setRHSFunction(convdiff_problem.rhs, rhs)
ts.setDuration(100, 1.e10)
# --------------------------------------------------------------------------------
# finish the TS setup
# --------------------------------------------------------------------------------
# set any -ts commend-line options (including those we checked above)
ts.setFromOptions()
# create an initial guess
field = dm.createGlobalVector()
convdiff_problem.create_initial_guess(field)
# have fun (and measure how long fun takes)
def transient_pipe_flow_1D(
npipes, nx, dof, nphases,
pipe_length,
initial_time,
final_time,
initial_time_step,
dt_min,
dt_max,
initial_solution,
impl_python=False
):
# Time Stepper (TS) for ODE and DAE
# DAE - https://en.wikipedia.org/wiki/Differential_algebraic_equation
# https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/
ts = PETSc.TS().create()
#ts.createPython(MyTS(), comm=PETSc.COMM_SELF)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/DM/index.html
pipes = []
for i in range(npipes):
boundary_type = PETSc.DMDA.BoundaryType.GHOSTED
da = PETSc.DMDA().create([nx], dof=dof, stencil_width=1, stencil_type='star', boundary_type=boundary_type)
da.setFromOptions()
pipes.append(da)
# Create a redundant DM, there is no petsc4py interface (yet)
# so we created our own wrapper
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/DM/DMREDUNDANT.html
# dmredundant = PETSc.DM().create()
# dmredundant.setType(dmredundant.Type.REDUNDANT)
# CompositeSimple1D.redundantSetSize(dmredundant, 0, dof)
# dmredundant.setDimension(1)
# dmredundant.setUp()
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/DM/DMCOMPOSITE.html
dm = PETSc.DMComposite().create()
for pipe in pipes:
dm.addDM(pipe)
# dm.addDM(dmredundant)
# CompositeSimple1D.compositeSetCoupling(dm)
CompositeSimple1D.registerNewSNES()
ts.setDM(dm)
F = dm.createGlobalVec()
if impl_python:
α0 = initial_solution.reshape((nx,dof))[:, nphases:-1]
pde = Flow(dm, nx, dof, pipe_length, nphases, α0)
ts.setIFunction(pde.evalFunction, F)
else:
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetIFunction.html
assert False, 'C function not implemented yet!'
# ts.setIFunction(CompositeSimple1D.formFunction, F,
# args=(conductivity, source_term, wall_length, temperature_presc))
snes = ts.getSNES()
snes.setUpdate(pde.updateFunction)
x = dm.createGlobalVec()
x[...] = initial_solution
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetDuration.html
ts.setDuration(max_time=final_time, max_steps=None)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetInitialTimeStep.html
ts.setInitialTimeStep(initial_time=initial_time, initial_time_step=initial_time_step)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetProblemType.html
ts.setProblemType(ts.ProblemType.NONLINEAR)
ts.setEquationType(ts.EquationType.IMPLICIT)
prev_sol = initial_solution.copy()
# restart = PreStep(prev_sol)
# ts.setPreStep(restart.prestep)
# ts.setPostStep(restart.poststep)
options = PETSc.Options()
options.setValue('-ts_adapt_dt_min', dt_min)
options.setValue('-ts_adapt_dt_max', dt_max)
ts.setFromOptions()
snes = ts.getSNES()
if options.getString('snes_type') in [snes.Type.VINEWTONRSLS, snes.Type.VINEWTONSSLS]:
# if True:
# snesvi = snes.getCompositeSNES(1)
snesvi = snes
xl = np.zeros((nx, dof))
xl[:,:nphases] = -100
xl[:,-1] = 0
xl[:, nphases:-1] = 0
xu = np.zeros((nx, dof))
xu[:,:nphases] = 100
xu[:,-1] = 1000
xu[:, nphases:-1] = 1
xlVec = dm.createGlobalVec()
xuVec = dm.createGlobalVec()
xlVec.setArray(xl.flatten())
xuVec.setArray(xu.flatten())
snesvi.setVariableBounds(xlVec, xuVec)
ts.solve(x)
# while ts.diverged:
# x[...] = prev_sol.copy()
# ts.setInitialTimeStep(initial_time=initial_time, initial_time_step=0.5*initial_time_step)
# ts.solve(x)
final_dt = ts.getTimeStep()
return x, final_dt
def transient_heat_transfer_1D(
npipes, nx,
initial_temperature,
temperature_presc,
conductivity,
source_term,
wall_length,
final_time,
initial_time_step,
impl_python=False
):
# Time Stepper (TS) for ODE and DAE
# DAE - https://en.wikipedia.org/wiki/Differential_algebraic_equation
# https://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/
ts = PETSc.TS().create()
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/DM/index.html
#
pipes = []
for i in range(npipes):
pipes.append(PETSc.DMDA().create([nx],dof=1, stencil_width=1, stencil_type='star'))
# Create a redundant DM, there is no petsc4py interface (yet)
# so we created our own wrapper
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/DM/DMREDUNDANT.html
dmredundant = PETSc.DM().create()
dmredundant.setType(dmredundant.Type.REDUNDANT)
HeatTransfer1D.redundantSetSize(dmredundant, 0, 1)
dmredundant.setDimension(1)
dmredundant.setUp()
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/DM/DMCOMPOSITE.html
dm = PETSc.DMComposite().create()
for pipe in pipes:
dm.addDM(pipe)
dm.addDM(dmredundant)
HeatTransfer1D.compositeSetCoupling(dm)
ts.setDM(dm)
F = dm.createGlobalVec()
if impl_python:
ode = Heat(dm, temperature_presc, conductivity, source_term, wall_length)
ts.setIFunction(ode.evalFunction, F)
else:
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetIFunction.html
ts.setIFunction(HeatTransfer1D.formFunction, F,
args=(conductivity, source_term, wall_length, temperature_presc))
x = dm.createGlobalVec()
x[...] = initial_temperature
#HeatTransfer1D.formInitGuess(x, dm, initial_temperature)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetDuration.html
ts.setDuration(max_time=final_time, max_steps=None)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetExactFinalTime.html
ts.setExactFinalTime(ts.ExactFinalTimeOption.STEPOVER)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetInitialTimeStep.html
ts.setInitialTimeStep(initial_time=0.0, initial_time_step=initial_time_step)
# http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSSetProblemType.html
ts.setProblemType(ts.ProblemType.NONLINEAR)
# Another way to set the solve type is through PETSc.Options()
#ts.setType(ts.Type.CRANK_NICOLSON)
#ts.setType(ts.Type.THETA)
#ts.setTheta(theta=0.9999)
#ts.setType(ts.Type.EIMEX) # http://www.mcs.anl.gov/petsc/petsc-current/docs/manualpages/TS/TSEIMEX.html
#ts.setType(ts.Type.BDF )
ts.setFromOptions()
ts.solve(x)
return x
