VISAN Documentation

VISAN is a visualization and analysis tool for atmospheric data. With this application you can ingest product data from atmospheric instruments for missions such as ENVISAT, ERS-2, Aura, MetOp, etc. You can apply a wide range of mathematical operations to this data, and you will be able to create advanced 2D and worldmap plots.

VISAN is the graphical front-end application for BEAT, the Basic Envisat Atmospheric Toolbox. The BEAT library is included as part of VISAN and provides the functionality to ingest data from the atmospheric product files.

An important aspect of VISAN is that it is an Open Source application. This not only means that you have access to the source code of the application (and are allowed to make changes wherever you want), but also that the implementation of VISAN is for a large part based on various freely available third-party Open Source packages (such as Python, wxPython, VTK, etc.).

A central Open Source package used within VISAN is the powerful high-level programming and scripting language Python. You will interact with VISAN through a Python-driven command line interface. This Python interface provides both easy interactive use and the possibility to implement scripts for advanced and/or repetitive types of analysis. Most of the code of the VISAN application itself was also written using the Python language.

Python provides a flexible way to add useful functionality. There are many freely available extension packages available for Python on the Internet. The VISAN application comes pre-configured with some important packages for your convenience, but you can easily add more. One extension that has already been added is the Numpy package, which provides a set of high-performance mathematical functions such as linear algebra operations, convolutions, Fourier transforms, etcetera.

Below you will find an overview of the documentation that is provided with VISAN.

Release Notes

For the latest release notes concerning this version of VISAN, look at the README file that is included in your VISAN package.

Installing and Running VISAN

For installation instructions for VISAN, look at the INSTALL file that is included in your VISAN package.

VISAN

Tutorial

This Tutorial contains a step-by-step walkthrough that demonstrates some of the VISAN functionality and provides a bird's-eye overview of the application.

The Tutorial can be found here.

User Manual

The User Manual gives a description of the graphical components of VISAN such as the main window and the plot windows. The manual also explains the basic VISAN functionality needed to successfully use the application.

The User Manual can be found here.

Reference Manual

The Reference Manual provides an overview of all VISAN-specific functions (i.e. functions that are not part of the Python or Numpy packages).

The Reference Manual can be found here.

Developer Reference

The Developer Reference is intended for programmers who are interested in extending the functionality of VISAN by implementing their own modules. It also provides instructions on how to add third-party Python extension packages to VISAN.

The Developer Reference can be found here.

Other Documentation

BEAT

BEAT consists of several modules. These modules can be applications, libraries, or interfaces to existing applications (such as IDL, MATLAB, and Python). Since the VISAN application is based on Python, VISAN uses the Python interfaces of BEAT.

BEAT is separated into two layers, CODA (the successor to BEAT-I) and BEAT-II, providing two complementary ways of accessing and dealing with product data. The Python interfaces of BEAT show this same separation; VISAN comes with both the CODA Python and BEAT-II Python interfaces.

CODA Python interface

CODA, the first layer of BEAT, deals with direct access to product data. The CODA interface for Python is a combination of the low level functions for direct product access (using Cursor objects as used in the C and Fortran interfaces) and the high level functions (using the fetch style functions as used in the MATLAB and IDL interfaces).

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

VISAN also contains a version of the 'old' BEAT-I Python interface that is provided for backward compatibility. Documentation for this interface is available in the BEAT-I Python interface documentation.

BEAT-II Python interface

The python interface to the second BEAT layer provides ingestion routines that allow you to easily extract data from product files into one of several basic data classes (such as spectral readout data, profile data, etc.) and compare data between products.

A description of the BEAT-II Python interface can be found in the BEAT-II Python interface documentation.

CODA Product Format Definition documentation

The first BEAT layer, called CODA, uses Product Format Definitions, stored in .codadef files, to interpret the format of atmospheric data products. A textual version of these Product Format Definitions can be found in the Product Format Definition documentation. If you want to know how a data file is structered and where you can find specific data within a file this is the documentation you should consult.

BEAT-II Data Description

The BEAT-II Data Description provides information about which products can be ingested using BEAT-II, what kind of ingestion options can (or should) be provided, the kind of data that you will receive, and how this was mapped from the originating product file.

Python

Python is the language in which you provide commands to the VISAN application. It is a very flexible and easy to learn language that can be used to create both small scripts as well as complete applications.

The Python Documentation can be found here.

Numpy

Numpy is an extension package for Python that provides a set of high performance mathematical functions such as linear algebra operations, convolutions, Fourier transforms, etcetera. The special Numpy 'array' data structures are used throughout the VISAN application. For instance, all array data that you retrieve via an ingest through CODA or BEAT-II will be stored using these special array types. If you want to perform mathematical operations on these arrays you should thus use the functions from this package.

The Numpy Documentation can be found (in pdf) here.