# CODA Documentation

The Common Data Access toolbox (CODA) provides a set of tools for ingesting, processing, and analyzing remote sensing data.

CODA consists of several modules. These modules can be applications, libraries, interfaces to existing applications (such as IDL and MATLAB), or interfaces to other programming languages (such as Fortran and Python). All modules deal with direct access to product data. With the CODA software you will be able to access each and every piece of data that is inside a product. In order to read data via this interface, you will first have to familiarize yourself with the structural layout of the products you want to access. The CODA interface provides functions to dynamically retrieve structural information of a product, but the easiest way to find your away around in a product is to have a look at the Data Definition documentation. This documentation provides an overview of the structure descriptions for each of the CODA supported products and is included with the CODA package.

## Installing CODA

For installation instructions for CODA look at the INSTALL file that comes with each downloadable source package.

## CODA Product Format Definitions

CODA uses a single view on data, independent of the underlying basic ascii/binary/xml/netcdf/hdf4/hdf5 file format.

A description of the common type system that CODA uses to provide a hierarchical view on data can be found in the CODA Product Format Definition Description Format documentation:

- CODA Product Format Definition Description Format

In order for CODA to be able to access a file, it will need to now about the format. For self-describing data formats such as netCDF/HDF, CODA can determine the format definition from the file itself (see below for mapping descriptions), but for other kinds of products you will need to have a CODA product format definition (.codadef) file containing the format definitions of the products that you want to access. Note that the CODA software package does not come with any .codadef files itself, but other software that embed CODA often do. In addition, on the CODA website you can find a set of .codadef files as well.

In order to use .codadef files, you must make sure that CODA knows where to find them. It is therefore important that you make sure that the CODA definition path is properly set. There are several ways to do this:

- Put your .codadef file in the default location for CODA definition files (`<prefix>/definitions` on Windows and `<prefix>/share/coda/definitions` on Linux/MacOSX; note that software that embed CODA may use their own default locations). However, only the CODA command line tools and IDL and MATLAB interfaces will use this default location. For the other interfaces you will have to use one of the options below.
- Set the `CODA_DEFINITION` environment variable. This environment variable should be a ':' separated (';' on Windows) list of absolute paths to directories containing .codadef files or absolute paths to .codadef files themselves (or a mix of those).
- Set the CODA definition path programmatically (for e.g. C, Fortran, Java). See the interface documentation below for details.

For formats that are self-describing or that are too complex to be captured by .codadef files, CODA comes with a special backend to deal with the format. The file formats that CODA supports in thise way (and thus don't require .codadef files per se) are XML, netCDF, CDF, GRIB, HDF4, HDF5, RINEX, and SP3. The approach that CODA uses to map the data from the native file format to CODA data types can be found in the mapping descriptions for each format below:

- CODA XML Mapping Description
- CODA netCDF Mapping Description
- CODA CDF Mapping Description
- CODA GRIB Mapping Description
- CODA HDF4 Mapping Description
- CODA HDF5 Mapping Description
- CODA RINEX Mapping Description
- CODA SP3 Mapping Description

## CODA Expression Language

CODA comes with an expression language that can be used to perform simple operations on product data. It is used in tools such as codafind and codaeval but is also used inside CODA product format definitions for e.g. determining array sizes, bit offsets, etc. This expression language is described in the CODA Expressions documentation:

- CODA Expressions

## C interface

The C interface is the foundation of CODA upon which all other CODA tools are build. As a developer you can also use this library and gain easy, high-performance access to all data in products that are supported by CODA.

A description of the C interface can be found in the CODA C interface documentation:

- CODA C interface documentation

## Fortran interface

The Fortran interface provides a small wrapper for the C Library and allows you to call its functions from your Fortran 77/90 programs.

A description of the Fortran interface can be found in the CODA Fortran interface documentation:

- CODA Fortran interface documentation

## IDL interface

The IDL interface provides a wrapper for the C Library through a small set of powerful functions (such as `coda_fetch`) which are available from within IDL.

A description of the IDL interface can be found in the CODA IDL interface documentation:

- CODA IDL interface documentation

## MATLAB interface

The MATLAB interface provides a wrapper for the C Library through a small set of powerful functions (such as `coda_fetch`) which are available from within MATLAB.

A description of the MATLAB interface can be found in the CODA MATLAB interface documentation:

- CODA MATLAB interface documentation

## Python interface

The Python interface provides a wrapper for the CODA C Library. It provides a set of high-level classes (such as `Product` and `Cursor`) and functions (similar to the IDL and MATLAB interfaces, such as `coda_fetch`), but also direct wrappers for all C Library functions.

A description of the Python interface can be found in the CODA Python interface documentation:

- CODA Python interface documentation

## Java interface

The Java interface provides a wrapper for the CODA C Library using JNI. The Java interface wraps the C Library functions behind classes for CODA Products, Types, and Cursors.

A description of the Java interface can be found in the CODA Java interface documentation:

- CODA Java interface documentation

## codacheck

With codacheck it is possible to provide a basic sanity check on product files.

More information about this tool can be found in the codacheck documentation:

- codacheck documentation

## codacmp

With codacmp two product files can be compared. In other words, it is a 'diff' tool for product data. The tool is primarily intended for verification purposes.

More information about this tool can be found in the codacmp documentation:

- codacmp documentation

## codadd

The codadd tool allows for a quick validation of .codadef files and is able to generate HTML documentation for the product format definitions that are inside the .codadef files.

More information about this tool can be found in the codadd documentation:

- codadd documentation

## codadump

With the codadump command line tool you can view data from any product file that is supported by CODA. The tool allows you to inspect the product structure (including array sizes), view and export data from the product in ASCII format, and export data into HDF4 format.

More information about this tool can be found in the codadump documentation:

- codadump documentation

## codaeval

CODA comes with an expression language. The codaeval tool allows you to run such an expression on one or more product files, or you can use it as a quick way to just syntactically and grammatically check an expression.

More information about this tool can be found in the codaeval documentation:

- codaeval documentation

## codafind

The codafind command line tool allows you to search files and directories for product files that are supported by CODA. The tool comes with a very powerful filtering mechanism that makes it possible to search for only those product files that match certain filter criteria.

More information about this tool can be found in the codafind documentation:

- codafind documentation