this is not possible in general, as we rely on external linear solvers (e.g.
umfpack), that do not support this feature. A progress bar might be feasible
for assembling, but that is in my experience only a minor part of the solving
process - most of the time is spent in the linear solver.
Well, the theory is well described in any finite element textbook, and even
on-line (e.g. the site Vladimir mentioned) - it's one of standard methods to
solve PDEs (partial differential equations). SfePy implements the basic version
without mesh adaptivity, and uses, for the moment, the most classical,
Lagrangian, basis for polynomial approximation on elements.
If you are really interested in the actual implementation, currently the best
way is to look at the source code in sfepy/fem, starting with
sfepy/fem/problemDef.py where the ProblemDefinition class is defined. But
before that, go through the tutorial (check especially "Sneak peek: what is
going on under the hood" and "Interactive Example: Linear Elasticity" sections).
There is no real "user" documentation of sfepy.fem yet. It would be nice to
have, but I do not have currently power to do it. But I can try to answer any
particular question, so if you have any, ask... :)
Check out the time-dependent examples, e.g.
examples/diffusion/time_poisson.py (long syntax)
examples/diffusion/laplace_time_ebcs.py (short syntax, changing boundary
Basically, just define the time-stepping solver, and if it's a dynamic
simulation, add some terms with time derivatives of variables, like dT/dt in
the first example above.
What do you mean by "100 constants"?
No, it is standard. The examples I mentioned show how to use it.
Well, it really cannot be estimated reliably - the solution time depends
heavily on the condition number of the matrix, and it is possible (as
far as I recall), for a given matrix size and number of nonzeros, to
generate a matrix with arbitrarily high condition number -> solution
time from almost zero to infinity. So one could estimate time for a
particular problem, e.g. Poisson, or elasticity, but there is no general
way. Maybe sfepy could just print "solving..." so that you know you have
Well, the problem is that sfepy cannot print anything when the solver
runs - it's still the same process. To do something dynamic like you
want would mean use threading. I would rather avoid such complication.
To conclude: it's easy to print "solving..." before the solver starts
(e.g. if the matrix size is big enough(?)), but nothing more.
> so just include the print "solving..." statement.
I have added 'verbose' option to Solver class, i.e. base class of all solvers.
Currently, only Newton solver uses it: add "'verbose' : True" to the nls.newton
solver options, and it will print 'solving linear system...'.