Package aips

Version 1.9 Build 000

Package aips

The aips package consists of core modules common to the entire aips++ system. Most applications and packages use the classes defined in these modules. The name of the module boss in in parenthesis.

Module Arrays
Module Containers
Module Exceptions
Module FITS
Module Fitting
Module Functionals
Module Glish
Module Graphics
Module Images
Module Inputs
Module IO
Module Lattices
Module Logging
Module Mathematics
Module MeasurementSets
Module Measures
Module OS
Module Quanta
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 Containers (Darrell Schiebel)

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 Exceptions (Darrell Schiebel)

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 (Bob Garwood)

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 Functionals (Ralph Marson)

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 Barnes)

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 (Ger van Diepen)

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 Lattices (Ger van Diepen)

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 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 (Ralph Marson)

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 MeasurementSets (Mark Wieringa)

The MeasurementSet module deals with tables containing the visibility data.

Module Measures (Wim Brouw)

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

Module OS (Ger van Diepen)

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