Minimum step size heuristic for DAEs

[pepijndevos]

I had a chat with the author of https://www.plexim.com/products/plecs/plecs_spice who bombarded me with simulation wisdom that I could sometimes only half follow or remember.

One thing that @oscardssmith thought was worth mentioning here is the following:

He said that conventional wisdom is that for an ODE you can just reduce the step size to make progress through tricky bits, but that a DAE is singular in the limit of step size approaching zero. So if you just keep reducing your step size you're just breaking the equations.

This may be one of those things where spice does things that appear hacky on the surface that actually solve a real problem. By sometimes just ignoring error bounds a little and marching on stuff will eventually converge.

I guess Oscar has some heuristic in mind where you can find an optimal step size to make progress with a stiff DAE.

[oscardssmith]

The hard part here is knowing when to try pushing through vs decreasing the step size (since with DAEs you do need to decrease dt to the point that steps become possible, but you likely don't want to decrease past that point). One option would be to just significantly increase maxiters for singular mass matrices, but it's somewhat hard to know what the optimal strategy here is. @ChrisRackauckas Do you know what IDA does here?

[ChrisRackauckas]

This may be one of those things where spice does things that appear hacky on the surface that actually solve a real problem.

It doesn't, because it just gives you an incorrect solution lol. If we say we're solving for a tolerance, we can't just say "oops, it's not at tolerance but let's just continue anyways". We have mindt and it errors because if it cannot find a dt that works then it fails. We already have a mindt and the ability to turn the error off documented in the kwargs, but we won't default to that because it's literally just accepting that the solution isn't correct and moving forward anyways.

Also, that's only a property of some methods (for example BDF methods) on index-2+ DAEs. It's because BDF methods are not convergent on higher index DAEs. Other methods can converge correctly on high index DAEs. So the proper thing here would be to have a strategy that could go (or rootfind) dt on non-convergent cases... but the better thing to do here is just make it convergent, for example, this is why we suggest index reduction.

[ChrisRackauckas]

@ChrisRackauckas Do you know what IDA does here?

IDA just says you need to give it an index-1 DAE, and it fails on index-2+ DAEs if it tries to converge.

[oscardssmith]

Oh I had missed the part of accepting steps above error tolerance here. The part that seems potentially worthwhile to me is to extend the number of nonlinear iterations instead of rejecting could sometimes be necessary.