FabArray.H File Reference
#include <cstring>#include <limits>#include <map>#include <utility>#include <vector>#include <BLassert.H>#include <PArray.H>#include <Array.H>#include <Box.H>#include <BoxLib.H>#include <BoxArray.H>#include <BoxDomain.H>#include <FArrayBox.H>#include <DistributionMapping.H>#include <ParallelDescriptor.H>#include <ccse-mpi.H>
Go to the source code of this file.
Classes | |
| class | FabArrayBase |
| class | MFIter |
| class | FabArray< FAB > |
| class | FillBoxId |
| class | CommDataCache |
| class | FabArrayId |
| struct | FabCopyDescriptor< FAB > |
| class | FabArrayCopyDescriptor< FAB > |
Enumerations | |
| enum | FabAlloc { Fab_noallocate = 0, Fab_allocate } |
| : A Collection of Fortran Array-like Objects More... | |
| enum | FillType { FillLocally, FillRemotely, Unfillable } |
Enumeration Type Documentation
| enum FabAlloc |
: A Collection of Fortran Array-like Objects
The FabArray<T,FAB> class implements a collection (stored as an array) of Fortran array-like objects. The parameterized type FAB is intended to be any class derived from BaseFab<T>. For example, FAB may be a BaseFab of integers, so we could write:
FabArray< int,BaseFab<int> > int;
Then int is a FabArray that can hold a collection of BaseFab<int> objects.
FabArray is not just a general container class for Fortran arrays. It is intended to hold "grid" data for use in finite difference calculations in which the data is defined on a union of (usually disjoint) rectangular regions embedded in a uniform index space. This region, called the valid region, is represented by a BoxArray. For the purposes of this discussion, the Kth Box in the BoxArray represents the interior region of the Kth grid.
Since the intent is to be used with finite difference calculations a FabArray also includes the notion of a boundary region for each grid. The boundary region is specified by the ngrow parameter which tells the FabArray to allocate each FAB to be ngrow cells larger in all directions than the underlying Box. The larger region covered by the union of all the FABs is called the region of definition. The underlying notion is that the valid region contains the grid interior data and the region of definition includes the interior region plus the boundary areas.
Operations are available to copy data from the valid regions into these boundary areas where the two overlap. The number of components, that is, the number of values that can be stored in each cell of a FAB, is either given as an argument to the constructor or is inherent in the definition of the underlying FAB. Each FAB in the FabArray will have the same number of components.
In summary, a FabArray is an array of FABs. The Kth element contains a FAB that holds the data for the Kth grid, a Box that defines the valid region of the Kth grid.
A typical use for a FabArray would be to hold the solution vector or right-hand-side when solving a linear system of equations on a union of rectangular grids. The copy operations would be used to copy data from the valid regions of neighboring grids into the boundary regions after each relaxation step of the iterative method. If a multigrid method is used, a FabArray could be used to hold the data at each level in the multigrid hierarchy.
This class is a concrete class not a polymorphic one.
This class does NOT provide a copy constructor or assignment operator. An enumumeration that controls whether or not the memory for a FAB will actually be allocated on construction of a FabArray. Possible values are: Fab and Fab.
| enum FillType |
