AIPS++ Class Library Documentation

Version 1.9 Build 1367

CASA Library Modules

The CASA library consists of modules used to the build CASA system. Most applications and packages use the classes defined in these modules. The name of the module boss in in parenthesis.

Module Arrays
Module BasicMath
Module BasicSL
Module Benchmarks
Module ComponentModels
Module Containers
Module Coordinates
Module DataSampling
Module Display
Module Exceptions
Module FITS
Module Fitting
Module Flagging
Module Functionals
Module Glish
Module Graphics
Module Images
Module Inputs
Module IO
Module Ionosphere
Module Lattices
Module LatticeMath
Module Logging
Module LogTables
Module Mathematics
Module MeasurementComponents
Module MeasurementEquations
Module MeasurementSets
Module MSVis
Module Measures
Module OS
Module Parallel
Module Quanta
Module SpectralComponents
Module System
Module Tables
Module TableMeasures
Module Tasking
Module Utilities

Module Arrays (Ger van Diepen)

Arrays have traditionally played an important role in scientific computation. While it is certainly true that some of the reliance on arrays was due to the paucity of other data structures in FORTRAN, it is also true that computation on arrays reflects the common occurrence of regularly sampled multi-dimensioned data in science. Array is the basic array class. Vector, Matrix, and Cube are one, two, and three dimensional specializations of Array.

There are a wide variety of operations that can be done on Arrays including Arithmetic, Logical and I/O. MaskedArrays can be used to restrict operations on an Array to a selected elements and iterators provide an efficient way to traverse multi-dimensional Arrays.

More detailed descriptions of these operations and the classes which implement them can be found in the Arrays module and the individual class descriptions. Arrays are memory based objects. If your Arrays may get large you should use Lattices which can optionally and optimally store the data on disk.

Module Benchmarks (Raymond Rusk)

Module BasicMath (Dongshan Guo)

Module BasicSL (Wim Brouw)

Module ComponentModels (Sanjay Bhatnagar)

Module Containers (David DeBonis)

This module provides non-mathematical containers. These containers are the prototypical computer science types of containers -- queues, stacks, lists, associative arrays, recordssimple arrays. These classes are useful for all of the various types of low level data management. In general, these classes will have familiar semantics and an unsurprising interface. Most of the important classes in this module also have IO shift operators, e.g. for writing out a Block (simple array). These operators typically allow the container (and the objects it contains) to be written out to both AipsIO and the standard ostream.

Module Coordinates (Neil Killeen)

Module DataSampling (Wes Young)

Module Display (David King)

Module DisplayDatas (David King)

Module DisplayEvents (David King)

Module DisplayShapes (David King)

These module provides display procedures available in AIPS++.

Module Exceptions (David DeBonis)

This module provides the exception handling mechanism used in AIPS++. It allows the user to define new exception types and to throw, catch, and rethrow these exceptions. The interface to this exception handling mechanism is very similarly to the ANSI standard exceptions. This will make it easy to switch when the time comes. This module supplies several common exception types . These provide examples for creating new errors. At some point, this exception mechanism will probably be replaced with compiler supported exceptions.

Module FITS (Gary Li)

Also FITS2, fits to arrays implementation?

Module Fitting (Wim Brouw)

This module provides the linear and non-linear least-squares fitting procedures available in AIPS++.

Module Flagging (Dongshan Guo)

Module Functionals (Wim Brouw)

Functional classes map an input object of some ``Domain'' type into an output object of some ``Range'' type. The Domain and Range types will normally be numeric types, and will often be the same type. The mapping occurs via operator(). The fundamental Functional classes are as follows:

Functional: This base class represents functions that map a Domain object into a Range object via operator().
FunctionND: This base class is used for N-dimensional functions, that is it maps a Vector into a Range object via operator(). FunctionND objects also have adjustable parameters. FunctionND inherits from Functional, Range>.
Function1D: This class is much like FunctionND, however it is strictly for one dimensional functions.
Parameterized: This base class provides the interface for adjustable parameters for Function1D and FunctionND.

Presently, the following Function1D classes are implemented:

Polynomial: A 1-Dimensional polynomial. The polynomial coefficients are its adjustable parameters.
Gaussian1D: A 1-dimensional Gaussian. The height, center, and width are the parameters of the Gaussian.
SumFunction1D: A Function which is made up of the sum of other Functions.

Module Glish (Darrell Schiebel)

The classes in the Glish module were created to make it easy to construct AIPS++ applications which interact with each other (via interprocess communications). This involves constructing values which are sent back and forth between the processes, sending and receiving these values, and managing all of the events (including X Windows events). This module is built upon Glish . Glish is a language (and supporting infrastructure) for constructing loosely coupled distributed systems. The values which Glish and this module deal with can either be arrays or records. Arrays correspond to the arrays found in C and other languages, and records correspond to the heterogeneous structures found in most languages, e.g. the C struct. The major external classes in this module are:

Glish Value is the class for all Glish value objects in this module. Glish Values follow copy-on-write semantics, so assignment and passing and return by value are cheap.
Glish Array is a (possibly n-dimensional) array of Glish values, all of which have the same type. This is also the class which is used to hold a single value.
Glish Record is a "structure" of values, made up of named arrays and records (the latter makes it hierarchical).
Glish SysEvent is a named value which has been sent from an external source.
Glish SysEventSource the object inside the program which emits the Glish SysEvent objects. It is also the object to which events from this executable are posted. This object can also be used to register callbacks and and handle incoming events in an event driven manner.
XSysEventSource allows the user to handle both Glish and X events using the same event loop. See XSysEventSource for an example.

These classes insulate the user from the underlying Glish classes by hiding event management complications and translating Glish values into AIPS++ classes. It is very easy to construct an application which can stand alone or be started from the Glish CLI with these classes. In addition, the application could easily be a windowing application. For information about the Glish system in general, a general introduction (75K) to Glish is available as well as a complete users manual (1Meg). These documents as well as the Glish source are available from the Lawrence Berkeley Laboratory.

Module Graphics (David King)

This module is (as of February 1997) a work in progress. It contains a PGPLOT wrapper and a test program, and nothing else. This module header file does not yet play the traditional role -- of allowing the application programmer to gain a lot of capability with only one include statement.

Module IO (Ger van Diepen)

This module provides the basic IO functionality for the AIPS++ classes. The main class in this module is AipsIO which is the general AIPS++ persistence mechanism. It stores the data in a canonical format. Almost all AIPS++ objects are made persistent via AipsIO. Only tables may have their own persistence mechanism. The templated global functions in AipsIOCarray form a little layer upon AipsIO. They provide the means to put or get a C-style array of any type.

Module Images (Neil Killeen)

An image is a particular type of lattice It holds an astronomical N-dimensional image and the associated world coordinates.
The module contains various classes representing an image:

ImageInterface is the abstract interface class.
PagedImage is a image stored on disk.
SubImage is an image formed by a region in another image.
ImageExpr is an image formed by an expression on other images.
TempImage is a temporary image (in core or on disk depending on size).

Various other classes deal with images. Usually they operate on the abstract interface.

Classes to generate moments, histograms, statistics, summary.
regions in world coordinates.
Conversion to/from FITS

Module Inputs (Joe McMullin)

During the AIPS++ prototyping stage a basic command line user interface was developed. This attempt at easing the trouble of passing information to an executable program resulted in a set of C++ classes called Param and Input. The programmer may simply include the Input class into their code and have immediate Command Line User Interface (CLUI) capabilities. The programmer's AIPS++ application is run from the unix level prompt by invoking its name and listing linearly on the same command line the "keyword=values" or "-keyword values" associated with proper execution. The Input and Param classes will successfully parse the command line into the executable program and check for appropriateness.

Module Ionosphere (Gary Li)

Module Lattices (Neil Killeen)

Lattices are a generalization of arrays. A lattice is an N-dimensional arrangement of data on regular orthogonal axes. A particular type of lattice is an image.

The Lattices module offers a lot of functionality to the user.

In-core and disk-based version of a lattice.
Various types of region classes.
A sublattice formed from a region in a lattice.
A lattice formed from an expression on other lattices.
Iterators and navigators to iterate in any way through a lattice.
Lattice based FFT, convolution, clean. FFT, convolution, clean.
Apply an algorithm to a lattice.

Module LatticeMath (Neil Killeen)

Module LogTables (Ger van Diepen)

Module Logging (Ger van Diepen)

This module gives the programmer a structured means of creating and "throwing" bundles of information that contain data on their source and any special messages the programmer deems important or helpful. The Logging module provides the application programmer the choice of many ways to reject, collect and store the passed logged information. The files are split along the lines of LogMessage.(h/.cc) (the means of passing information from within code to the outside) and LogBoss.(h/cc) (the means of rejecting, collecting, and storing the latter at applications level.) See the individual classes extracted documents for lots more information.

Module Mathematics (Dongshan Guo)

This module contains fundamental mathematical operations, data types and constants. The classes are of general utility in any scientific field although the range of operations provided will be targetted at astronomical applications. Some very complicated operations, particularly those that are specific to astronomy applications, might be in their own module.

Module MeasurementComponents (George Moellenbrock)

The MeasurementComponents module deals with ...

Module MeasurementEquations (Kumar Golap)

The MeasurementEquations module deals ...

Module MeasurementSets (Mark Wieringa)

The MeasurementSet module deals with tables containing the visibility data.

Module MSVis (George Moellenbrock)

Module Measures (Wim Brouw)

The Measures module deals with measures: quantities with a reference frame.

Module OS (Darrell Schiebel)

This module's main purpose is to provide convenient and uniform access to operating system features: environment variables, file and directory access, time and date services, and uniform data representation (which solves the variety of ways the fundamental data types are represented in hardware). This module header file does not yet play the traditional role -- of allowing the application programmer to gain a lot of capability with only one include statement. Furthermore, it may never do so -- the services provided in the module are simply to diverse to wrap together into one package.

Module Parallel (Kumar Golap)

Module Quanta (Wim Brouw)

The Quanta module deals with units and physical quantities. Units are handled in the Unit section (see Unit.h).
Quantities are handled in the Quantum section (see Quantum.h).

Module SpectralComponents (Raymond Rusk)

Module System (David DeBonis)

Module Tables (Ger van Diepen)

Tables are the fundamental storage mechanism for AIPS++.

Module TableMeasures (Ger van Diepen)

TableMeasures define the standard way to stores Measures in AIPS++ tables.

Module Tasking (Darrell Schiebel)

Module Utilities (Ger van Diepen)

This module is a bag of unrelated mini-modules, classes and global functions. The following functional groups can be recognized:

Object utilities:
- Compare objects with each other. A signature for comparison functions is defined (required for comparison functions used in the Sort class), and one such function is provided.
- Copy objects from one place to another.
- Mark objects as valid or invalid.
- Notices provide basic support for shared access of data by various objects.
- Sort objects on one or more keys, in ascending or descending order. Fast sorting is provided for certain types of objects.
- Binary Search templated functions for sorted containers (ascending or descending order) are available.
Logical utilities:
- Assertion lets you throw an error when a condition in not fulfilled.
- Bit vectors are an efficient method to keep True/False information on a set of items or conditions.
Pointer utilities
- Counted pointers provide support for reference counting.
- Pointer holders can be used to hold allocated pointers which should be deleted when an exception is thrown.
Data-type utilities
- DataType enumerates the possible data types in the table system.
- ValType describes the data types and their undefined values.
- Register defines runtime type information for a class.
Other utilities
- Dynamic buffers are used to store data in dynamically allocated buffers.
- Regular expressions are supported by the class Regex and the associated function library cregex.
- Sequences of any datatype can be derived from the base class Sequence. One example is uIntSequence, provided for general use. Another is RegSequence, exclusively used by the Register function.
- Strings.

You may want to look at the individual header files to see whether you might not prefer to include only the header files you really need; it may be more efficient to do so.

wyoung@nrao.edu

Last modified: 5-Sep-2001--08:56