[misabel]

Hello:

Not obtaining the desired results in two different problems, I would like
to clarify a concept that is the “Newton method”.

In both cases I want to simulate Navier Stokes equations: the first one is
a time dependent problem (which has an analytical solution) and the second
one is a steady state problem which uses time as a way to get the steady
state, so I will always have a temporal term in the equation.

In both cases, the NS equations are:

du/dt+(u*grad)u-viscosity(grad²)u+(grad)p=0;
(div)u=0;

To implement these equations I use different schemes: coupled method,
pressure projection method, consistent pressure method... and I am using
Finite Element Method (FEM).

The way I advance in time is the following one:

Assemble the unchanged matrices (i.e. mass matrix, diffusion matrix,
gradient matrix, divergence matrix)

for(unsigned int i=0; i<maximum_num_iterations;i++)
{
step value++;

Assemble the matrices (i.e. convection matrix and right hand side vector)

Solver the linear system (if working with coupled method) or the linear
systems (if working with projection method).

Steady state case: if the residual is less than a tolerance value I give I
stop the loop.
Time dependent problem: I continue until the total time I want to simulate
is reached.
}

I mean, inside this loop, I don't create any inner nonlinear loop.

I am not sure if I must also apply the Newton method in every case since I
always use the convection term in a previous time step or I linearize it
using (u^(n)*gradu)^(n+1). Anyway, it is supposed that convection term is
the only term that introduces a non linearity in the equation, isn't it?
And it is because of it, we should introduce the Newton method to reach
the right solution or on the contrary, I would like to know when and why
we should use Newton method to get the right solution. Is it always
compulsory?

I would be really grateful if you could clarify me this concept.

Thank-you very much in advance.

Isa

[agd]

Don't know if this will help, but I'll try - it's difficult to express some concepts on a message board. I find it very useful to think of the Newton iteration (which occurs inside the time step loop) as a search over solution space. If you discretize the governing equations at the new time level, you can write the system as

R(Q(N+1)) = 0

This is prior to any application of a Newton scheme, so you have essentially a semi-discrete form of the equation. Apply a Newton iterative scheme to this system, i.e. we solve for DQ where

A*DQ = -R(Q)

Here A is a system Jacobian, and Q is a possible solution out of a solution space, call it Q(N+1,M). The next Newton iterate of Q, call it Q(N+1,M+1) = Q(N+1,M) + DQ. If we drive DQ to zero (which is the purpose of the Newton scheme) then at convergence we have the "correct" solution at the new time step N+1.

One of the first applications I remember of this type of scheme was in conjunction with a Beam-Warming approximate factorization scheme. In the original scheme the splitting error completely destroys time accuracy in 3D for reasonable timestep sizes, but by using a Newton iterative solver the factorization error is contained within the Newton iteration and does not affect the converged value of Q(N+1). So it is not necessary, but it is a very useful approach for creating a scheme that is stable and accurate at very large timesteps. Hope that helps.

[misabel]

Agd,tThank-you very much!

But even being usefual approach, calculating the system Jacobian (A) for a NS equations must be really computationally expensive, mustn't it?

Best
Isa

[agd]

Depending on the way you construct the left-hand side, the system Jacobian is a combination of the inviscid flux Jacobians and/or viscous flux Jacobians. These have to be determined for an implicit scheme anyway. So the overall cost of using the Newton method versus a standard temporal marching approach is just roughly the product of the FLOPS for the temporal stepping and the number of Newton iterations. But the expense is offset by the improved convergence, the fact that you can impose boundary conditions within the Newton loop to get quasi-implicit BC implementation using simple BCs, and greatly enhanced time-accurate behavior.