Dear deal.ii team,

I am currently at the stage of choosing a transient solver for our 
deal.ii-based software OpenFCST. The solver will be applied to solving 
nonlinear transport and reaction problems. After days of research, I found 
two options:

   1. Variable order, variable step BDF schemes (as seen in LSODA, VODE; 
   they are combined with Adams methods there);
   2. Variable order, variable step implicit Runge-Kutta schemes.

The performance of both in general stiff problems is more or less similar 
with BDF being superior when used with the method of lines. I really like 
the idea of variable order and step implementation of the multistep methods 
(see, for example, this <http://epubs.siam.org/doi/abs/10.1137/0904010> 
work of L. Petzold). They have become a "must-have" for automated ODE 
solvers and are present in Matlab and Python, for example (RK methods are 
present there as well, to be fair). Their high flexibility allows to adapt 
to the stiffness of the problem that may change during time integration. 
This is important in the problems that describe coupled transport and 
reactions, such as the ones in our electrochemical models.


There is, however, one important drawback of the multistep methods 
(including BDF of order 2<k<6 that I am looking at): they require solution 
transfer from more than one previous steps compared to just one in one-step 
methods (Runge-Kutta, theta scheme). Therefore, if the mesh is continuously 
refined/coarsened during the simulation, this will lead to increase in 
computational expenses due to necessity of interpolation of several 
solutions onto the new grid.


I was 100 % sure in which method I was going to choose when I suddenly 
realized that shortcoming of the BDF method. How computationally complex is 
the implementation of the solution transfer in deal.ii? Will it really 
cause significant performance decrease in problems with, for example, rapid 
transients, during which the mesh would be continuously refined/coarsened 
and a higher order BDF scheme would be automatically chosen (the higher the 
order, the more solutions from previous time layers the method requires)? 
If I am not mistaken, IRK would also suffer from this case since, when 
simplified Newton iterations are used, it will require recomputation of m 
Jacobians (m - number of stages in the method) based on the transferred old 
solution. So, my question likely sums up to what will be more expensive 
(assuming particular implementations in deal.ii), to transfer k old 
solutions or to recompute k Jacobians? I do, of course, realize that 
complexity of computing a Jacobian depends on the particular problem. We 
can assume up to five arithmetic operations inside three for loops (for 
quadrature points and (i,j) components) for each cell.


I hope this discussion is not too broad for this message board. I will 
appreciate any help as I am currently unsure in how to proceed.


Regards,
Aslan Kosakian

Graduate Student
Energy Systems Design Laboratory
Department of Mechanical Engineering
University of Alberta
Edmonton, AB, Canada
T6G2G8

-- 
The deal.II project is located at http://www.dealii.org/
For mailing list/forum options, see 
https://groups.google.com/d/forum/dealii?hl=en
--- 
You received this message because you are subscribed to the Google Groups 
"deal.II User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to dealii+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to