You can subscribe to this list here.
2003 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(2) 
_{Oct}
(2) 
_{Nov}
(27) 
_{Dec}
(31) 

2004 
_{Jan}
(6) 
_{Feb}
(15) 
_{Mar}
(33) 
_{Apr}
(10) 
_{May}
(46) 
_{Jun}
(11) 
_{Jul}
(21) 
_{Aug}
(15) 
_{Sep}
(13) 
_{Oct}
(23) 
_{Nov}
(1) 
_{Dec}
(8) 
2005 
_{Jan}
(27) 
_{Feb}
(57) 
_{Mar}
(86) 
_{Apr}
(23) 
_{May}
(37) 
_{Jun}
(34) 
_{Jul}
(24) 
_{Aug}
(17) 
_{Sep}
(50) 
_{Oct}
(24) 
_{Nov}
(10) 
_{Dec}
(60) 
2006 
_{Jan}
(47) 
_{Feb}
(46) 
_{Mar}
(127) 
_{Apr}
(19) 
_{May}
(26) 
_{Jun}
(62) 
_{Jul}
(47) 
_{Aug}
(51) 
_{Sep}
(61) 
_{Oct}
(42) 
_{Nov}
(50) 
_{Dec}
(33) 
2007 
_{Jan}
(60) 
_{Feb}
(55) 
_{Mar}
(77) 
_{Apr}
(102) 
_{May}
(82) 
_{Jun}
(102) 
_{Jul}
(169) 
_{Aug}
(117) 
_{Sep}
(80) 
_{Oct}
(37) 
_{Nov}
(51) 
_{Dec}
(43) 
2008 
_{Jan}
(71) 
_{Feb}
(94) 
_{Mar}
(98) 
_{Apr}
(125) 
_{May}
(54) 
_{Jun}
(119) 
_{Jul}
(60) 
_{Aug}
(111) 
_{Sep}
(118) 
_{Oct}
(125) 
_{Nov}
(119) 
_{Dec}
(94) 
2009 
_{Jan}
(109) 
_{Feb}
(38) 
_{Mar}
(93) 
_{Apr}
(88) 
_{May}
(29) 
_{Jun}
(57) 
_{Jul}
(53) 
_{Aug}
(48) 
_{Sep}
(68) 
_{Oct}
(151) 
_{Nov}
(23) 
_{Dec}
(35) 
2010 
_{Jan}
(84) 
_{Feb}
(60) 
_{Mar}
(184) 
_{Apr}
(112) 
_{May}
(60) 
_{Jun}
(90) 
_{Jul}
(23) 
_{Aug}
(70) 
_{Sep}
(119) 
_{Oct}
(27) 
_{Nov}
(47) 
_{Dec}
(54) 
2011 
_{Jan}
(22) 
_{Feb}
(19) 
_{Mar}
(92) 
_{Apr}
(93) 
_{May}
(35) 
_{Jun}
(91) 
_{Jul}
(32) 
_{Aug}
(61) 
_{Sep}
(7) 
_{Oct}
(69) 
_{Nov}
(81) 
_{Dec}
(23) 
2012 
_{Jan}
(64) 
_{Feb}
(95) 
_{Mar}
(35) 
_{Apr}
(36) 
_{May}
(63) 
_{Jun}
(98) 
_{Jul}
(70) 
_{Aug}
(171) 
_{Sep}
(149) 
_{Oct}
(64) 
_{Nov}
(67) 
_{Dec}
(126) 
2013 
_{Jan}
(108) 
_{Feb}
(104) 
_{Mar}
(171) 
_{Apr}
(133) 
_{May}
(108) 
_{Jun}
(100) 
_{Jul}
(93) 
_{Aug}
(126) 
_{Sep}
(74) 
_{Oct}
(59) 
_{Nov}
(145) 
_{Dec}
(93) 
2014 
_{Jan}
(38) 
_{Feb}
(45) 
_{Mar}
(26) 
_{Apr}
(41) 
_{May}
(125) 
_{Jun}
(70) 
_{Jul}
(61) 
_{Aug}
(66) 
_{Sep}
(60) 
_{Oct}
(110) 
_{Nov}
(27) 
_{Dec}
(30) 
2015 
_{Jan}
(43) 
_{Feb}
(67) 
_{Mar}
(71) 
_{Apr}
(92) 
_{May}
(39) 
_{Jun}
(15) 
_{Jul}
(46) 
_{Aug}
(63) 
_{Sep}
(84) 
_{Oct}
(82) 
_{Nov}
(69) 
_{Dec}
(45) 
2016 
_{Jan}
(92) 
_{Feb}
(91) 
_{Mar}
(148) 
_{Apr}
(43) 
_{May}
(58) 
_{Jun}
(117) 
_{Jul}
(92) 
_{Aug}
(140) 
_{Sep}
(49) 
_{Oct}
(33) 
_{Nov}
(85) 
_{Dec}
(40) 
2017 
_{Jan}
(41) 
_{Feb}
(36) 
_{Mar}
(49) 
_{Apr}
(41) 
_{May}
(64) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 





1

2

3

4

5
(2) 
6

7

8
(1) 
9
(1) 
10
(1) 
11

12
(8) 
13
(5) 
14
(3) 
15

16
(5) 
17

18

19
(5) 
20
(3) 
21

22

23

24

25

26

27

28
(4) 
29
(5) 
30
(10) 
31
(1) 
From: Roy Stogner <roy@st...>  20080519 21:36:48

On Mon, 19 May 2008, Nasser Mohieddin Abukhdeir wrote: > John pointed this out too, all I can say is "oops," what meant to do was take > the error from the last iteration of nonlinear solver which I think makes > sense as an estimate of the LTE. I'm not sure of that, either. The error on your last algebraic nonlinear solver iteration should depend on those solver tolerances, which don't necessarily have anything to do with your time discretization error. > would this be as simple as just adding an additional UnsteadySolver member to > AdaptiveTimeSolver, so for example core_time_solver could be EulerSolver with > theta=1 and (let's call it) aux_time_solver would then be another EulerSolver > with theta=0. At this point we've differed enough from the original AdaptiveTimeSolver design that I'd refactor the class tree. Maybe make AdaptiveTimeSolver a branch class, with one leaf for the current behavior (with what name?) and another for the new PredictorCorrectorTimeSolver. Then you could rename core_time_solver as corrector_time_solver and call aux_time_solver predictor_time_solver, too. > We then just march them in parallel: > > 1) run the explicit scheme using aux_time_solver Right. I'd want the default diff_solver settings for that to be appropriate for linear problems, too; for forward Euler we're just solving a mass matrix. > 2) use the solution from aux_time_solver to seed the implicit scheme > (core_time_solver) and then solve Right. And since the solution is stored with the system, reusing it should be as simple as "doing nothing". ;) > 3) estimate the LTE from the difference of the two solutions and calculate > the new timestep Right. > 4) synchronize the current solution of the explicit solver (to that of the > implicit solution) Again, "doing nothing" (other than the advance_timestep() you'd do anyway). ;) The only catch that comes to mind is that the time solvers are also responsible for initializing old DiffSystem solution vectors. That's no trouble for forward vs backward Euler, but if you wanted to write an AdamsBashforth predictor for CrankNicholson, you'd have to be careful that the former gets used in initialization since it needs to save more old vectors. That's probably a safe rule of thumb: "use the predictor for initialization"; unless someone tries something weird, the corrector solver is always going to need the same or less old information.  Roy 
From: Nasser Mohieddin Abukhdeir <nasser.abukhdeir@mc...>  20080519 20:59:58

Roy Stogner wrote: > > On Mon, 19 May 2008, Nasser Mohieddin Abukhdeir wrote: > >> A while ago I mentioned something about the time stepping algorithm >> employed by AdaptiveTimeSolver as being nonideal for my PDE system. I >> think I have implemented a very simple adaptive time solver based on the >> local truncation error: >> >> core_time_solver>du() / calculate_norm(_system, *_system.solution) > > This isn't the local truncation error; it will be nonzero even if > your solver and system are chosen in such a way that the time > integration error is zero. > John pointed this out too, all I can say is "oops," what meant to do was take the error from the last iteration of nonlinear solver which I think makes sense as an estimate of the LTE. I'll go back to the drawing board for this taking into account your following suggestions (I am currently using an enum and default to the original AdaptiveTimeSolver method). > If this makes any sense for inclusion into LibMesh's >> AdaptiveTimeSolver I can cleanup and provide the code for review. > > That would be great, thanks! We've currently got the global_tolerance > flag for use in choosing between a couple different refinement > heuristics; another boolean would probably be the only interface > change we'd need to add for your method, right? We might want to > refactor that into an enum, a strategy pattern, subclasses, or > something like that eventually, but that's what the untested() macro > is for... > > If you've got time to play around with time solver adaptivity, one > thing on our todo list is predictorcorrector schemes. Pick an > explicit and an implicit scheme of the same order, use the difference > between them to estimate your truncation error, then use the implicit > scheme for your solution at the next time step to keep stability. > That can actually end up being faster than just the implicit scheme > alone, since the explicit result should give a better initial guess > for your solver. >  > Roy would this be as simple as just adding an additional UnsteadySolver member to AdaptiveTimeSolver, so for example core_time_solver could be EulerSolver with theta=1 and (let's call it) aux_time_solver would then be another EulerSolver with theta=0. We then just march them in parallel: 1) run the explicit scheme using aux_time_solver 2) use the solution from aux_time_solver to seed the implicit scheme (core_time_solver) and then solve 3) estimate the LTE from the difference of the two solutions and calculate the new timestep 4) synchronize the current solution of the explicit solver (to that of the implicit solution)  Nasser Mohieddin Abukhdeir Graduate Student (A.D. Rey Research Group) McGill University  Department of Chemical Engineering http://webpages.mcgill.ca/students/nabukh/web/ http://people.mcgill.ca/alejandro.rey/ 
From: Roy Stogner <roy@st...>  20080519 19:10:43

On Mon, 19 May 2008, Nasser Mohieddin Abukhdeir wrote: > A while ago I mentioned something about the time stepping algorithm > employed by AdaptiveTimeSolver as being nonideal for my PDE system. I > think I have implemented a very simple adaptive time solver based on the > local truncation error: > > core_time_solver>du() / calculate_norm(_system, *_system.solution) This isn't the local truncation error; it will be nonzero even if your solver and system are chosen in such a way that the time integration error is zero. > where it simply increases the time step up to a default of 2 > (max_growth=2). The only advantage of this approach for me application > is that the default algorithm is expensive (three nonlinear steps for > one effective time step) That's three nonlinear steps for two effective time steps, but yes, that's a reasonable complaint. > and, while locally it gives a good estimate of the error, is too > optimistic with its adaptive time stepping (my PDEs are highly > nonlinear). Also a reasonable complaint; I occasionally see the time stepper having to backtrack on an extremely nonlinear system. > If this makes any sense for inclusion into LibMesh's > AdaptiveTimeSolver I can cleanup and provide the code for review. That would be great, thanks! We've currently got the global_tolerance flag for use in choosing between a couple different refinement heuristics; another boolean would probably be the only interface change we'd need to add for your method, right? We might want to refactor that into an enum, a strategy pattern, subclasses, or something like that eventually, but that's what the untested() macro is for... If you've got time to play around with time solver adaptivity, one thing on our todo list is predictorcorrector schemes. Pick an explicit and an implicit scheme of the same order, use the difference between them to estimate your truncation error, then use the implicit scheme for your solution at the next time step to keep stability. That can actually end up being faster than just the implicit scheme alone, since the explicit result should give a better initial guess for your solver.  Roy 
From: John Peterson <jwpeterson@gm...>  20080519 19:01:49

On Mon, May 19, 2008 at 1:55 PM, Nasser Mohieddin Abukhdeir <nasser.abukhdeir@...> wrote: > Hello: > A while ago I mentioned something about the time stepping algorithm > employed by AdaptiveTimeSolver as being nonideal for my PDE system. I > think I have implemented a very simple adaptive time solver based on the > local truncation error: > > core_time_solver>du() / calculate_norm(_system, *_system.solution) As it's currently implemented, du() is the difference between two successive timesteps, not a measure of the truncation error. While this may be working for your particular application, I don't know of a theoretical justification for this particular method of adaptive timestep selection. J > where it simply increases the time step up to a default of 2 > (max_growth=2). The only advantage of this approach for me application > is that the default algorithm is expensive (three nonlinear steps for > one effective time step) and, while locally it gives a good estimate of > the error, is too optimistic with its adaptive time stepping (my PDEs > are highly nonlinear). > If this makes any sense for inclusion into LibMesh's > AdaptiveTimeSolver I can cleanup and provide the code for review. > >  > Nasser Mohieddin Abukhdeir > Graduate Student (A.D. Rey Research Group) > McGill University  Department of Chemical Engineering > http://webpages.mcgill.ca/students/nabukh/web/ > http://people.mcgill.ca/alejandro.rey/ > > >  > This SF.net email is sponsored by: Microsoft > Defy all challenges. Microsoft(R) Visual Studio 2008. > http://clk.atdmt.com/MRT/go/vse0120000070mrt/direct/01/ > _______________________________________________ > Libmeshusers mailing list > Libmeshusers@... > https://lists.sourceforge.net/lists/listinfo/libmeshusers > 
From: Nasser Mohieddin Abukhdeir <nasser.abukhdeir@mc...>  20080519 18:55:11

Hello: A while ago I mentioned something about the time stepping algorithm employed by AdaptiveTimeSolver as being nonideal for my PDE system. I think I have implemented a very simple adaptive time solver based on the local truncation error: core_time_solver>du() / calculate_norm(_system, *_system.solution) where it simply increases the time step up to a default of 2 (max_growth=2). The only advantage of this approach for me application is that the default algorithm is expensive (three nonlinear steps for one effective time step) and, while locally it gives a good estimate of the error, is too optimistic with its adaptive time stepping (my PDEs are highly nonlinear). If this makes any sense for inclusion into LibMesh's AdaptiveTimeSolver I can cleanup and provide the code for review.  Nasser Mohieddin Abukhdeir Graduate Student (A.D. Rey Research Group) McGill University  Department of Chemical Engineering http://webpages.mcgill.ca/students/nabukh/web/ http://people.mcgill.ca/alejandro.rey/ 