The @package{FL.GEOMG} package contains iterations which depend on geometric information, obtained for example from the discretization. At the moment, these are the geometric multigrid iteration, an AMG-like scheme for preconditioning high-order discretizations with low-order ones, and some block smoothers with overlapping blocks.

Source

geomg-defp.lisp.

Use List

common-lisp.
common-lisp-user.
fl.debug.
fl.discretization.
fl.function.
fl.iteration.
fl.macros.
fl.matlisp.
fl.mesh.
fl.multigrid.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.
fl.strategy.

Public Interface

<geometric-cs> (class).
<geometric-fas> (class).
<geometric-psc> (class).
<geometric-ssc> (class).
<s1-coarse-grid-iterator> (class).
<s1-reduction> (class).
<vanka> (class).
fas (function).
geometric-cs (function).
geometric-psc (function).
geometric-ssc (function).
s1-reduction-amg-solver (function).

Internals

<geometric-blocking-mixin> (class).
<geometric-mg> (class).
<local-mg> (class).
extend-horizontally (function).
extend-level-matrix (function).
extended-block (function).
find-vertex-centered-block (function).
galerkin-p (generic reader).
local-mg (function).
solution (generic reader).
(setf solution) (generic writer).
test-geomg (function).

Next: fl.strategy, Previous: fl.geomg, Up: Packages [Contents][Index]

5.3 `fl.utilities`

This package contains generally useful utility functions. Several of those functions were taken from @cite{(Graham 1996)}, the SANS function was contributed to the @cite{comp.lang.lisp} newsgroup by Erik Naggum.

Source

utilities-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.macros.

Used By List

Public Interface

add-hook (function).
array-for-each (function).
blackboard (function).
blackboard (class).
box (function).
call-hooks (function).
check-properties (function).
common-lisp-speed (function).
compose (function).
compose-2 (generic function).
concept-documentation (function).
constant-vector (function).
copy-hash-table (function).
copy-slots (generic function).
curry (function).
dequeue (generic function).
dequeue-all (generic function).
display-ht (function).
dli-object (reader).
(setf dli-object) (writer).
dli-pred (reader).
(setf dli-pred) (writer).
dli-succ (reader).
(setf dli-succ) (writer).
dll (class).
dll->list (function).
dll-empty-p (function).
dll-find (function).
dll-first (generic reader).
(setf dll-first) (generic writer).
dll-for-each (function).
dll-front-insert (function).
dll-item (structure).
dll-last (generic reader).
(setf dll-last) (generic writer).
dll-peek-first (function).
dll-peek-last (function).
dll-pop-first (function).
dll-pop-last (function).
dll-rear-insert (function).
dll-remove (function).
dll-remove-item (function).
dohash (macro).
dotuple (macro).
emptyp (generic function).
enqueue (generic function).
evaluate (generic function).
factorial (function).
file-documentation (function).
filter (function).
filter-if (function).
find-leaf (function).
find-leaf-if (function).
find-subtree (function).
find-subtree-if (function).
first-only (function).
fixnum-vec (function).
fixnum-vec (type).
flatten (function).
flatten-1 (function).
for-each (generic function).
for-each-tuple (function).
get-property (function).
(setf get-property) (function).
(setf geta) (setf expander).
geta (function).
getbb (function).
(setf getbb) (function).
group-by (function).
hash-table->alist (function).
hash-table-keys (function).
hash-table-values (function).
identity-permutation-p (function).
iterator (generic function).
iterator-end-p (generic function).
iterator-next (generic function).
k->l-subsets (function).
k-subsets (function).
kmgt (function).
list->dll (function).
list->queue (function).
loop+ (macro).
make-analog (generic function).
make-dll (function).
make-double-float-array (function).
make-filled-array (function).
make-fixnum-vec (function).
map-hash-table (function).
map-list-in-hash-table (function).
map-product (function).
map-tree (function).
mapf (macro).
mappend (function).
mapper-collect (function).
mapper-count (function).
mapper-every (function).
mapper-select-first (function).
mapper-some (function).
mapper-sum (function).
maximally-connected (function).
measure-time (function).
measure-time-for-block (macro).
memoize-1 (function).
memoize-expr (macro).
memoize-symbol (function).
mklist (function).
modify (function).
n-partitions-of-k (function).
nonempty-subsets (function).
on-leaves (function).
on-subtrees (function).
ordered-intersection (function).
ordered-set-difference (function).
ordered-union (function).
partial-sums (function).
permutation-inverse (function).
permutation-p (function).
permutation-shifted-inverse (function).
permutation-signum (function).
permute (function).
permute-into (function).
positive-fixnum (type).
positive-n-partitions-of-k (function).
positive-partitions-of-k (function).
properties (generic reader).
(setf properties) (generic writer).
property-mixin (class).
queue->list (function).
range (function).
range (class).
range< (function).
range<= (function).
rcurry (function).
reference (generic function).
(setf reference) (generic function).
required-argument (function).
safe-sort (function).
samep (function).
sans (function).
set-equal (function).
set-p (function).
single? (function).
split-by-length (function).
square (function).
subsets (function).
take (function).
thrice (function).
transfer-bb (function).
translate (function).
tree-uniform-number-of-branches (function).
tree-uniformp (function).
twice (function).
unbox (function).
(setf unbox) (function).
vector-cut (function).
vector-last (function).
(setf vector-last) (function).
vector-map (function).
with-items (macro).
xor (function).
zero-vector (function).

Internals

*hooks* (special variable).
*local-evaluation-memoization-table* (special variable).
*mflop-delta* (special variable).
+n-long+ (constant).
+n-short+ (constant).
array-contents (function).
binomial (function).
check (generic function).
copy-dll-item (function).
daxpy (function).
daxpy-speed (function).
ddot (function).
dll-check-consistency (function).
dll-item-p (function).
head (generic reader).
(setf head) (generic writer).
make-dll-item (function).
measure-time-repeated (function).
queue (class).
tail (generic reader).
(setf tail) (generic writer).
test-general (function).
test-mflop (function).
test-utilities (function).
undisplace-array (function).

Next: fl.discretization, Previous: fl.utilities, Up: Packages [Contents][Index]

5.4 `fl.strategy`

This package provides methods for solving problems by adaptive FEM.

Source

strategy-defp.lisp.

Use List

common-lisp.
fl.cdr.
fl.debug.
fl.dictionary.
fl.discretization.
fl.ellsys.
fl.function.
fl.geomg.
fl.iteration.
fl.macros.
fl.matlisp.
fl.mesh.
fl.plot.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Public Interface

*eta-observe* (special variable).
*fe-approximation-observe* (special variable).
*mentries-observe* (special variable).
*model-time-observe* (special variable).
*nr-of-cells-observe* (special variable).
*nr-of-dofs-observe* (special variable).
*rothe-observe* (special variable).
*stationary-fe-strategy-observe* (special variable).
<cell-rule-indicator> (class).
<duality-error-estimator> (class).
<fe-approximation> (class).
<fe-interpolation> (class).
<largest-eta-indicator> (class).
<projection-error-estimator> (class).
<refinement-indicator> (class).
<rothe> (class).
<stationary-fe-strategy> (class).
<strategy> (class).
<uniform-refinement-indicator> (class).
estimate (generic function).
indicate (generic function).
point-observe (function).

Internals

*cell->error* (special variable).
*cell->error-rank* (special variable).
*pivot-max-error* (special variable).
*u_1/4-observe* (special variable).
<difference-with-projection> (class).
<error-estimator> (class).
<fe-evp-strategy> (class).
<global-and-local-norm> (class).
<global-norm> (class).
<isotropizing-indicator> (class).
<local-test-with-dual> (class).
<setup-enriched-ansatz-space> (class).
<solve-dual-problem> (class).
<standard-error-estimator> (class).
approximate (generic function).
block-p (generic reader).
calculate-multistep-weights (function).
call-with-ivip (generic function).
call-with-time-step-problem (generic function).
cell-rule (generic function).
compute-error-approximant (generic function).
compute-local-estimate (generic function).
compute-weight-function (generic function).
ellsys-initial-value-interpolation-coefficients (function).
ellsys-time-step-coefficients (function).
ensure-ansatz-space (function).
ensure-mesh-quality-p (generic reader).
eta->p2-vec (function).
forced-times (generic reader).
fraction (generic reader).
from-level (generic reader).
functional (generic reader).
(setf functional) (generic writer).
global-estimate (generic function).
initial-value-interpolation-problem (generic function).
local-estimate (generic function).
maximal-time-step (generic reader).
minimal-time-step (generic reader).
model-time (generic reader).
old-time-step (generic reader).
pivot-factor (generic reader).
select-estimator (generic function).
select-indicator (generic function).
test-error-estimator (function).
test-error-indicator (function).
test-fe-interpolation (function).
test-fe-stationary (function).
test-rothe (function).
test-rothe-ellsys (function).
time-step (generic reader).
time-step-problem (generic function).
time-stepping-scheme (generic reader).
update-i-p-sol (function).
with-ivip (macro).
with-time-step-problem (macro).

Next: fl.problem, Previous: fl.strategy, Up: Packages [Contents][Index]

5.5 `fl.discretization`

The @package{FL.DISCRETIZATION} package defines @class{<discretization>} as an abstract class and @class{<fe-discretization>} as a concrete derived class.

The key for local assembly is given by the generic function @function{get-fe}, which yields a suitable finite element for a given cell. The value of @function{get-fe} is a class @class{<fe>} for scalar problems or @class{<vector-fe>} for vector-valued problems which contains information on base functions and node functionals. Another generic function @function{quadrature-rule} computes memoized quadrature rules for those finite elements.

Obviously, also non-standard finite element discretizations like hp-methods would fit into this scheme. The key for local assembly is given by the generic function @function{get-fe}, which yields a suitable finite element for a given cell. The value of @function{get-fe} is a class @class{<fe>} for scalar problems or @class{<vector-fe>} for vector-valued problems which contains information on base functions and node functionals. Another generic function @function{quadrature-rule} computes memoized quadrature rules for those finite elements.

The file @path{lagrange.lisp} provides Lagrange finite elements of arbitrary order. The evaluation points for the node functionals may be chosen either uniformly distributed or at the Gauss-Lobatto points. The latter choice of points yields better stability properties but is restricted to cube meshes. Also functions for constructing cell mappings by pointwise evaluation of the domain boundary are provided here, which may be used to construct isoparametric domain approximations.

In the file @path{fedisc.lisp}, the function @function{fe-discretize} is defined. This function performs the standard steps for finite element discretization: interior assembly, assembly and elimination of hanging-node and essential-boundary constraints. It works on a blackboard as explained in Section @ref{Blackboards} and can reuse already available matrix-vector structure. There is a somewhat less flexible interface provided by the funtion @function{discretize-globally} which calls @function{fe-discretize}.

In the files @path{ellsys-fe.lisp}, @path{elasticity-fe.lisp} and @path{navier-stokes.lisp} one can find methods for local assembly for the different problems. They are defined in own packages which use both the package @package{FL.DISCRETIZATION} and the package for the particular problem.

Source

discretization-defp.lisp.

Nickname

disc

Use List

common-lisp.
fl.cdr.
fl.debug.
fl.dictionary.
fl.function.
fl.iteration.
fl.macros.
fl.matlisp.
fl.mesh.
fl.parallel.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.elasticity-fe.
fl.ellsys-fe.
fl.flow-application.
fl.geomg.
fl.konwihr.
fl.navier-stokes-fe.
fl.plot.
fl.schaefer-turek.
fl.strategy.

Public Interface

*quadrature-order* (special variable).
*suggested-discretization-order* (special variable).
<ansatz-space-automorphism> (class).
<ansatz-space-morphism> (class).
<ansatz-space-vector> (class).
<ansatz-space> (class).
<discretization> (class).
<fe-discretization> (class).
<scalar-fe-discretization> (class).
<scalar-fe> (class).
<standard-fe-discretization> (class).
<vector-fe-discretization> (class).
<vector-fe> (class).
ansatz-space (generic reader).
assemble-constraints (function).
assemble-interior (generic function).
cell-integrate (generic function).
cell-key (function).
cell-lagrange-fe (function).
choose-start-vector (generic function).
component (generic function).
constrained-interpolation-matrix (function).
construct-coeff-input (function).
discretization-order (generic function).
discretize (generic function).
discretize-globally (function).
discretize-locally (generic function).
do-dof (macro).
dof (class).
dof-component (generic reader).
dof-coord (generic reader).
dof-functional (generic reader).
dof-gcoord (generic reader).
dof-in-vblock-index (generic reader).
dof-index (generic reader).
dof-subcell-index (generic reader).
domain-ansatz-space (generic function).
eliminate-constraints (function).
essential-boundary-constraints (generic function).
extended-extract (generic function).
fe-basis (generic reader).
fe-cell-geometry (function).
fe-class (slot).
fe-class (generic function).
fe-discretize (function).
fe-dofs (generic reader).
(setf fe-dofs) (generic writer).
fe-extraction-information (function).
fe-extreme-values (generic function).
fe-gradient (generic function).
fe-integrate (generic function).
fe-local-gradient (generic function).
fe-local-value (generic function).
fe-value (generic function).
gauss-lobatto-points (function).
gauss-lobatto-points-on-unit-interval (function).
gauss-lobatto-rule (function).
gauss-rule (function).
get-fe (generic function).
get-local-from-global-mat (generic function).
get-local-from-global-vec (generic function).
hierarchical-mesh (generic function).
image-ansatz-space (generic function).
increment-global-by-local-mat (generic function).
increment-global-by-local-vec (generic function).
inner-dof-indices (function).
integration-points (generic reader).
integration-rule (function).
integration-rule (class).
integration-weights (generic reader).
interior-dof? (function).
interpolate-on-refcell (generic function).
interpolation-matrix (function).
ip-gradients (generic function).
ip-values (generic function).
lagrange-ansatz-space (function).
lagrange-fe (function).
lagrange-mapping (function).
local-imatrix (function).
local-pmatrix (function).
local-transfer-matrix (function).
make-ansatz-space-automorphism (function).
make-ansatz-space-morphism (function).
make-ansatz-space-vector (function).
make-fe-ansatz-space (function).
make-local-mat (generic function).
make-local-vec (function).
mesh (generic function).
multiple-evaluate-local-fe (function).
nr-of-dofs (generic function).
nr-of-inner-dofs (generic function).
problem (generic function).
product-rule (function).
projection-matrix (function).
quadrature-rule (generic function).
random-ansatz-space-vector (function).
select-discretization (generic function).
set-global-to-local-mat (generic function).
set-global-to-local-vec (generic function).
sort-keys-hierarchically (function).
special-ansatz-space-vector (function).
subcell-ndofs (function).
subcell-offsets (function).
transfer-matrix (function).
weights-for-ips (function).

Internals

*check-hash-table* (special variable).
*check-lock* (special variable).
*dof-precise-evaluation* (special variable).
*interpolation-type* (special variable).
*ipt-tolerance* (special variable).
*local-interpolation-matrix* (special variable).
*local-mat-pool* (special variable).
*local-projection-matrix* (special variable).
*quadrature-rule-float-type* (special variable).
*quadrature-rule-internal-precision* (special variable).
*use-pool-p* (special variable).
<ansatz-space-object> (class).
<domain-image-mixin> (class).
<fe> (class).
add-local-part! (function).
assemble-cell (function).
assembly-heap (function).
c-dirichlet-dof-p (function).
c-find-master (function).
c-slave-dof-p (function).
cell-volume (function).
children-offsets (function).
chunk-enqueue (generic function).
chunk-queue (class).
combined-constraints (function).
compute-duals (function).
compute-energy (function).
compute-essential-boundary-constraints (function).
compute-local-imatrix (generic function).
compute-local-pmatrix (generic function).
cone-rule-for-simplex (function).
copy-ip (function).
delay-possible-p (function).
discretization (generic reader).
dof-subcell (generic reader).
domain-volume (function).
eliminate-hanging-node-constraints-from-matrix (function).
ensure-constraints (function).
essential-constraints-for-key (function).
evaluate-shapes-at-points (function).
extract-ip-data (function).
fast-ip-gradients (function).
fe-discretize-linear-problem (function).
fe-factors (generic reader).
fe-secondary-information (function).
fill-local-from-global-mat (generic function).
fill-local-from-global-vec (generic function).
gauss-lobatto-family (function).
gauss-lobatto-rule-on-unit-interval (function).
gauss-points-for-weight (function).
gauss-rule-for-simplex (function).
gauss-rule-for-weight (function).
get-matrix-blocks (function).
global-local-matrix-operation (generic function).
global-local-vector-operation (generic function).
gram-matrix (function).
hanging-nodes-constraints (function).
high-precision-integration-points (function).
high-precision-integration-weights (function).
high-precision-ips (generic reader).
identification-constraints (function).
identification-matrix (function).
integrate-monomial (function).
integrate-monomial-over-simplex-product (function).
integrate-over-reference-product-cell (function).
integrate-over-reference-simplex (function).
interpolate-coefficient (function).
interpolate-function (function).
interpolation-function (generic function).
ip-coords (function).
(setf ip-coords) (function).
ip-gradients-at-point (generic function).
ip-values-at-point (generic function).
ip-weight (function).
(setf ip-weight) (function).
jacobi-polynomial (function).
key-cells (function).
lagrange-basis (function).
lagrange-basis-boundary (function).
lagrange-basis-inner (function).
lagrange-basis-simplex (function).
lagrange-boundary-dofs (function).
lagrange-coords-1d (function).
lagrange-dofs (function).
lagrange-inner-coords (generic function).
lagrange-polynomial-vector (function).
lagrange-reference-parameters (function).
legendre-polynomial (function).
local-interpolation-matrix (function).
local-projection-matrix (function).
lock (function).
make-ip (function).
new-gauss-rule-for-simplex (function).
new-vector-dof-from-dof (function).
p-nomials-of-degree (function).
precise-coord (generic reader).
precise-gcoord (generic reader).
project (function).
projection-coefficients (function).
q-nomials-of-degree (function).
rule-factors (generic reader).
safer-find-cell-from-position (function).
set-constraints (generic function).
set-lagrange-ansatz-space-vector (function).
shapes-and-dof-coords (function).
slow-ip-gradients (function).
test-assembly-heap (function).
test-constraints (function).
test-fe (function).
test-fedisc (function).
test-fetransfer (function).
test-integration-rule (function).
test-lagrange (function).
test-quadrature (function).
test-sparseas (function).
test-sparseif (function).
unlock (function).
update-cell-extreme-values (function).
vector-dof (class).
volume-of-cell (function).
work-done (function).
work-on-queue (generic function).
zeros-of-separating-family (function).

Next: fl.matlisp, Previous: fl.discretization, Up: Packages [Contents][Index]

5.6 `fl.problem`

The @package{FL.PROBLEM} package introduces the
general class @class{<problem>} and some subclasses. The most interesting subclass is @class{<pde-problem>}. A @class{<pde-problem>} is defined on a domain and provides a table mapping the domain patches to property lists containing the coefficient functions.

Several subclasses of @class{<pde-problem>} are defined in own packages, e.g. @class{<cdr-problem>} in @package{FL.CDR}, @class{<elasticity-problem>} in @package{FL.ELASTICITY} and @class{<navier-stokes-problem} in @package{FL.NAVIER-STOKES}.

Source

problem-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.dictionary.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.utilities.

Used By List

fl.application.
fl.cdr.
fl.discretization.
fl.elasticity.
fl.elasticity-fe.
fl.ellsys.
fl.ellsys-fe.
fl.flow-application.
fl.iteration.
fl.konwihr.
fl.multigrid.
fl.navier-stokes.
fl.navier-stokes-fe.
fl.plot.
fl.schaefer-turek.
fl.strategy.

Public Interface

<coefficient> (class).
<domain-problem> (class).
<evp-mixin> (class).
<evp> (class).
<interpolation-problem> (class).
<ls-evp> (class).
<lse> (class).
<multiphysics-mixin> (class).
<nlse> (class).
<nonlinear-problem> (class).
<pde-problem> (class).
<problem> (class).
<time-dependent-problem> (class).
add-fe-parameters-demand (function).
assembly-type (generic reader).
coefficient-macros (function).
coefficient-name (generic reader).
coefficients-of-cell (generic function).
coefficients-of-patch (function).
component-length (function).
component-position (function).
component-symbol (function).
components (slot).
components (slot).
components (generic function).
(setf components) (generic writer).
components (slot).
components-of-cell (generic function).
components-of-patch (generic function).
(setf components-of-patch) (generic function).
constant-coefficient (function).
constraint-coefficient (function).
constraint-p (function).
copy-coefficient (function).
coupling-with (macro).
create-problem (macro).
define-coefficient-macro (macro).
demands (generic function).
dual-problem (generic function).
end-time (generic reader).
energy (generic function).
ensure-coefficient (function).
ensure-residual (generic function).
ensure-solution (generic function).
extract-from (function).
extraction-information (function).
filter-applicable-coefficients (function).
find-coefficient (function).
find-component (function).
fu->coefficient (function).
function->coefficient (function).
fx->coefficient (function).
fxu->coefficient (function).
get-coefficient (function).
get-coefficients (function).
identification-coefficient (function).
linear-p (generic function).
linearize (generic function).
lse (function).
make-coefficients-for (generic function).
mass (generic function).
mass-matrix (generic reader).
matrix (generic reader).
matrix (slot).
nlse (function).
nr-of-components (generic function).
nr-of-components-of-patch (function).
nr-of-components-of-problem (generic function).
prepare-coefficient-arguments (function).
register-coefficient-macros (function).
required-fe-functions (function).
rhs (generic reader).
select-linear-solver (generic function).
select-on-patch (macro).
select-solver (generic function).
self-adjoint-p (generic function).
start-time (generic reader).
start-time (slot).
stationary-problem-class (function).
stiffness-matrix (generic reader).
subproblem (macro).
subproblems (generic reader).
time-dependent-problem-class (generic function).

Internals

*assembly-type* (special variable).
*coefficient-component-offsets* (special variable).
check-component (function).
check-components (function).
classify-problem (generic function).
coeff-eval (generic reader).
component-name (function).
compress-fe-parameters (function).
constraint (macro).
derivative-symbol-p (function).
extract-from-gradient (function).
fe-parameter-p (function).
identification-coefficient-p (function).
internal-component (special variable).
internal-component-2 (special variable).
internal-components (special variable).
internal-dimension (special variable).
internal-domain (special variable).
internal-length (special variable).
internal-length-2 (special variable).
internal-multiplicity (special variable).
internal-patch (special variable).
internal-patch-dimension (special variable).
internal-patch-if (special variable).
internal-position (special variable).
internal-position-2 (special variable).
internal-problem (special variable).
internal-properties (special variable).
internal-subproblem-name (special variable).
internal-subproblem-package (special variable).
internal-subproblems (special variable).
internal-value (special variable).
parameter-name (function).
parameter-order (function).
select-components-on-patch (macro).
sigma-p (function).
solution-dependent (function).
some-components (function).
test-evp (function).
test-pde-problem (function).
test-problem (function).
test-time (function).
with-coefficient-macros (macro).
zero-constraints (generic function).

Next: fl.macros, Previous: fl.problem, Up: Packages [Contents][Index]

5.7 `fl.matlisp`

This package provides a Common Lisp version of full
matrices with elements being numbers of a given type. Those classes are automatically generated when needed. It provides also part of the BLAS and LAPACK operations for those matrices. The corresponding methods are automatically compiled for the given matrix classes. The interface is very similar to the library Matlisp @cite{(Matlisp)}, which provides a CLOS interface to the Fortran BLAS and LAPACK routines.

Source

matlisp-defp.lisp.

Use List

common-lisp.
fl.amop.
fl.debug.
fl.dictionary.
fl.lapack.
fl.macros.
fl.parallel.
fl.utilities.

Used By List

Public Interface

*mzerop-threshold* (special variable).
*parallel-vector-algebra* (special variable).
*print-matrix* (special variable).
*print-matrix-element-format* (special variable).
*print-tensor* (special variable).
*standard-matrix-default-element-type* (special variable).
<matrix> (class).
<sparse-matrix> (class).
<sparse-tensor> (class).
<sparse-vector> (class).
<submatrix> (class).
<vector> (class).
access-type (generic function).
add-svec-to-local-block (generic function).
area-of-span (function).
average (function).
axpy (generic function).
axpy! (generic function).
blocks (generic reader).
cholesky (function).
col-key->size (generic function).
col-keys (generic function).
column (function).
column-table (generic reader).
(setf column-table) (generic writer).
combined-projection (function).
compressed->matlisp (generic function).
compressed-eye (function).
compressed-matrix (function).
compressed-matrix (class).
compressed-pattern (class).
copy (generic function).
copy! (generic function).
det (generic function).
det-from-lr (function).
diag (function).
diagonal (generic function).
diagonal-sparse-tensor (function).
dimensions (generic reader).
display (generic function).
docol (macro).
docols (macro).
dorow (macro).
dorows (macro).
dot (generic function).
dot-abs (generic function).
dotensor (macro).
double-vec (function).
double-vec (type).
dovec (macro).
element-type (generic function).
elementary (function).
ensure-matlisp (generic function).
entries (generic function).
(setf entries) (generic writer).
entry-allowed-p (generic function).
extend-by-identity (function).
extract-if (generic function).
extract-value-blocks (generic function).
eye (function).
fd-laplace-matrix (function).
fill! (generic function).
fill-random! (generic function).
for-each-col-key (generic function).
for-each-entry (generic function).
for-each-entry-and-key (generic function).
for-each-entry-and-vector-index (generic function).
for-each-entry-in-col (generic function).
for-each-entry-in-row (generic function).
for-each-key (generic function).
for-each-key-and-entry-in-col (generic function).
for-each-key-and-entry-in-row (generic function).
for-each-key-in-col (generic function).
for-each-key-in-row (generic function).
for-each-row-key (generic function).
full-ccs-pattern (function).
full-compressed-pattern (function).
full-crs-pattern (function).
full-tensor (function).
full-tensor (class).
gemm (function).
gemm! (function).
gemm-nn! (generic function).
gemm-nt! (generic function).
gemm-tn! (generic function).
gemm-tt! (generic function).
gesv (function).
gesv! (generic function).
getrf (function).
getrf! (generic function).
getrs (function).
getrs! (generic function).
ggev (generic function).
hegv (generic function).
hyperplane-normal (function).
in-pattern-p (generic function).
index-range-disjoint-p (function).
indices (generic reader).
(setf indices) (generic writer).
int-vec (function).
int-vec (type).
join (function).
join-horizontal! (generic function).
join-instance (generic function).
join-vertical! (generic function).
key->size (generic function).
keys->pattern (generic function).
keys-of-column (generic function).
keys-of-row (generic function).
kronecker-product (generic function).
l2-norm (generic function).
laplace-full-matrix (function).
laplace-sparse-matrix (function).
linf-norm (generic function).
lp-norm (generic function).
m* (generic function).
m*-nt (generic function).
m*-product-instance (generic function).
m*-tn (generic function).
m*-tn-product-instance (generic function).
m+ (generic function).
m+! (generic function).
m- (function).
m-! (function).
m-incf (macro).
m.* (function).
m/ (function).
make-domain-vector-for (generic function).
make-double-vec (function).
make-full-block-analog (function).
make-full-crs-matrix (function).
make-image-vector-for (generic function).
make-int-vec (function).
make-matrix (function).
make-matrix-block (function).
make-real-matrix (function).
make-real-tensor (function).
make-real-vector (function).
make-sparse-automorphism (function).
make-sparse-matrix (function).
make-sparse-vector (function).
make-uint-vec (function).
map-matrix (generic function).
mat-diff (generic function).
matrix-block (generic function).
(setf matrix-block) (generic function).
matrix-col-p (function).
matrix-column (generic function).
(setf matrix-column) (generic function).
matrix-row (generic function).
(setf matrix-row) (generic function).
matrix-row-p (function).
matrix-slice (generic function).
matrix-transpose-instance (generic function).
mequalp (generic function).
mextract! (generic function).
midentity-p (generic function).
minject! (generic function).
mrandom (function).
mref (generic function).
(setf mref) (generic function).
msquare-p (generic function).
msymmetric-p (generic function).
multiplicity (slot).
multiplicity (slot).
multiplicity (generic function).
mzerop (generic function).
ncols (generic function).
norm (generic function).
normalize (function).
normalize! (function).
nr-of-entries (generic function).
nrows (generic function).
number-coercer (function).
number-of-nonzero-entries (generic function).
ones (function).
pattern (generic reader).
range-and-domain-disjoint-p (function).
rank (generic function).
read-compressed-matrix (function).
rearrange-tensor (function).
remove-column (generic function).
remove-key (generic function).
remove-keys (function).
remove-projection-range (generic function).
remove-row (generic function).
row (function).
row-key->size (generic function).
row-keys (generic function).
row-table (generic reader).
(setf row-table) (generic writer).
row<-id (generic function).
scal (function).
scal! (generic function).
scalar-type (generic function).
set-svec-to-local-block (generic function).
shift-diagonal-inverter (function).
shift-tensor (generic function).
show (generic function).
sizes (generic reader).
slice (generic function).
sparse-ldu (generic function).
sparse-m* (generic function).
sparse-matrix->ccs (function).
sparse-matrix->matlisp (generic function).
sparse-tensor (function).
sparse-vector->matlisp (function).
standard-matrix (function).
standard-matrix (class).
standard-matrix-p (function).
store (generic function).
store-vector (function).
store-vector (class).
submatrix (generic function).
t* (generic function).
tensor (class).
tensor-for-each (generic function).
tensor-map (generic function).
tensor-ref (generic function).
(setf tensor-ref) (generic function).
total-entries (generic function).
total-nrows (generic function).
transpose (generic function).
transpose! (generic function).
transposed-pattern (generic function).
uint (type).
uint-vec (function).
uint-vec (type).
unit-vector (function).
vector-block (generic function).
(setf vector-block) (generic function).
vector-of (function).
vector-slice (generic function).
vlength (generic function).
vref (generic function).
(setf vref) (generic function).
x<-0 (function).
zeros (function).

Internals

(<block-definition-mixin>⎵<ht-sparse-matrix>) (class).
(compressed-matrix⎵(store-vector⎵double-float⎵dynamic⎵nil)) (class).
(standard-matrix⎵double-float) (class).
(store-vector⎵double-float⎵dynamic⎵nil) (class).
*blas-macro-table* (special variable).
*blas2-operation-count* (special variable).
*blas3-operation-count* (special variable).
*cholesky-threshold* (special variable).
*crs-test-matrix* (special variable).
*crs-test-matrix-entries* (special variable).
*default-cm-solver* (special variable).
*maxrows-for-direct-solving* (special variable).
*print-matrix-pretty* (special variable).
*sparse-test-matrix* (special variable).
*test-blas-vector-generator* (special variable).
<block-definition-mixin> (class).
<ht-sparse-matrix> (class).
<ht-sparse-vector> (class).
<key->size-mixin> (class).
<ldu-sparse> (class).
<sparse-dictionary-matrix> (class).
<sparse-dictionary-vector> (class).
assert-same-size (function).
automorphism-p (generic function).
blas-macro (generic function).
canonical-number-type (function).
check-cpairs (function).
combine-real-and-imag-part (function).
combine-svec-block (function).
complex-to-real-vector (function).
complex-type (function).
compressed-eye-pattern (function).
compressed-gemm! (function).
compute-offset (function).
conditional-compile (macro).
consecutive-p (function).
decompose-offsets (function).
define-blas-macro (function).
define-blas-template (macro).
define-blas2-template (macro).
define-default-gemm! (macro).
define-matrix-matrix-operation (macro).
define-vector-blas-method (macro).
dimensions->offsets (function).
direct-solver-performance-test (function).
display-block-matrix-graph (function).
distance-numbering (function).
drop-content (generic function).
equal-type (function).
extended-mclear! (generic function).
extended-minject! (generic function).
fd-laplace-matrix-triplets (function).
find-compressed-offset (function).
find-first-position>= (function).
find-ordering (generic function).
five-point-stencil-matrix (function).
fl-matlisp->matlisp (function).
float-accuracy (function).
float-type-union (function).
for-each-index (function).
for-each-offset-pair (function).
generate-sparse-matrix-vector-gemm!-template (function).
generate-standard-matrix-gemm!-template (function).
get-place-in-tensor (function).
get-remaining-inds (function).
if-lapack-function (macro).
int (type).
key->index (function).
laplace-stencil (function).
last-key (function).
ldu-diagonal (generic reader).
list->real-tensor (function).
lower-left (generic reader).
m*-nt-product-instance (generic function).
m.*! (generic function).
make-analog-with-multiplicity (function).
make-full-compressed-matrix (function).
make-tensor-index (function).
matlisp (function).
matlisp->fl-matlisp (function).
matlisp-symbol (function).
matop-x->y! (generic function).
matop-x<-y! (generic function).
matop-y+=x! (generic function).
matop-y-=x! (generic function).
matrix-loop-expansion (function).
modify-diagonal (function).
msym-ncols (function).
msym-nrows (function).
msym-pos (function).
msym-size (function).
new-blas-method-code (function).
new-dispatcher-code (function).
number-of-stored-entries (generic function).
number-super-type (function).
numbering (function).
offset0 (generic reader).
offsets (generic reader).
ordering (generic reader).
orientation (generic reader).
pool-mixin (class).
print-element (generic function).
print-matlab-format (generic function).
print-matrix (function).
print-tensor (function).
read-matrix (generic function).
real-to-complex-vector (function).
select-linear-solver (generic function).
slice-copy (generic function).
standard-matrix-generator (function).
standard-matrix-indexing (function).
starts (generic reader).
static-store-vector (class).
stencil-matrix (function).
store-vector-generator (function).
superlu-solver (function).
swap-rows (function).
symbol-store (function).
symmetric-packed-store (function).
test-arrays (function).
test-blas (function).
test-blas-basic (function).
test-call-matlisp (function).
test-compressed (function).
test-ggev (function).
test-hegv (function).
test-matlisp-vector-combination (function).
test-number-blas (function).
test-sparse-matrix (function).
test-sparse-tensor (function).
test-sparse-vector (function).
test-sparselu (function).
test-standard-matrix (function).
test-standard-matrix-blas (function).
test-standard-matrix-lr (function).
test-store-vector-blas (function).
test-tensor (function).
test-vector (function).
test-vector-methods (function).
translate-list (function).
trsm (function).
umfpack-solver (function).
uniform-number-type (function).
upper-right (generic reader).
x<-eye (generic function).

Next: fl.ellsys, Previous: fl.matlisp, Up: Packages [Contents][Index]

5.8 `fl.macros`

This package contains some basic macro definitions used in Femlisp.

Source

macros.lisp.

Use List

common-lisp.

Used By List

Public Interface

*usually* (special variable).
?1 (macro).
?2 (macro).
?3 (macro).
?4 (macro).
?5 (macro).
?6 (macro).
_ (macro).
_f (macro).
aand (macro).
acond (macro).
aif (macro).
awhen (macro).
bif (macro).
definline (macro).
deletef (macro).
echo (macro).
ensure (macro).
fluid-let (macro).
gencase (macro).
inlining (macro).
lret (macro).
lret* (macro).
multi-dotimes (macro).
multi-for (macro).
multiple-defgen (macro).
named-let (macro).
once-only (macro).
quickly (macro).
quickly-if (macro).
remove-this-method (macro).
show-call (macro).
slowly (macro).
stringcase (macro).
symbol-macroletf (macro).
symconc (function).
usually-quickly (macro).
very-quickly (macro).
whereas (macro).
with-arrays (macro).
with-gensyms (macro).

Internals

awhile (macro).
chain (macro).
collecting (macro).
delay (macro).
force (generic function).
in-syntax (macro).
short-remove-method (macro).
symbol-macroletf-helper (macro).
(setf symbol-macroletf-helper) (setf expander).
test-macros (function).
with-array (macro).

Next: fl.multigrid, Previous: fl.macros, Up: Packages [Contents][Index]

5.9 `fl.ellsys`

This package contains the problem definition of systems
of second order PDEs. The system is defined in the following quasilinear form:

@math{div(-a(x,u_old,nabla u_old) nabla u)
+ div(b(x,u_old,nabla u_old) u) +
+ c(x,u_old,nabla u_old) nabla u +
+ r(x,u_old,nabla u_old) u
= f(x,u_old, nabla u_old)
- div(g(x,u_old, nabla u_old))
- div(a(x,u_old,nabla u_old) h(x,u_old, nabla u_old)) }

where @math{u:G to R^N}. Note that the last two terms are introduced in the variational formulation and imply a natural Neumann boundary condition @math{derivative{u}{n} = (g+a h) cdot n} at boundaries where no Dirichlet constraints are posed.

Source

ellsys.lisp.

Use List

common-lisp.
fl.debug.
fl.dictionary.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.cdr.
fl.elasticity.
fl.elasticity-fe.
fl.ellsys-fe.
fl.flow-application.
fl.konwihr.
fl.navier-stokes.
fl.schaefer-turek.
fl.strategy.

Public Interface

<ellsys-problem> (class).
<multiphysics-problem> (class).
artificial-diffusion (function).
diagonal-reaction-coefficient (function).
ellsys-model-problem (function).
ellsys-one-force-coefficient (function).
initial-value-provided-p (function).
isotropic-diffusion (function).
isotropic-diffusion-coefficient (function).
time-dependent-p (function).
unit-vector-force-coefficient (function).

Internals

a (macro).
ai (macro).
b (macro).
c (macro).
define-ellsys-coefficient-macro (macro).
f (macro).
g (macro).
h (macro).
initial (macro).
r (macro).
sigma (macro).
test-ellsys (function).

Next: fl.domains, Previous: fl.ellsys, Up: Packages [Contents][Index]

5.10 `fl.multigrid`

This package contains the definition of the multigrid iteration including algebraic multigrid (AMG).

Source

multigrid-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.function.
fl.iteration.
fl.macros.
fl.matlisp.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.geomg.
fl.konwihr.
fl.schaefer-turek.

Public Interface

<correction-scheme> (class).
<fas> (class).
<mg-iteration> (class).
<selection-amg> (class).
<stueben> (class).
base-level (generic reader).
cg-max-size (generic reader).
coarse-grid-iteration (generic reader).
coarse-grid-matrix (generic function).
coarsen (generic function).
dirichlet-dof-p (function).
fmg (generic reader).
galerkin-product (function).
multilevel-decomposition (generic function).
post-steps (generic reader).
pre-steps (generic reader).
preprocess-matrix (generic function).
prolongation (generic function).
restriction (generic function).
select-smoother (generic function).
slave-dof-p (function).
slave-or-dirichlet-dof-p (function).

Internals

*amg-cg-max-size* (special variable).
<aggregation-amg> (class).
<algebraic-mg> (class).
a_ (macro).
adapt-fill-pointer (function).
choose-coarse-grid (generic function).
combination-type (generic reader).
ensure-mg-residual (generic function).
ensure-sol-rhs-res (generic function).
f-cycle (generic function).
fas-r_ (macro).
filtered-matrix (generic function).
gamma (generic reader).
i_ (macro).
improved-prolongation (generic function).
lmgc (generic function).
max-depth (generic reader).
min-in-row (function).
post-smoother (generic reader).
post-smoother_ (macro).
pre-smoother (generic reader).
pre-smoother_ (macro).
priority-table (class).
prolongate (generic function).
pt-dictionary (generic reader).
pt-in-table-p (generic function).
pt-insert (generic function).
pt-pop (generic function).
pt-remove (generic function).
pt-shift-priority (generic function).
pt-table (generic reader).
r_ (macro).
res_ (macro).
residual-p_ (macro).
restrict (generic function).
rhs_ (macro).
smooth (generic function).
sol_ (macro).
tentative-prolongation (generic function).
test-stueben (function).
theta (generic reader).
(setf theta) (generic writer).
with-current-level-data (macro).

Next: fl.iteration, Previous: fl.multigrid, Up: Packages [Contents][Index]

5.11 `fl.domains`

Femlisp package for domain definitions.

Source

domains-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.demo.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Public Interface

bl-patch-on-artificial-boundary (function).
bl-patch-on-lower-boundary (function).
bl-patch-on-upper-boundary (function).
circle-ring-domain (function).
cylinder-domain (function).
n-cell-with-ball-hole (function).
n-cell-with-ball-inlay (function).
n-cell-with-cubic-hole (function).
n-cell-with-cubic-inlay (function).
n-cell-with-ellipsoidal-hole (function).
n-cube-with-ball-hole (function).
n-cube-with-ball-inlay (function).
n-cube-with-cubic-hole (function).
n-cube-with-cubic-inlay (function).
n-cube-with-ellipsoidal-hole (function).
oscillating-boundary-domain (function).
patch-in-inlay-p (function).
patch-on-inner-boundary-p (function).
patch-on-n-cube-boundary-p (function).
sinusoidal-bl-cell (function).
spline-interpolated-bl-cell (function).

Internals

bottom-mapping (function).
boundary-layer-cell-domain (function).
flat-disk-domain (function).
linear-interpolate (function).
polar->rect (function).
test-bl-cell (function).
test-circle-ring-domain (function).
test-hole-domain (function).
test-inlay-domain (function).
triangle-mapping (function).
xsinx-bl-cell (function).
zap-to-unit-vectors (function).

Next: fl.debug, Previous: fl.domains, Up: Packages [Contents][Index]

5.12 `fl.iteration`

The @package{FL.ITERATION} package includes the
definition for the abstract classes @class{<solver>}, @class{<iterative-solver>}, as well as the generic functions @function{iterate} and @function{solve} which constitutes the interface for linear and non-linear solving. Both functions work on a blackboard which is passed together with the iteration used as argument.

Several instances of iterative solvers are implemented, e.g. Gauss-Seidel, SOR, ILU (in @file{linit.lisp}) and CG (in @file{krylow.lisp}). A larger block of code is contained in a separate package @package{FL.MULTIGRID} and contains the multigrid iteration. From this class, an algebraic multigrid iteration is derived in @file{amg.lisp} and a geometric multigrid iteration in a separate file @file{geomg.lisp} and package @package{FL.GEOMG}.

Source

iteration-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.dictionary.
fl.function.
fl.macros.
fl.matlisp.
fl.parallel.
fl.problem.
fl.tests.
fl.utilities.

Used By List

fl.application.
fl.discretization.
fl.flow-application.
fl.geomg.
fl.konwihr.
fl.multigrid.
fl.schaefer-turek.
fl.strategy.

Public Interface

*cpu-time-observe* (special variable).
*discrete-iterative-solver-observe* (special variable).
*gauss-seidel* (special variable).
*iteration-depth* (special variable).
*output-depth* (special variable).
*step-observe* (special variable).
*undamped-jacobi* (special variable).
<bi-cgstab> (class).
<block-iteration> (class).
<cg> (class).
<custom-psc> (class).
<custom-ssc> (class).
<gauss-seidel> (class).
<gradient-method> (class).
<ilu> (class).
<iteration> (class).
<iterative-solver> (class).
<iterator> (class).
<jacobi> (class).
<linear-iteration> (class).
<linear-solver> (class).
<lu> (class).
<multi-iteration> (class).
<newton> (class).
<parallel-sor> (class).
<psc> (class).
<safe-linear-solver> (class).
<solver-iteration> (class).
<solver> (class).
<sor> (class).
<special-solver> (class).
<ssc> (class).
compute-residual (generic function).
finally (generic function).
initially (generic function).
intermediate (generic function).
iter-format (generic function).
iterate (generic function).
linsolve (function).
lu-solver (function).
make-iterator (generic function).
next-step (generic function).
observe (slot).
observe (slot).
observe (slot).
product-iterator (function).
setup-blocks (generic function).
solve (generic function).
terminate-p (generic function).

Internals

*evp-success* (special variable).
*iteration-failure-behavior* (special variable).
*iteration-name* (special variable).
*select-linear-solver* (special variable).
*store-decomposition* (special variable).
*suggested-nonlinear-solver* (special variable).
<discrete-iterative-solver> (class).
<evp-solver> (class).
<gmres> (class).
<lobpcg> (class).
<nonlinear-solver> (class).
<preconditioned-krylow> (class).
<richardson> (class).
<setup-blocks-mixin> (class).
<wielandt-iteration> (class).
compile-termination-test (function).
compute-block-inverse (function).
compute-block-inverses (function).
ensure-contained (generic function).
ensure-solution-structure (function).
fallback (generic reader).
fallback-p (generic reader).
(setf fallback-p) (generic writer).
float-quantity-observe (function).
gram-schmidt (function).
gram-schmidt-new (function).
inner-iteration (generic function).
iteration (generic function).
linear-solver (generic reader).
name (generic function).
ordering (generic reader).
(setf ordering) (generic writer).
output (generic reader).
output-p (generic function).
qlsolve (function).
residual-norm (generic reader).
restart-cycle (generic reader).
safe-divide-by-zero (function).
solver-function (generic reader).
step-control (generic reader).
store-p (generic reader).
test-evpsolve (function).
test-iterate (function).
test-krylow (function).
test-linit (function).
test-linsolve (function).
test-nlsolve (function).
test-solve (function).

Next: fl.alienc, Previous: fl.iteration, Up: Packages [Contents][Index]

5.13 `fl.debug`

This package adds debugging tools to Femlisp. This is a
slightly modified version of the debugging suite proposed in @cite{(Norvig 1992)}.

Source

debug.lisp.

Use List

common-lisp.

Used By List

Public Interface

dbg (generic function).
dbg-indent (generic function).
dbg-off (function).
dbg-on (function).
dbg-p (function).
dbg-print (macro).
dbg-show (macro).
dbg-when (macro).
with-dbg (macro).

Internals

*dbg-ids* (special variable).
*error-for-debug-output* (special variable).

Next: fl.lapack, Previous: fl.debug, Up: Packages [Contents][Index]

5.14 `fl.alienc`

Imports some functions from the standard C library.

Source

alienc.lisp.

Use List

common-lisp.
fl.debug.
fl.macros.
fl.port.
fl.utilities.

Public Interface

erf (function).
erfc (function).

Internals

test-alienc (function).

Next: fl.navier-stokes-fe, Previous: fl.alienc, Up: Packages [Contents][Index]

5.15 `fl.lapack`

Source

lapack.lisp.

Use List

common-lisp.
fl.debug.
fl.dictionary.
fl.macros.
fl.port.
fl.utilities.

Used By List

fl.matlisp.

Public Interface

call-lapack (function).
call-lapack-macro (macro).
call-lapack-with-error-test (function).
call-lapack-with-error-test-macro (macro).
cl->lapack-type (function).
lapack (function).
lapack-available-p (function).

Internals

*hegv* (special variable).
*lapack-templates* (special variable).
*lapack-types* (special variable).
*nrm2* (special variable).
*underscore-p* (special variable).
base-type (function).
check-spec (function).
convert-to-alien-type (function).
create-lapack-function (function).
define-lapack-template (macro).
ensure-lapack-type (function).
extract-applicable-spec (function).
insert-lapack-template (function).
lapack-convert (generic function).
lapack-external-name (function).
lapack-lisp-name (function).
lapack-type-p (function).
number-type (function).
remove-all-lapack-functions (function).
test-lapack (function).
translate-types (function).

Next: fl.parallel, Previous: fl.lapack, Up: Packages [Contents][Index]

5.16 `fl.navier-stokes-fe`

This package specializes the finite element
discretization for Navier-Stokes problems. Up to now, we use only generalized Taylor hood elements.

Source

navier-stokes-fe.lisp.

Use List

common-lisp.
fl.debug.
fl.discretization.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.navier-stokes.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Public Interface

navier-stokes-lagrange-fe (function).

Internals

navier-stokes-fe-tests (function).

Next: fl.elasticity-fe, Previous: fl.navier-stokes-fe, Up: Packages [Contents][Index]

5.17 `fl.parallel`

This package provides some Femlisp extensions for parallel execution building on the BORDEAUX-THREADS and LPARALLEL libraries

Source

parallel-defp.lisp.

Use List

bordeaux-threads.
common-lisp.
fl.debug.
fl.macros.
fl.utilities.
lparallel.
lparallel.kernel.
lparallel.queue.

Used By List

fl.application.
fl.dictionary.
fl.discretization.
fl.flow-application.
fl.iteration.
fl.konwihr.
fl.matlisp.
fl.schaefer-turek.

Public Interface

accessing-exclusively (macro).
accessing-exclusively-without-gcing (macro).
locked-region-mixin (class).
mp-dbg (function).
mutex-mixin (class).
mutex-object (class).
mutex-wrap (function).
new-kernel (function).
p-map (function).
parqueue (class).
pwork (function).
terminate-kernel (function).
waitqueue-mixin (class).
with-accumulators (macro).
with-atomic-output (macro).
with-femlisp-workers (macro).
with-mutex (macro).
with-mutual-exclusion (macro).
with-region (macro).
with-workers (macro).
worker-count (function).
worker-index (function).
workers-available-p (function).

Internals

*cachesize* (special variable).
*debug-lock* (special variable).
*distribute-workload-p* (special variable).
*input-queue* (special variable).
*number-of-threads* (special variable).
*output-queue* (special variable).
*pipeline-length* (special variable).
*print-lock* (special variable).
*set-affinity-p* (special variable).
add-pipeline-worker (function).
add-worker (function).
allowed-processors (function).
calculate-effective-cachesize (function).
call-with-workers (function).
copy-procinfo (function).
execute-in-parallel (function).
execute-in-pipeline (function).
femlisp-multiprocessing-tests (function).
femlisp-workers (function).
finish (generic function).
finished-p (generic reader).
(setf finished-p) (generic writer).
get-cachesize (function).
get-cpuinfo (function).
get-processors (function).
get-workers (function).
hand-over (function).
histogram (function).
lock-region (function).
locked-region (generic reader).
make-procinfo (function).
mandelbrot-box (function).
mandelbrot-iteration (function).
mutex (generic function).
notify (generic function).
optimal-thread-number (function).
perform-with-locked-region (generic function).
pi-core (function).
(setf pi-core) (function).
pi-cpu (function).
(setf pi-cpu) (function).
pi-node (function).
(setf pi-node) (function).
pi-socket (function).
(setf pi-socket) (function).
remove-worker (function).
send-task (function).
simple-consing (function).
speedup-test (function).
tasks (generic reader).
terminate-workers (function).
test-femlisp-parallel (function).
test-parallel-adaptions (function).
thread-local-memoization-pool (function).
thread-local-memoize (function).
threads (generic reader).
(setf threads) (generic writer).
unlock-region (function).
wait (generic function).
waitqueue (generic reader).
work (generic reader).
work-group (class).

Next: fl.navier-stokes, Previous: fl.parallel, Up: Packages [Contents][Index]

5.18 `fl.elasticity-fe`

This package specializes the discretization for systems
of elasticity. Since elasticity is a special case of elliptic systems which are handled in @path{ellsys-fe.lisp}, not much remains to do.

Source

elasticity-fe.lisp.

Use List

common-lisp.
fl.discretization.
fl.elasticity.
fl.ellsys.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Internals

discretize-elasticity (function).
elasticity-fe-tests (function).

Next: fl.amop, Previous: fl.elasticity-fe, Up: Packages [Contents][Index]

5.19 `fl.navier-stokes`

Defines incompressible Navier-Stokes problems as a special case of general elliptic systems.

Source

navier-stokes.lisp.

Use List

common-lisp.
fl.ellsys.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.navier-stokes-fe.
fl.schaefer-turek.

Public Interface

<navier-stokes-problem> (class).
driven-cavity (function).
navier-stokes-inertia-coefficients (function).
navier-stokes-pressure-and-continuity-coefficient (function).
navier-stokes-viscosity-coefficient (function).
no-slip-boundary (function).
periodic-cavity (function).
standard-navier-stokes-problem (function).

Internals

*alpha* (special variable).
*artificial-viscosity* (special variable).
*beta* (special variable).
*streamline-diffusion* (special variable).
*viscosity-model* (special variable).
artificial-viscosity (function).
continuity (macro).
cubic-channel (function).
div-u-coefficient (function).
driven-cavity-upper-boundary (function).
dudv-coefficient (function).
dudv-tensor (function).
force (macro).
gradp (macro).
inertia (macro).
initial (macro).
navier-stokes-streamline-diffusion-coefficient (function).
no-slip (macro).
oscillating-force (function).
p-div-coefficient (function).
prescribed-velocity (macro).
pressure-bc (macro).
pressure-boundary-conditions (function).
sigma (macro).
simple-pressure-boundary-conditions (function).
test-navier-stokes (function).
viscosity (macro).

Next: fl.flow-application, Previous: fl.navier-stokes, Up: Packages [Contents][Index]

5.20 `fl.amop`

This package provides some MOP functionality. These functions are non-ANSI and may represent a problem when porting Femlisp.

Source

amop.lisp.

Use List

common-lisp.
fl.debug.
fl.utilities.

Used By List

fl.matlisp.
net.scipolis.relations.

Public Interface

def-fgf (macro).
def-sealable-class (macro).
find-programmatic-class (function).
make-programmatic-instance (function).
remove-subclass-methods (function).

Internals

test-amop (function).

Next: fl.patches, Previous: fl.amop, Up: Packages [Contents][Index]

5.21 `fl.flow-application`

This package should be used for applications calculating Navier-Stokes flows.

Source

flowapp-defp.lisp.

Nickname

flowapp

Use List

Used By List

fl.schaefer-turek.

Public Interface

*navier-stokes-demo* (special variable).
calculate-drag/lift (function).
ns-cell-problem-force (function).
ns-hole-cell-problem (function).
permeability-tensor (function).
stokes-darcy-demo (function).
watch-velocity-and-pressure-at-point (function).
watch-velocity-at-point (function).

Internals

*effective-permeability-demo* (special variable).
*use-problem-p* (special variable).
*with-convection-p* (special variable).
drag/lift-contribution (function).
evaluate-force-boundary-test (function).
hom-ns-tests (function).
make-driven-cavity-demo (function).
make-effective-permeability-demo (function).
make-special-local-vec (function).
ns-driven-cavity-demo (function).
test-driven-cavity (function).
watch-dc-center-velocity (function).

Next: fl.ellsys-fe, Previous: fl.flow-application, Up: Packages [Contents][Index]

5.22 `fl.patches`

Source: patches.lisp.
Use List: common-lisp.
Public Interface: make-hash-table (function).

Next: fl.elasticity, Previous: fl.patches, Up: Packages [Contents][Index]

5.23 `fl.ellsys-fe`

Finite element discretization of a general second order
elliptic system, see the description in the ELLSYS package. The result is a local matrix A and local rhs b. They will usually depend on u_old which is stored in the solution vector.

Source

ellsys-fe.lisp.

Use List

common-lisp.
fl.debug.
fl.discretization.
fl.ellsys.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Internals

*upwinding* (special variable).
discretize-ellsys (function).
ellsys-fe-tests (function).
ensure-m-matrix-property (function).

Next: fl.dictionary, Previous: fl.ellsys-fe, Up: Packages [Contents][Index]

5.24 `fl.elasticity`

Defines elasticity problems.

Source

elasticity.lisp.

Use List

common-lisp.
fl.dictionary.
fl.ellsys.
fl.function.
fl.macros.
fl.matlisp.
fl.mesh.
fl.problem.
fl.utilities.

Used By List

fl.application.
fl.elasticity-fe.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.

Public Interface

<elasticity-problem> (class).
check-elasticity-tensor (function).
elasticity-model-problem (function).
isotropic-elasticity-tensor (function).
isotropic-elasticity-tensor-coefficient (function).

Internals

test-elasticity (function).

Next: fl.alien, Previous: fl.elasticity, Up: Packages [Contents][Index]

5.25 `fl.dictionary`

This package contains functions for dictionaries as a general concept for association lists, hash tables, etc.

Source

dictionary-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.macros.
fl.parallel.
fl.utilities.

Used By List

fl.application.
fl.discretization.
fl.elasticity.
fl.ellsys.
fl.flow-application.
fl.function.
fl.iteration.
fl.konwihr.
fl.lapack.
fl.matlisp.
fl.mesh.
fl.plot.
fl.problem.
fl.schaefer-turek.
fl.strategy.

Public Interface

cache-dictionary (class).
computed-value-dictionary (class).
decrease-refcount (function).
dic-count (generic function).
dic-empty-p (generic function).
dic-for-each (generic function).
dic-for-each-key (generic function).
dic-for-each-value (generic function).
dic-pop (generic function).
dic-ref (generic function).
(setf dic-ref) (generic function).
dic-remove (generic function).
dodic (macro).

The femlisp Reference Manual

Table of Contents

1 Introduction

2 Systems

2.1 femlisp

2.2 femlisp-basic

2.3 femlisp-parallel

2.4 femlisp-matlisp

2.5 femlisp-dictionary

3 Modules

3.1 femlisp/function

3.2 femlisp/mesh

3.3 femlisp/problem

3.4 femlisp/iteration

3.5 femlisp/discretization

3.6 femlisp/special-iteration

3.7 femlisp/graphic

3.8 femlisp/plot

3.9 femlisp/strategy

3.10 femlisp/applications

3.11 femlisp/applications/domains

3.12 femlisp/applications/demos

3.13 femlisp/applications/cdr

3.14 femlisp/applications/elasticity

3.15 femlisp/applications/navier-stokes

3.16 femlisp/applications/articles

3.17 femlisp/applications/books

3.18 femlisp/applications/courses

3.19 femlisp/applications/talks

3.20 femlisp-basic/config

3.21 femlisp-basic/basic

3.22 femlisp-parallel/parallel

3.23 femlisp-matlisp/alien

3.24 femlisp-matlisp/matlisp

3.25 femlisp-dictionary/dictionary

4 Files

4.1 Lisp

4.1.1 femlisp/femlisp.asd

4.1.2 femlisp-basic/femlisp-basic.asd

4.1.3 femlisp-parallel/femlisp-parallel.asd

4.1.4 femlisp-matlisp/femlisp-matlisp.asd

4.1.5 femlisp-dictionary/femlisp-dictionary.asd

4.1.6 femlisp/function/function-defp.lisp

4.1.7 femlisp/function/function.lisp

4.1.8 femlisp/function/polynom.lisp

4.1.9 femlisp/function/spline.lisp

4.1.10 femlisp/mesh/mesh-defp.lisp

4.1.11 femlisp/mesh/cell.lisp

4.1.12 femlisp/mesh/skeleton.lisp

4.1.13 femlisp/mesh/identify.lisp

4.1.14 femlisp/mesh/refine.lisp

4.1.15 femlisp/mesh/vertex.lisp

4.1.16 femlisp/mesh/simplex.lisp

4.1.17 femlisp/mesh/product-cell.lisp

4.1.18 femlisp/mesh/skeleton-build.lisp

4.1.19 femlisp/mesh/anisotropic.lisp

4.1.20 femlisp/mesh/rcb.lisp

4.1.21 femlisp/mesh/domain.lisp

4.1.22 femlisp/mesh/mesh.lisp

4.1.23 femlisp/mesh/meshgen.lisp

4.1.24 femlisp/mesh/blending.lisp

4.1.25 femlisp/mesh/triangulate.lisp

4.1.26 femlisp/mesh/triangle.lisp

4.1.27 femlisp/mesh/tetgen.lisp

4.1.28 femlisp/mesh/extend.lisp

4.1.29 femlisp/problem/problem-defp.lisp

4.1.30 femlisp/problem/problem.lisp

4.1.31 femlisp/problem/pde-problem.lisp

4.1.32 femlisp/problem/time.lisp

4.1.33 femlisp/problem/evp.lisp

4.1.34 femlisp/problem/pdef.lisp

4.1.35 femlisp/problem/ellsys.lisp

4.1.36 femlisp/problem/cdr.lisp

4.1.37 femlisp/problem/elasticity.lisp

4.1.38 femlisp/problem/navier-stokes.lisp

4.1.39 femlisp/iteration/iteration-defp.lisp

4.1.40 femlisp/iteration/iterate.lisp

4.1.41 femlisp/iteration/linit.lisp

4.1.42 femlisp/iteration/blockit.lisp

4.1.43 femlisp/iteration/krylow.lisp

2.1 `femlisp`

2.2 `femlisp-basic`

2.3 `femlisp-parallel`

2.4 `femlisp-matlisp`

2.5 `femlisp-dictionary`

3.1 `femlisp/function`

3.2 `femlisp/mesh`

3.3 `femlisp/problem`

3.4 `femlisp/iteration`

3.5 `femlisp/discretization`

3.6 `femlisp/special-iteration`

3.7 `femlisp/graphic`

3.8 `femlisp/plot`

3.9 `femlisp/strategy`

3.10 `femlisp/applications`

3.11 `femlisp/applications/domains`

3.12 `femlisp/applications/demos`

3.13 `femlisp/applications/cdr`

3.14 `femlisp/applications/elasticity`

3.15 `femlisp/applications/navier-stokes`

3.16 `femlisp/applications/articles`

3.17 `femlisp/applications/books`

3.18 `femlisp/applications/courses`

3.19 `femlisp/applications/talks`

3.20 `femlisp-basic/config`

3.21 `femlisp-basic/basic`

3.22 `femlisp-parallel/parallel`

3.23 `femlisp-matlisp/alien`

3.24 `femlisp-matlisp/matlisp`

3.25 `femlisp-dictionary/dictionary`

4.1.1 `femlisp/femlisp.asd`

4.1.2 `femlisp-basic/femlisp-basic.asd`

4.1.3 `femlisp-parallel/femlisp-parallel.asd`

4.1.4 `femlisp-matlisp/femlisp-matlisp.asd`

4.1.5 `femlisp-dictionary/femlisp-dictionary.asd`

4.1.6 `femlisp/function/function-defp.lisp`

4.1.7 `femlisp/function/function.lisp`

4.1.8 `femlisp/function/polynom.lisp`

4.1.9 `femlisp/function/spline.lisp`

4.1.10 `femlisp/mesh/mesh-defp.lisp`

4.1.11 `femlisp/mesh/cell.lisp`

4.1.12 `femlisp/mesh/skeleton.lisp`

4.1.13 `femlisp/mesh/identify.lisp`

4.1.14 `femlisp/mesh/refine.lisp`

4.1.15 `femlisp/mesh/vertex.lisp`

4.1.16 `femlisp/mesh/simplex.lisp`

4.1.17 `femlisp/mesh/product-cell.lisp`

4.1.18 `femlisp/mesh/skeleton-build.lisp`

4.1.19 `femlisp/mesh/anisotropic.lisp`

4.1.20 `femlisp/mesh/rcb.lisp`

4.1.21 `femlisp/mesh/domain.lisp`

4.1.22 `femlisp/mesh/mesh.lisp`

4.1.23 `femlisp/mesh/meshgen.lisp`

4.1.24 `femlisp/mesh/blending.lisp`

4.1.25 `femlisp/mesh/triangulate.lisp`

4.1.26 `femlisp/mesh/triangle.lisp`

4.1.27 `femlisp/mesh/tetgen.lisp`

4.1.28 `femlisp/mesh/extend.lisp`

4.1.29 `femlisp/problem/problem-defp.lisp`

4.1.30 `femlisp/problem/problem.lisp`

4.1.31 `femlisp/problem/pde-problem.lisp`

4.1.32 `femlisp/problem/time.lisp`

4.1.33 `femlisp/problem/evp.lisp`

4.1.34 `femlisp/problem/pdef.lisp`

4.1.35 `femlisp/problem/ellsys.lisp`

4.1.36 `femlisp/problem/cdr.lisp`

4.1.37 `femlisp/problem/elasticity.lisp`

4.1.38 `femlisp/problem/navier-stokes.lisp`

4.1.39 `femlisp/iteration/iteration-defp.lisp`

4.1.40 `femlisp/iteration/iterate.lisp`

4.1.41 `femlisp/iteration/linit.lisp`

4.1.42 `femlisp/iteration/blockit.lisp`

4.1.43 `femlisp/iteration/krylow.lisp`

4.1.44 `femlisp/iteration/solve.lisp`

4.1.45 `femlisp/iteration/linsolve.lisp`

4.1.46 `femlisp/iteration/nlsolve.lisp`

4.1.47 `femlisp/iteration/evpsolve.lisp`

4.1.48 `femlisp/iteration/multigrid-defp.lisp`

4.1.49 `femlisp/iteration/multigrid.lisp`

4.1.50 `femlisp/iteration/amg.lisp`