upgrade ast 8.7.1

1 files changed, 0 insertions, 4490 deletions

diff --git a/ast/fluxframe.c b/ast/fluxframe.c
deleted file mode 100644
index aca3e5f..0000000
--- a/ast/fluxframe.c
+++ /dev/null
@@ -1,4490 +0,0 @@
-/*
-*class++
-*  Name:
-*     FluxFrame
-
-*  Purpose:
-*     Measured flux description.
-
-*  Constructor Function:
-c     astFluxFrame
-f     AST_FLUXFRAME
-
-*  Description:
-*     A FluxFrame is a specialised form of one-dimensional Frame which
-*     represents various systems used to represent the signal level in an
-*     observation. The particular coordinate system to be used is specified
-*     by setting the FluxFrame's System attribute qualified, as necessary, by
-*     other attributes such as the units, etc (see the description of the
-*     System attribute for details).
-*
-*     All flux values are assumed to be measured at the same frequency or
-*     wavelength (as given by the SpecVal attribute). Thus this class is
-*     more appropriate for use with images rather than spectra.
-
-*  Inheritance:
-*     The FluxFrame class inherits from the Frame class.
-
-*  Attributes:
-*     In addition to those attributes common to all Frames, every
-*     FluxFrame also has the following attributes:
-*
-*     - SpecVal: The spectral position at which the flux values are measured.
-
-*  Functions:
-c     The FluxFrame class does not define any new functions beyond those
-f     The FluxFrame class does not define any new routines beyond those
-*     which are applicable to all Frames.
-
-*  Copyright:
-*     Copyright (C) 1997-2006 Council for the Central Laboratory of the
-*     Research Councils
-
-*  Licence:
-*     This program is free software: you can redistribute it and/or
-*     modify it under the terms of the GNU Lesser General Public
-*     License as published by the Free Software Foundation, either
-*     version 3 of the License, or (at your option) any later
-*     version.
-*
-*     This program is distributed in the hope that it will be useful,
-*     but WITHOUT ANY WARRANTY; without even the implied warranty of
-*     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-*     GNU Lesser General Public License for more details.
-*
-*     You should have received a copy of the GNU Lesser General
-*     License along with this program.  If not, see
-*     <http://www.gnu.org/licenses/>.
-
-*  Authors:
-*     DSB: David S. Berry (Starlink)
-
-*  History:
-*     6-DEC-2004 (DSB):
-*        Original version.
-*     14-DEC-2004 (DSB):
-*        Added AST__SBRIGHT and AST__SBRIGHTW systems.
-*     7-DEC-2005 (DSB):
-*        Free memory allocated by calls to astReadString.
-*     14-FEB-2006 (DSB):
-*        Override astGetObjSize.
-*     31-JAN-2007 (DSB):
-*        Modified so that a FluxFrame can be used as a template to find a
-*        FluxFrame contained within a CmpFrame. This involves changes in
-*        Match and the removal of the local versions of SetMaxAxes and
-*        SetMinAxes.
-*     3-SEP-2007 (DSB):
-*        In SubFrame, since AlignSystem is extended by the FluxFrame class
-*        it needs to be cleared before invoking the parent SubFrame
-*        method in cases where the result Frame is not a FluxFrame.
-*     2-OCT-2007 (DSB):
-*        In Overlay, clear AlignSystem as well as System before calling
-*        the parent overlay method.
-*     29-APR-2011 (DSB):
-*        Prevent astFindFrame from matching a subclass template against a
-*        superclass target.
-*class--
-*/
-
-/* Module Macros. */
-/* ============== */
-/* Set the name of the class we are implementing. This indicates to
-   the header files that define class interfaces that they should make
-   "protected" symbols available. */
-#define astCLASS FluxFrame
-
-/* Define the first and last acceptable System values. */
-#define FIRST_SYSTEM AST__FLUXDEN
-#define LAST_SYSTEM AST__SBRIGHTW
-
-/* Define other numerical constants for use in this module. */
-#define GETATTRIB_BUFF_LEN 50
-#define GETLABEL_BUFF_LEN 200
-#define GETSYMBOL_BUFF_LEN 20
-#define GETTITLE_BUFF_LEN 200
-
-/* Header files. */
-/* ============= */
-/* Interface definitions. */
-/* ---------------------- */
-
-#include "globals.h"             /* Thread-safe global data access */
-#include "error.h"               /* Error reporting facilities */
-#include "memory.h"              /* Memory allocation facilities */
-#include "unit.h"                /* Units management facilities */
-#include "globals.h"             /* Thread-safe global data access */
-#include "object.h"              /* Base Object class */
-#include "frame.h"               /* Parent Frame class */
-#include "fluxframe.h"           /* Interface definition for this class */
-#include "mapping.h"             /* Coordinate Mappings */
-#include "unitmap.h"             /* Unit Mappings */
-#include "cmpmap.h"              /* Compound Mappings */
-#include "zoommap.h"             /* Scaling Mappings */
-#include "specframe.h"           /* Spectral Frames */
-
-/* Error code definitions. */
-/* ----------------------- */
-#include "ast_err.h"             /* AST error codes */
-
-/* C header files. */
-/* --------------- */
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <stddef.h>
-#include <math.h>
-
-/* Module Variables. */
-/* ================= */
-
-/* Address of this static variable is used as a unique identifier for
-   member of this class. */
-static int class_check;
-
-/* Pointers to parent class methods which are used or extended by this
-   class. */
-static int (* parent_getobjsize)( AstObject *, int * );
-static AstSystemType (* parent_getalignsystem)( AstFrame *, int * );
-static AstSystemType (* parent_getsystem)( AstFrame *, int * );
-static const char *(* parent_getattrib)( AstObject *, const char *, int * );
-static const char *(* parent_getdomain)( AstFrame *, int * );
-static const char *(* parent_getlabel)( AstFrame *, int, int * );
-static const char *(* parent_getsymbol)( AstFrame *, int, int * );
-static const char *(* parent_gettitle)( AstFrame *, int * );
-static const char *(* parent_getunit)( AstFrame *, int, int * );
-static int (* parent_match)( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
-static int (* parent_subframe)( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
-static int (* parent_testattrib)( AstObject *, const char *, int * );
-static void (* parent_setunit)( AstFrame *, int, const char *, int * );
-static void (* parent_clearattrib)( AstObject *, const char *, int * );
-static void (* parent_overlay)( AstFrame *, const int *, AstFrame *, int * );
-static void (* parent_setattrib)( AstObject *, const char *, int * );
-static void (* parent_setsystem)( AstFrame *, AstSystemType, int * );
-static void (* parent_clearsystem)( AstFrame *, int * );
-static void (* parent_clearunit)( AstFrame *, int, int * );
-
-#if defined(THREAD_SAFE)
-static int (* parent_managelock)( AstObject *, int, int, AstObject **, int * );
-#endif
-
-/* Define macros for accessing each item of thread specific global data. */
-#ifdef THREAD_SAFE
-
-/* Define how to initialise thread-specific globals. */
-#define GLOBAL_inits \
-   globals->Class_Init = 0; \
-   globals->GetAttrib_Buff[ 0 ] = 0; \
-   globals->GetLabel_Buff[ 0 ] = 0; \
-   globals->GetSymbol_Buff[ 0 ] = 0; \
-   globals->GetTitle_Buff[ 0 ] = 0; \
-
-/* Create the function that initialises global data for this module. */
-astMAKE_INITGLOBALS(FluxFrame)
-
-/* Define macros for accessing each item of thread specific global data. */
-#define class_init astGLOBAL(FluxFrame,Class_Init)
-#define class_vtab astGLOBAL(FluxFrame,Class_Vtab)
-#define getattrib_buff astGLOBAL(FluxFrame,GetAttrib_Buff)
-#define getlabel_buff astGLOBAL(FluxFrame,GetLabel_Buff)
-#define getsymbol_buff astGLOBAL(FluxFrame,GetSymbol_Buff)
-#define gettitle_buff astGLOBAL(FluxFrame,GetTitle_Buff)
-
-
-
-/* If thread safety is not needed, declare and initialise globals at static
-   variables. */
-#else
-
-/* Buffers for strings returned by various functions. */
-static char getattrib_buff[ AST__FLUXFRAME_GETATTRIB_BUFF_LEN + 1 ];
-static char getlabel_buff[ AST__FLUXFRAME_GETLABEL_BUFF_LEN + 1 ];
-static char getsymbol_buff[ AST__FLUXFRAME_GETSYMBOL_BUFF_LEN + 1 ];
-static char gettitle_buff[ AST__FLUXFRAME_GETTITLE_BUFF_LEN + 1 ];
-
-
-/* Define the class virtual function table and its initialisation flag
-   as static variables. */
-static AstFluxFrameVtab class_vtab;   /* Virtual function table */
-static int class_init = 0;       /* Virtual function table initialised? */
-
-#endif
-
-/* Prototypes for Private Member Functions. */
-/* ======================================== */
-static int GetObjSize( AstObject *, int * );
-static AstSpecFrame *GetSpecFrame( AstFluxFrame *, int * );
-static AstSystemType DensitySystem( AstSystemType, int * );
-static AstSystemType GetAlignSystem( AstFrame *, int * );
-static AstSystemType GetDensitySystem( AstFluxFrame *, int * );
-static AstSystemType SystemCode( AstFrame *, const char *, int * );
-static AstSystemType ValidateSystem( AstFrame *, AstSystemType, const char *, int * );
-static const char *DefUnit( AstSystemType, const char *, const char *, int * );
-static const char *DensityUnit( AstSystemType, int * );
-static const char *FluxSystemString( AstSystemType, int * );
-static const char *GetDensityUnit( AstFluxFrame *, int * );
-static const char *GetDomain( AstFrame *, int * );
-static const char *GetLabel( AstFrame *, int, int * );
-static const char *GetSymbol( AstFrame *, int, int * );
-static const char *GetTitle( AstFrame *, int * );
-static const char *GetUnit( AstFrame *, int, int * );
-static const char *SystemLabel( AstSystemType, int * );
-static const char *SystemString( AstFrame *, AstSystemType, int * );
-static int GetActiveUnit( AstFrame *, int * );
-static int MakeFluxMapping( AstFluxFrame *, AstFluxFrame *, AstSystemType, AstMapping **, int * );
-static int Match( AstFrame *, AstFrame *, int, int **, int **, AstMapping **, AstFrame **, int * );
-static int SubFrame( AstFrame *, AstFrame *, int, const int *, const int *, AstMapping **, AstFrame **, int * );
-static int TestActiveUnit( AstFrame *, int * );
-static int UnitsOK( AstSystemType, const char *, int, const char *, const char *, int * );
-static void ClearUnit( AstFrame *, int, int * );
-static void Copy( const AstObject *, AstObject *, int * );
-static void Delete( AstObject *, int * );
-static void Dump( AstObject *, AstChannel *, int * );
-static void Overlay( AstFrame *, const int *, AstFrame *, int * );
-static void SetUnit( AstFrame *, int, const char *, int * );
-
-static AstSystemType GetSystem( AstFrame *, int * );
-static void SetSystem( AstFrame *, AstSystemType, int * );
-static void ClearSystem( AstFrame *, int * );
-
-static const char *GetAttrib( AstObject *, const char *, int * );
-static int TestAttrib( AstObject *, const char *, int * );
-static void ClearAttrib( AstObject *, const char *, int * );
-static void SetAttrib( AstObject *, const char *, int * );
-
-static double GetSpecVal( AstFluxFrame *, int * );
-static int TestSpecVal( AstFluxFrame *, int * );
-static void ClearSpecVal( AstFluxFrame *, int * );
-static void SetSpecVal( AstFluxFrame *, double, int * );
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *, int, int, AstObject **, int * );
-#endif
-
-/* Member functions. */
-/* ================= */
-
-static void ClearAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     ClearAttrib
-
-*  Purpose:
-*     Clear an attribute value for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void ClearAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astClearAttrib protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function clears the value of a specified attribute for a
-*     FluxFrame, so that the default value will subsequently be used.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     attrib
-*        Pointer to a null terminated string specifying the attribute
-*        name.  This should be in lower case with no surrounding white
-*        space.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     - This function uses one-based axis numbering so that it is
-*     suitable for external (public) use.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   int len;                      /* Length of attrib string */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Obtain the length of the "attrib" string. */
-   len = strlen( attrib );
-
-/* Check the attribute name and clear the appropriate attribute. */
-
-/* SpecVal. */
-/* -------- */
-   if ( !strcmp( attrib, "specval" ) ) {
-      astClearSpecVal( this );
-
-/* If the attribute is not recognised, pass it on to the parent method
-   for further interpretation. */
-   } else {
-      (*parent_clearattrib)( this_object, attrib, status );
-   }
-}
-
-static void ClearSystem( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     ClearSystem
-
-*  Purpose:
-*     Clear the System attribute for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void ClearSystem( AstFrame *this_frame, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astClearSystem protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function clears the System attribute for a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to FluxFrame structure */
-   AstSystemType newsys;         /* System after clearing */
-   AstSystemType oldsys;         /* System before clearing */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* Save the original system */
-   oldsys = astGetSystem( this_frame );
-
-/* Use the parent ClearSystem method to clear the System value. */
-   (*parent_clearsystem)( this_frame, status );
-
-/* Get the default System. */
-   newsys = astGetSystem( this_frame );
-
-/* If the system has actually changed. */
-   if( newsys != oldsys ) {
-
-/* Changing the System value will in general require the Units to change
-   as well. If the used has previously specified the units to be used with
-   the new system, then re-instate them (they are stored in the "usedunits"
-   array in the FluxFrame structure). Otherwise, clear the units so that
-   the default units will eb used with the new System. */
-      if( (int) newsys < this->nuunits && this->usedunits &&
-          this->usedunits[ (int) newsys ] ) {
-         (*parent_setunit)( this_frame, 0, this->usedunits[ (int) newsys ], status );
-      } else {
-         (*parent_clearunit)( this_frame, 0, status );
-      }
-
-/* Also, clear all attributes which have system-specific defaults. */
-      astClearLabel( this_frame, 0 );
-      astClearSymbol( this_frame, 0 );
-      astClearTitle( this_frame );
-   }
-
-}
-
-static void ClearUnit( AstFrame *this_frame, int axis, int *status ) {
-/*
-*  Name:
-*     ClearUnit
-
-*  Purpose:
-*     Clear the value of the Unit string for a FluxFrame's axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void ClearUnit( AstFrame *this_frame, int axis )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astClearUnit method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function clears the Unit string for a specified axis of a
-*     FluxFrame. It also clears the UsedUnit item in the FluxFrame
-*     structure corresponding to the current System.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     axis
-*        The number of the axis (zero-based).
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   int system;                   /* The FluxFrame's System value */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* Validate the axis index. */
-   astValidateAxis( this, axis, 1, "astClearUnit" );
-
-/* Clear the UsedUnit item for the current System, if current set. */
-   system = (int) astGetSystem( this );
-   if( system < this->nuunits && this->usedunits ) {
-      this->usedunits[ system ] = astFree( this->usedunits[ system ] );
-   }
-
-/* Use the parent method to clear the Unit attribute of the axis. */
-   (*parent_clearunit)( this_frame, axis, status );
-}
-
-static const char *DefUnit( AstSystemType system, const char *method,
-                            const char *class, int *status ){
-/*
-*  Name:
-*     DefUnit
-
-*  Purpose:
-*     Return the default units for a flux coordinate system type.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *DefUnit( AstSystemType system, const char *method,
-*                          const char *class, int *status )
-
-*  Class Membership:
-*     FluxFrame member function.
-
-*  Description:
-*     This function returns a textual representation of the default
-*     units associated with the specified flux coordinate system.
-
-*  Parameters:
-*     system
-*        The flux coordinate system.
-*     method
-*        Pointer to a string holding the name of the calling method.
-*        This is only for use in constructing error messages.
-*     class
-*        Pointer to a string holding the name of the supplied object class.
-*        This is only for use in constructing error messages.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     As tring describing the default units. This string follows the
-*     units syntax described in FITS WCS paper I "Representations of world
-*     coordinates in FITS" (Greisen & Calabretta).
-
-*  Notes:
-*     - A NULL pointer is returned if this function is invoked with
-*     the global error status set or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   const char *result;           /* Value to return */
-
-/* Initialize */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get an identifier for the default units. */
-   if( system == AST__FLUXDEN ) {
-      result = "W/m^2/Hz";
-
-   } else if( system == AST__FLUXDENW ) {
-      result = "W/m^2/Angstrom";
-
-   } else if( system == AST__SBRIGHT ) {
-      result = "W/m^2/Hz/arcmin**2";
-
-   } else if( system == AST__SBRIGHTW ) {
-      result = "W/m^2/Angstrom/arcmin**2";
-
-/* Report an error if the coordinate system was not recognised. */
-   } else {
-      astError( AST__SCSIN, "%s(%s): Corrupt %s contains illegal System "
-                "identification code (%d).", status, method, class, class,
-                (int) system );
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static AstSystemType DensitySystem( AstSystemType sys, int *status ) {
-/*
-*  Name:
-*     DensitySystem
-
-*  Purpose:
-*     Obtain the System describing the spectral density for a FluxFrame
-*     system.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstSystemType DensitySystem( AstSystemType sys, int *status )
-
-*  Class Membership:
-*     FluxFrame member function.
-
-*  Description:
-*     This function returns AST__FREQ if the FluxFrame system describes
-*     a quantity measured per unit frequency, and returns AST__WAVELEN if
-*     the FluxFrame system describes a quantity measured per unit wavelength.
-
-*  Parameters:
-*     sys
-*        A System value appropriate to a FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The density System value.
-
-*  Notes:
-*     - AST__BADSYSTEM is returned if this function is invoked with
-*     the global error status set or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstSystemType result;         /* Value to return */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Categorise the supplied system. */
-   if( sys == AST__FLUXDEN || sys == AST__SBRIGHT ) {
-      result = AST__FREQ;
-
-   } else if( sys == AST__FLUXDENW || sys == AST__SBRIGHTW ) {
-      result = AST__WAVELEN;
-
-   } else if( astOK ) {
-      astError( AST__INTER, "DensitySystem(FluxFrame): The "
-                "DensitySystem method does not yet support "
-                "FluxFrame system %d (AST internal programming error).", status,
-                sys );
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static const char *DensityUnit( AstSystemType sys, int *status ) {
-/*
-*  Name:
-*     DensityUnit
-
-*  Purpose:
-*     Obtain the default units for the spectral density of a FluxFrame
-*     system.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *DensityUnit( AstSystemType sys, int *status )
-
-*  Class Membership:
-*     FluxFrame member function.
-
-*  Description:
-*     This function returns "Hz" if the FluxFrame system describes
-*     a quantity measured per unit frequency, and returns "Angstrom" if
-*     the FluxFrame system describes a quantity measured per unit wavelength.
-
-*  Parameters:
-*     sys
-*        A FluxFrame system value.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer to a null-terminated string containing the Unit value.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   const char *result;           /* Pointer value to return */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Categorise the supplied FluxFrame system. */
-   if( sys == AST__FLUXDEN || sys == AST__SBRIGHT ) {
-      result = "Hz";
-
-   } else if( sys == AST__FLUXDENW || sys == AST__SBRIGHTW ) {
-      result = "Angstrom";
-
-   } else if( astOK ) {
-      astError( AST__INTER, "DensityUnit(FluxFrame): The DensityUnit "
-                "method does not yet support FluxFrame system %d (AST "
-                "internal programming error).", status, sys );
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static const char *FluxSystemString( AstSystemType system, int *status ) {
-/*
-*  Name:
-*     FluxSystemString
-
-*  Purpose:
-*     Convert a FluxFrame coordinate system type code into a string.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *FluxSystemString( AstSystemType system, int *status )
-
-*  Class Membership:
-*     FluxFrame member function
-
-*  Description:
-*     This function converts a FluxFrame coordinate system type code
-*     (System attribute value) into a string suitable for use as an
-*     external representation of the coordinate system type.
-
-*  Parameters:
-*     system
-*        The coordinate system type code.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to a constant null-terminated string containing the
-*     textual equivalent of the type code supplied.
-
-*  Notes:
-*     - A NULL pointer value is returned if the coordinate system
-*     code was not recognised. This does not produce an error.
-*     - A NULL pointer value is also returned if this function is
-*     invoked with the global error status set or if it should fail
-*     for any reason.
-*/
-
-/* Local Variables: */
-   const char *result;           /* Pointer value to return */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Match the "system" value against each possibility and convert to a
-   string pointer. */
-   switch ( system ) {
-
-   case AST__FLUXDEN:
-      result = "FLXDN";
-      break;
-
-   case AST__FLUXDENW:
-      result = "FLXDNW";
-      break;
-
-   case AST__SBRIGHT:
-      result = "SFCBR";
-      break;
-
-   case AST__SBRIGHTW:
-      result = "SFCBRW";
-      break;
-
-   }
-
-/* Return the result pointer. */
-   return result;
-}
-
-static int GetObjSize( AstObject *this_object, int *status ) {
-/*
-*  Name:
-*     GetObjSize
-
-*  Purpose:
-*     Return the in-memory size of an Object.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int GetObjSize( AstObject *this, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetObjSize protected
-*     method inherited from the parent class).
-
-*  Description:
-*     This function returns the in-memory size of the supplied FluxFrame,
-*     in bytes.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The Object size, in bytes.
-
-*  Notes:
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;         /* Pointer to FluxFrame structure */
-   int result;                /* Result value to return */
-   int i;
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointers to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Invoke the GetObjSize method inherited from the parent class, and then
-   add on any components of the class structure defined by thsi class
-   which are stored in dynamically allocated memory. */
-   result = (*parent_getobjsize)( this_object, status );
-
-   if( this && this->usedunits ) {
-      for( i = 0; i < this->nuunits; i++ ) {
-         result += astTSizeOf( this->usedunits[ i ] );
-      }
-      result += astTSizeOf( this->usedunits );
-   }
-
-   result += astGetObjSize( this->specframe );
-
-/* If an error occurred, clear the result value. */
-   if ( !astOK ) result = 0;
-
-/* Return the result, */
-   return result;
-}
-
-static int GetActiveUnit( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetActiveUnit
-
-*  Purpose:
-*     Obtain the value of the ActiveUnit flag for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int GetActiveUnit( AstFrame *this_frame, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetActiveUnit protected
-*     method inherited from the Frame class).
-
-*  Description:
-*    This function returns the value of the ActiveUnit flag for a
-*    FluxFrame, which is always 1.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The value to use for the ActiveUnit flag (1).
-
-*/
-   return 1;
-}
-
-static const char *GetAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     GetAttrib
-
-*  Purpose:
-*     Get the value of a specified attribute for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *GetAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the protected astGetAttrib
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the value of a specified
-*     attribute for a FluxFrame, formatted as a character string.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     attrib
-*        Pointer to a null-terminated string containing the name of
-*        the attribute whose value is required. This name should be in
-*        lower case, with all white space removed.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     - Pointer to a null-terminated string containing the attribute
-*     value.
-
-*  Notes:
-*     - This function uses one-based axis numbering so that it is
-*     suitable for external (public) use.
-*     - The returned string pointer may point at memory allocated
-*     within the FluxFrame, or at static memory. The contents of the
-*     string may be over-written or the pointer may become invalid
-*     following a further invocation of the same function or any
-*     modification of the FluxFrame. A copy of the string should
-*     therefore be made if necessary.
-*     - A NULL pointer will be returned if this function is invoked
-*     with the global error status set, or if it should fail for any
-*     reason.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   const char *result;           /* Pointer value to return */
-   double dval;                  /* Attribute value */
-   int len;                      /* Length of attrib string */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this_object);
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Obtain the length of the attrib string. */
-   len = strlen( attrib );
-
-/* Compare "attrib" with each recognised attribute name in turn,
-   obtaining the value of the required attribute. If necessary, write
-   the value into "getattrib_buff" as a null-terminated string in an appropriate
-   format.  Set "result" to point at the result string. */
-
-/* SpecVal */
-/* ------- */
-   if ( !strcmp( attrib, "specval" ) ) {
-      dval = astGetSpecVal( this );
-      if ( astOK ) {
-         if( dval != AST__BAD ) {
-            (void) sprintf( getattrib_buff, "%.*g", AST__DBL_DIG, dval );
-            result = getattrib_buff;
-         } else {
-            result = "<bad>";
-         }
-      }
-
-/* If the attribute name was not recognised, pass it on to the parent
-   method for further interpretation. */
-   } else {
-      result = (*parent_getattrib)( this_object, attrib, status );
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static AstSystemType GetDensitySystem( AstFluxFrame *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetDensitySystem
-
-*  Purpose:
-*     Obtain the System describing the spectral density of a FluxFrame.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstSystemType astGetDensitySystem( AstFluxFrame *this )
-
-*  Class Membership:
-*     FluxFrame method.
-
-*  Description:
-*     This function returns AST__FREQ if the FluxFrame system describes
-*     a quantity measured per unit frequency, and returns AST__WAVELEN if
-*     the FluxFrame system describes a quantity measured per unit wavelength.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-
-*  Returned Value:
-*     The System value.
-
-*  Notes:
-*     - AST__BADSYSTEM is returned if this function is invoked with
-*     the global error status set or if it should fail for any reason.
-*-
-*/
-
-/* Check the global error status. */
-   if ( !astOK ) return AST__BADSYSTEM;
-
-/* Get the FluxFrame system and categorise it. */
-   return DensitySystem( astGetSystem( this ), status );
-}
-
-static const char *GetDensityUnit( AstFluxFrame *this, int *status ) {
-/*
-*+
-*  Name:
-*     astGetDensityUnit
-
-*  Purpose:
-*     Obtain the default units for the spectral density of a FluxFrame.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *astGetDensityUnit( AstFluxFrame *this )
-
-*  Class Membership:
-*     FluxFrame method.
-
-*  Description:
-*     This function returns "Hz" if the FluxFrame system describes
-*     a quantity measured per unit frequency, and returns "Angstrom" if
-*     the FluxFrame system describes a quantity measured per unit wavelength.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-
-*  Returned Value:
-*     A pointer to a null-terminated string containing the Unit value.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*-
-*/
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get the FluxFrame system and categorise it. */
-   return DensityUnit( astGetSystem( this ), status );
-}
-
-static const char *GetDomain( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetDomain
-
-*  Purpose:
-*     Obtain a pointer to the Domain attribute string for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *GetDomain( AstFrame *this, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetDomain protected
-*     method inherited from the Frame class).
-
-*  Description:
-*    This function returns a pointer to the Domain attribute string
-*    for a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A pointer to a constant null-terminated string containing the
-*     Domain value.
-
-*  Notes:
-*     - The returned pointer or the string it refers to may become
-*     invalid following further invocation of this function or
-*     modification of the FluxFrame.
-*     - A NULL pointer is returned if this function is invoked with
-*     the global error status set or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to FluxFrame structure */
-   const char *result;           /* Pointer value to return */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* If a Domain attribute string has been set, invoke the parent method
-   to obtain a pointer to it. */
-   if ( astTestDomain( this ) ) {
-      result = (*parent_getdomain)( this_frame, status );
-
-/* Otherwise, provide a pointer to a suitable default string. */
-   } else {
-      result = "FLUX";
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static const char *GetLabel( AstFrame *this, int axis, int *status ) {
-/*
-*  Name:
-*     GetLabel
-
-*  Purpose:
-*     Access the Label string for a FluxFrame axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *GetLabel( AstFrame *this, int axis, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetLabel method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the Label string for a specified axis
-*     of a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     axis
-*        Axis index (zero-based) identifying the axis for which information is
-*        required.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to a constant null-terminated character string containing the
-*     requested information.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstMapping *map;              /* Mapping between units */
-   AstSystemType system;         /* Code identifying type of flux coordinates */
-   char *new_lab;                /* Modified label string */
-   const char *result;           /* Pointer to label string */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this);
-
-/* Initialise. */
-   result = NULL;
-
-/* Validate the axis index. */
-   astValidateAxis( this, axis, 1, "astGetLabel" );
-
-/* Check if a value has been set for the required axis label string. If so,
-   invoke the parent astGetLabel method to obtain a pointer to it. */
-   if ( astTestLabel( this, axis ) ) {
-      result = (*parent_getlabel)( this, axis, status );
-
-/* Otherwise, identify the flux coordinate system described by the
-   FluxFrame. */
-   } else {
-      system = astGetSystem( this );
-
-/* If OK, supply a pointer to a suitable default label string. */
-      if ( astOK ) {
-         result = strcpy( getlabel_buff, SystemLabel( system, status ) );
-         getlabel_buff[ 0 ] = toupper( getlabel_buff[ 0 ] );
-
-/* Modify this default to take account of the current value of the Unit
-   attribute, if set. */
-         if( astTestUnit( this, axis ) ) {
-
-/* Find a Mapping from the default Units for the current System, to the
-   units indicated by the Unit attribute. This Mapping is used to modify
-   the existing default label appropriately. For instance, if the default
-   units is "Jy" and the actual units is "log(Jy)", then the default label
-   of "Flux density" is changed to "log( Flux density )". */
-            map = astUnitMapper( DefUnit( system, "astGetLabel",
-                                          astGetClass( this ), status ),
-                                 astGetUnit( this, axis ), result,
-                                 &new_lab );
-            if( new_lab ) {
-               result = strcpy( getlabel_buff, new_lab );
-               new_lab = astFree( new_lab );
-            }
-
-/* Annul the unused Mapping. */
-            if( map ) map = astAnnul( map );
-
-         }
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static AstSpecFrame *GetSpecFrame( AstFluxFrame *this, int *status ) {
-/*
-*  Name:
-*     GetSpecFrame
-
-*  Purpose:
-*     Get a pointer to a SpecFrame associated with a FluxFrame
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstSpecFrame *GetSpecFrame( AstFluxFrame *this, int *status )
-
-*  Class Membership:
-*     FluxFrame member function
-
-*  Description:
-*     This function returns a SpecFrame describing the spectral system in
-*     which the FluxFrame's SpecVal attribute is stored. A default
-*     SpecFrame is created and returned if the no SpecFrame was supplied
-*     when the FluxFrame was created.
-
-*  Parameters:
-*     this
-*        The FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to the SpecFrame. It should be freed using astAnnul when no
-*     longer needed.
-
-*  Notes:
-*     - A NULL pointer value is returned if this function is
-*     invoked with the global error status set or if it should fail
-*     for any reason.
-*/
-
-/* Local Variables: */
-   AstSpecFrame *result;           /* Pointer value to return */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* If the FluxFrame contains a SpecFrame, return a clone of its pointer. */
-   if( this->specframe ) {
-      result = astClone( this->specframe );
-
-/* Otherwise, create a SpecFrame appropriate to the FluxFrames System. */
-   } else {
-      result = astSpecFrame( "", status );
-      astSetSystem( result, astGetDensitySystem( this ) );
-      astSetUnit( result, 0, astGetDensityUnit( this ) );
-   }
-
-/* Annul the result if an error occurred. */
-   if( !astOK ) result = astAnnul( result );
-
-/* Return the result pointer. */
-   return result;
-}
-
-static const char *GetSymbol( AstFrame *this, int axis, int *status ) {
-/*
-*  Name:
-*     GetSymbol
-
-*  Purpose:
-*     Obtain a pointer to the Symbol string for a FluxFrame axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *GetSymbol( AstFrame *this, int axis, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetSymbol method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the Symbol string for a specified axis
-*     of a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     axis
-*        Axis index (zero-based) identifying the axis for which information is
-*        required.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to a constant null-terminated character string containing the
-*     requested information.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstMapping *map;              /* Mapping between units */
-   AstSystemType system;         /* Code identifying type of sky coordinates */
-   char *new_sym;                /* Modified symbol string */
-   const char *result;           /* Pointer to symbol string */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this);
-
-/* Initialise. */
-   result = NULL;
-
-/* Validate the axis index. */
-   astValidateAxis( this, axis, 1, "astGetSymbol" );
-
-/* Check if a value has been set for the required axis symbol string. If so,
-   invoke the parent astGetSymbol method to obtain a pointer to it. */
-   if ( astTestSymbol( this, axis ) ) {
-      result = (*parent_getsymbol)( this, axis, status );
-
-/* Otherwise, identify the flux coordinate system described by the FluxFrame. */
-   } else {
-      system = astGetSystem( this );
-
-/* If OK, supply a pointer to a suitable default Symbol string. */
-      if ( astOK ) {
-
-         if( system == AST__FLUXDEN ) {
-	    result = "S_nu";
-
-         } else if( system == AST__FLUXDENW ) {
-	    result = "S_lambda";
-
-         } else if( system == AST__SBRIGHT ) {
-	    result = "mu_nu";
-
-         } else if( system == AST__SBRIGHTW ) {
-	    result = "mu_lambda";
-
-/* Report an error if the coordinate system was not recognised. */
-         } else {
-	    astError( AST__SCSIN, "astGetSymbol(%s): Corrupt %s contains "
-		      "invalid System identification code (%d).", status,
-                      astGetClass( this ), astGetClass( this ), (int) system );
-         }
-
-/* Modify this default to take account of the current value of the Unit
-   attribute, if set. */
-         if( astTestUnit( this, axis ) ) {
-
-/* Find a Mapping from the default Units for the current System, to the
-   units indicated by the Unit attribute. This Mapping is used to modify
-   the existing default symbol appropriately. For instance, if the default
-   units is "Jy" and the actual units is "log(Jy)", then the default symbol
-   of "S_nu" is changed to "log( S_nu )". */
-            map = astUnitMapper( DefUnit( system, "astGetSymbol",
-                                          astGetClass( this ), status ),
-                                 astGetUnit( this, axis ), result,
-                                 &new_sym );
-            if( new_sym ) {
-               result = strcpy( getsymbol_buff, new_sym );
-               new_sym = astFree( new_sym );
-            }
-
-/* Annul the unused Mapping. */
-            if( map ) map = astAnnul( map );
-
-         }
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static AstSystemType GetAlignSystem( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetAlignSystem
-
-*  Purpose:
-*     Obtain the AlignSystem attribute for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstSystemType GetAlignSystem( AstFrame *this_frame, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetAlignSystem protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns the AlignSystem attribute for a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The AlignSystem value.
-
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to FluxFrame structure */
-   AstSystemType result;         /* Value to return */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* If a AlignSystem attribute has been set, invoke the parent method to obtain
-   it. */
-   if ( astTestAlignSystem( this ) ) {
-      result = (*parent_getalignsystem)( this_frame, status );
-
-/* Otherwise, provide a suitable default. */
-   } else {
-      result = AST__FLUXDEN;
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static AstSystemType GetSystem( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetSystem
-
-*  Purpose:
-*     Obtain the System attribute for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstSystemType GetSystem( AstFrame *this_frame, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetSystem protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns the System attribute for a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The System value.
-
-*  Notes:
-*     - AST__BADSYSTEM is returned if this function is invoked with
-*     the global error status set or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to FluxFrame structure */
-   AstMapping *map;              /* Pointer to unit Mapping */
-   AstSystemType i;              /* System to check */
-   AstSystemType result;         /* Value to return */
-   const char *units;            /* FluxFrame units */
-   int unitSet;                  /* Has a value been supplied for Unit? */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* See if a value has been assigned to the Unit attribute. */
-   unitSet = astTestUnit( this_frame, 0 );
-
-/* If a System attribute has been set, invoke the parent method to obtain
-   it. */
-   if ( astTestSystem( this ) ) {
-      result = (*parent_getsystem)( this_frame, status );
-
-/* Otherwise, if the Unit attribute has been set, provide a suitable default
-   system based on the units. */
-   } else if( unitSet ){
-
-/* Loop round each known system value. If a Mapping can be found from the
-   current units to the default units for the system, then use the system as
-   the default system. */
-      units = astGetUnit( this_frame, 0 );
-      for( i = FIRST_SYSTEM; i <= LAST_SYSTEM; i++ ) {
-         map = astUnitMapper( units, DefUnit( i, "astGetSystem",
-                                    astGetClass( this ), status ), NULL, NULL );
-         if( map ) {
-            map = astAnnul( map );
-            result = i;
-            break;
-         }
-      }
-
-/* Otherwise, report an error. */
-      if( result == AST__BADSYSTEM && astOK ) {
-         astError( AST__BADUN, "astGetSystem(%s): The current units (%s) "
-                   "cannot be used with any of the supported flux systems.", status,
-                   astGetClass( this ), astGetUnit( this_frame, 0 ) );
-      }
-
-/* Otherwise, provide a suitable default based on the units. */
-   } else {
-      result = AST__FLUXDEN;
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static const char *GetTitle( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     GetTitle
-
-*  Purpose:
-*     Obtain a pointer to the Title string for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *GetTitle( AstFrame *this_frame, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetTitle method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the Title string for a FluxFrame.
-*     A pointer to a suitable default string is returned if no Title value has
-*     previously been set.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to a null-terminated character string containing the requested
-*     information.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Declare the thread specific global data */
-   AstFluxFrame *this;           /* Pointer to FluxFrame structure */
-   AstSpecFrame *sf;             /* Pointer to SpecFrame structure */
-   const char *result;           /* Pointer to result string */
-   const char *sv;               /* Formatted SpecVal string */
-   const char *su;               /* Units string */
-   double specval;               /* SpecVal value */
-   int pos;                      /* Buffer position to enter text */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Get a pointer to the structure holding thread-specific global data. */
-   astGET_GLOBALS(this_frame);
-
-/* Initialise. */
-   result = NULL;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* See if a Title string has been set. If so, use the parent astGetTitle
-   method to obtain a pointer to it. */
-   if ( astTestTitle( this ) ) {
-      result = (*parent_gettitle)( this_frame, status );
-
-/* Otherwise, we will generate a default Title string. */
-   } else {
-
-/* Classify the coordinate system type and create an appropriate Title
-   string.  */
-      if ( astOK ) {
-         result = gettitle_buff;
-
-/* Begin with the system's default label. */
-         pos = sprintf( gettitle_buff, "%s", SystemLabel( astGetSystem( this ), status ) );
-         gettitle_buff[ 0 ] = toupper( gettitle_buff[ 0 ] );
-
-/* Append the spectral position, if known. */
-         specval = astGetSpecVal( this );
-         sf = GetSpecFrame( this, status );
-         if( specval != AST__BAD && sf ) {
-            sv = astFormat( sf, 0, specval );
-            su = astGetUnit( sf, 0 );
-            pos += sprintf( gettitle_buff + pos, " at = %s %s", sv, su );
-         }
-         sf = astAnnul( sf );
-      }
-   }
-
-/* If an error occurred, clear the returned pointer value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-static const char *GetUnit( AstFrame *this_frame, int axis, int *status ) {
-/*
-*  Name:
-*     GetUnit
-
-*  Purpose:
-*     Obtain a pointer to the Unit string for a FluxFrame's axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *GetUnit( AstFrame *this_frame, int axis )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astGetUnit method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function returns a pointer to the Unit string for a specified axis
-*     of a FluxFrame. If the Unit attribute has not been set for the axis, a
-*     pointer to a suitable default string is returned instead.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     axis
-*        The number of the axis (zero-based) for which information is required.
-
-*  Returned Value:
-*     A pointer to a null-terminated string containing the Unit value.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   AstSystemType system;         /* The FluxFrame's System value */
-   const char *result;           /* Pointer value to return */
-
-/* Check the global error status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* Validate the axis index. */
-   astValidateAxis( this, axis, 1, "astGetUnit" );
-
-/* If a value has been set for the Unit attribute, use the parent
-   GetUnit method to return a pointer to the required Unit string. */
-   if( astTestUnit( this, axis ) ){
-      result = (*parent_getunit)( this_frame, axis, status );
-
-/* Otherwise, identify the flux coordinate system described by the
-   FluxFrame. */
-   } else {
-      system = astGetSystem( this );
-
-/* Return a string describing the default units. */
-      result = DefUnit( system, "astGetUnit", astGetClass( this ), status );
-   }
-
-/* If an error occurred, clear the returned value. */
-   if ( !astOK ) result = NULL;
-
-/* Return the result. */
-   return result;
-}
-
-void astInitFluxFrameVtab_(  AstFluxFrameVtab *vtab, const char *name, int *status ) {
-/*
-*+
-*  Name:
-*     astInitFluxFrameVtab
-
-*  Purpose:
-*     Initialise a virtual function table for a FluxFrame.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void astInitFluxFrameVtab( AstFluxFrameVtab *vtab, const char *name )
-
-*  Class Membership:
-*     FluxFrame vtab initialiser.
-
-*  Description:
-*     This function initialises the component of a virtual function
-*     table which is used by the FluxFrame class.
-
-*  Parameters:
-*     vtab
-*        Pointer to the virtual function table. The components used by
-*        all ancestral classes will be initialised if they have not already
-*        been initialised.
-*     name
-*        Pointer to a constant null-terminated character string which contains
-*        the name of the class to which the virtual function table belongs (it
-*        is this pointer value that will subsequently be returned by the Object
-*        astClass function).
-*-
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstFrameVtab *frame;          /* Pointer to Frame component of Vtab */
-   AstObjectVtab *object;        /* Pointer to Object component of Vtab */
-
-/* Check the local error status. */
-   if ( !astOK ) return;
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* Initialize the component of the virtual function table used by the
-   parent class. */
-   astInitFrameVtab( (AstFrameVtab *) vtab, name );
-
-/* Store a unique "magic" value in the virtual function table. This
-   will be used (by astIsAFluxFrame) to determine if an object belongs
-   to this class.  We can conveniently use the address of the (static)
-   class_check variable to generate this unique value. */
-   vtab->id.check = &class_check;
-   vtab->id.parent = &(((AstFrameVtab *) vtab)->id);
-
-/* Initialise member function pointers. */
-/* ------------------------------------ */
-/* Store pointers to the member functions (implemented here) that
-   provide virtual methods for this class. */
-   vtab->GetDensitySystem = GetDensitySystem;
-   vtab->GetDensityUnit = GetDensityUnit;
-
-   vtab->ClearSpecVal = ClearSpecVal;
-   vtab->TestSpecVal = TestSpecVal;
-   vtab->GetSpecVal = GetSpecVal;
-   vtab->SetSpecVal = SetSpecVal;
-
-/* Save the inherited pointers to methods that will be extended, and
-   replace them with pointers to the new member functions. */
-   object = (AstObjectVtab *) vtab;
-   frame = (AstFrameVtab *) vtab;
-   parent_getobjsize = object->GetObjSize;
-   object->GetObjSize = GetObjSize;
-
-   parent_clearattrib = object->ClearAttrib;
-   object->ClearAttrib = ClearAttrib;
-   parent_getattrib = object->GetAttrib;
-   object->GetAttrib = GetAttrib;
-   parent_setattrib = object->SetAttrib;
-   object->SetAttrib = SetAttrib;
-   parent_testattrib = object->TestAttrib;
-   object->TestAttrib = TestAttrib;
-
-#if defined(THREAD_SAFE)
-   parent_managelock = object->ManageLock;
-   object->ManageLock = ManageLock;
-#endif
-
-   parent_getdomain = frame->GetDomain;
-   frame->GetDomain = GetDomain;
-
-   parent_getsystem = frame->GetSystem;
-   frame->GetSystem = GetSystem;
-   parent_setsystem = frame->SetSystem;
-   frame->SetSystem = SetSystem;
-   parent_clearsystem = frame->ClearSystem;
-   frame->ClearSystem = ClearSystem;
-
-   parent_getalignsystem = frame->GetAlignSystem;
-   frame->GetAlignSystem = GetAlignSystem;
-
-   parent_getlabel = frame->GetLabel;
-   frame->GetLabel = GetLabel;
-
-   parent_getsymbol = frame->GetSymbol;
-   frame->GetSymbol = GetSymbol;
-
-   parent_gettitle = frame->GetTitle;
-   frame->GetTitle = GetTitle;
-
-   parent_clearunit = frame->ClearUnit;
-   frame->ClearUnit = ClearUnit;
-
-   parent_getunit = frame->GetUnit;
-   frame->GetUnit = GetUnit;
-
-   parent_setunit = frame->SetUnit;
-   frame->SetUnit = SetUnit;
-
-   parent_match = frame->Match;
-   frame->Match = Match;
-
-   parent_overlay = frame->Overlay;
-   frame->Overlay = Overlay;
-
-   parent_subframe = frame->SubFrame;
-   frame->SubFrame = SubFrame;
-
-/* Store replacement pointers for methods which will be over-ridden by new
-   member functions implemented here. */
-   frame->GetActiveUnit = GetActiveUnit;
-   frame->TestActiveUnit = TestActiveUnit;
-   frame->ValidateSystem = ValidateSystem;
-   frame->SystemString = SystemString;
-   frame->SystemCode = SystemCode;
-
-/* Declare the copy constructor, destructor and class dump
-   function. */
-   astSetCopy( vtab, Copy );
-   astSetDelete( vtab, Delete );
-   astSetDump( vtab, Dump, "FluxFrame", "Description of flux values" );
-
-/* If we have just initialised the vtab for the current class, indicate
-   that the vtab is now initialised, and store a pointer to the class
-   identifier in the base "object" level of the vtab. */
-   if( vtab == &class_vtab ) {
-      class_init = 1;
-      astSetVtabClassIdentifier( vtab, &(vtab->id) );
-   }
-}
-
-#if defined(THREAD_SAFE)
-static int ManageLock( AstObject *this_object, int mode, int extra,
-                       AstObject **fail, int *status ) {
-/*
-*  Name:
-*     ManageLock
-
-*  Purpose:
-*     Manage the thread lock on an Object.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "object.h"
-*     AstObject *ManageLock( AstObject *this, int mode, int extra,
-*                            AstObject **fail, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astManageLock protected
-*     method inherited from the parent class).
-
-*  Description:
-*     This function manages the thread lock on the supplied Object. The
-*     lock can be locked, unlocked or checked by this function as
-*     deteremined by parameter "mode". See astLock for details of the way
-*     these locks are used.
-
-*  Parameters:
-*     this
-*        Pointer to the Object.
-*     mode
-*        An integer flag indicating what the function should do:
-*
-*        AST__LOCK: Lock the Object for exclusive use by the calling
-*        thread. The "extra" value indicates what should be done if the
-*        Object is already locked (wait or report an error - see astLock).
-*
-*        AST__UNLOCK: Unlock the Object for use by other threads.
-*
-*        AST__CHECKLOCK: Check that the object is locked for use by the
-*        calling thread (report an error if not).
-*     extra
-*        Extra mode-specific information.
-*     fail
-*        If a non-zero function value is returned, a pointer to the
-*        Object that caused the failure is returned at "*fail". This may
-*        be "this" or it may be an Object contained within "this". Note,
-*        the Object's reference count is not incremented, and so the
-*        returned pointer should not be annulled. A NULL pointer is
-*        returned if this function returns a value of zero.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*    A local status value:
-*        0 - Success
-*        1 - Could not lock or unlock the object because it was already
-*            locked by another thread.
-*        2 - Failed to lock a POSIX mutex
-*        3 - Failed to unlock a POSIX mutex
-*        4 - Bad "mode" value supplied.
-
-*  Notes:
-*     - This function attempts to execute even if an error has already
-*     occurred.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;       /* Pointer to FluxFrame structure */
-   int result;               /* Returned status value */
-
-/* Initialise */
-   result = 0;
-
-/* Check the supplied pointer is not NULL. */
-   if( !this_object ) return result;
-
-/* Obtain a pointers to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Invoke the ManageLock method inherited from the parent class. */
-   if( !result ) result = (*parent_managelock)( this_object, mode, extra,
-                                                fail, status );
-
-/* Invoke the astManageLock method on any Objects contained within
-   the supplied Object. */
-   if( !result ) result = astManageLock( this->specframe, mode, extra, fail );
-
-   return result;
-
-}
-#endif
-
-static int MakeFluxMapping( AstFluxFrame *target, AstFluxFrame *result,
-                            AstSystemType align_sys, AstMapping **map, int *status ) {
-/*
-*  Name:
-*     MakeFluxMapping
-
-*  Purpose:
-*     Generate a Mapping between two FluxFrames.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int MakeFluxMapping( AstFluxFrame *target, AstFluxFrame *result,
-*                          AstSystemType align_sys, MakeFluAstMapping **map, int *status )
-
-*  Class Membership:
-*     FluxFrame member function.
-
-*  Description:
-*     This function takes two FluxFrames and generates a Mapping that
-*     converts between them, taking account of differences in their
-*     coordinate systems, reference frequency, etc.
-*
-*     In order to cut down the number of transformations to be considered,
-*     the scheme works by first converting from the target frame to an
-*     "alignment" Frame, using the attributes of the target to define the
-*     transformation. A transformation is then found from the alignment
-*     frame to the required result Frame,  using the attributes of the
-*     result to define the transformation. The alignment Frame is
-*     described by the supplied parameter "align_sys".
-
-*  Parameters:
-*     target
-*        Pointer to the first FluxFrame.
-*     result
-*        Pointer to the second FluxFrame.
-*     align_sys
-*        The flux system in which to align the two FluxFrames.
-*     map
-*        Pointer to a location which is to receive a pointer to the
-*        returned Mapping. The forward transformation of this Mapping
-*        will convert from "target" coordinates to "result"
-*        coordinates, and the inverse transformation will convert in
-*        the opposite direction (all coordinate values in radians).
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Non-zero if the Mapping could be generated, or zero if the two
-*     FluxFrames are sufficiently un-related that no meaningful Mapping
-*     can be produced (in which case a NULL Mapping pointer will be
-*     returned).
-
-*  Notes:
-*     A value of zero is returned if this function is invoked with the
-*     global error status set or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFrameSet *fs;
-   AstMapping *map1;
-   AstMapping *map2;
-   AstMapping *map3;
-   AstMapping *map4;
-   AstMapping *map5;
-   AstMapping *smap;
-   AstMapping *smap_in;
-   AstMapping *smap_out;
-   AstMapping *tmap;
-   AstSpecFrame *sfin1;
-   AstSpecFrame *sfin2;
-   AstSpecFrame *sfout1;
-   AstSpecFrame *sfout2;
-   AstSystemType rsys_in;
-   AstSystemType rsys_out;
-   AstSystemType sys_in;
-   AstSystemType sys_out;
-   double specval2;
-   double specval;
-   double specval_in;
-   double specval_out;
-   double zoom;
-   int match;
-   int sb_in;
-   int sb_out;
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Initialise the returned values. */
-   match = 0;
-   *map = NULL;
-
-/* Initialise to avoid compiler warnings. */
-   map1 = NULL;
-   map2 = NULL;
-   map3 = NULL;
-
-/* Note the target and result System */
-   rsys_in = astGetSystem( target );
-   rsys_out = astGetSystem( result );
-
-/* First get a Mapping which converts from the units used in the target
-   to the default units associated with the target's system.
-   ---------------------------------------------------------------------- */
-   map1 = astUnitMapper( astGetUnit( target, 0 ),
-                         DefUnit( rsys_in, "MakeFluxMapping", "FluxFrame", status ),
-                         NULL, NULL );
-
-/* If the target system is surface brightness, change it to the
-   corresponding flux density system. We are effectively converting from
-   surface brightness to the flux density normalised to unit area. Also
-   set flags indicating if the systems are surface brightness systems. */
-   if( rsys_in == AST__SBRIGHT ) {
-      sys_in = AST__FLUXDEN;
-      sb_in = 1;
-
-   } else if( rsys_in == AST__SBRIGHTW ) {
-      sys_in = AST__FLUXDENW;
-      sb_in = 1;
-
-   } else {
-      sys_in = rsys_in;
-      sb_in = 0;
-   }
-
-/* Likewise if the result system is surface brightness, change it to the
-   corresponding flux density system. */
-   if( rsys_out == AST__SBRIGHT ) {
-      sys_out = AST__FLUXDEN;
-      sb_out = 1;
-
-   } else if( rsys_out == AST__SBRIGHTW ) {
-      sys_out = AST__FLUXDENW;
-      sb_out = 1;
-
-   } else {
-      sys_out = rsys_out;
-      sb_out = 0;
-   }
-
-/* Assume at this point in the chain of coversions that we have target values
-   in some form of flux density system (either frequency or wavelength). The
-   precise units do not matter at this point (so long as they are
-   dimensionally correct for describing the relevant form of flux density).
-   When other systems are added (e.g. antenna temperature), some code
-   will have to come before this point which produces a Mapping from (e.g.)
-   antenna temperature to flux density. */
-
-
-/* Get a Mapping from the default units for the input flux density system
-   to the default units for the output flux density system.
-   ---------------------------------------------------------------------- */
-
-/* If one but not both of the systems represent surface brightness, then
-   we cannot form a Mapping. */
-   if( sb_in != sb_out ) {
-      zoom = AST__BAD;
-
-/* If the input and output flux density systems are the same, then the
-   required Mapping is a UnitMap. */
-   } else if( sys_in == sys_out ) {
-      zoom = 1.0;
-
-/* Otherwise, the required Mapping is a zoom map in which the scale factor is
-   the rate of change of the input spectral system with respect to the output
-   spectral system, at the position given by the SpecVal attribute (we
-   cannot do the conversion if the SpecVal values in the target and result
-   differ). Each spectral system is either wavelength (in Angstrom) or
-   frequency (in Hz), depending on whether the associated flux density
-   system is "per Angstrom" or "per Hertz". The SpecVal value may be
-   stored in some other system, so the first job is to create SpecFrames
-   with the required system and units from the SpecFrames encapsulated
-   within the target and result FluxFrames. Take deep copies of the two
-   SpecFrames, and set their systems and units. */
-   } else {
-      sfin1 = GetSpecFrame( target, status );
-      sfin2 = astCopy( sfin1 );
-      astSetSystem( sfin2, DensitySystem( sys_in, status ) );
-      astSetUnit( sfin2, 0, DensityUnit( sys_in, status ) );
-
-      sfout1 = GetSpecFrame( result, status );
-      sfout2 = astCopy( sfout1 );
-      astSetSystem( sfout2, DensitySystem( sys_out, status ) );
-      astSetUnit( sfout2, 0, DensityUnit( sys_out, status ) );
-
-/* Indicate we do not yet have a zoom factor */
-      zoom = AST__BAD;
-
-/* Get the Mapping from output to input spectral coordinate system */
-      fs = astConvert( sfout2, sfin2, "" );
-      if( fs ) {
-         tmap = astGetMapping( fs, AST__BASE, AST__CURRENT );
-         fs = astAnnul( fs );
-
-/* Simplify the Mapping. */
-         smap = astSimplify( tmap );
-         tmap = astAnnul( tmap );
-
-/* We first need to transform the two SpecVal attributes into the input
-   coordinate system of the "smap" Mapping (i.e. the standardised result
-   FluxFrame), and check they are the same. For this we need the Mappings
-   from the SpecFrames stored in the FluxFrames to the modified copies
-   created above. */
-         fs = astConvert( sfin1, sfin2, "" );
-         if( fs ) {
-            smap_in = astGetMapping( fs, AST__BASE, AST__CURRENT );
-            fs = astAnnul( fs );
-         } else {
-            smap_in = NULL;
-         }
-
-         fs = astConvert( sfout1, sfout2, "" );
-         if( fs ) {
-            smap_out = astGetMapping( fs, AST__BASE, AST__CURRENT );
-            fs = astAnnul( fs );
-         } else {
-            smap_out = NULL;
-         }
-
-/* Convert the target's SpecVal into the standardised target system */
-         specval = astGetSpecVal( target );
-         astTran1( smap_in, 1, &specval, 1, &specval2 );
-
-/* Now convert it into the standardised result system. Note, we need to
-   use "smap" in the inverse direction for this. */
-         astTran1( smap, 1, &specval2, 0, &specval_in );
-
-/* Convert the results's SpecVal into the standardised result system */
-         specval = astGetSpecVal( result );
-         astTran1( smap_out, 1, &specval, 1, &specval_out );
-
-/* Check they are equal and good. */
-         if( astEQUALS( specval_in, specval_out, 1.0E8 ) && specval_in != AST__BAD ) {
-
-/* If the siSimplified Mapping is a UnitMap the required rate of change
-   factor is 1.0. If it resuts in a ZoomMap, the required factor is
-   the zoom factor in the ZoomMap. */
-            if( astIsAUnitMap( smap ) ) {
-               zoom = 1.0;
-
-            } else if( astIsAZoomMap( smap ) ) {
-               zoom = astGetZoom( smap );
-
-/* For any other type of Mapping, we must determine the rate of change factor
-   by differentiating the Mapping at the SpecVal position. */
-            } else {
-               specval = 0.5*( specval_in  + specval_out );
-               zoom = astRate( smap, &specval, 0, 0 );
-            }
-         }
-
-/* Free resources */
-         if( smap_in ) smap_in = astAnnul( smap_in );
-         if( smap_out ) smap_out = astAnnul( smap_out );
-         smap = astAnnul( smap );
-      }
-
-      sfout1 = astAnnul( sfout1 );
-      sfin1 = astAnnul( sfin1 );
-      sfout2 = astAnnul( sfout2 );
-      sfin2 = astAnnul( sfin2 );
-   }
-
-/* Create the required zoom map if a scaling factor was found. */
-   if( zoom != AST__BAD ) {
-      map2 = (AstMapping *) astZoomMap( 1, fabs( zoom ), "", status );
-   } else {
-      map2 = NULL;
-   }
-
-/* Now get a Mapping which converts from the default units associated with
-   the results's system, to the units used in the result.
-   ----------------------------------------------------------------------- */
-   map3 = astUnitMapper( DefUnit( rsys_out, "MakeFluxMapping", "FluxFrame", status ),
-                         astGetUnit( result, 0 ), NULL, NULL );
-
-/* Indicate a match was found and combine all Mapings in series. */
-   if( map1 && map2 && map3 ) {
-      match = 1;
-      map4 = (AstMapping *) astCmpMap( map1, map2, 1, "", status );
-      map5 = (AstMapping *) astCmpMap( map4, map3, 1, "", status );
-
-/* Return the simplified Mapping. */
-      *map = astSimplify( map5 );
-
-/* Free resources. */
-      map4 = astAnnul( map4 );
-      map5 = astAnnul( map5 );
-   }
-
-/* Free resources. */
-   if( map1 ) map1 = astAnnul( map1 );
-   if( map2 ) map2 = astAnnul( map2 );
-   if( map3 ) map3 = astAnnul( map3 );
-
-/* If an error occurred, annul the returned Mapping and clear the returned
-   values. */
-   if ( !astOK ) {
-      *map = astAnnul( *map );
-      match = 0;
-   }
-
-/* Return the result. */
-   return match;
-}
-
-static int Match( AstFrame *template_frame, AstFrame *target, int matchsub,
-                  int **template_axes, int **target_axes, AstMapping **map,
-                  AstFrame **result, int *status ) {
-/*
-*  Name:
-*     Match
-
-*  Purpose:
-*     Determine if conversion is possible between two coordinate systems.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int Match( AstFrame *template, AstFrame *target, int matchsub,
-*                int **template_axes, int **target_axes,
-*                AstMapping **map, AstFrame **result, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the protected astMatch method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function matches a "template" FluxFrame to a "target" Frame and
-*     determines whether it is possible to convert coordinates between them.
-*     If it is, a mapping that performs the transformation is returned along
-*     with a new Frame that describes the coordinate system that results when
-*     this mapping is applied to the "target" coordinate system. In addition,
-*     information is returned to allow the axes in this "result" Frame to be
-*     associated with the corresponding axes in the "target" and "template"
-*     Frames from which they are derived.
-
-*  Parameters:
-*     template
-*        Pointer to the template FluxFrame. This describes the coordinate
-*        system (or set of possible coordinate systems) into which we wish to
-*        convert our coordinates.
-*     target
-*        Pointer to the target Frame. This describes the coordinate system in
-*        which we already have coordinates.
-*     matchsub
-*        If zero then a match only occurs if the template is of the same
-*        class as the target, or of a more specialised class. If non-zero
-*        then a match can occur even if this is not the case.
-*     template_axes
-*        Address of a location where a pointer to int will be returned if the
-*        requested coordinate conversion is possible. This pointer will point
-*        at a dynamically allocated array of integers with one element for each
-*        axis of the "result" Frame (see below). It must be freed by the caller
-*        (using astFree) when no longer required.
-*
-*        For each axis in the result Frame, the corresponding element of this
-*        array will return the index of the template FluxFrame axis from
-*        which it is derived. If it is not derived from any template
-*        FluxFrame axis, a value of -1 will be returned instead.
-*     target_axes
-*        Address of a location where a pointer to int will be returned if the
-*        requested coordinate conversion is possible. This pointer will point
-*        at a dynamically allocated array of integers with one element for each
-*        axis of the "result" Frame (see below). It must be freed by the caller
-*        (using astFree) when no longer required.
-*
-*        For each axis in the result Frame, the corresponding element of this
-*        array will return the index of the target Frame axis from which it
-*        is derived. If it is not derived from any target Frame axis, a value
-*        of -1 will be returned instead.
-*     map
-*        Address of a location where a pointer to a new Mapping will be
-*        returned if the requested coordinate conversion is possible. If
-*        returned, the forward transformation of this Mapping may be used to
-*        convert coordinates between the "target" Frame and the "result"
-*        Frame (see below) and the inverse transformation will convert in the
-*        opposite direction.
-*     result
-*        Address of a location where a pointer to a new Frame will be returned
-*        if the requested coordinate conversion is possible. If returned, this
-*        Frame describes the coordinate system that results from applying the
-*        returned Mapping (above) to the "target" coordinate system. In
-*        general, this Frame will combine attributes from (and will therefore
-*        be more specific than) both the target and the template Frames. In
-*        particular, when the template allows the possibility of transformaing
-*        to any one of a set of alternative coordinate systems, the "result"
-*        Frame will indicate which of the alternatives was used.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A non-zero value is returned if the requested coordinate conversion is
-*     possible. Otherwise zero is returned (this will not in itself result in
-*     an error condition).
-
-*  Notes:
-*     -  A value of zero will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-
-*  Implementation Notes:
-*     This implementation addresses the matching of a FluxFrame class
-*     object to any other class of Frame. A FluxFrame will match any class
-*     of FluxFrame (i.e. possibly from a derived class) but will not match
-*     a less specialised class of Frame.
-*/
-
-/* Local Variables: */
-   AstFrame *frame0;             /* Pointer to Frame underlying axis 0 */
-   AstFluxFrame *template;       /* Pointer to template FluxFrame structure */
-   int iaxis0;                   /* Axis index underlying axis 0 */
-   int iaxis;                    /* Axis index */
-   int match;                    /* Coordinate conversion possible? */
-   int target_axis0;             /* Index of FluxFrame axis in the target */
-   int target_naxes;             /* Number of target axes */
-
-/* Initialise the returned values. */
-   *template_axes = NULL;
-   *target_axes = NULL;
-   *map = NULL;
-   *result = NULL;
-   match = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return match;
-
-/* Obtain a pointer to the template FluxFrame structure. */
-   template = (AstFluxFrame *) template_frame;
-
-/* Obtain the number of axes in the target Frame. */
-   target_naxes = astGetNaxes( target );
-
-/* The first criterion for a match is that the template matches as a
-   Frame class object. This ensures that the number of axes (1) and
-   domain, etc. of the target Frame are suitable. Invoke the parent
-   "astMatch" method to verify this. */
-   match = (*parent_match)( template_frame, target, matchsub,
-                            template_axes, target_axes, map, result, status );
-
-/* If a match was found, annul the returned objects, which are not
-   needed, but keep the memory allocated for the axis association
-   arrays, which we will re-use. */
-   if ( astOK && match ) {
-      *map = astAnnul( *map );
-      *result = astAnnul( *result );
-   }
-
-/* If OK so far, obtain pointers to the primary Frames which underlie
-   all target axes. Stop when a FluxFrame axis is found. */
-   if ( match && astOK ) {
-      match = 0;
-      for( iaxis = 0; iaxis < target_naxes; iaxis++ ) {
-         astPrimaryFrame( target, iaxis, &frame0, &iaxis0 );
-         if( astIsAFluxFrame( frame0 ) ) {
-            frame0 = astAnnul( frame0 );
-            target_axis0 = iaxis;
-            match = 1;
-            break;
-         } else {
-            frame0 = astAnnul( frame0 );
-         }
-      }
-   }
-
-/* Check at least one FluxFrame axis was found it the target. Store the
-   axis associataions. */
-   if( match && astOK ) {
-      (*template_axes)[ 0 ] = 0;
-      (*target_axes)[ 0 ] = target_axis0;
-
-/* Use the target's "astSubFrame" method to create a new Frame (the
-   result Frame) with copies of the target axes in the required
-   order. This process also overlays the template attributes on to the
-   target Frame and returns a Mapping between the target and result
-   Frames which effects the required coordinate conversion. */
-      match = astSubFrame( target, template, 1, *target_axes, *template_axes,
-                           map, result );
-   }
-
-/* If an error occurred, or conversion to the result Frame's
-   coordinate system was not possible, then free all memory, annul the
-   returned objects, and reset the returned value. */
-   if ( !astOK || !match ) {
-      *template_axes = astFree( *template_axes );
-      *target_axes = astFree( *target_axes );
-      if( *map ) *map = astAnnul( *map );
-      if( *result ) *result = astAnnul( *result );
-      match = 0;
-   }
-
-/* Return the result. */
-   return match;
-}
-
-static void Overlay( AstFrame *template, const int *template_axes,
-                     AstFrame *result, int *status ) {
-/*
-*  Name:
-*     Overlay
-
-*  Purpose:
-*     Overlay the attributes of a template FluxFrame on to another Frame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void Overlay( AstFrame *template, const int *template_axes,
-*                   AstFrame *result, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the protected astOverlay method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function overlays attributes of a FluxFrame (the "template") on to
-*     another Frame, so as to over-ride selected attributes of that second
-*     Frame. Normally only those attributes which have been specifically set
-*     in the template will be transferred. This implements a form of
-*     defaulting, in which a Frame acquires attributes from the template, but
-*     retains its original attributes (as the default) if new values have not
-*     previously been explicitly set in the template.
-*
-*     Note that if the result Frame is a FluxFrame and a change of flux
-*     coordinate system occurs as a result of overlaying its System
-*     attribute, then some of its original attribute values may no
-*     longer be appropriate (e.g. the Title, or attributes describing
-*     its axes). In this case, these will be cleared before overlaying
-*     any new values.
-
-*  Parameters:
-*     template
-*        Pointer to the template FluxFrame, for which values should have been
-*        explicitly set for any attribute which is to be transferred.
-*     template_axes
-*        Pointer to an array of int, with one element for each axis of the
-*        "result" Frame (see below). For each axis in the result frame, the
-*        corresponding element of this array should contain the (zero-based)
-*        index of the template axis to which it corresponds. This array is used
-*        to establish from which template axis any axis-dependent attributes
-*        should be obtained.
-*
-*        If any axis in the result Frame is not associated with a template
-*        axis, the corresponding element of this array should be set to -1.
-*
-*        If a NULL pointer is supplied, the template and result axis
-*        indices are assumed to be identical.
-*     result
-*        Pointer to the Frame which is to receive the new attribute values.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     void
-
-*  Notes:
-*     -  In general, if the result Frame is not from the same class as the
-*     template FluxFrame, or from a class derived from it, then attributes may
-*     exist in the template FluxFrame which do not exist in the result Frame.
-*     In this case, these attributes will not be transferred.
-*/
-
-
-/* Local Variables: */
-   AstFluxFrame *resff;          /* Result FluxFrame */
-   AstFluxFrame *tmpff;          /* Template FluxFrame */
-   AstSystemType new_alignsystem;/* Code identifying alignment coords */
-   AstSystemType new_system;     /* Code identifying new cordinates */
-   AstSystemType old_system;     /* Code identifying old coordinates */
-   const char *method;           /* Pointer to method string */
-   const char *new_class;        /* Pointer to template class string */
-   const char *old_class;        /* Pointer to result class string */
-   int fluxframe;                /* Result Frame is a FluxFrame? */
-   int resetSystem;              /* Was the template System value cleared? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Initialise strings used in error messages. */
-   new_class = astGetClass( template );
-   old_class = astGetClass( result );
-   method = "astOverlay";
-
-/* Get the old and new systems. */
-   old_system = astGetSystem( result );
-   new_system = astGetSystem( template );
-
-/* If the result Frame is a FluxFrame, we must test to see if overlaying its
-   System attribute will change the type of coordinate system it describes.
-   Determine the value of this attribute for the result and template
-   FluxFrames. */
-   resetSystem = 0;
-   fluxframe = astIsAFluxFrame( result );
-   if( fluxframe ) {
-
-/* If the coordinate system will change, any value already set for the result
-   FluxFrame's Title will no longer be appropriate, so clear it. */
-      if ( new_system != old_system ) {
-         astClearTitle( result );
-
-/* If the systems have the same default units, we can retain the current
-   Unit value. */
-         if( strcmp( DefUnit( new_system, method, new_class, status ),
-                     DefUnit( old_system, method, old_class, status ) ) ) {
-            astClearUnit( result, 0 );
-         }
-
-/* If necessary, clear inappropriate values for all those axis attributes
-   whose access functions are over-ridden by this class (these access functions
-   will then provide suitable defaults appropriate to the new coordinate system
-   instead). */
-         astClearLabel( result, 0 );
-         astClearSymbol( result, 0 );
-      }
-
-/* Transfer the default SpecVal value and the SpecFrame. */
-      resff = (AstFluxFrame *) result;
-      tmpff = (AstFluxFrame *) template;
-      resff->defspecval = tmpff->defspecval;
-      if( resff->specframe ) (void) astAnnul( resff->specframe );
-      resff->specframe = tmpff->specframe ? astCopy( tmpff->specframe ) : NULL;
-
-/* If the result Frame is not a FluxFrame, we must temporarily clear the
-   System and AlignSystem values since the values used by this class are only
-   appropriate to this class. */
-   } else {
-      if( astTestSystem( template ) ) {
-         astClearSystem( template );
-
-         new_alignsystem = astGetAlignSystem( template );
-         astClearAlignSystem( template );
-
-         resetSystem = 1;
-      }
-   }
-
-/* Invoke the parent class astOverlay method to transfer attributes inherited
-   from the parent class. */
-   (*parent_overlay)( template, template_axes, result, status );
-
-/* Reset the System and AlignSystem values if necessary */
-   if( resetSystem ) {
-      astSetSystem( template, new_system );
-      astSetAlignSystem( template, new_alignsystem );
-   }
-
-/* Check if the result Frame is a FluxFrame or from a class derived from
-   FluxFrame. If not, we cannot transfer FluxFrame attributes to it as it is
-   insufficiently specialised. In this case simply omit these attributes. */
-   if ( fluxframe && astOK ) {
-
-/* Define macros that test whether an attribute is set in the template and,
-   if so, transfers its value to the result. */
-#define OVERLAY(attribute) \
-   if ( astTest##attribute( template ) ) { \
-      astSet##attribute( result, astGet##attribute( template ) ); \
-   }
-
-/* Use the macro to transfer each FluxFrame attribute in turn. */
-      OVERLAY(SpecVal)
-
-
-   }
-
-/* Undefine macros local to this function. */
-#undef OVERLAY
-}
-
-static void SetAttrib( AstObject *this_object, const char *setting, int *status ) {
-/*
-*  Name:
-*     SetAttrib
-
-*  Purpose:
-*     Set an attribute value for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void SetAttrib( AstObject *this, const char *setting, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (extends the astSetAttrib method inherited from
-*     the Mapping class).
-
-*  Description:
-*     This function assigns an attribute value for a FluxFrame, the attribute
-*     and its value being specified by means of a string of the form:
-*
-*        "attribute= value "
-*
-*     Here, "attribute" specifies the attribute name and should be in lower
-*     case with no white space present. The value to the right of the "="
-*     should be a suitable textual representation of the value to be assigned
-*     and this will be interpreted according to the attribute's data type.
-*     White space surrounding the value is only significant for string
-*     attributes.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     setting
-*        Pointer to a null terminated string specifying the new attribute
-*        value.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     void
-
-*  Notes:
-*     This protected method is intended to be invoked by the Object astSet
-*     method and makes additional attributes accessible to it.
-*/
-
-/* Local Vaiables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   double dval;                  /* Floating point attribute value */
-   int len;                      /* Length of setting string */
-   int nc;                       /* No. of characters read */
-   int ulen;                     /* Used length of setting string */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Obtain the length of the setting string. */
-   len = strlen( setting );
-
-/* Obtain the used length of the setting string. */
-   ulen = astChrLen( setting );
-
-/* Test for each recognised attribute in turn, using "astSscanf" to parse the
-   setting string and extract the attribute value (or an offset to it in the
-   case of string values). In each case, use the value set in "nc" to check
-   that the entire string was matched. Once a value has been obtained, use the
-   appropriate method to set it. */
-
-/* SpecVal. */
-/* -------- */
-   if ( nc = 0,
-        ( 1 == astSscanf( setting, "specval= %lg %n", &dval, &nc ) )
-        && ( nc >= len ) ) {
-      astSetSpecVal( this, dval );
-
-/* Pass any unrecognised setting to the parent method for further
-   interpretation. */
-   } else {
-      (*parent_setattrib)( this_object, setting, status );
-   }
-}
-
-static void SetSystem( AstFrame *this_frame, AstSystemType newsys, int *status ) {
-/*
-*  Name:
-*     SetSystem
-
-*  Purpose:
-*     Set the System attribute for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void SetSystem( AstFrame *this_frame, AstSystemType newsys, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astSetSystem protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function sets the System attribute for a FluxFrame.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     newsys
-*        The new System value to be stored.
-*     status
-*        Pointer to the inherited status variable.
-
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to FluxFrame structure */
-   AstSystemType oldsys;         /* Original System value */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* Save the original System value */
-   oldsys = astGetSystem( this_frame );
-
-/* Use the parent SetSystem method to store the new System value. */
-   (*parent_setsystem)( this_frame, newsys, status );
-
-/* If the system has changed... */
-   if( oldsys != newsys ) {
-
-/* Changing the System value will in general require the Units to change
-   as well. If the user has previously specified the units to be used with
-   the new system, then re-instate them (they are stored in the "usedunits"
-   array in the FluxFrame structure). Otherwise, clear the units so that
-   the default units will eb used with the new System. */
-      if( (int) newsys < this->nuunits && this->usedunits &&
-          this->usedunits[ (int) newsys ] ) {
-         (*parent_setunit)( this_frame, 0, this->usedunits[ (int) newsys ], status );
-      } else {
-         (*parent_clearunit)( this_frame, 0, status );
-      }
-
-/* Also, clear all attributes which have system-specific defaults. */
-      astClearLabel( this_frame, 0 );
-      astClearSymbol( this_frame, 0 );
-      astClearTitle( this_frame );
-   }
-}
-
-static void SetUnit( AstFrame *this_frame, int axis, const char *value, int *status ) {
-/*
-*  Name:
-*     SetUnit
-
-*  Purpose:
-*     Set a pointer to the Unit string for a FluxFrame's axis.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     void SetUnit( AstFrame *this_frame, int axis, const char *value )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astSetUnit method inherited
-*     from the Frame class).
-
-*  Description:
-*     This function stores a pointer to the Unit string for a specified axis
-*     of a FluxFrame. It also stores the string in the "usedunits" array
-*     in the FluxFrame structure, in the element associated with the
-*     current System.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     axis
-*        The number of the axis (zero-based) for which information is required.
-*     unit
-*        The new string to store.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   AstSystemType system;         /* The FluxFrame's System value */
-   int i;                        /* Loop counter */
-   int isystem;                  /* The FluxFrame's System value */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Use the parent SetUnit method to store the value in the Axis
-   structure */
-   (*parent_setunit)( this_frame, axis, value, status );
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_frame;
-
-/* Validate the axis index. */
-   astValidateAxis( this, axis, 1, "astSetUnit" );
-
-/* If the new units are appropriate for the current System, store the
-   supplied value as the UsedUnit for the current System. First ensure the
-   array is big enough. Free any previous value stored for the current
-   system. */
-   system = astGetSystem( this );
-   if( UnitsOK( system, value, 0, "astSetUnit", astGetClass( this ), status ) ) {
-      isystem = (int) astGetSystem( this );
-      if( isystem >= this->nuunits ) {
-         this->usedunits = astGrow( this->usedunits, isystem + 1,
-                                    sizeof(char *) );
-         if( astOK ) {
-            for( i = this->nuunits; i < isystem + 1; i++ ) this->usedunits[ i ] = NULL;
-            this->nuunits = isystem + 1;
-         }
-      }
-
-/* Now store a copy of the value, if it is different to the stored string. */
-      if( astOK && ( !this->usedunits[ isystem ] ||
-                     strcmp( this->usedunits[ isystem ], value ) ) ) {
-         this->usedunits[ isystem ] = astStore( this->usedunits[ isystem ],
-                                               value, strlen( value ) + 1 );
-      }
-
-/* If the new units are not appropriate for the current System, clear the
-   System value. Use the parent ClearSystem function since the
-   astClearSystem implemented by this class will clear the units. */
-   } else {
-      (*parent_clearsystem)( this_frame, status );
-   }
-
-}
-
-static int SubFrame( AstFrame *target_frame, AstFrame *template,
-                     int result_naxes, const int *target_axes,
-                     const int *template_axes, AstMapping **map,
-                     AstFrame **result, int *status ) {
-/*
-*  Name:
-*     SubFrame
-
-*  Purpose:
-*     Select axes from a FluxFrame and convert to the new coordinate
-*     system.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int SubFrame( AstFrame *target, AstFrame *template,
-*                   int result_naxes, const int *target_axes,
-*                   const int *template_axes, AstMapping **map,
-*                   AstFrame **result, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the protected astSubFrame
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function selects a requested sub-set (or super-set) of the axes
-*     from a "target" FluxFrame and creates a new Frame with copies of
-*     the selected axes assembled in the requested order. It then
-*     optionally overlays the attributes of a "template" Frame on to the
-*     result. It returns both the resulting Frame and a Mapping that
-*     describes how to convert between the coordinate systems described by
-*     the target and result Frames. If necessary, this Mapping takes
-*     account of any differences in the Frames' attributes due to the
-*     influence of the template.
-
-*  Parameters:
-*     target
-*        Pointer to the target FluxFrame, from which axes are to be
-*        selected.
-*     template
-*        Pointer to the template Frame, from which new attributes for the
-*        result Frame are to be obtained. Optionally, this may be NULL, in
-*        which case no overlaying of template attributes will be performed.
-*     result_naxes
-*        Number of axes to be selected from the target Frame. This number may
-*        be greater than or less than the number of axes in this Frame (or
-*        equal).
-*     target_axes
-*        Pointer to an array of int with result_naxes elements, giving a list
-*        of the (zero-based) axis indices of the axes to be selected from the
-*        target FluxFrame. The order in which these are given determines
-*        the order in which the axes appear in the result Frame. If any of the
-*        values in this array is set to -1, the corresponding result axis will
-*        not be derived from the target Frame, but will be assigned default
-*        attributes instead.
-*     template_axes
-*        Pointer to an array of int with result_naxes elements. This should
-*        contain a list of the template axes (given as zero-based axis indices)
-*        with which the axes of the result Frame are to be associated. This
-*        array determines which axes are used when overlaying axis-dependent
-*        attributes of the template on to the result. If any element of this
-*        array is set to -1, the corresponding result axis will not receive any
-*        template attributes.
-*
-*        If the template argument is given as NULL, this array is not used and
-*        a NULL pointer may also be supplied here.
-*     map
-*        Address of a location to receive a pointer to the returned Mapping.
-*        The forward transformation of this Mapping will describe how to
-*        convert coordinates from the coordinate system described by the target
-*        FluxFrame to that described by the result Frame. The inverse
-*        transformation will convert in the opposite direction.
-*     result
-*        Address of a location to receive a pointer to the result Frame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     A non-zero value is returned if coordinate conversion is possible
-*     between the target and the result Frame. Otherwise zero is returned and
-*     *map and *result are returned as NULL (but this will not in itself
-*     result in an error condition). In general, coordinate conversion should
-*     always be possible if no template Frame is supplied but may not always
-*     be possible otherwise.
-
-*  Notes:
-*     -  A value of zero will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-
-*  Implementation Notes:
-*     -  This implementation addresses the selection of axes from a
-*     FluxFrame object. This results in another object of the same class
-*     only if the single FluxFrame axis is selected exactly once.
-*     Otherwise, the result is a Frame class object which inherits the
-*     FluxFrame's axis information (if appropriate) but none of the other
-*     properties of a FluxFrame.
-*     -  In the event that a FluxFrame results, the returned Mapping will
-*     take proper account of the relationship between the target and result
-*     coordinate systems.
-*     -  In the event that a Frame class object results, the returned Mapping
-*     will only represent a selection/permutation of axes.
-
-*  Implementation Deficiencies:
-*     -  Any axis selection is currently permitted. Probably this should be
-*     restricted so that each axis can only be selected once. The
-*     astValidateAxisSelection method will do this but currently there are bugs
-*     in the CmpFrame class that cause axis selections which will not pass this
-*     test. Install the validation when these are fixed.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *target;      /* Pointer to the FluxFrame structure */
-   AstFluxFrame *temp;        /* Pointer to copy of target FluxFrame */
-   AstSystemType align_sys;   /* System in which to align the FluxFrames */
-   int match;                 /* Coordinate conversion is possible? */
-   int report;                /* Report errors if FluxFrames cannot be aligned? */
-
-/* Initialise the returned values. */
-   *map = NULL;
-   *result = NULL;
-   match = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return match;
-
-/* Obtain a pointer to the target FluxFrame structure. */
-   target = (AstFluxFrame *) target_frame;
-
-/* Result is a FluxFrame. */
-/* -------------------------- */
-/* Check if the result Frame is to have one axis obtained by selecting
-   the single target FluxFrame axis. If so, the result will also be
-   a FluxFrame. */
-   if ( ( result_naxes == 1 ) && ( target_axes[ 0 ] == 0 ) ) {
-
-/* Form the result from a copy of the target. */
-      *result = astCopy( target );
-
-/* Initialise a flag to indicate that MakeFluxMapping should not report
-   errors if no Mapping can be created. */
-      report = 0;
-
-/* If required, overlay the template attributes on to the result FluxFrame.
-   Also get the system in which to align the two FluxFrames. These are the
-   values from the template (if there is a template). */
-      if ( template ) {
-         astOverlay( template, template_axes, *result );
-         if( astIsAFluxFrame( template ) ) {
-            align_sys = astGetAlignSystem( template );
-
-/* Since we now know that both the template and target are FluxFrames, it
-   should usually be possible to convert betwen them. If conversion is
-   *not* possible then the user will probably be interested in knowing the
-   reason why conversion is not possible. Therefore, indicate that
-   MakeFluxMapping should report errors if no Mapping can be created. */
-            report = 1;
-
-         } else {
-            align_sys = astGetAlignSystem( target );
-         }
-
-/* If no template was supplied, align in the System of the target. */
-      } else {
-         align_sys = astGetSystem( target );
-      }
-
-/* Generate a Mapping that takes account of changes in the coordinate system
-   between the target FluxFrame and the result FluxFrame. If this Mapping can
-   be generated, set "match" to indicate that coordinate conversion is
-   possible. If the template is a fluxframe, report errors if a match is not
-   possible. */
-      match = ( MakeFluxMapping( target, (AstFluxFrame *) *result,
-                align_sys, map, status ) != 0 );
-
-/* Result is not a FluxFrame. */
-/* ------------------------------ */
-/* In this case, we select axes as if the target were from the Frame
-   class.  However, since the resulting data will then be separated
-   from their enclosing FluxFrame, default attribute values may differ
-   if the methods for obtaining them were over-ridden by the FluxFrame
-   class. To overcome this, we ensure that these values are explicitly
-   set for the result Frame (rather than relying on their defaults). */
-   } else {
-
-/* Make a temporary copy of the target FluxFrame. We will explicitly
-   set the attribute values in this copy so as not to modify the original. */
-      temp = astCopy( target );
-
-/* Define a macro to test if an attribute is set. If not, set it
-   explicitly to its default value. */
-#define SET(attribute) \
-   if ( !astTest##attribute( temp ) ) { \
-      astSet##attribute( temp, astGet##attribute( temp ) ); \
-   }
-
-/* Set attribute values which apply to the Frame as a whole and which
-   we want to retain, but whose defaults are over-ridden by the
-   FluxFrame class. */
-      SET(Domain)
-      SET(Title)
-
-/* Define a macro to test if an attribute is set for axis zero (the only
-   axis of a FluxFrame). If not, set it explicitly to its default value. */
-#define SET_AXIS(attribute) \
-   if ( !astTest##attribute( temp, 0 ) ) { \
-      astSet##attribute( temp, 0, \
-                         astGet##attribute( temp, 0 ) ); \
-   }
-
-/* Use this macro to set explicit values for all the axis attributes
-   for which the FluxFrame class over-rides the default value. */
-      SET_AXIS(Label)
-      SET_AXIS(Symbol)
-      SET_AXIS(Unit)
-
-/* Clear attributes which have an extended range of values allowed by
-   this class. */
-      astClearSystem( temp );
-      astClearAlignSystem( temp );
-
-/* Invoke the astSubFrame method inherited from the Frame class to
-   produce the result Frame by selecting the required set of axes and
-   overlaying the template Frame's attributes. */
-      match = (*parent_subframe)( (AstFrame *) temp, template,
-                                  result_naxes, target_axes, template_axes,
-                                  map, result, status );
-
-/* Delete the temporary copy of the target FluxFrame. */
-      temp = astDelete( temp );
-   }
-
-/* If an error occurred or no match was found, annul the returned
-   objects and reset the returned result. */
-   if ( !astOK || !match ) {
-      if( *map ) *map = astAnnul( *map );
-      if( *result ) *result = astAnnul( *result );
-      match = 0;
-   }
-
-/* Return the result. */
-   return match;
-
-/* Undefine macros local to this function. */
-#undef SET
-#undef SET_AXIS
-}
-
-static AstSystemType SystemCode( AstFrame *this, const char *system, int *status ) {
-/*
-*  Name:
-*     SystemCode
-
-*  Purpose:
-*     Convert a string into a coordinate system type code.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstSystemType SystemCode( AstFrame *this, const char *system, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astSystemCode method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function converts a string used for the external
-*     description of a coordinate system into a FluxFrame
-*     coordinate system type code (System attribute value). It is the
-*     inverse of the astSystemString function.
-
-*  Parameters:
-*     this
-*        The Frame.
-*     system
-*        Pointer to a constant null-terminated string containing the
-*        external description of the sky coordinate system.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The System type code.
-
-*  Notes:
-*     - A value of AST__BADSYSTEM is returned if the sky coordinate
-*     system description was not recognised. This does not produce an
-*     error.
-*     - A value of AST__BADSYSTEM is also returned if this function
-*     is invoked with the global error status set or if it should fail
-*     for any reason.
-*/
-
-/* Local Variables: */
-   AstSystemType result;      /* Result value to return */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Match the "system" string against each possibility and assign the
-   result. */
-   if ( astChrMatch( "FLXDN", system ) ) {
-      result = AST__FLUXDEN;
-
-   } else if ( astChrMatch( "FLXDNW", system ) ) {
-      result = AST__FLUXDENW;
-
-   }else if ( astChrMatch( "SFCBR", system ) ) {
-      result = AST__SBRIGHT;
-
-   } else if ( astChrMatch( "SRCBR", system ) ) {
-      result = AST__SBRIGHTW;
-
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static const char *SystemLabel( AstSystemType system, int *status ) {
-/*
-*  Name:
-*     SystemLabel
-
-*  Purpose:
-*     Return a label for a coordinate system type code.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *SystemLabel( AstSystemType system, int *status )
-
-*  Class Membership:
-*     FluxFrame member function.
-
-*  Description:
-*     This function converts a FluxFrame coordinate system type code
-*     (System attribute value) into a descriptive string for human readers.
-
-*  Parameters:
-*     system
-*        The coordinate system type code.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to a constant null-terminated string containing the
-*     textual equivalent of the type code supplied.
-
-*  Notes:
-*     - A NULL pointer value is returned if the sky coordinate system
-*     code was not recognised. This does not produce an error.
-*     - A NULL pointer value is also returned if this function is
-*     invoked with the global error status set or if it should fail
-*     for any reason.
-*/
-
-/* Local Variables: */
-   const char *result;           /* Pointer value to return */
-
-/* Initialise. */
-   result = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Match the "system" value against each possibility and convert to a
-   string pointer. */
-   switch ( system ) {
-
-   case AST__FLUXDEN:
-      result = "flux density";
-      break;
-
-   case AST__FLUXDENW:
-      result = "flux wavelength density";
-      break;
-
-   case AST__SBRIGHT:
-      result = "surface brightness";
-      break;
-
-   case AST__SBRIGHTW:
-      result = "surface brightness (per wavelength)";
-      break;
-
-   }
-
-/* Return the result pointer. */
-   return result;
-}
-
-static const char *SystemString( AstFrame *this, AstSystemType system, int *status ) {
-/*
-*  Name:
-*     SystemString
-
-*  Purpose:
-*     Convert a coordinate system type code into a string.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     const char *SystemString( AstFrame *this, AstSystemType system, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astSystemString method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function converts a FluxFrame coordinate system type code
-*     (System attribute value) into a string suitable for use as an
-*     external representation of the coordinate system type.
-
-*  Parameters:
-*     this
-*        The Frame.
-*     system
-*        The coordinate system type code.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     Pointer to a constant null-terminated string containing the
-*     textual equivalent of the type code supplied.
-
-*  Notes:
-*     - A NULL pointer value is returned if the coordinate system
-*     code was not recognised. This does not produce an error.
-*     - A NULL pointer value is also returned if this function is
-*     invoked with the global error status set or if it should fail
-*     for any reason.
-*/
-
-   return FluxSystemString( system, status );
-}
-
-static int TestActiveUnit( AstFrame *this_frame, int *status ) {
-/*
-*  Name:
-*     TestActiveUnit
-
-*  Purpose:
-*     Test the ActiveUnit flag for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int TestActiveUnit( AstFrame *this_frame, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astTestActiveUnit protected
-*     method inherited from the Frame class).
-
-*  Description:
-*    This function test the value of the ActiveUnit flag for a FluxFrame,
-*    which is always "unset".
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The result of the test (0).
-
-*/
-   return 0;
-}
-
-static int TestAttrib( AstObject *this_object, const char *attrib, int *status ) {
-/*
-*  Name:
-*     TestAttrib
-
-*  Purpose:
-*     Test if a specified attribute value is set for a FluxFrame.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int TestAttrib( AstObject *this, const char *attrib, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astTestAttrib protected
-*     method inherited from the Frame class).
-
-*  Description:
-*     This function returns a boolean result (0 or 1) to indicate whether
-*     a value has been set for one of a FluxFrame's attributes.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame.
-*     attrib
-*        Pointer to a null terminated string specifying the attribute
-*        name.  This should be in lower case with no surrounding white
-*        space.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     One if a value has been set, otherwise zero.
-
-*  Notes:
-*     - This function uses one-based axis numbering so that it is
-*     suitable for external (public) use.
-*     - A value of zero will be returned if this function is invoked
-*     with the global status set, or if it should fail for any reason.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   int len;                      /* Length of attrib string */
-   int result;                   /* Result value to return */
-
-/* Initialise. */
-   result = 0;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Obtain the length of the attrib string. */
-   len = strlen( attrib );
-
-/* Check the attribute name and test the appropriate attribute. */
-
-/* SpecVal. */
-/* -------- */
-   if ( !strcmp( attrib, "specval" ) ) {
-      result = astTestSpecVal( this );
-
-/* If the attribute is not recognised, pass it on to the parent method
-   for further interpretation. */
-   } else {
-      result = (*parent_testattrib)( this_object, attrib, status );
-   }
-
-/* Return the result, */
-   return result;
-}
-
-static int UnitsOK( AstSystemType system, const char *units, int report,
-                    const char *method, const char *class, int *status ) {
-/*
-*  Name:
-*     UnitsOK
-
-*  Purpose:
-*     Check if a units string is appropriate for the current System.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int UnitsOK( AstSystemType system, const char *units, int report,
-*                  const char *method, const char *class, int *status )
-
-*  Class Membership:
-*     FluxFrame member function
-
-*  Description:
-*     This function returns a non-zero value if the supplied units string
-*     can be mapped to the defaultunits for the current System in the
-*     supplied FluxFrame.
-
-*  Parameters:
-*     system
-*        The system type to check.
-*     unit
-*        The units string to check.
-*     report
-*        Should an error be reported if the units and system are
-*        inconsistent?
-*     method
-*        String holding a method name to be used in error messages.
-*     class
-*        String holding a class name to be used in error messages.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returns Value:
-*     Non-zero if the units string can be used to describe the current
-*     flux System. Zero otherwise.
-
-*/
-
-/* Local Variables: */
-   AstMapping *map;
-   int result;
-
-/* Check the global error status. */
-   if ( !astOK ) return 0;
-
-/* Get the Mapping from the default units for the supplied system to the
-   supplied Units. */
-   map = astUnitMapper( DefUnit( system, method, class, status ), units, NULL, NULL );
-
-/* If a Mapping was found succesfully, annul it and return non-zero.
-   Otherwise return zero. */
-   if( map ) {
-      result = 1;
-      map = astAnnul( map );
-
-   } else {
-      result = 0;
-
-/* Report an error if required. */
-      if( report && astOK ) {
-         astError( AST__BADUN, "%s(%s): The units (%s) and system (%s) "
-                   "within the supplied %s are inconsistent.", status, method,
-                   class, units, FluxSystemString( system, status ), class );
-      }
-   }
-
-/* Return the result. */
-   return result;
-}
-
-static int ValidateSystem( AstFrame *this, AstSystemType system, const char *method, int *status ) {
-/*
-*
-*  Name:
-*     ValidateSystem
-
-*  Purpose:
-*     Validate a value for a Frame's System attribute.
-
-*  Type:
-*     Protected virtual function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     int ValidateSystem( AstFrame *this, AstSystemType system,
-*                         const char *method, int *status )
-
-*  Class Membership:
-*     FluxFrame member function (over-rides the astValidateSystem method
-*     inherited from the Frame class).
-
-*  Description:
-*     This function checks the validity of the supplied system value.
-*     If the value is valid, it is returned unchanged. Otherwise, an
-*     error is reported and a value of AST__BADSYSTEM is returned.
-
-*  Parameters:
-*     this
-*        Pointer to the Frame.
-*     system
-*        The system value to be checked.
-*     method
-*        Pointer to a constant null-terminated character string
-*        containing the name of the method that invoked this function
-*        to validate an axis index. This method name is used solely
-*        for constructing error messages.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Returned Value:
-*     The validated system value.
-
-*  Notes:
-*     - A value of AST__BADSYSTEM will be returned if this function is invoked
-*     with the global error status set, or if it should fail for any
-*     reason.
-*/
-
-/* Local Variables: */
-   AstSystemType result;              /* Validated system value */
-
-/* Initialise. */
-   result = AST__BADSYSTEM;
-
-/* Check the global error status. */
-   if ( !astOK ) return result;
-
-/* If the value is out of bounds, report an error. */
-   if ( system < FIRST_SYSTEM || system > LAST_SYSTEM ) {
-         astError( AST__AXIIN, "%s(%s): Bad value (%d) given for the System "
-                   "or AlignSystem attribute of a %s.", status, method,
-                   astGetClass( this ), (int) system, astGetClass( this ) );
-
-/* Otherwise, return the supplied value. */
-   } else {
-      result = system;
-   }
-
-/* Return the result. */
-   return result;
-}
-
-/* Functions which access class attributes. */
-/* ---------------------------------------- */
-/*
-*att++
-*  Name:
-*     SpecVal
-
-*  Purpose:
-*     The spectral position at which flux values are measured.
-
-*  Type:
-*     Public attribute.
-
-*  Synopsis:
-*     Floating point.
-
-*  Description:
-*     This attribute specifies the spectral position (frequency, wavelength,
-*     etc.), at which the values described by the FluxFrame are measured.
-*     It is used when determining the Mapping between between FluxFrames.
-*
-*     The default value and spectral system used for this attribute are
-*     both specified when the FluxFrame is created.
-
-*  Applicability:
-*     FluxFrame
-*        All FluxFrames have this attribute.
-
-*att--
-*/
-astMAKE_CLEAR(FluxFrame,SpecVal,specval,AST__BAD)
-astMAKE_GET(FluxFrame,SpecVal,double,AST__BAD,((this->specval!=AST__BAD)?this->specval:this->defspecval))
-astMAKE_SET(FluxFrame,SpecVal,double,specval,value)
-astMAKE_TEST(FluxFrame,SpecVal,( this->specval != AST__BAD ))
-
-/* Copy constructor. */
-/* ----------------- */
-static void Copy( const AstObject *objin, AstObject *objout, int *status ) {
-/*
-*  Name:
-*     Copy
-
-*  Purpose:
-*     Copy constructor for FluxFrame objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Copy( const AstObject *objin, AstObject *objout, int *status )
-
-*  Description:
-*     This function implements the copy constructor for FluxFrame objects.
-
-*  Parameters:
-*     objin
-*        Pointer to the object to be copied.
-*     objout
-*        Pointer to the object being constructed.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     -  This constructor makes a deep copy.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *in;             /* Pointer to input FluxFrame */
-   AstFluxFrame *out;            /* Pointer to output FluxFrame */
-   char *usedunit;               /* Pointer to an element of usedunits array */
-   int i;                        /* Loop count */
-   int nused;                    /* Size of "usedunits" array */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain pointers to the input and output FluxFrames. */
-   in = (AstFluxFrame *) objin;
-   out = (AstFluxFrame *) objout;
-
-/* Nullify the pointers stored in the output object since these will
-   currently be pointing at the input data (since the output is a simple
-   byte-for-byte copy of the input). Otherwise, the input data could be
-   freed by accidient if the output object is deleted due to an error
-   occuring in this function. */
-   out->usedunits = NULL;
-   out->specframe = NULL;
-
-/* Store the last used units in the output SpecMap. */
-   if( in && in->usedunits ) {
-      nused = in->nuunits;
-      out->usedunits = astMalloc( nused*sizeof( char * ) );
-      if( out->usedunits ) {
-         for( i = 0; i < nused; i++ ) {
-            usedunit = in->usedunits[ i ];
-            if( usedunit ) {
-               out->usedunits[ i ] = astStore( NULL, usedunit,
-                                               strlen( usedunit ) + 1 );
-            } else {
-               out->usedunits[ i ] = NULL;
-            }
-         }
-      }
-   }
-
-/* Copy the SpecFrame */
-   if( in->specframe ) out->specframe = astCopy( in->specframe );
-
-/* If an error has occurred, free the output resources. */
-   if( !astOK ) Delete( (AstObject *) out, status );
-
-}
-
-/* Destructor. */
-/* ----------- */
-static void Delete( AstObject *obj, int *status ) {
-/*
-*  Name:
-*     Delete
-
-*  Purpose:
-*     Destructor for FluxFrame objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Delete( AstObject *obj, int *status )
-
-*  Description:
-*     This function implements the destructor for FluxFrame objects.
-
-*  Parameters:
-*     obj
-*        Pointer to the object to be deleted.
-*     status
-*        Pointer to the inherited status variable.
-
-*  Notes:
-*     This function attempts to execute even if the global error status is
-*     set.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;
-   int i;
-
-/* Release the memory referred to in the FluxFrame structure. */
-   this = (AstFluxFrame *) obj;
-   if( this && this->usedunits ) {
-      for( i = 0; i < this->nuunits; i++ ) {
-         this->usedunits[ i ] = astFree( this->usedunits[ i ] );
-      }
-      this->usedunits = astFree( this->usedunits );
-   }
-
-/* Annulthe SpecFrame. */
-   if( this->specframe ) this->specframe = astAnnul( this->specframe );
-
-}
-
-/* Dump function. */
-/* -------------- */
-static void Dump( AstObject *this_object, AstChannel *channel, int *status ) {
-/*
-*  Name:
-*     Dump
-
-*  Purpose:
-*     Dump function for FluxFrame objects.
-
-*  Type:
-*     Private function.
-
-*  Synopsis:
-*     void Dump( AstObject *this, AstChannel *channel, int *status )
-
-*  Description:
-*     This function implements the Dump function which writes out data
-*     for the FluxFrame class to an output Channel.
-
-*  Parameters:
-*     this
-*        Pointer to the FluxFrame whose data are being written.
-*     channel
-*        Pointer to the Channel to which the data are being written.
-*     status
-*        Pointer to the inherited status variable.
-*/
-
-/* Local Variables: */
-   AstFluxFrame *this;           /* Pointer to the FluxFrame structure */
-   char buff[ 20 ];              /* Buffer for item name */
-   char comm[ 50 ];              /* Buffer for comment */
-   double dval;                  /* Double value */
-   int i;                        /* Loop count */
-   int j;                        /* Loop count */
-   int set;                      /* Attribute value set? */
-
-/* Check the global error status. */
-   if ( !astOK ) return;
-
-/* Obtain a pointer to the FluxFrame structure. */
-   this = (AstFluxFrame *) this_object;
-
-/* Write out values representing the instance variables for the
-   FluxFrame class.  Accompany these with appropriate comment strings,
-   possibly depending on the values being written.*/
-
-/* In the case of attributes, we first use the appropriate (private)
-   Test...  member function to see if they are set. If so, we then use
-   the (private) Get... function to obtain the value to be written
-   out.
-
-   For attributes which are not set, we use the astGet... method to
-   obtain the value instead. This will supply a default value
-   (possibly provided by a derived class which over-rides this method)
-   which is more useful to a human reader as it corresponds to the
-   actual default attribute value.  Since "set" will be zero, these
-   values are for information only and will not be read back. */
-
-/* SpecVal. */
-/* -------- */
-   set = TestSpecVal( this, status );
-   dval = set ? GetSpecVal( this, status ) : astGetSpecVal( this );
-   if( dval != AST__BAD ) {
-      astWriteDouble( channel, "SpcVl", set, 0, dval, "Spectral position" );
-   }
-
-/* The SpecFrame */
-/* ------------- */
-   if( this->specframe ) {
-      astWriteObject( channel, "SpcFr", 1, 0, this->specframe, "SpcVl coord system" );
-   }
-
-/* Default SpecVal. */
-/* ---------------- */
-   if( this->defspecval != AST__BAD ) {
-      astWriteDouble( channel, "DfSpc", 1, 0, this->defspecval, "Default spectral position" );
-   }
-
-/* UsedUnits */
-/* --------- */
-   if( this->usedunits ) {
-      for( i = 0; i < this->nuunits; i++ ) {
-         if( this->usedunits[ i ] ) {
-            sprintf( buff, "U%s", astSystemString( this, (AstSystemType) i ));
-            for( j = 2; j < strlen( buff ); j++ ) buff[ j ] = tolower( buff[ j ] );
-            sprintf( comm, "Preferred units for %s", SystemLabel( (AstSystemType) i, status ) );
-            astWriteString( channel, buff, 1, 0, this->usedunits[ i ], comm );
-         }
-      }
-   }
-}
-
-/* Standard class functions. */
-/* ========================= */
-/* Implement the astIsAFluxFrame and astCheckFluxFrame functions using the
-   macros defined for this purpose in the "object.h" header file. */
-astMAKE_ISA(FluxFrame,Frame)
-astMAKE_CHECK(FluxFrame)
-
-AstFluxFrame *astFluxFrame_( double specval, void *specfrm_void,
-                             const char *options, int *status, ...) {
-/*
-*+
-*  Name:
-*     astFluxFrame
-
-*  Purpose:
-*     Create a FluxFrame.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstFluxFrame *astFluxFrame( double specval, AstSpecFrame *specfrm,
-*                                 const char *options, ..., int *status )
-
-*  Class Membership:
-*     FluxFrame constructor.
-
-*  Description:
-*     This function creates a new FluxFrame and optionally initialises its
-*     attributes.
-
-*  Parameters:
-*     specval
-*        The spectral value to which the flux values refer, given in the
-*        spectral coordinate system specified by "specfrm". The value
-*        supplied for the "specval" parameter becomes the default value for
-*        the SpecVal attribute.
-*     specfrm
-*        A pointer to a SpecFrame describing the spectral coordinate system
-*        in which the "specval" parameter is given. A deep copy of this object
-*        is taken, so any subsequent changes to the SpecFrame using the
-*        supplied pointer will have no effect on the new FluxFrame.
-*     options
-*        Pointer to a null terminated string containing an optional
-*        comma-separated list of attribute assignments to be used for
-*        initialising the new FluxFrame. The syntax used is the same as for the
-*        astSet method and may include "printf" format specifiers identified
-*        by "%" symbols in the normal way.
-*     status
-*        Pointer to the inherited status variable.
-*     ...
-*        If the "options" string contains "%" format specifiers, then an
-*        optional list of arguments may follow it in order to supply values to
-*        be substituted for these specifiers. The rules for supplying these
-*        are identical to those for the astSet method (and for the C "printf"
-*        function).
-
-*  Returned Value:
-*     A pointer to the new FluxFrame.
-
-*  Notes:
-*     -  A NULL pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*-
-
-*  Implementation Notes:
-*     - This function implements the basic FluxFrame constructor which
-*     is available via the protected interface to the FluxFrame class.
-*     A public interface is provided by the astFluxFrameId_ function.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstMapping *um;               /* Mapping from default to actual units */
-   AstFluxFrame *new;            /* Pointer to new FluxFrame */
-   AstSpecFrame *sfrm;           /* Pointer to SpecFrame */
-   AstSystemType s;              /* System */
-   const char *u;                /* Units string */
-   va_list args;                 /* Variable argument list */
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* Check the global status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain and validate a pointer to the SpecFrame structures provided. */
-   sfrm = specfrm_void ? astCheckSpecFrame( specfrm_void ) : NULL;
-
-/* Initialise the FluxFrame, allocating memory and initialising the virtual
-   function table as well if necessary. */
-   new = astInitFluxFrame( NULL, sizeof( AstFluxFrame ), !class_init,
-                           &class_vtab, "FluxFrame", specval, sfrm );
-
-/* If successful, note that the virtual function table has been initialised. */
-   if ( astOK ) {
-      class_init = 1;
-
-/* Obtain the variable argument list and pass it along with the options string
-   to the astVSet method to initialise the new FluxFrame's attributes. */
-      va_start( args, status );
-      astVSet( new, options, NULL, args );
-      va_end( args );
-
-/* Check the Units are appropriate for the System. */
-      u = astGetUnit( new, 0 );
-      s = astGetSystem( new );
-      um = astUnitMapper( DefUnit( s, "astFluxFrame", "FluxFrame", status ),
-                          u, NULL, NULL );
-      if( um ) {
-         um = astAnnul( um );
-      } else {
-         astError( AST__BADUN, "astFluxFrame: Inappropriate units (%s) "
-                   "specified for a %s axis.", status, u, SystemLabel( s, status ) );
-      }
-
-/* If an error occurred, clean up by deleting the new object. */
-      if ( !astOK ) new = astDelete( new );
-   }
-
-/* Return a pointer to the new FluxFrame. */
-   return new;
-}
-
-AstFluxFrame *astInitFluxFrame_( void *mem, size_t size, int init,
-                                 AstFluxFrameVtab *vtab, const char *name,
-                                 double specval, AstSpecFrame *specfrm, int *status ) {
-/*
-*+
-*  Name:
-*     astInitFluxFrame
-
-*  Purpose:
-*     Initialise a FluxFrame.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstFluxFrame *astInitFluxFrame( void *mem, size_t size, int init,
-*                                     AstFrameVtab *vtab, const char *name,
-*                                     double specval, AstSpecFrame *specfrm)
-
-*  Class Membership:
-*     FluxFrame initialiser.
-
-*  Description:
-*     This function is provided for use by class implementations to
-*     initialise a new FluxFrame object. It allocates memory (if
-*     necessary) to accommodate the FluxFrame plus any additional data
-*     associated with the derived class. It then initialises a
-*     FluxFrame structure at the start of this memory. If the "init"
-*     flag is set, it also initialises the contents of a virtual function
-*     table for a FluxFrame at the start of the memory passed via the
-*     "vtab" parameter.
-
-*  Parameters:
-*     mem
-*        A pointer to the memory in which the FluxFrame is to be
-*	created. This must be of sufficient size to accommodate the
-*	FluxFrame data (sizeof(FluxFrame)) plus any data used by
-*	the derived class. If a value of NULL is given, this function
-*	will allocate the memory itself using the "size" parameter to
-*	determine its size.
-*     size
-*        The amount of memory used by the FluxFrame (plus derived
-*	class data). This will be used to allocate memory if a value of
-*	NULL is given for the "mem" parameter. This value is also stored
-*	in the FluxFrame structure, so a valid value must be supplied
-*	even if not required for allocating memory.
-*     init
-*        A logical flag indicating if the FluxFrame's virtual function
-*	table is to be initialised. If this value is non-zero, the
-*	virtual function table will be initialised by this function.
-*     vtab
-*        Pointer to the start of the virtual function table to be
-*	associated with the new FluxFrame.
-*     name
-*        Pointer to a constant null-terminated character string which
-*	contains the name of the class to which the new object belongs
-*	(it is this pointer value that will subsequently be returned by
-*	the astGetClass method).
-*     specval
-*        The spectral value to which the flux values refer, given in the
-*        spectral coordinate system specified by "specfrm". The value
-*        supplied for the "specval" parameter becomes the default value for
-*        the SpecVal attribute. May be AST__BAD.
-*     specfrm
-*        A pointer to a SpecFrame describing the spectral coordinate system
-*        in which the "specval" parameter is given. A deep copy of this object
-*        is taken, so any subsequent changes to the SpecFrame using the
-*        supplied pointer will have no effect on the new FluxFrame. Should
-*        be NULL if "specval" is AST__BAD.
-
-*  Returned Value:
-*     A pointer to the new FluxFrame.
-
-*  Notes:
-*     -  A null pointer will be returned if this function is invoked with the
-*     global error status set, or if it should fail for any reason.
-*-
-*/
-
-/* Local Variables: */
-   AstFluxFrame *new;        /* Pointer to the new FluxFrame */
-
-/* Check the global status. */
-   if ( !astOK ) return NULL;
-
-/* If necessary, initialise the virtual function table. */
-   if ( init ) astInitFluxFrameVtab( vtab, name );
-
-/* Initialise a 1D Frame structure (the parent class) as the first component
-   within the FluxFrame structure, allocating memory if necessary. */
-   new = (AstFluxFrame *) astInitFrame( mem, size, 0,
-                                        (AstFrameVtab *) vtab, name, 1 );
-
-   if ( astOK ) {
-
-/* Initialise the FluxFrame data. */
-/* ----------------------------- */
-/* Initialise all attributes to their "undefined" values. */
-      new->specval = AST__BAD;
-      new->defspecval = specval;
-      new->specframe = specfrm ? astCopy( specfrm ) : NULL;
-      new->nuunits = 0;
-      new->usedunits = NULL;
-
-/* If an error occurred, clean up by deleting the new object. */
-      if ( !astOK ) new = astDelete( new );
-
-   }
-
-/* Return a pointer to the new object. */
-   return new;
-}
-
-AstFluxFrame *astLoadFluxFrame_( void *mem, size_t size, AstFluxFrameVtab *vtab,
-                                 const char *name, AstChannel *channel, int *status ) {
-/*
-*+
-*  Name:
-*     astLoadFluxFrame
-
-*  Purpose:
-*     Load a FluxFrame.
-
-*  Type:
-*     Protected function.
-
-*  Synopsis:
-*     #include "fluxframe.h"
-*     AstFluxFrame *astLoadFluxFrame( void *mem, size_t size, AstFluxFrameVtab *vtab,
-*                                      const char *name, AstChannel *channel )
-
-*  Class Membership:
-*     FluxFrame loader.
-
-*  Description:
-*     This function is provided to load a new FluxFrame using data read
-*     from a Channel. It first loads the data used by the parent class
-*     (which allocates memory if necessary) and then initialises a
-*     FluxFrame structure in this memory, using data read from the
-*     input Channel.
-
-*  Parameters:
-*     mem
-*        A pointer to the memory into which the FluxFrame is to be
-*        loaded.  This must be of sufficient size to accommodate the
-*        FluxFrame data (sizeof(FluxFrame)) plus any data used by
-*        derived classes. If a value of NULL is given, this function
-*        will allocate the memory itself using the "size" parameter to
-*        determine its size.
-*     size
-*        The amount of memory used by the FluxFrame (plus derived class
-*        data).  This will be used to allocate memory if a value of
-*        NULL is given for the "mem" parameter. This value is also
-*        stored in the FluxFrame structure, so a valid value must be
-*        supplied even if not required for allocating memory.
-*
-*        If the "vtab" parameter is NULL, the "size" value is ignored
-*        and sizeof(AstFluxFrame) is used instead.
-*     vtab
-*        Pointer to the start of the virtual function table to be
-*        associated with the new FluxFrame. If this is NULL, a pointer
-*        to the (static) virtual function table for the FluxFrame class
-*        is used instead.
-*     name
-*        Pointer to a constant null-terminated character string which
-*        contains the name of the class to which the new object
-*        belongs (it is this pointer value that will subsequently be
-*        returned by the astGetClass method).
-*
-*        If the "vtab" parameter is NULL, the "name" value is ignored
-*        and a pointer to the string "FluxFrame" is used instead.
-
-*  Returned Value:
-*     A pointer to the new FluxFrame.
-
-*  Notes:
-*     - A null pointer will be returned if this function is invoked
-*     with the global error status set, or if it should fail for any
-*     reason.
-*-
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstFluxFrame *new;            /* Pointer to the new FluxFrame */
-   char buff[ 20 ];              /* Buffer for item name */
-   char *sval;                   /* Pointer to string value */
-   int i;                        /* Loop count */
-   int j;                        /* Get a pointer to the thread specific global data structure. */
-
-/* Loop count */
-   int sys;                      /* System value */
-
-   astGET_GLOBALS(channel);
-
-/* Initialise. */
-   new = NULL;
-
-/* Check the global error status. */
-   if ( !astOK ) return new;
-
-/* If a NULL virtual function table has been supplied, then this is
-   the first loader to be invoked for this FluxFrame. In this case the
-   FluxFrame belongs to this class, so supply appropriate values to be
-   passed to the parent class loader (and its parent, etc.). */
-   if ( !vtab ) {
-      size = sizeof( AstFluxFrame );
-      vtab = &class_vtab;
-      name = "FluxFrame";
-
-/* If required, initialise the virtual function table for this class. */
-      if ( !class_init ) {
-         astInitFluxFrameVtab( vtab, name );
-         class_init = 1;
-      }
-   }
-
-/* Invoke the parent class loader to load data for all the ancestral
-   classes of the current one, returning a pointer to the resulting
-   partly-built FluxFrame. */
-   new = astLoadFrame( mem, size, (AstFrameVtab *) vtab, name,
-                       channel );
-   if ( astOK ) {
-
-/* Read input data. */
-/* ================ */
-/* Request the input Channel to read all the input data appropriate to
-   this class into the internal "values list". */
-       astReadClassData( channel, "FluxFrame" );
-
-/* Now read each individual data item from this list and use it to
-   initialise the appropriate instance variable(s) for this class. */
-
-/* In the case of attributes, we first read the "raw" input value,
-   supplying the "unset" value as the default. If a "set" value is
-   obtained, we then use the appropriate (private) Set... member
-   function to validate and set the value properly. */
-
-/* Default SpecVal */
-/* --------------- */
-      new->defspecval = astReadDouble( channel, "dfspc", AST__BAD );
-
-/* SpecFrame  */
-/* ---------- */
-      new->specframe = astReadObject( channel, "spcfr", NULL );
-
-/* SpecVal */
-/* ------- */
-      new->specval = astReadDouble( channel, "spcvl", AST__BAD );
-      if ( TestSpecVal( new, status ) ) SetSpecVal( new, new->specval, status );
-
-/* UsedUnits */
-/* --------- */
-      new->nuunits = 0;
-      new->usedunits = NULL;
-      for( sys = FIRST_SYSTEM; sys <= LAST_SYSTEM; sys++ ) {
-         sprintf( buff, "u%s", astSystemString( new, (AstSystemType) sys ));
-         for( j = 0; j < strlen( buff ); j++ ) buff[ j ] = tolower( buff[ j ] );
-         sval = astReadString( channel, buff, NULL );
-         if( sval ) {
-            if( (int) sys >= new->nuunits ) {
-               new->usedunits = astGrow( new->usedunits, sys + 1,
-                                          sizeof(char *) );
-               if( astOK ) {
-                  for( i = new->nuunits; i < sys + 1; i++ ) new->usedunits[ i ] = NULL;
-                  new->nuunits = sys + 1;
-               }
-            } else {
-               new->usedunits[ sys ] = astFree( new->usedunits[ sys ] );
-            }
-            if( astOK ) {
-               new->usedunits[ sys ] = astStore( new->usedunits[ sys ],
-                                                 sval, strlen( sval ) + 1 );
-            }
-            sval = astFree( sval );
-         }
-      }
-
-/* If an error occurred, clean up by deleting the new FluxFrame. */
-       if ( !astOK ) new = astDelete( new );
-   }
-
-/* Return the new FluxFrame pointer. */
-   return new;
-}
-
-/* Virtual function interfaces. */
-/* ============================ */
-/* These provide the external interface to the virtual functions defined by
-   this class. Each simply checks the global error status and then locates and
-   executes the appropriate member function, using the function pointer stored
-   in the object's virtual function table (this pointer is located using the
-   astMEMBER macro defined in "object.h").
-
-   Note that the member function may not be the one defined here, as it may
-   have been over-ridden by a derived class. However, it should still have the
-   same interface. */
-
-AstSystemType astGetDensitySystem_( AstFluxFrame *this, int *status ){
-   if ( !astOK ) return AST__BADSYSTEM;
-   return (**astMEMBER(this,FluxFrame,GetDensitySystem))(this, status );
-}
-
-const char *astGetDensityUnit_( AstFluxFrame *this, int *status ){
-   if ( !astOK ) return NULL;
-   return (**astMEMBER(this,FluxFrame,GetDensityUnit))(this, status );
-}
-
-
-/* Special public interface functions. */
-/* =================================== */
-/* These provide the public interface to certain special functions
-   whose public interface cannot be handled using macros (such as
-   astINVOKE) alone. In general, they are named after the
-   corresponding protected version of the function, but with "Id"
-   appended to the name. */
-
-/* Public Interface Function Prototypes. */
-/* ------------------------------------- */
-/* The following functions have public prototypes only (i.e. no
-   protected prototypes), so we must provide local prototypes for use
-   within this module. */
-AstFluxFrame *astFluxFrameId_( double, void *, const char *, ... );
-
-/* Special interface function implementations. */
-/* ------------------------------------------- */
-AstFluxFrame *astFluxFrameId_( double specval, void *specfrm_void,
-                               const char *options, ... ) {
-/*
-*++
-*  Name:
-c     astFluxFrame
-f     AST_FLUXFRAME
-
-*  Purpose:
-*     Create a FluxFrame.
-
-*  Type:
-*     Public function.
-
-*  Synopsis:
-c     #include "fluxframe.h"
-c     AstFluxFrame *astFluxFrame( double specval, AstSpecFrame *specfrm,
-c                                 const char *options, ... )
-f     RESULT = AST_FLUXFRAME( SPECVAL, SPECFRM, OPTIONS, STATUS )
-
-*  Class Membership:
-*     FluxFrame constructor.
-
-*  Description:
-*     This function creates a new FluxFrame and optionally initialises
-*     its attributes.
-*
-*     A FluxFrame is a specialised form of one-dimensional Frame which
-*     represents various systems used to represent the signal level in an
-*     observation. The particular coordinate system to be used is specified
-*     by setting the FluxFrame's System attribute qualified, as necessary, by
-*     other attributes such as the units, etc (see the description of the
-*     System attribute for details).
-*
-*     All flux values are assumed to be measured at the same frequency or
-*     wavelength (as given by the SpecVal attribute). Thus this class is
-*     more appropriate for use with images rather than spectra.
-
-*  Parameters:
-c     specval
-f     SPECVAL = DOUBLE PRECISION (Given)
-*        The spectral value to which the flux values refer, given in the
-*        spectral coordinate system specified by
-c        "specfrm". The value supplied for the "specval"
-f        SPECFRM. The value supplied for the SPECVAL
-*        parameter becomes the default value for the SpecVal attribute.
-*        A value of AST__BAD may be supplied if the spectral position is
-*        unknown, but this may result in it not being possible for the
-c        astConvert
-f        AST_CONVERT
-*        function to determine a Mapping between the new FluxFrame and
-*        some other FluxFrame.
-c     specfrm
-f     SPECFRM = INTEGER (Given)
-*        A pointer to a SpecFrame describing the spectral coordinate system
-*        in which the
-c        "specval"
-f        SPECVAL
-*        parameter is given. A deep copy of this object is taken, so any
-*        subsequent changes to the SpecFrame using the supplied pointer will
-*        have no effect on the new FluxFrame.
-c        A NULL pointer can be supplied if AST__BAD is supplied for "specval".
-f        AST__NULL can be supplied if AST__BAD is supplied for SPECVAL.
-c     options
-f     OPTIONS = CHARACTER * ( * ) (Given)
-c        Pointer to a null-terminated string containing an optional
-c        comma-separated list of attribute assignments to be used for
-c        initialising the new FluxFrame. The syntax used is identical to
-c        that for the astSet function and may include "printf" format
-c        specifiers identified by "%" symbols in the normal way.
-c        If no initialisation is required, a zero-length string may be
-c        supplied.
-f        A character string containing an optional comma-separated
-f        list of attribute assignments to be used for initialising the
-f        new FluxFrame. The syntax used is identical to that for the
-f        AST_SET routine. If no initialisation is required, a blank
-f        value may be supplied.
-c     ...
-c        If the "options" string contains "%" format specifiers, then
-c        an optional list of additional arguments may follow it in
-c        order to supply values to be substituted for these
-c        specifiers. The rules for supplying these are identical to
-c        those for the astSet function (and for the C "printf"
-c        function).
-f     STATUS = INTEGER (Given and Returned)
-f        The global status.
-
-*  Returned Value:
-c     astFluxFrame()
-f     AST_FLUXFRAME = INTEGER
-*        A pointer to the new FluxFrame.
-
-*  Notes:
-*     - When conversion between two FluxFrames is requested (as when
-c     supplying FluxFrames to astConvert),
-f     supplying FluxFrames AST_CONVERT),
-*     account will be taken of the nature of the flux coordinate systems
-*     they represent, together with any qualifying attribute values, including
-*     the AlignSystem attribute. The results will therefore fully reflect the
-*     relationship between positions measured in the two systems. In addition,
-*     any difference in the Unit attributes of the two systems will also be
-*     taken into account.
-*     - A null Object pointer (AST__NULL) will be returned if this
-c     function is invoked with the AST error status set, or if it
-f     function is invoked with STATUS set to an error value, or if it
-*     should fail for any reason.
-*--
-
-*  Implementation Notes:
-*     - This function implements the external (public) interface to
-*     the astFluxFrame constructor function. It returns an ID value
-*     (instead of a true C pointer) to external users, and must be
-*     provided because astFluxFrame_ has a variable argument list which
-*     cannot be encapsulated in a macro (where this conversion would
-*     otherwise occur).
-*     - The variable argument list also prevents this function from
-*     invoking astFluxFrame_ directly, so it must be a
-*     re-implementation of it in all respects, except for the final
-*     conversion of the result to an ID value.
-*/
-
-/* Local Variables: */
-   astDECLARE_GLOBALS            /* Pointer to thread-specific global data */
-   AstMapping *um;               /* Mapping from default to actual units */
-   AstFluxFrame *new;            /* Pointer to new FluxFrame */
-   AstSpecFrame *sfrm;           /* Pointer to SpecFrame */
-   AstSystemType s;              /* System */
-   const char *u;                /* Units string */
-   va_list args;                 /* Variable argument list */
-
-   int *status;                  /* Pointer to inherited status value */
-
-/* Get a pointer to the thread specific global data structure. */
-   astGET_GLOBALS(NULL);
-
-/* Get a pointer to the inherited status value. */
-   status = astGetStatusPtr;
-
-/* Check the global status. */
-   if ( !astOK ) return NULL;
-
-/* Obtain and validate a pointer to the SpecFrame structures provided. */
-   sfrm = specfrm_void ? astVerifySpecFrame( astMakePointer( specfrm_void ) ) : NULL;
-
-/* Initialise the FluxFrame, allocating memory and initialising the virtual
-   function table as well if necessary. */
-   new = astInitFluxFrame( NULL, sizeof( AstFluxFrame ), !class_init,
-                           &class_vtab, "FluxFrame", specval, sfrm );
-
-/* If successful, note that the virtual function table has been initialised. */
-   if ( astOK ) {
-      class_init = 1;
-
-/* Obtain the variable argument list and pass it along with the options string
-   to the astVSet method to initialise the new FluxFrame's attributes. */
-      va_start( args, options );
-      astVSet( new, options, NULL, args );
-      va_end( args );
-
-/* Check the Units are appropriate for the System. */
-      u = astGetUnit( new, 0 );
-      s = astGetSystem( new );
-      um = astUnitMapper( DefUnit( s, "astFluxFrame", "FluxFrame", status ),
-                          u, NULL, NULL );
-      if( um ) {
-         um = astAnnul( um );
-      } else {
-         astError( AST__BADUN, "astFluxFrame: Inappropriate units (%s) "
-                   "specified for a %s axis.", status, u, SystemLabel( s, status ) );
-      }
-
-/* If an error occurred, clean up by deleting the new object. */
-      if ( !astOK ) new = astDelete( new );
-   }
-
-/* Return an ID value for the new FluxFrame. */
-   return astMakeId( new );
-}
-
-
-
-
-
-
-
-
-