As some of you may know, I am now working at NASA's Johnson Space Center
doing CFD for hypersonic aerodynamic applications. The network setup is a
little backwards around here, so it will be a couple of days before I can
check in/out at work. For some reason they restrict where I ssh.
Anyway, I checked in a lot of changes last week when I got back from North
Carolina. Now, most of these were trivial (changing Copyright 2002-2003 to
2002-2004) and don't warrant discussing, but the new solver stuff is a
little more interesting.
The basic idea is this:
1.) Each simulation will have one EquationSystems class. This can contain
multiple Systems of various types.
(It might be worth making the EquationSystems a singleton?)
2.) Calling EquationSystems::solve() simply calls solve on each of the
systems contained in it. This goes for init(), reinit(), etc... Therefore
the EquationSystems interface is quite similar to that of each individual
system.
3.) The new interface maintains backward compatibility. However, we can now
do some more interesting stuff, too. In the past, all systems got a matrix,
which is super-stupid and wasteful for field data or post-processed
quantities. Now the idea is that something like this will work:
EquationSystems es(mesh);
es.add_system<ImplicitSystem> ("S1"); // Create a
standard implicit system. solve() solves Ku=f
es.add_system<Nonlinear<ImplicitSystem> > ("S2"); // Create a nonlinear
implicit system. solve() solves K(u)u=f(u)
es.add_system<ExplicitSystem> ("S3"); // An explicit
system, no matrix.
4.) Now, the solvers can operate on an individual system *or* the entire
EquationSystems. Above "Nonlinear<>" is a solver acting on an individual
system. But consider this example:
Transient<> solver (es);
solver.solve();
Here "Transient<>" is a solver acting on an entire EquationSystems object.
In this case, the solver will execute a timestep loop and call es.solve() at
each time step. Now, suppose instead I want a transient loop with
adaptivity at each time step?
No problem:
Transient<Adaptive<> > solver(es);
solver.solve();
Oh, what about a transient loop with adaptivity at each timestep, and a
nonlinear loop inside each adaptive loop? Well,
Transient<Adaptive<Nonlinear<> > > solver(es);
...
-------------------------------------------
This is where it is all going. The interface needs a little more work...
The user should be able to add pre and post-processing functions that get
called at specified increments to do things like write the solution at each
time step, etc... I just wanted to check this in so that we can get more
people interested in it.
Steffen: I think that in this framework we can easily add an EigenSolver,
and then have:
Eigen<> solver (es);
solver.solve();
-Ben
|