Dear all,
Currently, I'm working on some implicit RungeKutta scheme for an
instationary problem. If "u" is the actual unknown of the problem, my
idea is to add variables "u2" and "u3" (let's say it's a threestage
method for now) to the system and then solve the coupled system for
the updates, temporarily storing them in "u", "u2", and "u3". After
that, I want to compute the new solution, which is given by the old
solution (the "u" component of the System::old_current_solution
vector) plus some multiples of the "u", "u2" and "u3" components of
the System::solution vector. The result should be stored in the "u"
component again.
I did this before for the case of a onestage method (well, there's
nothing particular "RungeKutta" in that case, I know, but the problem
was much handier to assemble for the update than for the new solution)
as follows:
for(i=system.solution>first_local_index(); i<system.solution>last_local_index(); i++)
{
system.solution>add(i,(*system.old_local_solution)(i));
}
system.solution>close();
system.update();
This seemed to work well. Unfortunately, I can't think of a sensible
generalization of this construction to the case of more than one
stage. The point is that I should loop only over those indices that
belong to the "u" variable and then access the corresponding indices
of the "u2" and "u3" variables, but there seems to be no API for that
in libMesh  or did I miss something?
I could use an elementwise loop, but that's also problematic since
most dofs will certainly be processed more than once, resulting in a
wrong update.
Does somebody know a nice solution to this problem?
Best Regards,
Tim

Dr. Tim Kroeger
tim.kroeger@... Phone +494212187710
tim.kroeger@... Fax +494212184236
Fraunhofer MEVIS, Institute for Medical Image Computing
Universitaetsallee 29, 28359 Bremen, Germany
