AWFD Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:

AdaptiveB (AdaptiveB is the data structure consisting of vectors to store numerical data and index sets to mark the active indices, see AdaptiveB::AdaptiveLevel. All the one-dimensional adaptive operations, like basis transforms, evaluation of FD operators and so on operate on instances of AdaptiveB)
AdaptiveData (AdaptiveData<DIM> is just a collection of ordinary vectors of doubles which contain the actual numerical data associated to an AdaptiveGrid<DIM>)
AdaptiveGrid (AdaptiveGrid<DIM> handles the information which multiscale coefficient with index (l,t) is associated to a particular entry of the vectors of AdaptiveData<DIM>.
Furthermore, some kind of pointers to neighbours with respect to all DIM coordinate directions, auxiliary data vectors used by e.g. the solvers and other rather basic stuff about the adaptive grid are stored. In this way, all these logical connectivities are kept only once. They are shared by all AdaptiveData associated to the same grid.

The internal structure of AdaptiveGrid<DIM> is tailored to allow for a very fast evaluation of tensorproducts of univariate oprations like a wavelet transform w.r.t the x-coordinate direction or the evaluation of a first derivative w.r.t. the y-coordinate direction. These functions require fast access to 1D 'lines', i.e. data associated to indices with common subindices (l1,..,li-1,li+1,...lDIM) and (t1,..,ti-1,ti+1,..,tDIM). The one-dimenional lines are essentially handled using the data structure AdaptiveLevels)
AdaptiveGS (AdaptiveGS is the data structure consisting of vectors to store numerical data and index sets for an adaptive generating system AdaptiveGS is used as auxiliary data structure for e.g. the wavelet transform of the eveluation of finite difference operators)
AdaptiveB::AdaptiveLevel (Numercical data and set of active indices on a single level)
AdaptiveLevels (AdaptiveLevels handles the indices {(l,t)} associated to a one-dimensional line out of the multivariate index set handled by AdaptiveGrid. For the indices of each level l we use a binary tree structure (STL: map<int,long,intlt>) with an int-value for the translation index t (the key) and a long-value for the index (the value) which points to the entry in the data vector of AdaptiveData. It is this value which is needed for the access to the actual numerical data! AdaptiveLevels is essentially an array (l=Level0...LMAX) of such binary trees.
We used binary trees here, since we need a fast in order iteration over all entries of one level (read/write of numerical data for the copies from/to AdaptiveB) and a fast insert/removal of indices)
AdaptiveLevelsIndex (AdaptiveLevelsIndex stores the DIM-1 dimensional level and spatial index)
AdaptiveLevelsIndexCmp (Comparison: *a < *b ?)
AdaptivityCriterion (AdaptivityCriterion provides the criteria for the refinement process. First one has to set a refinement strategy and the appropriate parameters)
BlendingData (Collection of arrays for combination technique-type operations)
BlendingWeights (Array with weights for the blending (combination) formula)
BlockAllocator (BlockAllocator provides a basic mechanism for the heap friendly dynamic allocation and de-allocation of many instances of I. Requirements on I:
* must have a member function void Init () which mimics a default constructor
* must have a member function void Clear() which clears proprietary members of I
* must have a member function void Delete() which mimics a destructor
)
ConstFunction (The most simple function, just return a constant value which may be set using SetParameters)
ConvectionOperator (Operator for evaluation of convection terms (standard) or (conservative). The advection velocity must be given as nodal values)
Extensions (This data structure stores the additional information shared by all numerical data like bounds of the computational domain [XA_0 , XE_0] x ... x [XA_. , XE_.], the wavelets, boundary conditions on all the 2*DIM faces, and whether the numerical data corresponds to a multiscale representation (with respect to Lifting Interpolets) along the DIM coordinate directions. This is used for runtime checks of operations)
FullGridFunction (Function used for selection of active levels for regular full grids. If (x<=MaxLevel) then (*this)(x) = |l|_infty; otherwise (*this)(x) = MAXINT)
Function (Abstract class for real valued multivariate functions)
GeneralRadialFunction (U(x)=(e + |x-y|^2) ^ (a/2) , a,e and y are parameters which determine the location and the type of possible singularities
the parameters are set using a vector with the following order of entries: a,e,y[0],y[1],..,y[DIM-1])
GeneralRadialFunctionDX (Derivative w.r.t. x of the above function)
GeneralRadialFunctionDY (Derivative w.r.t. y of the above function)
HelmholtzOperator (Class for general operators )
IndexSet (Struct IndexSet is an efficient representation of the index set actually only the number and the beginnings/ends of the intervals are stored)
IntegroDifferentialOperator (Class for a general integro differntial operator of type
up to now implemented for LevelAdaptiveData<DIM>, only!!!
a,b,c are stored in par[3] (in this order); D is given as a pointer to another general operator and the Kernel is given by means of a 2*DIM-dimensional function)
Matrix::iterator (The iterator class, it is mainly a DIM-dimensional integer multi-index plus bounds to iterate within)
LaplaceGeneralRadialFunction (Laplacian of the above function)
LevelAdaptiveData (Level adaptive numerical data)
LevelAdaptiveGrid (For level adaptive data, the adaptive grid just consists of an Boolean array a[].
If a[l]==true then the subspace W_l is part of the ansatz space)
Matrix (Matrix<class I,int DIM> is a general implementation of a DIM-dimensional array. Besides initialization, data access via iterators we provide some basic IO and linear algebra stuff (when I is a scalar type))
Operator (Base class for differential operators)
OperatorMatrix (TransformMatrix represents finite difference, collocation or Galerkin operator matrices. These consist of L-shaped blocks in the upper left and the lower right corner as well as generic coefficients for the inner region)
PressureOperatorI (Simple Laplacian for pressure poisson equation. Based on second derivatives)
PressureOperatorII (Consistent pressure Laplacian div*grad WITHOUT stabilized discretization.

For a particular face of the computational domain there are either periodic BC for pressure and velocity OR there are homogeneous Neumann BC for the pressure and no BC for the velocity.
The resulting Poisson problem is in any case singular. In order to improve the convergence to a particular (or an almost) solution one can augment the problem to a saddle point formulation of type . is the singular operator and are the augmention vectors. If and are the right and left null vector of , i.e. , then must satisfy the following conditions: )
PressureOperatorIII (Stabilized, consistent pressure Laplacian div*grad, see above for further details)
Solver (Struct Solver<I,DIM> provides several iterative methods to solve the arising linear systems. The basic interface to the linear systems is a pointer to an Operator<I,DIM>. The member function Apply() of this operator performs the matrix vector multiply.
The behaviour of the iterative solvers is controlled by the parameters StopCriterion, eps, maxiter, restart, print, prstep.
The auxiliary vectors needed by the iterative solvers must be set in advance. So the user has to care about the memory management. The numbers of required auxiliary vectors are geven below)
SparseGridFunction (Function used for selection of active levels for regular sparse grids. If (x<=MaxLevel) then (*this)(x) = |l|_1; otherwise (*this)(x) = MAXINT)
SubFunction (Assume you have a DIM-variate function F with arguments x[0],...,x[DIM-1], but you need a (DIM-1)-variate function whose arguments are the x[.] except e.g. x[1] which shall always take the value, say 3.32. Using SubFunction one can derive such a function from F. You may set the parameters in the following way:

SubFunction SF ;
double v[4]={NULL , DIM , 1, 3.32};
*((Function **)v) = &F
SF.SetParameters(v) ;

This is a little bit dirty pointer arithmetics, but nevertheless legal as long as sizeof(double)>=sizeof(Function *))
TensorNPolynomFunction (Tensor product of simple polynomials
Eval(x) returns
parameters are set using a vector with the following order of entries: q,p(0),...,p(N-1) , c(0,0),c(0,1),..,c(0,p(0)) , c(1,0),..)
TransformMatrix (TransformMatrix stores the low or high pass filter coefficients for primal or dual scaling functions or wavelets. Only the coefficients for inner and boundary adapted functions are stored, not a complete matrix)
UniformData (UniformData is a very simple data structure for uniform grids based on arrays.
Like the other data structures it additionally contains the Extensions<DIM>.
)
Wavelets (Struct Wavelets contains all the filter coefficients required for the (inverse)wavelet transform, application of differential operators and quadratures for
1D wavelets / scaling functions on the interval; the information for periodic wavelets is just a subset of this)

Generated at Mon Aug 19 10:02:32 2002 for AWFD by