File: faq.html

package info (click to toggle)
petsc 3.1.dfsg-7
links: PTS, VCS
area: main
in suites: squeeze
size: 131,360 kB
ctags: 491,710
sloc: ansic: 288,064; cpp: 66,909; python: 28,799; fortran: 19,153; makefile: 13,945; sh: 3,502; f90: 1,655; xml: 620; csh: 230; java: 13
file content (1073 lines) | stat: -rw-r--r-- 55,878 bytes
<html>
<body BGCOLOR="FFFFFF">

      <h1>Docs:&nbsp; FAQ</h1>


      <h4><a href="faq.html#General">General</a></h4>
      <menu> <li><a href="faq.html#petsc-mailing-list">How
can I subscribe to the PETSc&nbsp;mailing lists?</a></li>
      <li><a href="faq.html#computers">What kind of
parallel computers or clusters are needed
to use PETSc?</a></li>
      <li><a href="faq.html#license">What kind of
license is PETSc released under?</a></li>
      <li><a href="faq.html#why-c">Why is PETSc
programmed in C, instead of Fortran or C++?</a> </li>
      <li><a href="faq.html#logging-overhead">Does
all the PETSc error checking and logging reduce PETSc's efficiency?</a></li>
      <li><a href="faq.html#work-efficiently">How do
such a small group of people manage to write and maintain such a large
and marvelous package as PETSc?</a></li>
      <li><a href="faq.html#complex">For complex numbers will I get
better performance using C or C++?&nbsp;</a></li>
      <li><a href="faq.html#different">How come when I run the same
program on the same number of processes I get "different" answers"?</a></li>
      <li><a href="faq.html#differentiterations">How come when I run
the same linear solver with different number of processes it takes a
different number of iterations?</a></li>
      <li><a href="faq.html#newremotebranches">How come I get an hg
error indicating "new remote branches" might be created when I try to
push?</a></li>
      </menu>
      <h4><a href="faq.html#Installation">Installation</a></h4>
      <menu> <li><a href="faq.html#already-installed">How
do I begin using PETSc if the software has already been completely
built and installed by someone else?</a></li>
      <li><a href="faq.html#reduce-disk-space">The
PETSc distribution is SO large. How can I reduce my disk space usage?</a></li>
      <li><a href="faq.html#petsc-uni">I want to use
PETSc only for uniprocessor programs. Must I still install and use a
version of MPI?</a></li>
      <li><a href="faq.html#no-x">Can I install
PETSc to not use X windows (either under Unix or Windows with gcc, the
gnu compiler)?</a></li>
      <li><a href="faq.html#use-mpi">Why do you use MPI</a>?</li>
      <li><a href="faq.html#mpi-compilers">What do I do if my MPI
compiler wrappers are invalid</a>?</li>
      </menu>
      <p><a href="#usage"><b>Usage</b></a></p>
      <ul>
        <li><a href="#redirectstdout">How can I redirect PETSc's stdout
and stderr when programming with a GUI interface in Windows Developer
Studio?</a></li>
        <li><a href="#hypre">I want to use hypre
boomerAMG without GMRES
but when I run -pc_type hypre -pc_hypre_type boomeramg -ksp_type
preonly I don't get a very accurate answer!</a></li>
        <li><a href="#nosaij">You have AIJ and BAIJ
matrix formats, and SBAIJ for symmetric storage, how come no SAIJ?</a></li>
        <li><a href="#domaindecomposition">How do I
use PETSc for domain decomposition?</a></li>
        <li><a href="#blocks">Can I create BAIJ
matrices with different size blocks for different block rows?</a></li>
        <li><a href="faq.html#mpi-vec-to-seq-vec">How do I
collect all the values from a parallel PETSc vector into a sequential
vector on each processor?</a></li>
        <li><a href="faq.html#mpi-vec-to-mpi-vec">How do I
collect all the values from a parallel PETSc vector into a vector on
the zeroth (or any particular) processor?</a></li>
        <li><a href="faq.html#sparse-matrix-ascii-format">How can I
read in or write out a sparse matrix in Matrix Market, Harwell-Boeing,
SLAPC or other ASCII format?</a></li>
        <li><a href="faq.html#setfromoptions">Does TSSetFromOptions(),
SNESSetFromOptions() or KSPSetFromOptions() reset all the parameters I
set or how come TS/SNES/KSPSetXXX() don't seem to work?</a></li>
        <li><a href="faq.html#makefiles">Can I use my own makefiles or
rules for compiling code, rather than PETSc's?</a></li>
        <li><a href="faq.html#carriagereturns">How can I put carriage
returns in PetscPrintf() statements from Fortran?</a></li>
        <li><a href="faq.html#functionjacobian">Everyone knows that
when you code Newton's method you should compute the function and its
Jacobian at the same time. How can one do this in PETSc?</a></li>
        <li><a href="faq.html#invertmatrix">How can I compute the
inverse of a PETSc matrix?</a></li>
        <li><a href="faq.html#schurcomplement">How can I compute a
Schur complement: Kbb - Kba *inverse(Kaa)*Kab?</a></li>
        <li><a href="faq.html#fem">Do you have examples of doing
unstructured grid finite element computations (FEM) with PETSc?</a></li>
        <li><a href="faq.html#da_mpi_cart">The PETSc DA object
decomposes the domain differently than the MPI_Cart_create() command.
How can one use them together?</a></li>
        <li><a href="faq.html#redistribute">When solving a symmetric
system with Dirichlet boundary conditions I can use MatZeroRows() to
eliminate the Dirichlet rows but this results in a non-symmetric
system. How come there is no MatZeroColumns() to keep the matrix
symmetric?</a></li>
        <li></li>
      </ul>
      <h4><a href="faq.html#Execution">Execution</a></h4>
      <menu> <li><a href="faq.html#long-link-time">PETSc
executables are SO big and take SO long to link.</a></li>
      <li><a href="faq.html#petsc-options">PETSc has
so many options for my program that it is hard to keep them straight.</a></li>
      <li><a href="faq.html#petsc-log-info">PETSc
automatically handles many of the details in parallel PDE solvers. How
can I understand what is really happening within my program? </a></li>
      <li><a href="faq.html#efficient-assembly">Assembling
large sparse matrices takes a long time. What can I do make this
process faster?</a></li>
      <li><a href="faq.html#log-summary">How can I
generate performance summaries with PETSc?</a></li>
      <li><a href="faq.html#parallel-roundoff">Why
do I get different answers on a different numbers of processors?</a></li>
      <li><a href="faq.html#mg-log">How do I know the amount
of time spent on each level of the solver in multigrid (PCType of PCMG)
-pc_type mg.</a></li>
      <li><a href="faq.html#datafiles">Where do I get the input
matrices for the examples?&nbsp;</a></li>
      <li><a href="faq.html#info">When I dump some matrices and vectors
to binary, I seem to be generating some empty files with .info
extensions.&nbsp; What's the deal with these?</a></li>
      <li><a href="faq.html#slow">MatSetValues() is <span
 style="font-weight: bold;">so slow, </span>what can I do to make it
faster<span style="font-weight: bold;">?</span></a></li>
      <li><a href="faq.html#slowerparallel">Why is my parallel <span
 style="font-weight: bold;">solver slower </span>than the sequential
solver?<span style="font-weight: bold;"></span></a></li>
      <li><a href="faq.html#singleprecision">When using PETSc in single
precision mode (--with-precision=single when running
config/configure.py) are the operations done in single or double
precision?</a></li>
      </menu>
      <a href="faq.html#Debugging"><span style="font-weight: bold;"></span>Debugging</a>
      <menu> <li><a href="faq.html#debug-ibmfortran">How
do I turn off PETSc signal handling so I can use the -C option on xlF?</a></li>
      <li><a href="faq.html#debug-cray">How do I
debug on the Cray T3D/T3E?</a></li>
      <li><a href="faq.html#start_in_debugger-doesnotwork">How
do I debug if -start_in_debugger does not work on my machine?</a></li>
      <li><a href="faq.html#debug-hang">How can I
see where my code is hanging?</a></li>
      <li><a href="faq.html#debug-inspect">How can I
inspect Vec and Mat values when in the debugger?</a></li>
      <li><a href="faq.html#libimf">error while loading shared
libraries: libimf.so: cannot open shared object file: No such file or
directory.</a></li>
      </menu>
      <h4><a href="faq.html#Shared%20Libraries">Shared
Libraries</a></h4>
      <menu> <li><a href="faq.html#install-shared">Can
I install PETSc libraries as shared libraries?</a></li>
      <li><a href="faq.html#why-use-shared">Why
should I use shared libraries?</a></li>
      <li><a href="faq.html#link-shared">How do I
link to the PETSc shared libraries?</a></li>
      <li><a href="faq.html#link-regular-lib">What
if I want to link to the regular .a library files?</a></li>
      <li><a href="faq.html#move-shared-exec">What
do I do if I want to move my executable to a different machine?</a></li>
      <li><a href="#dynamic-shared">What is the deal
with dynamic libraries (and difference with shared libraries)</a></li>
      </menu>
      <hr>
      <h3><a name="General">General</a></h3>
      <p><a name="petsc-mailing-list"><strong><font color="#ff0000">How
can I subscribe to the
PETSc&nbsp;mailing lists?</font></strong> </a></p>
      <p>See <a
 href="http://www.mcs.anl.gov/petsc/petsc-as/miscellaneous/mailing-lists.html">http://www.mcs.anl.gov/petsc/petsc-as/miscellaneous/mailing-lists.html</a></p>
      <p><a name="computers"><strong><font color="#ff0000">What kind of
parallel computers or clusters
are needed to use PETSc?</font></strong><br>
      </a><br>
PETSc can be used with
any kind of parallel system that supports MPI.<span
 style="font-weight: bold;"> BUT </span>for any decent
performance one needs&nbsp;</p>
      <ul>
        <li>a <span style="font-weight: bold;">fast,
low-latency interconnect</span>; any ethernet, even 10 gigE
simply cannot provide the needed performance.&nbsp;</li>
        <li><span style="font-weight: bold;">high
per-CPU memory performance</span>. Each CPU (core in dual core
systems) needs to have its <span style="font-weight: bold;">own</span>
memory bandwith of roughly 2 or more gigabytes. For example, standard
dual processor "PC's" will <span style="font-weight: bold;">not</span>
provide better performance when the second processor is used, that is,
you will not see speed-up when you using the second processor. This is
because the speed of sparse matrix computations is almost totally
determined by the speed of the memory, not the speed of the CPU.</li>
        <li>The software &nbsp;<a href="http://open-mx.org">http://open-mx.org</a>
provides faster speed for ethernet systems, we have not tried it but it
claims it can dramatically reduce latency and increase bandwidth on
Linux system. You must first install this software and then install
MPICH or OpenMPI to use it.</li>
      </ul>
      <a name="license"><strong><font color="#ff0000">What kind of
license is PETSc released under?</font></strong><br>
      </a><br>
See the <a href="copyright.html">copyright notice.</a>&nbsp; <span
 style="text-decoration: underline;"></span><strong></strong>
      <p><strong><a name="why-c"><font color="#ff0000">Why is PETSc
programmed in C, instead of
Fortran or C++?</font> </a></strong></p>
      <p>C enables us to build data structures for storing sparse
matrices, solver information, etc. in ways that Fortran simply does not
allow. ANSI C is a complete standard that all modern C compilers
support. The language is identical on all machines. C++ is still
evolving and compilers on different machines are not identical. Using C
function pointers to provide data encapsulation and polymorphism allows
us to get many of the advantages of C++ without using such a large and
more complicated language. It would be natural and reasonable to have
coded PETSc in C++; we opted to use C instead. </p>
      <p><strong><a name="logging-overhead"><font color="#ff0000">Does
all the PETSc error checking and
logging reduce PETSc's efficiency? </font></a></strong></p>
      <p>No, </p>
      <p><strong><font color="#ff0000"><a name="work-efficiently">How
do such a small group of people
manage to write and maintain such a large and marvelous package as
PETSc?</a> </font></strong></p>
      <p>a) We work very efficiently. </p>
      <ol>
        <li>We use Emacs for all editing; the etags feature makes
navigating and changing our source code very easy. </li>
        <li>Our manual pages are generated automatically from
formatted comments in the code, thus alleviating the need for creating
and maintaining manual pages. </li>
        <li>We employ automatic nightly tests of PETSc on several
different machine architectures. This process helps us to discover
problems the day after we have introduced them rather than weeks or
months later. </li>
      </ol>
      <p>b) We are very careful in our design (and are constantly
revising our design) to make the package easy to use, write, and
maintain. </p>
      <p>c) We are willing to do the grunt work of going through
all the code regularly to make sure that <u><strong>all</strong></u>
code conforms to our interface design. We will <u><strong>never</strong></u>
keep in a bad design decision simply because changing it will require a
lot of editing; we do a lot of editing. </p>
      <p>d) We constantly seek out and experiment with new design
ideas; we retain the the useful ones and discard the rest. All of these
decisions are based on <u><strong>practicality</strong></u>. </p>
      <p>e) Function and variable names are chosen to be very
consistent throughout the software. Even the rules about capitalization
are designed to make it easy to figure out the name of a particular
object or routine. Our memories are terrible, so careful consistent
naming puts less stress on our limited human RAM. </p>
      <p>f) The PETSc directory tree is carefully designed to
make it easy to move throughout the entire package. </p>
      <p>g) Our bug reporting system, based on email to <a
 href="../documentation/bugreporting.html">petsc-maint@mcs.anl.gov</a>,
makes it very simple to keep track of what bugs have been found and
fixed. In addition, the bug report system retains an archive of all
reported problems and fixes, so it is easy to refind fixes to
previously discovered problems. </p>
      <p>h) We contain the complexity of PETSc by using
object-oriented programming techniques including data encapsulation
(this is why your program cannot, for example, look directly at what is
inside the object Mat) and polymorphism (you call MatMult() regardless
of whether your matrix is dense, sparse, parallel or sequential; you
don't call a different routine for each format).</p>
      <p>i) We try to provide the functionality requested by our
users.</p>
      <p>j) We never sleep. </p>
      <br>
      <p><strong><a name="complex"><font color="#ff0000">For complex
numbers will I get better performance with C++?</font></a></strong><span
 style="font-weight: bold;"></span></p>
      <p><span style="font-weight: bold;"></span>To use PETSc with
complex numbers you either config/configure.py with the option
--with-scalar-type complex and either --with-clanguage=c++ or, the
default, --with-clanguage=c. In our experience they will deliver very
similar performance (speed), but if one is concerned they should just
try both and see if one is faster.</p>
      <p><br>
      </p>
      <p><strong><a name="different"><font color="#ff0000">How come
when I run the same program on the same number of processes I get a
"different" answer?</font></a></strong><span style="font-weight: bold;"></span></p>
      <p><span style="font-weight: bold;"></span>Inner products and
norms in PETSc are&nbsp;
computed using the MPI_Allreduce() command. In different runs the order
at which values arrive at a given process (via MPI) can be in a
different order, thus the order in which some floating point arithmetic
operations are performed will be&nbsp;different. Since floating point
arithmetic arithmetic is not commutative the computed quantity may be
(slightly) different. Over a run the many slight differences in the
inner products and norms will effect all the computed results. It is
important to realize that none of the computed answers are any less
right or wrong (in fact the sequential computation is no more right
then the parallel ones), they are all equally valid.</p>
The discussion above assumes that the exact same algorithm is being
used on the different number of processes. When the algorithm is
different for the different number of processes (almost all
preconditioner algorithms except Jacobi are different for different
number of processes) then one expects to see (and does) a greater
difference in results for different numbers of processes. In some cases
(for example block Jacobi preconditioner) it may be that the algorithm
works for some number of processes and does not work for others.
      <p><strong><a name="differentiterations"><font color="#ff0000">How
come when I run the same linear solver on a different number of
processes it takes a different number of iterations?</font></a></strong><span
 style="font-weight: bold;"></span></p>
      <p><span style="font-weight: bold;"></span>The convergence of
many of the preconditioners in PETSc including the the default parallel
preconditioner block Jacobi depends on the number of processes. The
more processes the (slightly) slower convergence it has. This is the
nature of iterative solvers, the more parallelism means the more
"older" information is used in the solution process hence slower
convergence.</p>
      <p></p>
      <p><strong><a name="newremotebranches"><font color="#ff0000">How
come I get an hg error indicating "new remote branches" might be
created when I try to push?</font></a></strong><span
 style="font-weight: bold;"></span></p>
      <p>Here is an example:</p>
[linux]% hg push<br>
pushing to https://petsc.cs.iit.edu/petsc/petsc-dev<br>
searching for changes<br>
abort: push creates new remote branches!<br>
      <p>This is almost always an indication that you have done serious
harm to your local repo. If you run <strong>hg heads</strong> and
there are more than 1 (which causes this), then you know its true.</p>
      <p>Here is how it happens. You make some local changes, but do
not commit. You pull down and it aborts part way because you have
"uncommitted local changes". However, you do not <strong>hg rollback</strong>.
Instead you just <strong>hg commit</strong>, which creates another
head. This is supposed to be a feature. I think it should have a user
disable.</p>
      <p>Fixing this is complicated. Basically, you clone the repo
before you made head #2, then create the diff for the bad changeset
that made head #2. Apply it to the clone and checkin, then pull the
master.</p>
      <strong><font color="#ff0000"></font></strong>
      <h3><a name="Installation">Installation</a></h3>
      <p><strong><a name="already-installed"><font color="#ff0000">How
do I begin using PETSc if the software
has already been completely built and installed by someone else?</font>
      </a></strong></p>
      <p>Assuming that the PETSc libraries have been successfully
built for a particular architecture and level of optimization, a new
user must merely: </p>
      <p>a) Set the environmental variable PETSC_DIR to the full
path of the PETSc home directory (for example, /home/username/petsc). </p>
      <p>b) Set the environmental variable PETSC_ARCH, which
indicates
the configuration on which PETSc will be used.&nbsp; Note that the
PETSC_ARCH is simply a name the installer used when installing the
libraries. There many be several on a single system, like mylinux-g for
the debug versions of the library and mylinux-O for the optimized
version, or petscdebug for the debug version &nbsp;and petscopt for
the
optimized version. </p>
      <p>c) Begin by copying one of the many PETSc examples (in,
for example, petsc/src/ksp/examples/tutorials) and its corresponding
makefile. </p>
      <p>d) See the introductory section of the PETSc users
manual for tips on documentation. </p>
      <p><a name="reduce-disk-space"><strong><font color="#ff0000">The
PETSc distribution is SO large. How can
I reduce my disk space usage?</font> </strong></a></p>
      <p>a) Don't install the -doc package.</p>
      <p>b) <strong><font color="#ff0000"><a name="petsc-uni">I want
to use PETSc only for uniprocessor
programs. Must I still install and use a version of MPI</a>?</font> </strong></p>
No, run config/configure.py with the option --with-mpi=0<br>
      <p><strong><a name="no-x"><font color="#ff0000">Can I install
PETSc to not use X windows
(either under Unix or Windows with gcc, the gnu compiler)?</font></a></strong></p>
      <p>Yes. Run config/configure.py with the additional flag
--with-x=0</p>
      <p><strong><font color="#ff0000"><a name="use-mpi">Why do you use
MPI</a>? </font></strong></p>
      <p>MPI is the message-passing standard. Because it is a
standard, it will not change over time; thus, we do not have to change
PETSc every time the provider of the message-passing system decides to
make an interface change. MPI was carefully designed by experts from
industry, academia, and government labs to provide the highest quality
performance and capability. For example, the careful design of
communicators in MPI allows the easy nesting of different libraries; no
other message-passing system provides this support. All of the major
parallel computer vendors were involved in the design of MPI and have
committed to providing quality implementations. In addition, since MPI
is a standard, several different groups have already provided complete
free implementations. Thus, one does not have to rely on the technical
skills of one particular group to provide the message-passing
libraries. Today, MPI is the only practical, portable approach to
writing efficient parallel numerical software. </p>
      <p><strong><font color="#ff0000"><a name="mpi-compilers">What do
I do if my MPI compiler wrappers are invalid</a>?</font></strong></p>
      <p>Most MPI implementations provide compiler wrappers (such as
mpicc) which give the include and link options necessary to use that
verson of MPI to the underlying compilers . These wrappers are either
absent or broken in the MPI pointed to by --with-mpi-dir. You can rerun
the configure with the additional option --with-mpi-compilers=0, which
will try to auto-detect working compilers; however, these compilers may
be incompatible with the particular MPI build. If this fix does not
work, run with --with-cc=c_compiler where you know c_compiler works
with this particular MPI, and likewise for C++ and Fortran.</p>
      <p>&nbsp; </p>
      <hr>
      <h3><a name="Using">Using</a></h3>
      <p>&nbsp;<strong><a name="redirectstdout"><font color="#ff0000">How
can I redirect PETSc's stdout and stderr when programming with a GUI
interface in Windows Developer Studio?&nbsp;</font></a></strong><strong></strong>
      </p>
These directions where supplied by a user. You just need to add this <br>
      <br>
extern "C"<br>
{<br>
&nbsp; &nbsp;int PASCAL WinMain(HINSTANCE inst,HINSTANCE dumb,LPSTR
param,int show);<br>
};<br>
      <br>
#include "petscsys.h"<br>
#include "mpi.h"<br>
      <br>
      <br>
int MyPrintError(const char error[],...){<br>
      <br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; printf("%s",error);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; return 0;<br>
}<br>
      <br>
      <br>
int main(int ac,char *av[])<br>
{<br>
&nbsp;&nbsp;&nbsp; char buf[256];<br>
&nbsp;&nbsp;&nbsp; int i;<br>
&nbsp;&nbsp;&nbsp; HINSTANCE inst;<br>
      <br>
&nbsp;&nbsp;&nbsp; inst=(HINSTANCE)GetModuleHandle(NULL);<br>
&nbsp;&nbsp;&nbsp; PetscErrorPrintf = MyPrintError;<br>
      <br>
&nbsp;&nbsp;&nbsp; buf[0]=0;<br>
&nbsp;&nbsp;&nbsp; for(i=1; i&lt;ac; i++)<br>
&nbsp;&nbsp;&nbsp; {<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; strcat(buf,av[i]);<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; strcat(buf," ");<br>
&nbsp;&nbsp;&nbsp; }<br>
&nbsp; &nbsp; PetscErrorCode ierr;<br>
&nbsp; &nbsp; char* help = "Set up from main";<br>
      <br>
&nbsp;&nbsp;&nbsp;&nbsp;ierr = PetscInitialize(&amp;ac, &amp;av,
(char*)0, help);<br>
      <br>
&nbsp;&nbsp;&nbsp; return WinMain(inst,NULL,buf,SW_SHOWNORMAL);<br>
}<br>
      <br>
file in the project and compile with this preprocessor definitiions:
WIN32,_DEBUG,_CONSOLE,_MBCS,USE_PETSC_LOG,USE_PETSC_BOPT_g,USE_PETSC_STA<br>
CK,_AFXDLL<br>
      <br>
And this link options /nologo /subsystem:console
/incremental:yes&nbsp;&nbsp; /debug /machine:I386
/nodefaultlib:"libcmtd.lib" /nodefaultlib:"libcd.lib"
/nodefaultlib:"mvcrt.lib" /pdbtype:sept<br>
      <br>
With this simple trick any print to stdout&nbsp; (that is not from a
library) will work.<br>
      <br>
Note that it is compiled and linked as if it was a console program. The
linker will search for a main,&nbsp; and then from it the WinMain will
start. This works with MFC templates and derived classes too.<br>
      <br>
You can also reassign PetscVFPrintf() to handle stdout and stderr any
way you like<br>
      <br>
&nbsp;Note: When writing a Window's console application you do not need
to do anything, the stdout and stderr is automatically output to the
console window.<strong><a name="nosaij"><br>
      </a></strong>
      <p>&nbsp;<strong><a name="hypre"><font color="#ff0000">I want to
use hypre boomerAMG without GMRES but when I run -pc_type hypre
-pc_hypre_type boomeramg -ksp_type preonly I don't get a very accurate
answer!</font></a></strong> </p>
You should run with -ksp_type richardson to have PETSc run several V or
W cycles. -ksp_type of preonly causes boomerAMG to use only one V/W
cycle. You can control how many cycles are used in a single application
of the boomerAMG preconditioner with
-pc_hypre_boomeramg_max_iter <it> (the default is 1). You can
also control the tolerance boomerAMG uses to decide if to stop before
max_iter with -pc_hypre_boomeramg_tol <tol> (the default is
1.e-7). Run with -ksp_view to see all the hypre options used and -help
| grep boomeramg to see all the command line options. </tol></it>
      <p>&nbsp;<strong><a name="nosaij"><font color="#ff0000">You have
AIJ and BAIJ matrix formats, and
SBAIJ for symmetric storage, how come no SAIJ</font></a></strong> </p>
Just for historical reasons, the SBAIJ format with blocksize one is
just as efficient as an SAIJ would be
      <p></p>
      <p>&nbsp;<strong><a name="long-link-time"><font color="#ff0000">How
do I use P</font></a></strong><strong><a name="domaindecomposition"><font
 color="#ff0000">ETSc
for Domain Decomposition?</font></a></strong> </p>
      <p>PETSc includes Additive Schwarz methods in the suite of
preconditioners. These may be activated with the runtime
option&nbsp;<br>
      <i>-pc_type asm.</i>&nbsp;<br>
Various other options may be set, including the degree of overlap<br>
      <i> -pc_asm_overlap &lt;number&gt;</i><br>
the type of restriction/extension&nbsp;<br>
      <i>-pc_asm_type [basic,restrict,interpolate,none] </i>
- Sets ASM type and several others. You may see the available ASM
options by using<br>
      <i> -pc_type asm -help</i><br>
Also, see the procedural interfaces in the manual pages, with names <b>PCASMxxxx()</b><br>
and check the index of the users manual for <b>PCASMxxx</b>().<br>
      <br>
Note that Paulo Goldfeld contributed a preconditioner "nn", a version
of your Neumann-Neumann balancing preconditioner; this may be activated
via<br>
      <i> -pc_type nn</i><br>
The program petsc/src/contrib/oberman/laplacian_ql contains an example
of its use.<br>
      </p>
      <hr>
      <p>&nbsp;<strong><a name="blocks"><font color="#ff0000">Can I
create BAIJ matrices with different
size blocks for different block rows?</font></a></strong></p>
Sorry, this is not possible, the BAIJ format only supports a single
fixed block size on the entire matrix. But the AIJ format automatically
searches for matching rows and thus still takes advantage of the
natural blocks in your matrix to obtain good performance. Unfortunately
you cannot use the MatSetValuesBlocked().<br>
      <br>
      <br>
      <p><strong><a name="mpi-vec-to-seq-vec"><font color="#ff0000">How
do I collect all the values from a
parallel PETSc vector into a sequential vector on each processor?</font></a></strong></p>
      <p> </p>
      <ul>
        <li> Create the scatter context that will do the
communication </li>
        <li> <a
 href="manualpages/Vec/VecScatterCreateToAll.html"><strong>VecScatterCreateToAll</strong></a>(v,&amp;ctx,&amp;w);</li>
      </ul>
      <table width="100%">
        <tbody>
          <tr>
            <td valign="top" width="75%"><li> Actually do the
communication; this can be done
repeatedly as needed</li>
            <ul>
              <li> <a
 href="manualpages/Vec/VecScatterBegin.html"><strong>VecScatterBegin</strong></a>(ctx,v,w,INSERT_VALUES,SCATTER_FORWARD);</li>
              <li> <a
 href="manualpages/Vec/VecScatterEnd.html"><strong>VecScatterEnd</strong></a>(ctx,v,w,INSERT_VALUES,SCATTER_FORWARD);</li>
            </ul>
            <li> Remember to free the scatter context when no longer
needed</li>
            <ul>
              <li> <a
 href="manualpages/Vec/VecScatterDestroy.html"><strong>VecScatterDestroy</strong></a>(ctx);</li>
            </ul>
Note that this simply concatenates in the parallel ordering of the
vector. If you are using a vector from DACreateGlobalVector() you
likely want to first call DAGlobalToNaturalBegin/End() to scatter the
original vector into the natural ordering in a new global vector before
calling VecScatterBegin/End() to scatter the natural vector onto all
processes.
            <p></p>
            <p><strong><a name="mpi-vec-to-mpi-vec"><font
 color="#ff0000">How do I collect all the values from a
parallel PETSc vector into a vector on the zeroth processor?</font></a></strong></p>
            <p> </p>
            <ul>
              <li> Create the scatter context that will do the
communication </li>
              <ul>
                <li> <a
 href="manualpages/Vec/VecScatterCreateToZero.html"><strong>VecScatterCreateToZero</strong></a>(v,&amp;ctx,&amp;w);</li>
              </ul>
              <li> Actually do the communication; this can be done
repeatedly as needed</li>
              <ul>
                <li> <a
 href="manualpages/Vec/VecScatterBegin.html"><strong>VecScatterBegin</strong></a>(ctx,v,w,INSERT_VALUES,SCATTER_FORWARD);</li>
                <li> <a
 href="manualpages/Vec/VecScatterEnd.html"><strong>VecScatterEnd</strong></a>(ctx,v,w,INSERT_VALUES,SCATTER_FORWARD);</li>
              </ul>
              <li> Remember to free the scatter context when no longer
needed</li>
              <ul>
                <li> <a
 href="manualpages/Vec/VecScatterDestroy.html"><strong>VecScatterDestroy</strong></a>(ctx);</li>
              </ul>
            </ul>
Note that this simply concatenates in the parallel ordering of the
vector. If you are using a vector from DACreateGlobalVector() you
likely want to first call DAGlobalToNaturalBegin/End() to scatter the
original vector into the natural ordering in a new global vector before
calling VecScatterBegin/End() to scatter the natural vector onto
process 0.
            <p>&nbsp;<br>
            <strong><a name="sparse-matrix-ascii-format"></a></strong><span
 style="color: rgb(255, 0, 0);">How can I read in or write out a sparse
matrix in Matrix Market, Harwell-Boeing, SLAPC or other ASCII format?</span><strong
 style="color: rgb(255, 0, 0);"></strong></p>
See the examples in
src/mat/examples/tests, specifically ex72.c and ex32.c. You will
likely need to modify the code slightly to match your required ASCII
format. Note: Never read or write in parallel an ASCII matrix file,
instead for reading: read in sequentially then save the matrix with the
binary viewer PetscBinaryViewerOpen() and load the matrix in parallel
with MatLoad(); for writing save with the binary viewer and then load
with the sequential code to store it as ASCII.<br>
            <br>
            <br>
            <strong><a name="setfromoptions"></a></strong><span
 style="color: rgb(255, 0, 0);">Does
TSSetFromOptions(), SNESSetFromOptions() or KSPSetFromOptions() reset
all the parameters I previously set or how come my TS/SNES/KSPSetXXX()
does not seem to work?</span><strong style="color: rgb(255, 0, 0);"></strong>
            <br>
            <br>
If XXSetFromOptions() is used (with -xxx_type aaaa) to change the type
of the object then all parameters associated with the previous type are
removed. Otherwise it does not reset parameters.<br>
            <br>
TS/SNES/KSPSetXXX() commands that set properties for a particular type
of object (such as KSPGMRESSetRestart()) ONLY work if the object is
ALREADY of that type. For example, with<br>
KSPCreate(PETSC_COMM_WORLD,&amp;ksp);<br>
KSPGMRESSetRestart(ksp,10); the restart will be ignored since the type
has not yet been set to GMRES. &nbsp;To have those values take effect
you should do one of the following<br>
            <br>
XXXCreate(..,&amp;obj);<br>
            <br>
XXXSetFromOptions(obj); &nbsp; allow setting the type from the command
line, if it is not on the command line then the default type is
automatically set<br>
            <br>
XXXSetYYYYY(obj,...); &nbsp; if the obj is the appropriate type then
the operation takes place<br>
            <br>
XXXSetFromOptions(obj); &nbsp;allow user to overwrite options hardwired
in code (optional)<br>
            <br>
The other approach is to replace the first XXXSetFromOptions() to
XXXSetType(obj,type) and hardwire the type at that point.<br>
            <br>
            <br>
            <br>
            <strong><a name="setfromoptions"></a></strong><span
 style="color: rgb(255, 0, 0);">Can I use my own makefiles or rules for
compiling code, instead of using PETSc's?</span><br>
            <br>
Yes, see the section of the <a
 href="manual.pdf">users
manual</a> called Makefiles <br>
            <br>
            <a name="carriagereturns"></a><span
 style="color: rgb(255, 0, 0);">How can I put carriage returns in
PetscPrintf() statements from Fortran?</span><br>
            <br>
You can use the same notation as in C, just put a \n in the string.
Note that no other C format instruction is supported. <br>
Or you can use the Fortran concatination // and&nbsp;char(10); for
example 'some string'//char(10)//'another string on the next line'<br>
            <br>
            <a name="functionjacobian"></a><span
 style="color: rgb(255, 0, 0);">Everyone
knows that when you code Newton's method you should compute the
function and its Jacobian at the same time. How can one do this in
PETSc?<br>
            <br>
            </span>The update in Newton's method is computed as u^{n+1}
= u^n - lambda * approx-inverse[J(u^n)] * F(u^n)]. The reason PETSc
doesn't default to computing both the function and Jacobian at the same
time is<br>
            <ol>
              <li>In order to do the line search, F (u^n - lambda *
step) may need to be computed for several lambda, the Jacobian is not
needed for each of those and one does not know in advance which will be
the final lambda until after the function value is computed, so many
extra Jacobians may be computed.</li>
              <li>In the final step if || F(u^p)|| satisfies the
convergence criteria then a Jacobian need not be computed.</li>
            </ol>
You are free to have your "FormFunction" compute as much of the
Jacobian at that point as you like, keep the information in the user
context (the final argument to FormFunction and FormJacobian) and then
retreive the information in your FormJacobian() function.<br>
            <br>
            <span style="color: rgb(255, 0, 0);"><a name="invertmatrix"></a>How
can I compute the inverse of a matrix in PETSc?<br>
            <br>
            </span>It is very expensive to compute the inverse of a
matrix and very rarely needed in practice. We highly recommend avoiding
&nbsp;algorithms that need it. The inverse of a matrix (dense or
sparse) is essentially always dense, so begin by creating a dense
matrix B and fill it with the identity matrix (ones along the
diagonal), also create a dense matrix X of the same size that will hold
the solution. Then factor the matrix you wish to invert with
MatLUFactor() or MatCholeskyFactor(), call the result A. Then call
MatMatSolve(A,B,X) to compute the inverse into X. <a
 href="faq.html#schurcomplement">See also</a>.<br>
            <br>
            <span style="color: rgb(255, 0, 0);"><a
 name="schurcomplement"></a>How can I compute the Schur complement, Kbb
- Kab * inverse(Kbb) * Kba in PETSc?<br>
            <br>
            </span>It
is very expensive to compute the Schur complement of a matrix and very
rarely
needed in practice. We highly recommend avoiding &nbsp;algorithms that
need
it. The Schur complement of a matrix (dense or sparse) is essentially
always
dense, so begin by<br>
            <ul>
              <li>forming a dense matrix Kba,&nbsp;</li>
              <li>also create another dense matrix T
of the same size.&nbsp;</li>
              <li>Then factor the matrix
Kaa&nbsp; with MatLUFactor() or MatCholeskyFactor(), call the
result A.</li>
              <li>Then call MatMatSolve(A,Kba,T).&nbsp;</li>
              <li>Then call
MatMatMult(Kab,T,MAT_INITIAL_MATRIX,1.0,&amp;S).</li>
              <li>Now call MatAXPY(S,-1.0,Kbb,MAT_SUBSET_NONZERO).</li>
              <li>Followed by MatScale(S,-1.0);</li>
            </ul>
As you can see, this requires a great deal of work space and
computation so is best avoided. For example if you want to solve S x =
b, instead of forming S explicitly you can provide the action of S on a
vector efficiently with a MATSHELL and pass this to a KSP solver.<br>
            <br>
            <span style="color: rgb(255, 0, 0);"><a name="fem"></a>Do
you have examples of doing unstructured grid finite element
computations (FEM) with PETSc?<br>
            <br>
            </span>There are at least two ways to write a finite
element code using PETSc<br>
1) use the Sieve construct in PETSc, this is a high level approach that
uses a small number of abstractions to help you manage distributing the
grid data structures and computing the elements into the matrices.<br>
2) manage the grid data structure yourself and use PETSc IS and
VecScatter to communicate the required ghost point communication. See <a
 href="www.mcs.anl.gov/petsc/petsc-as/snapshots/petsc-current/src/snes/examples/tutorials/ex10d/ex10.c.html">src/snes/examples/tutorials/ex10d/ex10.c</a><br>
            <br>
            <br>
            <span style="color: rgb(255, 0, 0);"><a name="da_mpi_cart"></a>The
PETSc DA object decomposes the domain differently than the
MPI_Cart_create() command. How can one use them together?<br>
            <br>
            </span>The MPI_Cart_create() first divides the mesh along
the z direction, then the y, then the x. DA divides along the x, then
y, then z. Thus, for example, rank 1 of the processes will be in a
different part of the mesh for the two schemes. To resolve this you can
create a new MPI communicator that you pass to DACreate() that
renumbers the process ranks so that each physical process shares the
same part of the mesh with both the DA and the MPI_Cart_create(). The
code to determine the new numbering was provided by Rolf Kuiper. <br>
            <br>
// the numbers of processors per direction are (int) x_procs, y_procs,
z_procs respectively <br>
// (no parallelization in direction 'dir' means dir_procs = 1)<br>
            <br>
MPI_Comm NewComm;<br>
int MPI_Rank, NewRank, x,y,z;<br>
            <br>
// get rank from MPI ordering:<br>
MPI_Comm_rank(MPI_COMM_WORLD, &amp;MPI_Rank);<br>
            <br>
// calculate coordinates of cpus in MPI ordering:<br>
x = MPI_rank / (z_procs*y_procs);<br>
y = (MPI_rank % (z_procs*y_procs)) / z_procs;<br>
z = (MPI_rank % (z_procs*y_procs)) % z_procs;<br>
            <br>
// set new rank according to PETSc ordering:<br>
NewRank = z*y_procs*x_procs + y*x_procs + x;<br>
            <br>
// create communicator with new ranks according to PETSc ordering:<br>
MPI_Comm_split(PETSC_COMM_WORLD, 1, NewRank, &amp;NewComm);<br>
            <br>
// override the default communicator (was MPI_COMM_WORLD as default)<br>
PETSC_COMM_WORLD = NewComm;<br>
            <br>
            <span style="color: rgb(255, 0, 0);"><a name="redistribute"></a>The
When
solving a symmetric system with Dirichlet boundary conditions I can use
MatZeroRows() to eliminate the Dirichlet rows but this results in a
non-symmetric system. How come there is no MatZeroColumns() to keep the
matrix symmetric?<br>
            <br>
            </span>For the default PETSc sparse matrix data structures (parallel and sequential) which are row based, zeroing certain columns is very expensive (it would require either searches or additional data structures). Hence we don't provide this functionality. One can solve Dirichilet boundary condition problems using symmetric methods three ways. (1) Manually call MatGetSubMatrix() to extract your symmetric subproblem or (2) call MatZeroRows() then use the PCREDISTRIBUTE preconditioner to solve the reduced system using. (3) When assemblying the matrix, (generating values and passing them to the matrix), never include locations for the Dirichlet grid points in the vector and matrix, instead take them into account as you put the other values into the load. This approach has the advantage of less memory usage since (1) and (2) will require essentially twice as much memory.
symmetric methods. See its manual page.
            <hr> </td>
          </tr>
        </tbody>
      </table>
      <hr>
      <h3><a name="Execution">Execution</a></h3>
      <p><strong><a name="long-link-time"><font color="#ff0000">PETSc
executables are SO big and take SO
long to link</font>.</a></strong></p>
      <p>We find this annoying as well. On most machines PETSc
can use
shared libraries, so executables should be much smaller, run
config/configure.py with the additional option --with-shared. Also, if
you have room, compiling and linking PETSc on your machine's /tmp disk
or similar local disk, rather than over the network will be much
faster. </p>
      <p><a name="petsc-options"><strong><font color="#ff0000">PETSc
has so many options for my program
that it is hard to keep them straight.</font></strong> </a></p>
      <p>Running the PETSc program with the option -help will
print of many of the options. To print the options that have been
specified within a program, employ -optionsleft to print any options
that the user specified but were not actually used by the program and
all options used; this is helpful for detecting typo errors. </p>
      <p><strong><a name="petsc-log-info"><font color="#ff0000">PETSc
automatically handles many of the
details in parallel PDE solvers. How can I understand what is really
happening within my program?</font> </a></strong></p>
      <p>You can use the option -info to get more details about
the solution process. The option -log_summary provides details about
the distribution of time spent in the various phases of the solution
process. You can use ${PETSC_DIR}/bin/petscview, which is a Tk/Tcl
utility that provides high-level visualization of the computations
within a PETSc program. This tool illustrates the changing
relationships among objects during program execution in the form of a
dynamic icon tree.</p>
      <p><strong><a name="efficient-assembly"><font color="#ff0000">Assembling
large sparse matrices takes a
long time. What can I do make this process faster?</font> </a></strong></p>
      <p>See the Performance chapter of the users manual for many
tips on this.</p>
      <p>a) Preallocate enough space for the sparse matrix. For
example, rather than calling
MatCreateSeqAIJ(comm,n,n,0,PETSC_NULL,&amp;mat); call
MatCreateSeqAIJ(comm,n,n,rowmax,PETSC_NULL,&amp;mat); where rowmax
is the maximum number of nonzeros expected per row. Or if you know the
number of nonzeros per row, you can pass this information in instead of
the PETSC_NULL argument. See the&nbsp; manual pages for each of the
MatCreateXXX() routines.</p>
      <p>b) Insert blocks of values into the matrix, rather than
individual components.&nbsp;</p>
      <p><strong><a name="log-summary"><font color="#ff0000">How can I
generate performance summaries
with PETSc?</font> </a></strong></p>
      <p>Use these options at runtime: -log_summary. See the
Performance chapter of the users manual for information on interpreting
the summary data. If using the PETSc (non)linear solvers, one can also
specify -snes_view or -ksp_view for a printout of solver info. Only the
highest level PETSc object used needs to specify the view option. </p>
      <p><strong><a name="parallel-roundoff"><font color="#ff0000">Why
do I get different answers on a
different numbers of processors?</font> </a></strong></p>
      <p>Most commonly, you are using a preconditioner which
behaves differently based upon the number of processors, such as
Block-Jacobi which is the PETSc default. However, since computations
are reordered in parallel, small roundoff errors will still be present
with identical mathematical formulations. If you set a tighter linear
solver tolerance (using -ksp_rtol), the differences will decrease.</p>
      <p><strong><a name="mg-log"><font color="#ff0000">How do I know
the amount of time spent on
each level of the multigrid solver/preconditioner?</font></a></strong></p>
      <p>Run with -log_summary and -pc_mg_log</p>
      <p><strong></strong><font><strong><a name="datafiles"><font
 color="#ff0000">Where do I get the input matrices for the examples?<br>
      </font></a></strong></font></p>
      <p>Some makefiles use &nbsp;${DATAFILESPATH}/matrices/medium and
other files. These test matrices in PETSc binary format can be found
with anonymous ftp from <a href="http://ftp.mcs.anl.gov">ftp.mcs.anl.gov</a>
in the directory pub/petsc/matrices. The are not included
with the PETSc distribution in the interest of reducing the
distribution size.</p>
      <p><font><strong><a name="info"><font color="#ff0000">When I dump
some matrices and vectors to binary, I seem to be generating some empty
files with .info extensions.&nbsp; What's the deal with these?<br>
      </font></a></strong></font> </p>
      <p>PETSc binary viewers put some additional information into
.info files like matrix block size; it is harmless<br>
but if you really don't like it you can use -viewer_binary_skip_info
or&nbsp; PetscViewerBinarySkipInfo()<br>
note you need to call PetscViewerBinarySkipInfo() before
PetscViewerFileSetName(). In other words you<br>
cannot use PetscViewerBinaryOpen() directly.<br>
      </p>
      <p><font><strong><a name="slow"><font color="#ff0000">MatSetValues()
is so slow, what can I do to speed it up?<br>
      </font></a></strong></font> </p>
Preallocation of matrix memory is crucial for good performance for
large problems, see <br>
      <a
 href="manual.pdf#sec_matsparse">manual.pdf#sec_matsparse</a><br>
      <a
 href="manualpages/Mat/MatCreateMPIAIJ.html">manualpages/Mat/MatCreateMPIAIJ.html</a><br>
      <br>
If you can set several nonzeros in a block at the same time, this is
faster than calling MatSetValues() for each <br>
individual matrix entry.<br>
      <br>
It is best to generate most matrix entries on the process they belong
to (so they do not have to be stashed and then shipped to the owning
process). Note: it is fine to have some entries generated on the
"wrong" process, just not many.<br>
      <br>
      <p><font><strong><a name="slowerparallel"><font color="#ff0000">Why
is my parallel solver&nbsp;slower than my sequential solver?<br>
      </font></a></strong></font> </p>
This can happen for many reasons:<br>
      <ul>
        <li>First make sure it is truely the time in KSPSolve() that is
slower (by running the code with <a href="faq.html#log-summary">-log_summary</a>).
Often the slower time is in <a href="faq.html#slow">generating the
matrix</a> or some other operation.</li>
        <li>There must be enough work for each process to overweigh the
communication time. We recommend an absolute minimum of about 10,000
unknowns per process, better is 20,000 or more.</li>
        <li>Make sure the&nbsp; <a href="faq.html#computers">communication
speed of the parallel computer</a> is good enough for parallel solvers.</li>
        <li>Check the number of solver iterates with the parallel
solver against the sequential solver. Most preconditioners require more
iterations when used on
more processes, this is particularly true for block Jaccobi, the
default parallel preconditioner, you can try -pc_type asm (<a
 href="manualpages/PC/PCASM.html">PCASM</a>)
its iterations scale a bit better for more processes. You may also
consider multigrid preconditioners like <a
 href="manualpages/PC/PCMG.html">PCMG</a>
or BoomerAMG in <a
 href="manualpages/PC/PCHYPRE.html">PCHYPRE</a>.</li>
      </ul>
      <p><font><strong><a name="singleprecision"><font color="#ff0000">When
using PETSc in single precision mode (--with-precision=single when
running config/configure.py) are the operations done in single or
double precision? </font></a></strong></font> </p>
PETSc does NOT do any explicit conversion of single precision to double
before performing computations;
this it depends on the hardware and compiler what happens. For example,
the compiler could
choose to put the single precision numbers into the usual double
precision registers and then use
the usual double precision floating point unit. Or it could use SSE2
instructions that work directly
on the single precision numbers. It is a bit of a mystery what
decisions get made sometimes.
There may be compiler flags in some circumstances that can affect this.
      <p></p>
      <hr>
      <h3><a name="Debugging">Debugging</a></h3>
      <p><a name="debug-ibm"><font color="#ff0000"><strong>How
do I turn off PETSc signal handling so I can use the -C option on xlF?</strong>
      </font></a></p>
      <p>Immediately after calling PetscInitialize() call
PetscPopSignalHandler()</p>
      <p>Some Fortran compilers including the IBM xlf, xlF etc
compilers have a compile option (-C for IBM's) that causes all array
access in Fortran to be checked that they are in-bounds. This is a
great feature but does require that the array dimensions be set
explicitly, not with a *.</p>
      <p><a name="debug-cray"><font color="#ff0000"><strong>How do I
debug on the Cray
T3D/T3E?</strong> </font></a></p>
      <p>Use TotalView. First, link your program with the
additional option -Xn where n is the number of processors to use when
debugging. Then run totalview programname -a your arguments The -a is
used to distinguish between totalview arguments and yours. </p>
      <p><strong><a name="start_in_debugger-doesnotwork"><font
 color="#ff0000">How do I debug if -start_in_debugger does
not work on my machine?</font> </a></strong></p>
      <p>For a uniprocessor job, just try&nbsp;the debugger
directly, for example: gdb ex1 </p>
      <p><a name="debug-hang"><font color="#ff0000"><strong>How do I
see where my code is
hanging?</strong> </font></a></p>
      <p>You can use the -start_in_debugger option to start all
processes in the debugger (each will come up in its own xterm). Then
use cont (for continue) in each xterm. Once you are sure that the
program is hanging, hit control-c in each xterm and then use 'where' to
print a stack trace for each process.</p>
      <p><a name="debug-inspect"><font color="#ff0000"><strong>How can
I inspect Vec and Mat
values when in the debugger?</strong> </font></a></p>
      <p>I will illustrate this with gdb, but it should be
similar on other debuggers. You can look at local Vec values directly
by obtaining the array. For a Vec v, we can print all local values using</p>
      <p>(gdb) p ((Vec_Seq*)
v-&gt;data)-&gt;array[0]@v-&gt;map.n</p>
      <p>However, this becomes much more complicated for a
matrix. Therefore, it is advisable to use the default viewer to look at
the object. For a Vec v and a Mat m, this would be</p>
      <p>(gdb) call VecView(v, 0)</p>
      <p>(gdb) call MatView(m, 0)</p>
      <p>or with a communicator other than MPI_COMM_WORLD,</p>
      <p>(gdb) call MatView(m,
PETSC_VIEWER_STDOUT_(m-&gt;comm))</p>
      <p>&nbsp;<span style="color: rgb(255, 0, 0);"><a name="libimf"></a>error
while loading shared libraries: libimf.so: cannot open shared object
file: No such file or directory.</span></p>
      <p>The Intel compilers use shared libraries (like libimf) that
cannot by default at run time. When using the Intel compilers (and
running the resulting code) you must make sure that the proper Intel
initialization scripts are run. This is usually done by putting some
code into your .cshrc, .bashrc, .profile etc file. Sometimes on batch
file systems that do now access your initialization files (like .cshrc)
you must include the initialization calls in your batch file submission.</p>
For example, on my Mac using csh I have the following in my .cshrc file<br>
      <br>
source /opt/intel/cc/10.1.012/bin/iccvars.csh<br>
source /opt/intel/fc/10.1.012/bin/ifortvars.csh<br>
source /opt/intel/idb/10.1.012/bin/idbvars.csh<br>
      <br>
in my .profile I have<br>
      <br>
source /opt/intel/cc/10.1.012/bin/iccvars.sh<br>
source /opt/intel/fc/10.1.012/bin/ifortvars.sh<br>
source /opt/intel/idb/10.1.012/bin/idbvars.sh<br>
      <br>
      <p></p>
      <p></p>
      <p><span style="color: rgb(255, 0, 0);"></span></p>
      <p><span style="color: rgb(255, 0, 0);"></span></p>
      <hr>
      <h3><a name="Shared Libraries">Shared Libraries</a></h3>
      <p><font color="#ff0000"><strong><a name="install-shared">Can I
install PETSc libraries as
shared libraries</a>?</strong></font></p>
      <p>Yes.&nbsp;Use the config/configure.py option
--with-shared</p>
      <p><a name="why-use-shared"><strong><font color="#ff0000">Why
should I use shared libraries?</font></strong></a></p>
      <p>When you link to shared libraries, the function symbols
from the shared libraries are not copied in the executable. This way
the size of the executable is considerably smaller than when using
regular libraries. This helps in a couple of ways: <br>
&nbsp;&nbsp;&nbsp; 1) saves disk space when more than one
executable is created, and &nbsp; <br>
&nbsp;&nbsp;&nbsp; 2) improves the compile time immensly,
because the compiler has to write a much smaller file (executable) to
the disk.</p>
      <p><font color="#ff0000"><strong><a name="link-shared">How do I
link to the PETSc shared
libraries</a>?</strong></font></p>
      <p>By default, the compiler should pick up the shared
libraries instead of the regular ones. Nothing special should be done
for this.</p>
      <p><font color="#ff0000"><strong><a name="link-regular-lib">What
If I want to link to the
regular .a library files</a>?</strong></font></p>
      <p>You must run config/configure.py without the option
--with-shared (you can use a different PETSC_ARCH for this build so you
can easily switch between the two).</p>
      <p><a name="move-shared-exec"><font color="#ff0000"><strong>What
do I do if I want to move
my executable to a different machine?</strong></font></a></p>
      <p>You would also need to have access to the shared
libraries on this new machine. The other alternative is to build the
exeutable without shared libraries by first deleting the shared
libraries, and then creating the executable.&nbsp;</p>
      <p><a name="dynamic-shared"><font color="#ff0000"><strong>What is
the deal with dynamic
libraries (and difference between shared libraries)</strong></font></a></p>
      <p>PETSc libraries are installed as dynamic libraries when
the
config/configure.py flag --with-dynamic is used. The difference with
this - from shared libraries - is the way the libraries are used. From
the program the library is loaded using dlopen() - and the functions
are searched using dlsymm(). This separates the resolution of function
names from link-time to run-time - i.e when dlopen()/dlsymm() are
called.</p>
      <p>When using Dynamic libraries - PETSc libraries cannot be
moved to a different location after they are built. </p>
      <p>&nbsp; </p>
      <p></body>
</html>