diff options
author | William Joye <wjoye@cfa.harvard.edu> | 2019-05-10 19:01:49 (GMT) |
---|---|---|
committer | William Joye <wjoye@cfa.harvard.edu> | 2019-05-10 19:01:49 (GMT) |
commit | beb90b7d3f526440250bba67e5ab07bb7eb7bbc3 (patch) | |
tree | 8d0d428ac62291f834ea8927bfa82c115ff1689d /ast/fluxframe.c | |
parent | a213dadabce2b2e02eca8376765fa425f01792f5 (diff) | |
download | blt-beb90b7d3f526440250bba67e5ab07bb7eb7bbc3.zip blt-beb90b7d3f526440250bba67e5ab07bb7eb7bbc3.tar.gz blt-beb90b7d3f526440250bba67e5ab07bb7eb7bbc3.tar.bz2 |
upgrade ast 8.7.1
Diffstat (limited to 'ast/fluxframe.c')
-rw-r--r-- | ast/fluxframe.c | 4490 |
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 ); -} - - - - - - - - - |