This package provides routines for building a
demo suite. Wherever something interesting can be demonstrated, a small demo node should be generated with the @function{make-demo} and added to the tree of all demos with @function{adjoin-demo}. After loading @femlisp{}, the whole demo suite is available and can be run with the command @function{femlisp-demo}.

Source

demo.lisp.

Use List

common-lisp.
fl.macros.
fl.utilities.

Used By List

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

Public Interface

*demo-root* (special variable).
*demo-time* (special variable).
adjoin-demo (function).
extract-demo-strings (function).
femlisp-demo (function).
find-demo (function).
leaves (generic reader).
(setf leaves) (generic writer).
make-demo (function).
remove-demo (function).
test-all-demos (function).
user-input (function).
user-input-textfield (function).

Internals

*demo-help* (special variable).
*user-input-stream* (special variable).
*visited-demos* (special variable).
<demo> (class).
execute (generic reader).
(setf execute) (generic writer).
fuzzy-match-strings (function).
match-input (function).
name (generic reader).
(setf name) (generic writer).
show-demo (function).
test-demo (function).
update-demo-status (function).

Next: fl.cdr, Previous: fl.demo, Up: Packages [Contents][Index]

5.7 `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.elasticity-fe, Previous: fl.amop, Up: Packages [Contents][Index]

5.8 `fl.cdr`

Defines convection-diffusion-reaction problems

Source

cdr.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.discretization.
fl.flow-application.
fl.konwihr.
fl.schaefer-turek.
fl.strategy.

Public Interface

<cdr-problem> (class).
bratu-problem (function).
cdr-model-problem (function).
ensure-dirichlet-coefficient (function).
ensure-tensor-coefficient (function).
ensure-vector-coefficient (function).
scalar-diffusion (function).
scalar-reaction (function).
scalar-source (function).

Internals

*streamline-diffusion* (special variable).
conservative-convection (macro).
constraint (macro).
convection (macro).
derivative-source (macro).
diffusion (macro).
ensure-1-component-tensor (function).
ensure-1-component-vector (function).
initial (macro).
reaction (macro).
resistance (macro).
sigma (macro).
source (macro).
streamline-diffusion (macro).
test-cdr (function).
zero-constraint (macro).

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

5.9 `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.iteration, Previous: fl.elasticity-fe, 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.mesh, Previous: fl.multigrid, Up: Packages [Contents][Index]

5.11 `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.utilities, Previous: fl.iteration, Up: Packages [Contents][Index]

5.12 `fl.mesh`

This module contains the definitions of meshes and
routines for mesh management. The meshes allowed in @femlisp{} are more general than those of most other software for solving PDEs. In @femlisp{}, both mesh, domain and problem definitions are defined over an underlying abstraction, the so-called @class{<skeleton>}. A @class{<skeleton>} captures the mathematical idea of a "cell complex" which builds a topological space by mapping from standard cells @class{<cell>}. Now, a @class{<skeleton>} can be seen as mapping the cells of such a cell complex to arbitrary values. Then, a @class{<domain>} is a @class{<skeleton>} where each cell (which we call "patch" in this case) is mapped to geometric properties, and a @class{<mesh>} is a @class{<skeleton>} where each cell is mapped to the patch to which it belongs.

The basic entities are the class @class{<cell>}, the subclass @class{<simplex>} which in turn contains subclasses for arbitrarily dimensional simplices generated on demand, and the subclass @class{<product-cell>} containing arbitrary products of simplices, e.g. square or cube.

Meshes can be refined either uniformly or locally using the Freudenthal algorithm as presented in @cite{JBey_2000a} and generalized to product elements. When local refinement is used, hanging nodes may occur. In contrast to most other finite element software, in @femlisp{} the difference of refinement levels of adjacent cells may be arbitrarily large. Up to now, anisotropic refinement of product cells has not yet been implemented.

Source

mesh-defp.lisp.

Use List

common-lisp.
fl.debug.
fl.dictionary.
fl.function.
fl.macros.
fl.matlisp.
fl.utilities.
it.bese.fiveam.

Used By List

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

Public Interface

*reference-vertex* (special variable).
*unit-cube* (special variable).
*unit-interval* (special variable).
*unit-quadrangle* (special variable).
*unit-tetrahedron* (special variable).
*unit-triangle* (special variable).
<boundary-cell> (class).
<cell> (class).
<domain> (class).
<hierarchical-mesh> (class).
<mapped-cell> (class).
<mesh> (class).
<product-cell> (class).
<simplex> (class).
<skeleton> (class).
<vertex> (class).
anisotropic-rule-p (function).
bottom-level-cells (function).
boundary (generic function).
boundary-identifications (function).
box-domain (function).
cartesian-product (generic function).
cell->cube (function).
cell-identification (function).
(setf cell-identification) (function).
cell-mapping (generic function).
cellp (function).
cells-of-dim (function).
cells-of-highest-dim (function).
cells-on-level (function).
children (function).
(setf children) (function).
combine-identifications (function).
compare-lexicographically (function).
copy-mesh (function).
copy-skeleton (function).
corners (generic function).
cube-extender (function).
cube-p (function).
dealii-n-ball-domain (function).
diameter (generic function).
dimension (generic function).
(setf dimension) (generic writer).
dimension (slot).
dimension-of-part (generic function).
dissection-compare (function).
domain (generic reader).
domain (slot).
domain-boundary (function).
domain-characteristics (function).
doskel (macro).
embedded-dimension (generic function).
ensure-domain (function).
ensure-simplex-product (function).
etable (generic function).
etable-of-highest-dim (function).
etables (generic reader).
(setf etables) (generic writer).
extend (function).
factor-dimensions (function).
factor-simplices (function).
find-cell (function).
find-cell-from-corners (function).
find-cell-from-position (generic function).
find-cells (function).
find-patch (function).
for-each-cell-of-highest-dimension-on-surface (function).
g2l (generic function).
get-cell-property (function).
(setf get-cell-property) (function).
get-refinement-rule (function).
(setf get-refinement-rule) (function).
global->embedded-local (generic function).
global->local (generic function).
hierarchically-ordered-cells (function).
identification-p (function).
identified-cells (generic function).
identified-p (function).
identify (function).
identify-unit-cell-faces (function).
inner-refcell-children (function).
insert-cell! (function).
insert-cell-from-corners (function).
insert-cells! (function).
inside-cell? (generic function).
iterate-identifications (function).
key-is-subcell-p (function).
l-domain (function).
l2dg (generic function).
l2g (generic function).
level-of-cell (function).
linearly-transformed-skeleton (function).
local->dglobal (generic function).
local->global (generic function).
local-coordinates-of-midpoint (generic function).
make-cell-from-corners (function).
make-cell-from-vertices (function).
make-classifier (function).
make-domain (function).
make-hierarchical-mesh-from (function).
make-hierarchical-mesh-from-domain (generic function).
make-line (function).
make-mesh-from (generic function).
make-simplex (function).
make-vertex (function).
mapped-cell-class (function).
mapped-p (function).
mapping (generic function).
(setf mapping) (generic writer).
mark-skeleton (function).
member-of-skeleton? (function).
meshsize (generic function).
midpoint (generic function).
multiple-local->dglobal (generic function).
multiple-local->global (generic function).
n-ball-domain (function).
n-cell-domain (function).
n-cube (function).
n-cube-domain (function).
n-simplex (function).
n-simplex-domain (function).
nr-of-cells (function).
nr-of-levels (function).
nr-of-sides (function).
nr-of-subcells (function).
nr-of-surface-cells (function).
nr-of-vertices (function).
origin (generic function).
parent (function).
(setf parent) (function).
patch-classification (function).
patch-of-cell (function).
(setf patch-of-cell) (function).
periodic-polygonal (function).
product-cell-p (function).
refcell-children (function).
refcell-refinement-skeleton (function).
reference-cell (generic function).
reference-cell-p (function).
refine (generic function).
refine-info (function).
refined-p (function).
refined-skeleton-copy (function).
refinement (function).
refinement-interface (function).
refinement-rule (function).
refinement-rule (class).
regular-rule-p (function).
representative (generic function).
rotated-square-domain (function).
shift-skeleton (function).
simplex-class (function).
simplex-p (function).
simplex-product-domain (function).
skel-add! (function).
skel-empty-p (function).
skel-for-each (function).
skel-map (generic function).
skel-ref (function).
(setf skel-ref) (function).
skeleton (generic function).
skeleton-boundary (function).
skeleton-disjoint-union (function).
skeleton-without-cell (function).
sort-lexicographically (function).
special-mesh-on-box-domain (function).
standard-extender (function).
structured-mesh-on-box-domain (function).
structured-skeleton (function).
subcell-children (function).
subcells (generic function).
subskeleton (generic function).
surface-cells-of-dim (function).
surface-cells-of-highest-dim (function).
telescope (function).
test-condition (function).
top-level (generic function).
top-level (slot).
top-level-cells (function).
transformed-skeleton (function).
triangle-domain (function).
triangulate (function).
triangulize (function).
uniformly-refined-hierarchical-mesh (function).
uniformly-refined-mesh (function).
vertex-p (function).
vertex-position (generic reader).
vertex? (function).
vertices (generic function).

Internals

(refinement-rule⎵<anisotropic-rule-mixin>) (class).
*allow-child-patch-change* (special variable).
*check-well-defined-embedded-dimension* (special variable).
*constant-refinement-type* (special variable).
*find-cell-base-level* (special variable).
*g2l-newton-steps* (special variable).
*inside-threshold* (special variable).
*meshfile-basename* (special variable).
*optional-skeleton-checks* (special variable).
*print-cell* (special variable).
*print-skeleton* (special variable).
*print-skeleton-values* (special variable).
*refcell-refinement-memoize-depth* (special variable).
*refcell-refinement-table* (special variable).
*tetgen-pathname* (special variable).
*triangle-pathname* (special variable).
*unit-prism-1-2* (special variable).
*unit-prism-2-1* (special variable).
+per-class-allocation-slot+ (constant).
<1-1-1-1-product-cell> (class).
<1-1-1-product-cell> (class).
<1-1-product-cell> (class).
<1-2-product-cell> (class).
<1-simplex> (class).
<2-1-product-cell> (class).
<2-simplex> (class).
<3-simplex> (class).
<anisotropic-rule-mixin> (class).
<cell-with-boundary> (class).
<child-info> (structure).
<child-info>-p (function).
<distorted-cell> (class).
<mapped-1-1-product-cell> (class).
<mapped-1-simplex> (class).
<mapped-2-1-product-cell> (class).
<mapped-2-simplex> (class).
<mapped-vertex> (class).
<standard-cell> (class).
add-new-refinement-rule (function).
anisotropic-boundary-refinement-rules (function).
anisotropic-name (function).
anisotropic-refinement-indicator (function).
anisotropic-refinement-info (function).
anisotropic-refinement-rule (function).
anisotropic-refinement-skeleton (function).
barycentric->euclidean (function).
barycentric-coordinates (generic function).
barycentric-coordinates-factors (function).
barycentric-gradients (generic function).
bisect (function).
bisection-parameters (function).
blending-map (function).
boundary-refinement-rules (generic reader).
build-level-table (function).
calculate-bounding-box (function).
call-tetgen (function).
call-triangle (function).
cartesian-product-map (function).
cell-class-information (generic function).
(setf cell-class-information) (generic function).
cell-class-information (structure).
cell-class-information-p (function).
cell-vec (type).
cells (generic reader).
cells->skeleton (function).
change-to-blending (function).
check-for-multiples (function).
check-identification (function).
child-barycentric-corners (reader).
(setf child-barycentric-corners) (writer).
child-boundary-paths (reader).
(setf child-boundary-paths) (writer).
child-info-vec (type).
child-reference-cell (reader).
(setf child-reference-cell) (writer).
child-transform-a (reader).
(setf child-transform-a) (writer).
child-transform-b (reader).
(setf child-transform-b) (writer).
ci-boundary-indices-of-subcells (reader).
(setf ci-boundary-indices-of-subcells) (writer).
ci-dimension (reader).
(setf ci-dimension) (writer).
ci-factor-simplices (reader).
(setf ci-factor-simplices) (writer).
ci-nr-of-sides (reader).
(setf ci-nr-of-sides) (writer).
ci-nr-of-subcells (reader).
(setf ci-nr-of-subcells) (writer).
ci-nr-of-vertices (reader).
(setf ci-nr-of-vertices) (writer).
ci-reference-cell (reader).
(setf ci-reference-cell) (writer).
ci-refine-info (reader).
(setf ci-refine-info) (writer).
ci-refinement-rules (reader).
(setf ci-refinement-rules) (writer).
classify-top-bottom-lateral (function).
closed? (function).
compute-raster (function).
consistent-vertex-numbering (function).
coordinates-inside? (generic function).
copy-<child-info> (function).
copy-cell (generic function).
copy-cell-class-information (function).
copy-refinement-rule (function).
create-boundary-paths (function).
create-boundary-paths-of-product-cell (function).
cube-index->product-cell-index (function).
cube-index->simplex-index (function).
cube-without-corner (function).
curved-triangle-domain (function).
decrease-priority (function).
describe-all (generic function).
do-refinement! (generic function).
domain-substance (function).
domain-substance-boundaries (function).
drop-empty-limits (function).
ensure-secondary-information (function).
ensure-simplex (function).
euclidean->barycentric (function).
extend-triangulation (generic function).
find-cell-on-patch-with-midpoint (function).
fix-identification-for-positive-dimension (function).
flat-mesh-p (function).
freudenthal-refinement (function).
g-corner-matrix (function).
g-corners (function).
generate-refine-info (generic function).
generate-subcells-method (function).
generate-subcells-method-source (function).
get-patch-property (function).
(setf get-patch-property) (function).
get-path-create (function).
get-subcell-children (function).
hierarchical-mesh-p (function).
hierarchical-search (function).
holes (generic reader).
identification (class).
increase-priority (function).
induced-refinement-of-subcell-refcells (function).
initialize-cell-class (function).
insert-simplex-in-table (function).
interface-table (function).
interpolate (function).
ip (function).
isotropic-mesh-on-rectangle-domain (function).
l2g-evaluator (function).
levels (generic reader).
(setf levels) (generic writer).
make-<child-info> (function).
make-cell-class-information (function).
make-product-cell (generic function).
make-reference-product-cell (function).
make-reference-simplex (function).
map-cell-vec (function).
map-skeleton (function).
mesh-file (function).
meshes-pathname (function).
multiple-barycentric-coordinates (function).
multiple-barycentric-gradients (function).
multiple-l2dg (generic function).
multiple-l2g (generic function).
n-ball-dphi (function).
n-ball-phi (function).
names (generic reader).
parametric (generic reader).
patch-boundary-mesh (function).
patch-mesh (function).
pq-get (function).
(setf pq-get) (function).
pq-insert (function).
pq-pop (function).
pq-remove (function).
priority-queue (class).
product-cell-class (function).
product-table (function).
projection-matrix (function).
pseudo-vertices (generic function).
rcb-ordered-cells (function).
rcb-sort-items (function).
read-next-numbers-line (function).
read-next-uncommented-line (function).
read-nodes (function).
read-numbers-from-string (function).
read-tetgen-mesh (function).
read-tetgen-mesh-for (function).
read-tetgen-simplices (function).
read-triangle-mesh-for (function).
recursive-bisection (function).
refine-cell! (generic function).
refine-cell-interior (function).
refine-info->refinement-rule (function).
refinement-info (generic reader).
refinement-rules (function).
refpatch-boundary-mesh (function).
remove-cells! (generic function).
rule-position (function).
sample-domain (function).
sample-mesh (function).
simple-newton (function).
simplex-corner (function).
skeleton->refinement-rule (function).
skeleton-substance (function).
standard-classifier (function).
sub-cells-of-child (function).
sub-cells-of-children (function).
sub-side-mapping (function).
subcell-access-indices (function).
substance-boundary-cells (function).
synchronize-identification (function).
test-f (function).
transform-cell! (generic function).
triangulate-patch (function).
two-sorted-parts (function).
unmapped-cell-class (function).
update-refinement! (generic function).
weight-lists (function).
weight-lists-grad-product-cell (function).
weight-lists-grad-simplex (function).
with-cell-class-information (macro).
with-cell-information (macro).
with-ci-slots (macro).
without-component (function).
write-1d-skeleton-to-poly-file (function).
write-2d-skeleton-to-poly-file (function).

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

5.13 `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.konwihr, Previous: fl.utilities, Up: Packages [Contents][Index]

5.14 `fl.geomg`

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.problem, Previous: fl.geomg, Up: Packages [Contents][Index]

5.15 `fl.konwihr`

Special package for the KONWIHR demo problem.

Source

heisig-neuss-2017.lisp.

Use List

Public Interface

*heisig-neuss-2017-demo* (special variable).
*konwihr-initialized* (special variable).
heisig-neuss-2017-demo (function).
initialize-konwihr-paper-calculation (function).
konwihr-paper-max-levels (function).
konwihr-speed (function).

Internals

*konwihr-speed* (special variable).
initialize-elahom-calculation (function).
konwihr-demo (function).

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

5.16 `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