Starlink Software Collection Summary

ASTROM performs ``plate reductions''. You supply star positions from a catalogue and the (x,y) ccoordinates of the corresponding star images. ASTROM uses this information to establish the relationship between (x,y) and (ra,dec) enabling the coordinates of ``unknown stars'' to be determined.

ATOOLS is a package of applications which manipulate descriptions of coordinate frames, mappings, etc, in the form of AST Objects (see SUN/210). Each application within the ATOOLS package corresponds closely to one of the functions within the AST library. ATOOLS thus provides a high-level interface to the AST library.

CCDPACK is a package of programs for reducing CCD-like data. They allow you to debias, remove dark current, flatfield, register, resample and normalize data from single- or multiple-CCD instruments.

CCDPACK is designed to help you to reduce your data easily. The basic reduction stages can be set up using an X-based GUI that controls an automated reduction system. The GUI is designed to allow you to start working without any detailed knowledge of the package (or indeed of CCD reduction). Registration is performed using graphical, script based or automated techniques that help reduce the amount of work to a minimum.

The COCO program converts star coordinates from one system to another. Both the improved IAU system, post-1976, and the old pre-1976 system are supported.

The CONVERT package contains utilities for converting data files between Starlink's Extensible n-dimensional Data Format (NDF), which is used by most Starlink applications, and a number of other common data formats including FITS.

CUPID is a package of applications which identify and analyse clumps of emission within one-, two- or three-dimensional data arrays.

CURSA is a package of Starlink applications for manipulating astronomical catalogues and similar tabular datasets. It provides facilities for: browsing or examining catalogues, selecting subsets from a catalogue, sorting catalogues, copying catalogues, pairing two catalogues, converting catalogue coordinates between some celestial coordinate systems, plotting finding charts and photometric calibration. Also, subsets can be extracted from a catalogue in a format suitable for plotting using other Starlink packages, such as PONGO. CURSA can access catalogues held in the popular FITS table format, the Tab-Separated Table (TST) format or the Small Text List (STL) format. Catalogues in the STL and TST formats are simple ASCII text files. CURSA also includes some facilities for accessing remote on-line catalogues via the Internet.

DAOPHOT is a stellar photometry package designed by Peter Stetson at DAO to deal with crowded fields. The package performs various tasks including finding objects, aperture photometry, obtaining the point-spread function, and profile-fitting photometry. Profile fitting in crowded regions is performed iteratively, which improves the accuracy of the photometry.

DATACUBE is a package which includes the IFU Data Product Co okbook (SC/16), a small number of applications used for AXIS and WCS manipulation, and a collection of example shell and IDL scripts for IFS data cube manipulation.

DIPSO is an interactive spectrum manipulation, plotting and analysis tool. It includes blended-spectral-line fitting. Its macro facility allows convenient execution of regularly used sequence of commands, and a simple interface permits personal functions to be easily integrated.

Simplify searching of Starlink documents. See also findme/showme.

ECHOMOP provides facilities for the extraction of spectra from 2-D data frames. These data can be single-order spectra, or multi-order echelle spectra.

A substantial degree of automation is provided, particularly in the traditionally manual functions for cosmic-ray detection and wavelength calibration; manual overrides are available.

Features include; robust and flexible order tracing, optimal extraction, support for variance arrays, and 2-D distortion fitting and extraction.

ESP (Extended Surface Photometry) is a package of application programs developed to allow you to determine the photometric properties of galaxies and other extended objects.

It has applications that: detect flatfielding faults, remove cosmic rays, median filter images, determine image statistics, determine local background values, perform galaxy profiling, fit 2-D Gaussian profiles to galaxies, generate pie slice cross-sections of galaxies and display profiling results.

EXTRACTOR will detect sources in an astronomical image and build a catalogue listing them. It is based on the popular SExtractor program, has very flexible configuration facilities and can handle images and catalogues in a variety of formats.

This package provides some utilities, background documentation, and associated files for adapting the Starlink Software Collection, and software which uses it, to handle very large data sets. The principal focus of this is to move to use of 64 bits of address space on 64-bit operating systems.

It is squarely aimed at the problem of adapting the Starlink Software Collection, and consequently focuses on the three operating systems (Solaris, Linux and Tru64) supported by Starlink, the compiled languages Fortran 77 and ANSI C, and Starlink's somewhat idiosyncratic build mechanisms. However, some of the discussion here may be of interest or use to people who are considering the change from 32 to 64 bits for software in other contexts.

Figaro is a general-purpose data reduction package. The programs it contains can be used to process a wide range of images and spectra. It is amalgam of traditional Figaro and previously separate packages TWODSPEC and SPECDRE. It does not use Starlink's AST infrastructure for world co-ordinate systems.

findcoords is a utility for finding the equatorial coordinates of a named astronomical object. You simply enter the name of the object and its coordinates are displayed.

FLUXES calculates accurate topocentric positions of the planets and also integrated flux densities of five of them at several wavelengths. These provide calibration information at the effective frequencies and beam-sizes employed by the UKT14 and SCUBA receivers on the JCMT telescope based on Mauna Kea, Hawaii.

GAIA is an image display and analysis tool for astronomy. It provides the usual facilities of image display tools, plus more astronomically useful ones such as aperture & optimal photometry, contouring, source detection, surface photometry, arbitrary region analysis, celestial coordinate readout, calibration and modification, grid overlays, blink comparison, defect patching and the ability to query on-line (WWW) catalogues.

GENERIC is a utility which preprocesses a generic Fortran subroutine into its different types and concatenates these routines into a file. The file can then be compiled with the Fortran compiler to produce an object module.

The HDSTOOLS package contains a number of tools to edit and display HDS objects. The tools originated in the ASTERIX package but have now been modified to run as normal Starlink tasks.

Traces an HDS file

HTX is a set of ``Hypertext Cross-Reference Utilities'', which are designed to help maintain large documentation sets whose constituent documents are written using the Hypertext Markup Language (HTML).

The central part of HTX is a hypertext linker, hlink. This allows hyper-links (or cross-references) to be established between related documents in such a way that it is easy to maintain their integrity as individual documents are updated. Information produced by this linking process is also used by other HTX utilities to provide document search facilities and the ability to randomly access any part of a documentation set. This latter capability forms a basis for constructing hypertext help systems for use by other software.

ICL shell.

Interface Definition Files (IFDs) provide a generic method of defining the interface between Starlink (ADAM) applications and various software environments. Software is described which enables developers to create IFDs and use them to create files required by the Starlink or IRAF environments.

KAPPA is an applications package comprising about 200 general-purpose commands for image processing, data visualisation, and manipulation of the standard Starlink data format---the NDF. It is intended to work in conjunction with Starlink's various specialised packages.

LaTeX style files, classes and ancillary configuration files for building starlink pdf (using pdflatex) and html documentation (using tex4ht).

The MESSGEN program creates files required for proper operation of the system for associating messages with Starlink facility status values on UNIX platforms. The utility program CREMSG can be used to produce source files for MESSGEN.

Simple interactive tool for reading release notes.

OBSERVE is designed to allow you to get a quick overview of the observability of a star through the year from the geographical location selected. You will be prompted for the RA and Dec of the star, the telescope (you can also specify arbitrary locations), and the year. On the selected GKS graphics device a plot will be drawn that tells you, for all dates of the year, the star rising and setting times and the times that it is 30degrees above the horizon, the times of astronomical twilight, the phase and rising and setting times of the Moon as well as its distance from the star in question.

Pamela is a package of routines for the reduction of two-dimensional spectral data to one-dimensional. It does not deal with any subsequent steps such as arc calibration etc. Pamela includes full propagation of uncertainties through the reduction. It implements two forms of optimal extraction: Keith Horne's original method for reasonably straight spectra and a bespoke version for spectra with significant tilts or curvature.

A software package designed to search for periodicities in data.

PHOTOM is a package for measuring the sky corrected magnitudes and fluxes of astronomical objects, within circular and elliptical apertures, using either the aperture or optimal extraction algorithms.

POLMAP is a package designed for interactive analysis of linear spectropolarimetry data, complimenting facilities available in TSP.

POLPACK is a package of applications for reducing imaging polarimetry or spectropolarimetry data. They cover registration, sky subtraction, calculation of Stokes parameters, and display of vector maps.

PONGO is a set of commands for interactively plotting data stored in ordinary text files. It is based around the PGPLOT (SUN/15) graphics package.

This program merges one or more Encapsulated Postscript (EPS) files into a single postscript file that can be sent to a printer. Arbritrary origin shifts scaling and rotations can be applied to each EPS file independently.

It should not be confused with the completely different psmerge utility that ships as part of the psutils package.

The RV program produces a report listing the components, in a given direction, of the observer's velocity on a given date. This allows an observed radial velocity to be referred to an appropriate standard of rest -- typically either the Sun or an LSR.

SMURF is a set of ADAM tasks necessary for reducing raw Submillimetre Common-User Bolometer Array 2 (SCUBA-2) data obtained from the James Clerk Maxwell Telescope. The tasks allows one to completely reduce your SCUBA-2 data. It can also be used to make maps obtained with the ACSIS correlator at JCMT.

SPECX is a general purpose mm and submm spectral line data reduction system.

SPT is an inhomogeneous set ofsoftware tools designed to assist in the conversion of code from one operating system to another (principally from VMS to UNIX and vice-versa, and between different flavours of UNIX).

SST is now considered obsolete; it is included to support those applications which currently use it, but it should not be used for new code.

The Simple Software Tools package (SST) is a package of applications designed to help with the production of software and documentation, with particular emphasis on ADAM programming using Fortran 77.

As its name suggests, SST is intended for performing fairly simple manipulation of software, but it aims to tackle some of the commonly encountered problems which are not catered for in more sophisticated commercial software tools (such as FORCHECK and VAXset) which are available on Starlink. In future, SST may also duplicate a few of the simpler facilities which commercial products offer in order to avoid the cost (and generally much higher overheads, such as disk space) which prevent the commercial products being freely available on all Starlink machines.

Star2HTML lets you write (or convert) a Starlink document so that you can create two versions of it from a single source file. A paper version is produced by LaTeX, and a hypertext version (suitable for browsing on the web) is produced by TeX4HT Documents must use the 'starlink' document class, is installed by the starlink application 'latexsupport'.

The STARTCL package is a set of extensions to the Tcl/Tk language to enable Tcl and Tk applications to display Starlink graphics inside widgets embedded in the application, send and receive ADAM messages and access ADAM noticeboards. This document will be of interest to programmers writing graphics user interfaces for Starlink applications in Tcl/Tk.

This application provides a simple routine for obtaining the link options suitable for linking against an X application. It is provided for backwards compatibility with the old Starlink linking scheme. New applications should use the configure system directly.

SURF is a set of ADAM tasks necessary for reducing demodulated Submillimetre Common-User Bolometer Array (SCUBA) data obtained from the James Clerk Maxwell Telescope. The tasks allows one to completely re-reduce your SCUBA data.

TSP is an astronomical data reduction package which handles time series data and polarimetric data. These facilities are missing from most existing data reduction packages which are usually oriented towards either spectroscopy or image processing or both. Where facilities for polarimetry or time series data have been provided they have usually not been sufficiently general to handle data from a variety of different instruments.

This C shell script will set up the DISPLAY environment variable to point to the machine that you logged in from. This allow X displays created on a remote X client to be pointed back to your own terminal or computer. Generally not needed since ssh does this automatically.

IBM DX (Data Explorer) is the data visualisation package recommended by Starlink, particularly for the visualisation of three-dimensional scalar and vector data. This cookbook provides a set of simple recipes for performing common operations using DX. No prior knowledge of DX is required. You can use the recipes as they are provided, if they are suitable for your purposes, or alternatively you can use them as a starting point for generating your own visualisations. The cookbook also contains a brief summary of the DX data model. It is useful to have at least some understanding of this data model in order to use DX effectively.

This document is the first version of the Starlink Echelle Data Reduction Cookbook. It contains scripts and procedures developed by regular or heavy users of the existing software packages. These scripts are generally of two types; {\em templates} which readers may be able to modify to suit their particular needs and {\em utilities} which carry out a particular common task and can probably be used `off-the-shelf'.

This cookbook describes the fundamentals of writing scripts using the UNIX C shell. It shows how to combine Starlink and private applications with shell commands and constructs to create powerful and time-saving tools for performing repetitive jobs, creating data-processing pipelines, and encapsulating useful recipes. The cookbook aims to give practical and reassuring examples to at least get you started without having to consult a UNIX manual. However, it does not offer a comprehensive description of C-shell syntax to prevent you from being overwhelmed or intimidated. The topics covered are: how to run a script, defining shell variables, prompting, arithmetic and string processing, passing information between Starlink applications, obtaining dataset attributes and FITS header information, processing multiple files and filename modification, command-line arguments and options, and loops. There is also a glossary.

This cookbook presents simple recipes and scripts for reducing direct images acquired with optical CCD detectors. Using these recipes and scripts you can correct un-processed images obtained from CCDs for various instrumental effects to retrieve an accurate picture of the field of sky observed. The recipes and scripts use standard software available at all Starlink sites. The topics covered include: creating and applying bias and flat-field corrections, registering frames and creating a stack or mosaic of registered frames. Related auxiliary tasks, such as converting between different data formats, displaying images and calculating image statistics are also presented. In addition to the recipes and scripts, sufficient background material is presented to explain the procedures and techniques used. The treatment is deliberately practical rather than theoretical, in keeping with the aim of providing advice on the actual reduction of observations. Additional material outlines some of the differences between using conventional optical CCDs and the similar arrays used to observe at infrared wavelengths.

This cookbook presents simple recipes for the photometric calibration of CCD frames. Using these recipes you can calibrate the brightness of objects measured in CCD frames into magnitudes in standard photometric systems, such as the Johnson-Morgan UBV, system. The recipes use standard software available at all Starlink sites. The topics covered include: selecting standard stars, measuring instrumental magnitudes and calibrating instrumental magnitudes into a standard system. The recipes are appropriate for use with data acquired with optical CCDs and filters, operated in standard ways, and describe the usual calibration technique of observing standard stars. The software is robust and reliable, but the techniques are usually not suitable where very high accuracy is required. In addition to the recipes and scripts, sufficient background material is presented to explain the procedures and techniques used. The treatment is deliberately practical rather than theoretical, in keeping with the aim of providing advice on the actual calibration of observations.

This Cookbook describes the basic concepts and methods used in optical astronomical spectroscopy; it is aimed at those new to the field. Complete worked example reductions for both 1-D and 2-D longslit spectra, using real datasets, are described. Common problems and their solutions are discussed. A section on related resources is included, as is a glossary of commonly used terms This cookbook presents simple recipes for the photometric calibration of CCD frames. Using these recipes you can calibrate the brightness of objects measured in CCD frames into magnitudes in standard photometric systems, such as the Johnson-Morgan UBV, system. The recipes use standard software available at all Starlink sites.

This cookbook shows some examples of LaTeX in action and should help you to get to know how to use LaTeX effectively.

This Cookbook shows you how to write your own software for astronomical data reduction. There are two parts. The first part introduces you to simple data reduction using Starlink's IMG subroutine library. This hides a lot of the underlying complications. The second part introduces you to the more powerful (but more complex) NDF subroutine library for handling data.

This cookbook is intended to assemble references to resources likely to be of interest to theorists and modellers. It's not a collection of standard recipes, but instead a repository of brief introductions to facilities. It includes references to sources of authoritative information, including those Starlink documents most likely to be of interest to theorists.

Although the topics are chosen for their relevance to theoretical work, a good proportion of the information should be of interest to all of the astronomical computing community.

This cookbook is an introduction to fibre spectroscopy and, in particular, the techniques and software available for reducing fibre-spectroscopy observations. It covers the principal common-user instruments available to UK astronomers: the Anglo-Australian Telescope 2dF, WYFFOS/AUTOFIB2 on the William Herschel Telescope and FLAIR on the UK Schmidt. It is not a manual for any particular package, though it does contain some worked examples.

This cookbook is a collection of introductory material covering a wide range of topics dealing with data display, format conversion and presentation. Along with this material are pointers to more advanced documents dealing with the various packages, and hints and tips about how to deal with commonly occurring graphics problems.

GAIA (Graphical Astronomy and Image Analysis) is an interactive astronomical image display and analysis tool. It includes a comprehensive suite of facilities for displaying and manipulating images. It also has extensive facilities for the astronomical analysis of images, including: astrometric calibration, automatic object detection and aperture, optimal and surface photometry. GAIA can access images in most of the data formats common in astronomy and can also retrieve copies of remote images and catalogues via the Internet. This cookbook is an introduction to GAIA. It describes the facilities that GAIA provides and gives some simple examples of their use. It refers to GAIA version 2.6 or higher.

This cookbook provides a short introduction to Starlink facilities, especially SMURF, the Sub-Millimetre User Reduction Facility and Kappa, the Kernel Application Package, for reducing, displaying, and analysing ACSIS data. In particular, this cookbook illustrates the various steps required to reduce the data; and gives an overview of the ORAC-DR pipeline which carries out many of these steps using a single command. Specialised pipeline recipes are discussed.

This cookbook provides a short introduction to \starlink\ facilities, especially \smurf, the Sub-Millimetre User Reduction Facility, for reducing, displaying, and calibrating SCUBA-2 data. It describes some of the data artefacts present in SCUBA-2 time-series and methods to mitigate them. In particular, this cookbook illustrates the various steps required to reduce the data; and gives an overview of the Dynamic Iterative Map-Maker, which carries out all of these steps using a single command controlled by a configuration file. Specialised configuration files are presented.

This cookbook provides an introduction to POL-2 data reduction, using the Starlink facilities SMURF (the Sub-Millimetre User Reduction Facility), and in particular its command POL2MAP. This cookbook illustrates the various steps required to reduce the data, including an overview of the method. It also describes how to calibrate and display the data as images or vector maps.

This is a comprehensive description of the Starlink Software Environment.

This document contains a directory of the facilities available to the ADAM programmer. All documented aspects of ADAM programming are covered, ranging from introductory documentation, through applications programming to real-time and system programming. Each facility is briefly described along with the type of work for which it might be used. Most importantly, this guide shows at a glance where to obtain the relevant documentation. It is hoped to update this document relatively frequently, so that it serves as a guide to the latest ADAM developments. Its format, which includes an overall index, is designed to allow its use as a table of contents for a personal file of programming documentation.

Echelle spectrographs are available as common-user instruments at several observatories and satellites. These spectrographs offer the observer both a reasonably high resolution and a wide wavelength-coverage; at the expense of a fairly complex data-reduction procedure. This document is intended as an introductory guide for observers new to echelle work. It includes outline information on the main packages available for echelle data reduction.

This describes Starlink's coding standard for the C language. The advice wis grouped into five sections concerning Starlink naming conventions, programming advice, program design, machine independence, and preprocessor advice respectively. The suggestions are made with maintainability, portability and efficiency in mind.

This Programming Standard should be read by all those who implement programs on Starlink computers. The techniques described are requirements for Starlink-supported applications software but are equally appropriate for private programming. The standard applies mainly to the implementation of freestanding VAX/VMS and Unix applications, but also includes some material specific to developing programs for the Starlink ADAM Software Environment.

This document gives advice on how to write good Starlink documents. It lists Starlink documents which users said they liked in the 1994 Starlink Software Survey, and identifies common characteristics of style and organisation which can be recommended to authors. Various features of documentation which the authors believe to be harmful are specified, including common problems with pages produced for the World Wide Web. Many of these will inevitably reflect the taste of the authors, and these may not correspond to your own. However, they derive from our belief that it is right for an author to spend time and effort on a document in order to save the reader time and effort in reading it.

This document should be read by programmers wishing to write applications software for Starlink. It describes various standard ways of arranging data, using the Hierarchical Data System (HDS). The most important of these is the NDF (Extensible n-Dimensional-Data Format), which is suitable for expressing a wide variety of data which occur in n-dimensional arrays, for example, pictures, spectra and time series.

The ECH package consists of a set of routines which model the behaviour of the UCL coude echelle spectrograph (UCLES) and of echelle spectrographs of similar design. Such spectrographs can differ in focal length (which is in fact irrelevant to the model package), cross-dispersing-prism apex angle, echelle ruling frequency, echelle blaze angle, and camera focal length. It is not capable of dealing with spectrographs which differ in any more major ways from UCLES, although it could be extended to do so should the need arise.

This document defines a set of naming conventions to be used for accessing Starlink subroutine libraries on VAX/VMS machines.

This defines the coordinate system adopted by Starlink for pixel arrays. The bottom left-hand corner of the bottom left-hand pixel has picture coordinates (0.0,0.0).

This document explains the standard way in which ADAM applications packages are set up to run on Starlink machines. It covers the systems permitting use of the applications direct from the shell and from the Interactive Command Language on Unix.

GAIA and CURSA can interrogate remote catalogues via the Internet to return lists of objects which satisfy a given criterion. GAIA can also extract images of a specified region of sky from remote databases. Similar facilities are also available in other packages, such as the ESO SkyCat image display tool and the Gemini observing tool. This functionality is achieved by having servers running on the remote systems, These accept queries sent by GAIA etc., interrogate their local copies of the catalogues to find the data which satisfy the query, and return them. The servers can communicate with GAIA etc. because the query is sent, and the results returned, in a standard format. This document describes how to write such servers.

This document provides an introduction to the Starlink build system. It describes how to use the Starlink versions of the GNU autotools (autoconf, automake and libtool), how to build the software set from a checkout, how to add and configure new components, and acts as a reference manual for the Starlink-specific autoconf macros and Starlink automake features.

This is a general introduction to the Starlink Project for new users. You should also read the local guide for your site before attempting to use Starlink computers. This will tell you how to access your local machine and what facilities are available. As these documents cannot be updated very frequently, you should refer to the on-line files mentioned for current details of Starlink staff, sites, documents, and software.

The Starlink Software Collection is a set of software which is managed and distributed by the Starlink Project. Some of the software was written by members of the Project, but some of it comes from outside the Project. This note describes the functions of the individual items in the Collection and provides an overview of the software so that readers can identify the items they need. The software is classified into four main divisions: Packages -- are large collections of programs for people who want to analyse, convert, and display data. They are subdivided into eleven classes to help you find what you want. Utilities -- are small programs devoted to a specific purpose. For example, they help you prepare for observations, write documents, and write programs. Subroutine Libraries -- are for programmers writing astronomical software. They provide facilities such as astronomical calculations, data management and graphics. Infrastructure -- are items which are mainly of interest to people writing programs within the Starlink Software Environment. They are included for completeness. Each item is described in sufficient detail for you to decide whether or not to investigate it further. If you want to find out more about an item, follow the document references given opposite the item name. If you are using the hypertext version of this document, the most up-to-date document references can be found by following the link from the software item name.

This document is a tutorial in the art of ADAM programming. ADAM is the Starlink Software Environment.

This note gives a general overview of the methods available for using Starlink Infrastructure subroutine libraries with applications. There is an outline of how to use the include files for a subroutine library, and a guide to the methods available for linking with the subroutine libraries. All the Starlink Infrastructure libraries are organised in the same way, so it is possible to give a general guide to the principles involved. However, some libraries do differ, and for precise details of how to use a particular subroutine library, you should consult the Starlink document for that library.

We describe the autoastrom package, which provides an interface to the ASTROM application. This creates a semi-automatic route to doing astrometry on CCD images.

Images observed using the Wide Field Camera instrument on the Isaac Newton Telescope contain nonlinear optical distortions. This note gives a quantitative description of these distortions. It also explains how they can be corrected for easily using the CCDPACK package.

Documentation and advice for using the starlink.cls \LaTeX\ class and its TeX4HT configurations when building pdf and html starlink documentation.

Collection of routines for reading and writing ACSIS format data files containing collections of spectra.

AGI and AGP interface.

The ARD (ASCII Region Definition) system provides a textual language for describing regions within a data array, together with software for converting a textual description into a pixel mask, or plotting it on a graphics device. The textual language is based on a set of keywords identifying simple shapes (boxes, circles, lines, etc.). These keywords can be combined together using Boolean-style operators (AND, OR, NOT, etc.) to create more complex shapes. Data arrays can be multi-dimensional.

The ARY library is a set of routines for accessing Starlink ARRAY data structures built using the Hierarchical Data System (HDS).

ATL provides routines that perform high-level AST-related functions.

CAT is the Starlink Fortran subroutine library for manipulating astronomical catalogues and similar tabular datasets.

The CHR library augments the limited character handling facilities provided by the Fortran 77 standard. It offers a range of character handling facilities: from formatting Fortran data types into text strings and the reverse, to higher level functions such as wild card matching, string sorting, paragraph reformatting and justification. The library may be used simply for building text strings for interactive applications or as a basis for more complex text processing applications.

The CNF package comprises two sets of software which ease the task of writing portable programs in a mixture of FORTRAN and C. F77 is a set of C macros for handling the FORTRAN/C subroutine linkage in a portable way, and CNF is a set of functions to handle the difference between FORTRAN and C character strings, logical values and pointers to dynamically allocated memory.

CTG provides routines for accessing groups of catalogues through a single parameter using wild-cards, and lists in text files. This is analogous to the way the NDG library accesses groups of NDFs using a single parameter.

CVG is a library of functions that were originally written as part of the CONVERT package (a data format conversion package). CVG provides software developers with access to many of the internal CONVERT routines, so that applications that use data-conversion can be written and built independently of CONVERT.

The purpose of EMS is to provide facilities for constructing and storing error messages for future delivery to the user -- usually via the Starlink Error Reporting System, ERR (see SUN/104). EMS can be regarded as a simplified version of ERR without the binding to any software environment (e.g., for message output or access to the parameter and data systems).

The ARY library is a set of routines for accessing Starlink ARRAY data structures built using the Hierarchical Data System (HDS).

The Extensible N-Dimensional Data Format (NDF) is a format for storing bulk data in the form of N-dimensional arrays of numbers. It is typically used for storing spectra, images and similar datasets with higher dimensionality. The NDF format is based on the Hierarchical Data System HDS (SUN/92) and is extensible; not only does it provide a comprehensive set of standard ancillary items to describe the data, it can also be extended indefinitely to handle additional user-defined information of any type.

Almost any program that does any graphics requires the user to identify which graphics device is to be used. When the graphics package used by the program is GKS (SUN/83)---and for the majority of Starlink software it is, at least indirectly---graphics devices are identified by two integers, a `workstation type' and a `connection identifier'. (`Workstation' is GKS terminology for a graphics device of any description and this is the sense in which it is used throughout this note.) No one can be expected to remember the workstation types of all the devices supported by Starlink (nearly 50 at present) so a library has been provided that translates `friendly' and easy to remember names into their GKS equivalents.

Libraries for incorporating graphics into ADAM applications. The routines handle the necessary interactions with the ADAM parameter system where a graphics device is opened for a GKS based graphics package.

GRP provides facilities for handling groups of objects which can be described by character strings (e.g. file names, astronomical objects, numerical values, etc). Facilities are provided for storing and retrieving such character strings within groups, and for passing groups of character strings between applications by means of a text file. It also allows the creation of groups in which each element is a modified version of an element in another group.

This library provides read-only access to GSD files created at the James Clerk Maxwell Telescope. It is mainly useful for accessing JCMT archive data.

These applications provide a means to create graphics windows on an X display that do not disappear when a program terminates.

HDS is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed.

HDS organises data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as deletion, copying, renaming, etc..

All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines.

The routines in this package may be used to perform operations on any HDS data. In addition, HDS forms a toolkit for the construction of higher level (more specialised) data structures and the software which accesses them. HDS routines are therefore invoked indirectly by many other items of Starlink software.

The Starlink HLP system allows an application program to retrieve named items from a hierarchically-arranged library of text. The facility resembles VAX/VMS HELP. It consists of a library plus utility programs for creating, listing and reading help libraries.

The Image Display Interface (IDI) is an international standard for displaying astronomical data on an image display. The specification of the interface is given in Terrett et al, 1988 (A&AS, 76, 263).

IMG is a subroutine library for accessing astronomical image data and associated header information. It is designed to be easy to use and understand.

This library is a set of Fortran routines that permit management and use of textual names representing bits in the NDF QUALITY component.

KAPLIBS is a package of Fortran subroutine libraries which were originally written as part of the KAPPA package (a package of general-purpose image-processing and visualization tools). KAPLIBS provides software developers with access to many of the internal KAPPA routines, so that KAPPA-like applications can be written and built independently of KAPPA.

This library is a set of Fortran routines that provides looping of tasks within a monolith, in order to allow a command to be invoked repeatedly until all supplied data files (catalogues or NDFs) have been processed. Thus it can be used to enable lists of files including wildcards to be processed in a single command.

This package contains two Fortran subroutine libraries, MSG and ERR, which can be used to provide informational text to the user from any application program. It also contains a preliminary C interface for the two libraries -- this may be subject to change in the light of experience.

The Message Reporting System, MSG, is used for reporting non-error information and the Error Reporting System, ERR, is used specifically for reporting error messages.

The noticeboard system routines provide a fast means for processes to share data in global memory. A given process may own as many noticeboards as it wishes and may access noticeboards owned by other processes. Normally the only process that writes to a noticeboard is its owner but other processes that know what they are doing can subvert this rule either by calling a special routine or else by accessing noticeboard data by using a pointer.

The Extensible N-Dimensional Data Format (NDF) is a format for storing bulk data in the form of N-dimensional arrays of numbers. It is typically used for storing spectra, images and similar datasets with higher dimensionality. The NDF format is based on the Hierarchical Data System HDS (SUN/92) and is extensible; not only does it provide a comprehensive set of standard ancillary items to describe the data, it can also be extended indefinitely to handle additional user-defined information of any type.

NDG provides facilities for handling groups of NDFs. Facilities are provided which allow an application to obtain a group of NDFs using a single parameter prompt, and then allow the application to obtain NDF identifiers for specific members of the group. The syntax for specifying groups of NDFs is inherited from the GRP library (see SUN/150).

This library is a set of Fortran and C routines of a general nature and usefulness, which are not suitable for inclusion in other more focussed Starlink libraries.

PAR is a library of Fortran subroutines that provides convenient mechanisms for applications to exchange information with the outside world, through input-output channels called parameters. Parameters enable a user to control an application's behaviour. PAR supports numeric, character, and logical parameters, and is currently implemented only on top of the ADAM parameter system.

The PAR library permits parameter values to be obtained, without or with a variety of constraints. Results may be put into parameters to be passed onto other applications. Other facilities include setting a prompt string, and suggested defaults.

This document also introduces a preliminary C interface for the PAR library -- this may be subject to change in the light of experience.

Application programs often need to obtain parameter values from a variety of sources and to communicate with other programs. The Parameter and Communication Subsystems (PCS) are a set of closely-related subroutine libraries which provide these facilities for many Starlink applications and the associated user-interfaces.

The PCS libraries will not generally be called directly by application programs, but form a basic part of the Starlink Software Environment which is described in Starlink Guide SG/4. Additional notes on using it under Unix are given in Starlink User Note SUN/144.

Replacements of NAG routines with public domain equivalents from packages such as NETLIB and SLATEC. They have been homogenized to fit into the Starlink calling scheme.

GKS implementation of the PGPLOT graphics library.

This document describes the PRM package (once called PRIMDAT), which is a collection of Fortran functions and subroutines providing support for ``primitive data processing''. Routines from this package may be used to perform arithmetic, mathematical operations, type conversion and inter-comparison of any of the primitive numerical data types supported by the Starlink Hierarchical Data System HDS (SUN/92).

PSX is a FORTRAN subroutine library that allows programmers to use the functionality provided by the POSIX and X/OPEN libraries. The use of this library will enable programmers to make use of operating system facilities in a machine independent way.

It is sometimes useful to use the Hierarchical Data System HDS (SUN/92) to store references or pointers to other HDS objects. For instance, this allows the same data object to be used in several places without the need to have more than one copy. The REF library is provided to facilitate this data object referencing process and the subsequent accessing of objects which have been referenced in this way.

The SAE package brings together some include files, a facility error file and a shell script needed for development of software in the Starlink environment, and for building the USSC.

SGS is a set of subroutines for performing low-level graphics input/output. SGS is implemented above the GKS package (described in SUN/83, the RAL GKS Guide and the ISO document GKS 7.4) which is a device independent graphics system designed to be the kernel of a wide variety of graphics systems. GKS, which is very comprehensive, does not itself set out to provide the most convenient interfaces for all applications, and SGS allows easy access to many of its more straightforward features.

SGS, while preserving GKS concepts and indeed allowing direct GKS calls to be interspersed with SGS calls, is optimised for convenience in simple cases. Many of its features are low level (for example: open, draw a line, draw a text string, close), but there are some routines of a slightly higher level (drawing arcs and formatted numbers etc). SGS does not include routines for high level operations like drawing annotated axes or complete graphs.

The Starlink HLP system allows an application to retrieve named items from a hierarchically-arranged library of text. The facility resembles VAX/VMS HELP. It consists of a library plus utility programs for creating, listing and reading help libraries.

Since each application needs its own help system, it made little sense to rewrite a help browser for each application independently. Over the years Starlink applications have switched to using the standard KAPPA help application code. Implemented by copying the KAPPA files to each application in turn. Now that all the applications are in a single location, the KAPPA help infrastructure has been factored out into the SHL library.

In addition to the KAPPA Fortran infrastructure, a C implementation of a help browser has also been integrated (from Figaro) into SHL.

SLALIB is a library used by writers of positional-astronomy applications. Most of the routines are concerned with astronomical position and time, but a number have wider trigonometrical, numerical or general applications.

The NCAR graphics suite (SUN/88) consists of a set of subprograms which can be used to produce complete graphs in a variety of formats. The package has been in wide use for some years; the latest version employs the ISO standard GKS interfaces for its low-level plotting, giving it access to all Starlink graphics devices, present and future.

C Memory management wrapper routines.

This library is a set of low-level C utility routines. They deliberately do not require any other Starlink software and do not use Starlink status handling. This is simply somewhere to put useful C functions.

THR provides high level utility functions for creating and using pools of persistent execution thread.

TRANSFORM provides a standard, flexible method for manipulating coordinate transformations and for transferring information about them between applications. It can handle coordinate systems with any number of dimensions and can efficiently process large (i.e. image-sized) arrays of coordinate data using a variety of numerical precisions. No specific support for astronomical coordinate transformations or map projections is included -- these features are provided by the AST (SUN/210) library.

The AST library provides a comprehensive range of facilities for attaching world coordinate systems to astronomical data, for retrieving and interpreting that information in a variety of formats, including FITS-WCS, and for generating graphical output based on it.

This library should be of interest to anyone writing astronomical applications which need to manipulate coordinate system data, especially celestial or spectral coordinate systems. AST is portable and environment-independent.

HDS is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed.

HDS organises data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as deletion, copying, renaming, etc..

All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines.

The routines in this package may be used to perform operations on any HDS data. In addition, HDS forms a toolkit for the construction of higher level (more specialised) data structures and the software which accesses them. HDS routines are therefore invoked indirectly by many other items of Starlink software.

This library handles HDS files version 4 and below.

HDS is a file-based hierarchical data system designed for the storage of a wide variety of information. It is particularly suited to the storage of large multi-dimensional arrays (with their ancillary data) where efficient access is needed.

HDS organises data into hierarchies, broadly similar to the directory structure of a hierarchical filing system, but contained within a single HDS container file. The structures stored in these files are self-describing and flexible; HDS supports modification and extension of structures previously created, as well as deletion, copying, renaming, etc..

All information stored in HDS files is portable between the machines on which HDS is implemented. Thus, there are no format conversion problems when moving between machines.

The routines in this package may be used to perform operations on any HDS data. In addition, HDS forms a toolkit for the construction of higher level (more specialised) data structures and the software which accesses them. HDS routines are therefore invoked indirectly by many other items of Starlink software.

This library is a collection of code designed to aid in replacing the SLA library with code from SOFA. Where possible the API is similar to the C SLA API except for the use of a "pal" prefix.

The CFITSIO package is a series of C functions that provide easy access to FITS files on disk. It was written by William D. Pence of HEASARC (High Energy Astrophysics Science Archive Research Center) at the Goddard Space Flight Center, USA. Starlink is grateful to William Pence for giving his permission for CFITSIO to be released on Starlink.

The National Center for Atmospheric Research in Boulder, Colorado has, for many years, distributed a extensive suite of high level graphics utilities. When NCAR converted these utilities to run over the ISO standard GKS, Starlink was used as a test site. Starlink was subsequently given permission to release the NCAR utilities as part of the Starlink Software Collection. The NCAR utilities offer an alternative high level graphics package to PGPLOT (SUN/15) for use within Starlink applications. The NCAR package is arguably more powerful than PGPLOT in functionality and flexibility, but it does require a little more time to master. Starlink provides a set of extensions to the NCAR graphics utilities, SNX (SUN/90), to make the use of NCAR more accessible to the beginner. For lower level work, SGS (SUN/85) or GKS (SUN/83) should be used.

This package contains software to match one list of objects against another list, allowing for arbitrary translation, rotation, scaling, and some distortion.

This library is the official IAU SOFA implementation.