You can subscribe to this list here.
2003 
_{Jan}
(4) 
_{Feb}
(1) 
_{Mar}
(9) 
_{Apr}
(2) 
_{May}
(7) 
_{Jun}
(1) 
_{Jul}
(1) 
_{Aug}
(4) 
_{Sep}
(12) 
_{Oct}
(8) 
_{Nov}
(3) 
_{Dec}
(4) 

2004 
_{Jan}
(1) 
_{Feb}
(21) 
_{Mar}
(31) 
_{Apr}
(10) 
_{May}
(12) 
_{Jun}
(15) 
_{Jul}
(4) 
_{Aug}
(6) 
_{Sep}
(5) 
_{Oct}
(11) 
_{Nov}
(43) 
_{Dec}
(13) 
2005 
_{Jan}
(25) 
_{Feb}
(12) 
_{Mar}
(49) 
_{Apr}
(19) 
_{May}
(104) 
_{Jun}
(60) 
_{Jul}
(10) 
_{Aug}
(42) 
_{Sep}
(15) 
_{Oct}
(12) 
_{Nov}
(6) 
_{Dec}
(4) 
2006 
_{Jan}
(1) 
_{Feb}
(6) 
_{Mar}
(31) 
_{Apr}
(17) 
_{May}
(5) 
_{Jun}
(95) 
_{Jul}
(38) 
_{Aug}
(44) 
_{Sep}
(6) 
_{Oct}
(8) 
_{Nov}
(21) 
_{Dec}

2007 
_{Jan}
(5) 
_{Feb}
(46) 
_{Mar}
(9) 
_{Apr}
(23) 
_{May}
(17) 
_{Jun}
(51) 
_{Jul}
(41) 
_{Aug}
(4) 
_{Sep}
(28) 
_{Oct}
(71) 
_{Nov}
(193) 
_{Dec}
(20) 
2008 
_{Jan}
(46) 
_{Feb}
(46) 
_{Mar}
(18) 
_{Apr}
(38) 
_{May}
(14) 
_{Jun}
(107) 
_{Jul}
(50) 
_{Aug}
(115) 
_{Sep}
(84) 
_{Oct}
(96) 
_{Nov}
(105) 
_{Dec}
(34) 
2009 
_{Jan}
(89) 
_{Feb}
(93) 
_{Mar}
(119) 
_{Apr}
(73) 
_{May}
(39) 
_{Jun}
(51) 
_{Jul}
(27) 
_{Aug}
(8) 
_{Sep}
(91) 
_{Oct}
(90) 
_{Nov}
(77) 
_{Dec}
(67) 
2010 
_{Jan}
(25) 
_{Feb}
(36) 
_{Mar}
(98) 
_{Apr}
(45) 
_{May}
(25) 
_{Jun}
(60) 
_{Jul}
(17) 
_{Aug}
(36) 
_{Sep}
(48) 
_{Oct}
(45) 
_{Nov}
(65) 
_{Dec}
(39) 
2011 
_{Jan}
(26) 
_{Feb}
(48) 
_{Mar}
(151) 
_{Apr}
(108) 
_{May}
(61) 
_{Jun}
(108) 
_{Jul}
(27) 
_{Aug}
(50) 
_{Sep}
(43) 
_{Oct}
(43) 
_{Nov}
(27) 
_{Dec}
(37) 
2012 
_{Jan}
(56) 
_{Feb}
(120) 
_{Mar}
(72) 
_{Apr}
(57) 
_{May}
(82) 
_{Jun}
(66) 
_{Jul}
(51) 
_{Aug}
(75) 
_{Sep}
(166) 
_{Oct}
(232) 
_{Nov}
(284) 
_{Dec}
(105) 
2013 
_{Jan}
(168) 
_{Feb}
(151) 
_{Mar}
(30) 
_{Apr}
(145) 
_{May}
(26) 
_{Jun}
(53) 
_{Jul}
(76) 
_{Aug}
(33) 
_{Sep}
(23) 
_{Oct}
(72) 
_{Nov}
(125) 
_{Dec}
(38) 
2014 
_{Jan}
(47) 
_{Feb}
(62) 
_{Mar}
(27) 
_{Apr}
(8) 
_{May}
(12) 
_{Jun}
(2) 
_{Jul}
(22) 
_{Aug}
(22) 
_{Sep}

_{Oct}
(17) 
_{Nov}
(20) 
_{Dec}
(12) 
2015 
_{Jan}
(25) 
_{Feb}
(2) 
_{Mar}
(16) 
_{Apr}
(13) 
_{May}
(21) 
_{Jun}
(5) 
_{Jul}
(1) 
_{Aug}
(8) 
_{Sep}
(9) 
_{Oct}
(30) 
_{Nov}
(8) 
_{Dec}

2016 
_{Jan}
(16) 
_{Feb}
(31) 
_{Mar}
(43) 
_{Apr}
(18) 
_{May}
(21) 
_{Jun}
(11) 
_{Jul}
(17) 
_{Aug}
(26) 
_{Sep}
(4) 
_{Oct}
(16) 
_{Nov}
(5) 
_{Dec}
(6) 
S  M  T  W  T  F  S 




1

2
(6) 
3
(11) 
4

5

6

7
(1) 
8

9
(3) 
10

11

12

13

14

15

16
(14) 
17
(10) 
18

19

20
(11) 
21

22
(6) 
23
(8) 
24

25

26

27
(1) 
28
(5) 
29
(5) 
30
(5) 
31
(10) 

From: Roy Stogner <roystgnr@ic...>  20081002 23:40:29

On Thu, 2 Oct 2008, John Peterson wrote: > This was probably a confusing description but try it for > a simple example to convince yourself the first Newton step is not the > same as an explicit solve. John's right  in fact, consider the case where f(U) is linear. Then Newton will obviously hit the correct solution after one step, but (presuming you're using an implicit time discretization) that correct solution is still the result of an implicit, not an explicit, solve.  Roy 
From: John Peterson <jwpeterson@gm...>  20081002 21:07:07

On Thu, Oct 2, 2008 at 3:12 PM, Nasser Mohieddin Abukhdeir <nasser.abukhdeir@...> wrote: > Just to clarify things, my understanding of the backwards Euler method that > is implemented now is such that for the initial u' = f(theta*u_new + > (1theta)*u_old), so the first iteration of the nonlinear solver should be > equivalent to an explicit solve, assuming u_new = u_old during the first > step. Please correct me if I'm wrong. Let's assume our semidiscrete problem statement is M du/dt = f(u) M is the "mass" matrix, f(u) represents the discretized in space part of the operator. The theta discretization gives: M (U^{n+1}  U^{n}) / (Delta t) = f (U^{theta}) We define the "residual" vector F(U^{n+1}) := M (U^{n+1}  U^{n}) /(Delta t)  f (U^{theta}) At each nonlinear iteration, the system to be solved is F'(U_i) dU = F(U_i) for the update dU, where U_i is Newton iterate i and generally, and the initial guess U_{i=0} = U^{n} is the solution at the prior time level. The Jacobian is F'(U_i) = M/(Delta t)  theta*f'(U_i) When theta=0 (explicit) we're basically just inverting the mass matrix. When theta>0 the Jacobian is different than the explicit case even when the initial guess is the solution at the previous time level, U^{n}, since the matrix f'(U_0) := df / dU (U^{n}) != 0 in general. This was probably a confusing description but try it for a simple example to convince yourself the first Newton step is not the same as an explicit solve.  John 
From: Nasser Mohieddin Abukhdeir <nasser.abukhdeir@mc...>  20081002 20:12:26

Just to clarify things, my understanding of the backwards Euler method that is implemented now is such that for the initial u' = f(theta*u_new + (1theta)*u_old), so the first iteration of the nonlinear solver should be equivalent to an explicit solve, assuming u_new = u_old during the first step. Please correct me if I'm wrong. My goal to get an adaptive time solver working such that it is less costly than the current implementation. I am very much *not* and expert, but am very committed to using LibMesh, so if there can be a consensus on a) if there needs to be a faster/less accurate adaptive time solver implementation and b) if so, what would be the best implementation, I will do my best to implement it. Nasser Mohieddin Abukhdeir Graduate Student (Materials Modeling Research Group) McGill University  Department of Chemical Engineering http://webpages.mcgill.ca/students/nabukh/web/ http://mmrg.chemeng.mcgill.ca/ John Peterson wrote: > On Thu, Oct 2, 2008 at 1:41 PM, Nasser Mohieddin Abukhdeir > <nasser.abukhdeir@...> wrote: > >> Hello all: >> After some enlightening conversations with Roy, I am going to be >> implementing a predictor/corrector AdaptiveTimeSolver class that does >> the following: >> >> 1) An explicit solve (just an EulerSolver step with theta=0) yields the >> "predictor" which is stored. >> >> 2) The explicit solve solution is used as the starting iterate for a >> full nonlinear implicit solve , which is done to the user's tolerances >> or maximum step count. >> >> 3) The implicit solution is compared with the copy of the explicit >> solution to get an error estimate and adapt the time step. >> > > While this algorithm will work in practice for certain problems, I > have a few doubts about its robustness. In particular, the explicit > solve step need not be 1.) a good initial guess for the implicit > solve, or 2.) useful as an error estimate when compared with the > implicit solve solution. > > You might be interested in ABTR (AdamsBashforth/Trapezoidal Rule, > though I have my doubts about it for the same reasons) or possibly the > predictormulticorrector methods suggested by Hughes et al (CMAME v. > 17/18, 1979, p. 159182) although these do not necessarily update the > timestep. I think Ben may have also implemented some interesting > adaptive timestep selection algorithms in his dissertation work on > compressible flows, but I can't remember for sure. I don't want to > discourage you from trying any particular algorithm, but I think we > should be somewhat careful about what goes in the library. > >  > John > 
From: John Peterson <jwpeterson@gm...>  20081002 19:09:37

On Thu, Oct 2, 2008 at 1:41 PM, Nasser Mohieddin Abukhdeir <nasser.abukhdeir@...> wrote: > Hello all: > After some enlightening conversations with Roy, I am going to be > implementing a predictor/corrector AdaptiveTimeSolver class that does > the following: > > 1) An explicit solve (just an EulerSolver step with theta=0) yields the > "predictor" which is stored. > > 2) The explicit solve solution is used as the starting iterate for a > full nonlinear implicit solve , which is done to the user's tolerances > or maximum step count. > > 3) The implicit solution is compared with the copy of the explicit > solution to get an error estimate and adapt the time step. While this algorithm will work in practice for certain problems, I have a few doubts about its robustness. In particular, the explicit solve step need not be 1.) a good initial guess for the implicit solve, or 2.) useful as an error estimate when compared with the implicit solve solution. You might be interested in ABTR (AdamsBashforth/Trapezoidal Rule, though I have my doubts about it for the same reasons) or possibly the predictormulticorrector methods suggested by Hughes et al (CMAME v. 17/18, 1979, p. 159182) although these do not necessarily update the timestep. I think Ben may have also implemented some interesting adaptive timestep selection algorithms in his dissertation work on compressible flows, but I can't remember for sure. I don't want to discourage you from trying any particular algorithm, but I think we should be somewhat careful about what goes in the library.  John 
From: Nasser Mohieddin Abukhdeir <nasser.abukhdeir@mc...>  20081002 18:44:06

Hello all: After some enlightening conversations with Roy, I am going to be implementing a predictor/corrector AdaptiveTimeSolver class that does the following: 1) An explicit solve (just an EulerSolver step with theta=0) yields the "predictor" which is stored. 2) The explicit solve solution is used as the starting iterate for a full nonlinear implicit solve , which is done to the user's tolerances or maximum step count. 3) The implicit solution is compared with the copy of the explicit solution to get an error estimate and adapt the time step. The tentative algorithm for this, unless anyone has any better ideas is: 1) the structure of the class data will be exactly the same as AdaptiveTimeSolver except a vector will be added for the explicit solution storage. My understanding is that using clone() will result in dynamic memory allocation everytime, even though this might not be necessary (in the case that the mesh has not changed since the previous solve). 2) the core_time_solver (EulerSolver) will be run with theta=0 and max_iterations=1 to generate the predictor solution, which will be copied. 3) theta will be restored to its previous value and max_iterations=N1 and the implicit solution will be found (Roy pointed out that we just don't touch system.solution and all will be fine) 4) the error will then be determined as is done currently in AdaptiveTimeSolver, I'll literally just cut and paste the code. I'll be working on this over the weekend, and will surely need help since I'm quite new to C++ and the FEM...  Nasser Mohieddin Abukhdeir Graduate Student (Materials Modeling Research Group) McGill University  Department of Chemical Engineering http://webpages.mcgill.ca/students/nabukh/web/ http://mmrg.chemeng.mcgill.ca/ 
From: Roy Stogner <roystgnr@ic...>  20081002 14:41:28

On Thu, 2 Oct 2008, Nasser Mohieddin Abukhdeir wrote: > I ran a simulation with the newly reformulated class structure, everything > is peachy. I'll get started on this PCAdaptiveTimeSolver over the weekend, > should I send an email to the devel list detailing this change and the game > plan for PCAdaptiveTimeSolver? Post the details and future plans on devel, but I just realized we should mention this on users too, since there's an API change that can affect people who follow the SVN head: Anyone who was previously instantiating an AdaptiveTimeSolver, we've renamed that due to refactoring. You'll want to build a TwostepTimeSolver instead  same functionality, just a different leaf class since we'll have more adaptive time solver implementations coming in the future. You'll also need to include "twostep_time_solver.h" for the new class.  Roy 