Starting BDF iterations - suggestions?

  • Context: Graduate 
  • Thread starter Thread starter maistral
  • Start date Start date
  • Tags Tags
    Suggestions
Click For Summary

Discussion Overview

The discussion revolves around generating initial values for backward differentiation formulas (BDF) when solving ordinary differential equations (ODEs). Participants explore methods for obtaining the required initial point for second-order BDF iterations, considering the implications of using explicit methods versus implicit methods.

Discussion Character

  • Exploratory
  • Technical explanation
  • Debate/contested
  • Mathematical reasoning

Main Points Raised

  • One participant suggests using a standard Runge-Kutta method to generate the initial point, but expresses concern that this may contradict the purpose of using implicit methods to avoid instabilities associated with explicit approaches.
  • Another participant agrees with the concern regarding the use of Runge-Kutta and emphasizes that these issues are typically addressed in textbooks on ODE methods.
  • A later reply mentions that if calculating ##y_{n+2}##, the value of ##y_{n+1}## is already known, implying a potential method for obtaining the necessary initial values.
  • Another participant questions how ##y_{n+1}## can be known if calculating ##y_{n+2}##.
  • One participant introduces the idea of using automatic implicit integration packages, such as the Gear package and Dassl, which start at first order and can switch to higher order based on accuracy criteria, suggesting that these methods may provide the needed initial values.

Areas of Agreement / Disagreement

Participants express differing views on the appropriateness of using explicit methods like Runge-Kutta for generating initial values for BDF. There is no consensus on the best approach, and the discussion remains unresolved regarding the optimal method for generating the required initial point.

Contextual Notes

Participants reference the need for careful consideration of stability and accuracy when selecting methods for generating initial values, highlighting the dependence on the choice of integration technique.

maistral
Messages
235
Reaction score
17
TL;DR
How do I start BDF iterations? Any suggestions?
As we know, backward differentiation formulas for ODE start off with the backward Euler; which proceeds as:
y_{n+1} - y_n = h f(t_{n+1}, y_{n+1})


If I wanted to switch to the second order method;
{\displaystyle y_{n+2}-{\tfrac {4}{3}}y_{n+1}+{\tfrac {1}{3}}y_{n}={\tfrac {2}{3}}hf(t_{n+2},y_{n+2})}


Can anyone recommend me ideas as to how to generate the initially required yn+1? The only thing I can think of are as follows:
  • Use a standard Runge-Kutta to generate the second point, but in my opinion this is somehow futile as the reason why we use implicit methods is to avoid the instabilities which will generated via a standard explicit approach (like Runge-Kutta).
  • Use the backward Euler technique with some microscopic (lol) stepsizes to assure that I am accurate, then I switch to a higher BDF method? Say, I want to propagate a second-order solution with a stepsize of 0.1. Maybe I should generate a backward Euler solution of step 0.001? Or something?
I'm very open to suggestions as I have no idea how to proceed. Any suggestions?
 
Reply
  • Like
Likes   Reactions: Delta2
Physics news on Phys.org
maistral said:
Use a standard Runge-Kutta to generate the second point
This is the usual approach.

maistral said:
, but in my opinion this is somehow futile as the reason why we use implicit methods is to avoid the instabilities which will generated via a standard explicit approach (like Runge-Kutta).
Indeed.

maistral said:
I'm very open to suggestions as I have no idea how to proceed. Any suggestions?
These issues are considered in any good textbook on ODE methods, the 'gold standard' being Lambert Computational Methods in Ordinary Differential Equations or alternatively these excellent lecture notes available online: https://people.maths.ox.ac.uk/suli/nsodes.pdf (see s3.2 et seq).
 
Last edited:
Reply
  • Like
Likes   Reactions: Delta2, jim mcnamara, maistral and 1 other person
Oh! Thank you very much.
 
Reply
  • Like
Likes   Reactions: Delta2
If you are calculating ##y_{n+2}##, you already know ##y_{n+1}##.
 
Chestermiller said:
If you are calculating ##y_{n+2}##, you already know ##y_{n+1}##.
How?
 
pbuk said:
How?
Automatic implicit integration packages like the Gear package (available from IMSL)and Dassl (available for free online) feature automatic control over step size, order, and accuracy. These all start out at first order, and switch to higher order according to their accuracy criteria. So, once you get to 2nd order, you already know the solution values from the two previously executed integration steps.

https://www.osti.gov/servlets/purl/5882821/
 

Similar threads

Graduate Backward Euler technique vs. periodic function: Damping out?
  • · Replies 7 ·
Replies
7
Views
3K
Graduate Runge Kutta finite difference of differential equations
  • · Replies 6 ·
Replies
6
Views
3K
Undergrad Runge-Kutta 4 w/ some sugar on the top: How to do error approximation?
  • · Replies 65 ·
3
Replies
65
Views
8K
Graduate Spectral Theorem to Convert PDE into ODE
  • · Replies 2 ·
Replies
2
Views
3K
Graduate Runge-Kutta: Maintaining Units in Numerical Methods
  • · Replies 16 ·
Replies
16
Views
4K
Undergrad Connection between numerical integration and solving ODE numerically.
  • · Replies 3 ·
Replies
3
Views
3K
Graduate Computing first derivative based on second derivative
  • · Replies 2 ·
Replies
2
Views
2K
Graduate How to improve stabilities of numerical solutions of PDEs
  • · Replies 3 ·
Replies
3
Views
2K
Graduate Nonlinear Wave Equation (Nonlinear Helmholtz)
  • · Replies 1 ·
Replies
1
Views
2K
Graduate Should This System Settle? - Discrepancy in MathCad Solving Methods
  • · Replies 2 ·
Replies
2
Views
2K