Starlink-AST
view release on metacpan or search on metacpan
ast/src/dsbspecframe.c view on Meta::CPAN
/* 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 DSBSpecFrame
#define BADSB -9999
#define FIRST_SB -1
#define LSB -1
#define LO 0
#define USB 1
#define LAST_SB 1
/* Include files. */
/* ============== */
/* Interface definitions. */
/* ---------------------- */
#include "globals.h" /* Thread-safe global data access */
#include "error.h" /* Error reporting facilities */
#include "memory.h" /* Memory management facilities */
#include "object.h" /* Base Object class */
#include "channel.h" /* I/O channels */
#include "specframe.h" /* Spectral frames (parent class) */
#include "unit.h" /* Unit handling */
#include "cmpmap.h" /* Compound Mappings */
#include "unitmap.h" /* Unit Mappings */
#include "winmap.h" /* Window Mappings */
#include "dsbspecframe.h" /* Interface definition for this class */
#include "globals.h" /* Thread-safe global data access */
/* Error code definitions. */
/* ----------------------- */
#include "ast_err.h" /* AST error codes */
/* C header files. */
/* --------------- */
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <ctype.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 extended by this class. */
static const char *(* parent_getattrib)( AstObject *, const char *, int * );
static const char *(* parent_getlabel)( 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_clearattrib)( AstObject *, const char *, int * );
static void (* parent_setattrib)( AstObject *, const char *, int * );
static void (* parent_overlay)( AstFrame *, const int *, AstFrame *, int * );
static const char *(* parent_getdomain)( AstFrame *, int * );
/* 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; \
/* Create the function that initialises global data for this module. */
astMAKE_INITGLOBALS(DSBSpecFrame)
/* Define macros for accessing each item of thread specific global data. */
#define class_init astGLOBAL(DSBSpecFrame,Class_Init)
#define class_vtab astGLOBAL(DSBSpecFrame,Class_Vtab)
#define getattrib_buff astGLOBAL(DSBSpecFrame,GetAttrib_Buff)
#define getlabel_buff astGLOBAL(DSBSpecFrame,GetLabel_Buff)
/* If thread safety is not needed, declare and initialise globals at static
variables. */
#else
/* Define the thread-specific globals for this class. */
/* Buffer returned by GetAttrib. */
static char getattrib_buff[ 101 ];
/* Default Label string buffer */
static char getlabel_buff[ 101 ];
/* Define the class virtual function table and its initialisation flag
as static variables. */
static AstDSBSpecFrameVtab class_vtab; /* Virtual function table */
static int class_init = 0; /* Virtual function table initialised? */
#endif
/* External 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. */
AstDSBSpecFrame *astDSBSpecFrameId_( const char *, ... );
/* Prototypes for Private Member Functions. */
/* ======================================== */
static AstMapping *TopoMap( AstDSBSpecFrame *, int, const char *, int * );
static AstMapping *ToLOMapping( AstDSBSpecFrame *, const char *, int * )__attribute__((unused));
static AstMapping *ToLSBMapping( AstDSBSpecFrame *, const char *, int * );
static AstMapping *ToUSBMapping( AstDSBSpecFrame *, const char *, int * );
static const char *GetAttrib( AstObject *, const char *, int * );
static const char *GetLabel( AstFrame *, int, int * );
static double GetImagFreq( AstDSBSpecFrame *, int * );
static double GetLO( AstDSBSpecFrame *, const char *, const char *, int * );
ast/src/dsbspecframe.c view on Meta::CPAN
/* 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. */
astInitSpecFrameVtab( (AstSpecFrameVtab *) vtab, name );
/* Store a unique "magic" value in the virtual function table. This
will be used (by astIsADSBSpecFrame) 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 = &(((AstSpecFrameVtab *) vtab)->id);
/* Initialise member function pointers. */
/* ------------------------------------ */
/* Store pointers to the member functions (implemented here) that provide
virtual methods for this class. */
vtab->ClearDSBCentre = ClearDSBCentre;
vtab->TestDSBCentre = TestDSBCentre;
vtab->GetDSBCentre = GetDSBCentre;
vtab->SetDSBCentre = SetDSBCentre;
vtab->ClearIF = ClearIF;
vtab->TestIF = TestIF;
vtab->GetIF = GetIF;
vtab->SetIF = SetIF;
vtab->ClearSideBand = ClearSideBand;
vtab->TestSideBand = TestSideBand;
vtab->GetSideBand = GetSideBand;
vtab->SetSideBand = SetSideBand;
vtab->ClearAlignSideBand = ClearAlignSideBand;
vtab->TestAlignSideBand = TestAlignSideBand;
vtab->GetAlignSideBand = GetAlignSideBand;
vtab->SetAlignSideBand = SetAlignSideBand;
vtab->GetImagFreq = GetImagFreq;
/* 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_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;
parent_getdomain = frame->GetDomain;
frame->GetDomain = GetDomain;
parent_overlay = frame->Overlay;
frame->Overlay = Overlay;
parent_match = frame->Match;
frame->Match = Match;
parent_subframe = frame->SubFrame;
frame->SubFrame = SubFrame;
parent_getlabel = frame->GetLabel;
frame->GetLabel = GetLabel;
/* Declare the class delete function.*/
astSetDump( vtab, Dump, "DSBSpecFrame", "Dual sideband spectral axis" );
/* 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) );
}
}
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 "dsbspecframe.h"
* int Match( AstFrame *template, AstFrame *target, int matchsub,
* int **template_axes, int **target_axes,
* AstMapping **map, AstFrame **result, int *status )
* Class Membership:
* DSBSpecFrame member function (over-rides the protected astMatch method
* inherited from the SpecFrame class).
* Description:
* This function matches a "template" DSBSpecFrame 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 DSBSpecFrame. This describes the coordinate
* system (or set of possible coordinate systems) into which we wish to
ast/src/dsbspecframe.c view on Meta::CPAN
* 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 DSBSpecFrame class
* object to any other class of Frame. A DSBSpecFrame will match any class
* of DSBSpecFrame (i.e. possibly from a derived class) but will not match
* a less specialised class of Frame (except for a SpecFrame).
*/
/* Local Variables: */
AstDSBSpecFrame *template; /* Pointer to template DSBSpecFrame structure */
AstFrame *frame0; /* Pointer to Frame underlying axis 0 */
int iaxis0; /* Axis index underlying axis 0 */
int match; /* Coordinate conversion possible? */
/* 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 DSBSpecFrame structure. */
template = (AstDSBSpecFrame *) template_frame;
/* The first criterion for a match is that the template matches as a
SpecFrame class object. This ensures that the number of axes (1) and
domain, class, 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, the target Frame must be (or contain) a SpecFrame,
but this target SpecFrame may be a simple SpecFrame rather than a
DSBSpecFrame. We use the returned objects directly if the target
SpecFrame is not a DSBSpecFrame. So if a DSBSpecFrame and a base
SpecFrame are aligned, this will result in the DSBSpecFrame behaving as
a normal SpecFrame. */
if ( astOK && match ) {
/* Get the primary Frame associated with the matching target axis. */
astPrimaryFrame( target, (*target_axes)[ 0 ], &frame0, &iaxis0 );
/* Skip this next section, thus retaining the values returned by the
parent Match method above, if the target axis is not a DSBSpecFrame. */
if( astIsADSBSpecFrame( frame0 ) ) {
/* Annul the returned objects, which are not needed, but keep the axis
association arrays which already hold the correct values. */
*map = astAnnul( *map );
*result = astAnnul( *result );
/* Use the target's "astSubFrame" method to create a new Frame (the
result Frame) with a copy of of the target axis. 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 );
}
/* Free resources. */
frame0 = astAnnul( frame0 );
}
/* 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 ) {
if( *template_axes ) *template_axes = astFree( *template_axes );
if( *target_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 DSBSpecFrame on to another Frame.
* Type:
* Private function.
* Synopsis:
* #include "specframe.h"
* void Overlay( AstFrame *template, const int *template_axes,
* AstFrame *result, int *status )
* Class Membership:
* DSBSpecFrame member function (over-rides the protected astOverlay method
* inherited from the SpecFrame class).
* Description:
* This function overlays attributes of a DSBSpecFrame (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 DSBSpecFrame and a change of spectral
* 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 DSBSpecFrame, 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 DSBSpecFrame, or from a class derived from it, then attributes may
* exist in the template DSBSpecFrame which do not exist in the result Frame.
* In this case, these attributes will not be transferred.
*/
/* Check the global error status. */
if ( !astOK ) return;
/* Invoke the parent class astOverlay method to transfer attributes inherited
from the parent class. */
(*parent_overlay)( template, template_axes, result, status );
/* Check if the result Frame is a DSBSpecFrame or from a class derived from
DSBSpecFrame. If not, we cannot transfer DSBSpecFrame attributes to it as it is
insufficiently specialised. In this case simply omit these attributes. */
if( astIsADSBSpecFrame( result ) && 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 DSBSpecFrame attribute in turn. */
OVERLAY(DSBCentre)
OVERLAY(IF)
OVERLAY(SideBand)
OVERLAY(AlignSideBand)
}
/* 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 DSBSpecFrame.
* Type:
* Private function.
* Synopsis:
* #include "dsbspecframe.h"
* void SetAttrib( AstObject *this, const char *setting )
* Class Membership:
* DSBSpecFrame member function (over-rides the astSetAttrib protected
* method inherited from the SpecFrame class).
* Description:
* This function assigns an attribute value for a DSBSpecFrame, 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 DSBSpecFrame.
ast/src/dsbspecframe.c view on Meta::CPAN
/* AlignSideBand */
/* ------------- */
} else if ( nc = 0,
( 1 == astSscanf( setting, "alignsideband= %d %n", &ival, &nc ) )
&& ( nc >= len ) ) {
astSetAlignSideBand( this, ival );
/* Read-only attributes. */
/* --------------------- */
/* Define a macro to see if the setting string matches any of the
read-only attributes of this class. */
#define MATCH(attrib) \
( nc = 0, ( 0 == astSscanf( setting, attrib "=%*[^\n]%n", &nc ) ) && \
( nc >= len ) )
/* Use this macro to report an error if a read-only attribute has been
specified. */
} else if ( MATCH( "imagfreq" ) ) {
astError( AST__NOWRT, "astSet: The setting \"%s\" is invalid for a %s.", status,
setting, astGetClass( this ) );
astError( AST__NOWRT, "This is a read-only attribute." , status);
/* Pass any unrecognised setting to the parent method for further
interpretation. */
} else {
(*parent_setattrib)( this_object, setting, 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 DSBSpecFrame and convert to the new coordinate
* system.
* Type:
* Private function.
* Synopsis:
* #include "dsbspecframe.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:
* DSBSpecFrame member function (over-rides the protected astSubFrame
* method inherited from the SpecFrame class).
* Description:
* This function selects a requested sub-set (or super-set) of the axes
* from a "target" DSBSpecFrame 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 DSBSpecFrame, 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 DSBSpecFrame. 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
* DSBSpecFrame 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
* DSBSpecFrame object. This results in another object of the same class
* only if the single DSBSpecFrame axis is selected exactly once.
* Otherwise, the result is a Frame class object which inherits the
* DSBSpecFrame's axis information (if appropriate) but none of the other
* properties of a DSBSpecFrame.
* - In the event that a DSBSpecFrame 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: */
AstDSBSpecFrame *dsbresult;/* Pointer to the DSBSpecFrame result Frame */
AstDSBSpecFrame *dsbtarget;/* Pointer to the DSBSpecFrame target Frame */
AstMapping *map1; /* Intermediate Mapping */
AstMapping *map2; /* Intermediate Mapping */
AstMapping *map3; /* Intermediate Mapping */
int alignsb; /* Use sidebands to align the Frames? */
int match; /* Coordinate conversion is possible? */
int obs_sb; /* The observed sideband value */
int old_sb; /* The original Sideband value */
ast/src/dsbspecframe.c view on Meta::CPAN
/* Return NULL if an error has occurred. */
if( !astOK ) result = astAnnul( result );
/* Return the result. */
return result;
}
static AstMapping *TopoMap( AstDSBSpecFrame *this, int forward,
const char *method, int *status ){
/*
* Name:
* TopoMap
* Purpose:
* Create a Mapping which transforms a DSBSpecFrame to topocentric
* frequency.
* Type:
* Private function.
* Synopsis:
* #include "dsbspecframe.h"
* AstMapping *TopoMap( AstDSBSpecFrame *this, int forward,
* const char *method, int *status )
* Class Membership:
* DSBSpecFrame member function
* Description:
* This function returns a pointer to a new Mapping which transforms
* positions in the supplied DSBSpecFrame to the corresponding
* topocentric frequency values in Hz (or the inverse of this).
* Parameters:
* this
* Pointer to the DSBSpecFrame.
* forward
* If zero, the calcuated Mapping is inverted before being returned.
* method
* Pointer to a null-terminated string containing the name of the
* public invoking method. This is only used in the construction of
* error messages.
* status
* Pointer to the inherited status variable.
* Returned Value:
* Pointer to a new Mapping.
* 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: */
AstMapping *result; /* The returned Mapping */
AstFrameSet *fs; /* FrameSet connecting tf1 and tf2 */
AstSpecFrame *tf1; /* SpecFrame corresponding to this DSBSpecFrame */
AstSpecFrame *tf2; /* Topocentric frequency SpecFrame */
int template_axis; /* The axis to overlay */
/* Initialise. */
result = NULL;
/* Check the global error status. */
if ( !astOK ) return result;
/* Make a SpecFrame and then overlay the SpecFrame attributes of this
DSBSpecFrame onto the new SpecFrame. This means it inherits the current
values of things like ObsLon and ObsLat. */
tf1 = astSpecFrame( "", status );
template_axis = 0;
(*parent_overlay)( (AstFrame *) this, &template_axis, (AstFrame *) tf1, status );
/* Copy this new SpecFrame and set its attributes to describe topocentric
frequency in Hz. Ensure that alignment occurs in the topocentric Frame. */
astSetAlignStdOfRest( tf1, AST__TPSOR);
tf2 = astCopy( tf1 );
astSetSystem( tf2, AST__FREQ );
astSetStdOfRest( tf2, AST__TPSOR );
astSetUnit( tf2, 0, "Hz" );
/* Find the Mapping from the spectral system described by this SpecFrame to
topocentric frequency in Hz. */
fs = astConvert( tf1, tf2, "" );
if ( astOK ) {
if( !fs ) {
astError( AST__INTER, "%s(%s): Cannot convert DSBCentre "
"value from the supplied system to topocentric frequency "
"(internal AST programming error).", status, method,
astGetClass( this ) );
} else {
result = astGetMapping( fs, AST__BASE, AST__CURRENT );
if( !forward ) astInvert( result );
}
fs = astAnnul( fs );
}
/* Free resources */
tf1 = astAnnul( tf1 );
tf2 = astAnnul( tf2 );
/* Annul the result if an error has occurred. */
if( !astOK ) result = astAnnul( result );
/* Return the result. */
return result;
}
static AstMapping *ToUSBMapping( AstDSBSpecFrame *this, const char *method, int *status ){
/*
* Name:
* ToUSBMapping
* Purpose:
* Create a Mapping which transforms a DSBSpecFrame to the upper
* sideband.
* Type:
* Private function.
* Synopsis:
* #include "dsbspecframe.h"
* AstMapping *ToUSBMapping( AstDSBSpecFrame *this, const char *method, int *status )
* Class Membership:
* DSBSpecFrame member function
* Description:
* This function returns a pointer to a new Mapping which transforms
* positions in the supplied DSBSpecFrame to the upper sideband. This
* will be a UnitMap if the DSBSpecFrame already represents the upper
( run in 0.509 second using v1.01-cache-2.11-cpan-600a1bdf6e4 )