void smf_rebinsparse( smfData *data, int first, int *ptime, AstFrame *ospecfrm,
AstMapping *ospecmap, AstSkyFrame *oskyframe,
Grp *detgrp, int lbnd_out[ 3 ], int ubnd_out[ 3 ],
int genvar, float *data_array, float *var_array,
int *ispec, float *texp_array, float *teff_array,
double *fcon, int *status ){
/* Local Variables */
AstCmpMap *fmap = NULL; /* Mapping from spectral grid to topo freq Hz */
AstCmpMap *ssmap = NULL; /* I/p GRID-> o/p PIXEL Mapping for spectral axis */
AstFitsChan *fc = NULL; /* Storage for FITS headers */
AstFrame *specframe = NULL; /* Spectral Frame in input FrameSet */
AstFrame *specframe2 = NULL; /* Temporary copy of SpecFrame in input WCS */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
AstFrameSet *swcsin = NULL; /* FrameSet describing spatial input WCS */
AstMapping *fsmap = NULL; /* Base->Current Mapping extracted from a FrameSet */
AstMapping *specmap = NULL; /* PIXEL -> Spec mapping in input FrameSet */
char *fftwin = NULL; /* Name of FFT windowing function */
const char *name = NULL; /* Pointer to current detector name */
const double *tsys=NULL; /* Pointer to Tsys value for first detector */
dim_t timeslice_size; /* No of detector values in one time slice */
double *spectab = NULL;/* Workspace for spectral output grid positions */
double *xin = NULL; /* Workspace for detector input grid positions */
double *xout = NULL; /* Workspace for detector output pixel positions */
double *yin = NULL; /* Workspace for detector input grid positions */
double *yout = NULL; /* Workspace for detector output pixel positions */
double at; /* Frequency at which to take the gradient */
double dnew; /* Channel width in Hz */
double fcon2; /* Variance factor for whole file */
double k; /* Back-end degradation factor */
double tcon; /* Variance factor for whole time slice */
float *pdata = NULL; /* Pointer to next data sample */
float *qdata = NULL; /* Pointer to next data sample */
float rtsys; /* Tsys value */
float teff; /* Effective integration time, times 4 */
float texp; /* Total time ( = ton + toff ) */
float toff; /* Off time */
float ton; /* On time */
int *nexttime = NULL; /* Pointer to next time slice index to use */
int dim[ 3 ]; /* Output array dimensions */
int found; /* Was current detector name found in detgrp? */
int good; /* Are there any good detector samples? */
int ibasein; /* Index of base Frame in input FrameSet */
int ichan; /* Index of current channel */
int iv; /* Offset to next element */
int iz; /* Output grid index on axis 3 */
int nchan; /* Number of input spectral channels */
int pixax[ 3 ]; /* The output fed by each selected mapping input */
int specax; /* Index of spectral axis in input FrameSet */
size_t irec; /* Index of current input detector */
size_t itime; /* Index of current time slice */
smfHead *hdr = NULL; /* Pointer to data header for this time slice */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context.*/
astBegin;
/* Store a pointer to the input NDFs smfHead structure. */
hdr = data->hdr;
/* Store the dimensions of the output array. */
dim[ 0 ] = ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1;
dim[ 1 ] = ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1;
dim[ 2 ] = ubnd_out[ 2 ] - lbnd_out[ 2 ] + 1;
/* Store the number of pixels in one time slice */
timeslice_size = (data->dims)[ 0 ]*(data->dims)[ 1 ];
/* We want a description of the spectral WCS axis in the input file. If
the input file has a WCS FrameSet containing a SpecFrame, use it,
otherwise we will obtain it from the FITS header later. NOTE, if we knew
that all the input NDFs would have the same spectral axis calibration,
then the spectral WCS need only be obtained from the first NDF. However,
in the general case, I presume that data files may be combined that use
different spectral axis calibrations, and so these differences need to
be taken into account. */
if( hdr->tswcs ) {
fs = astClone( hdr->tswcs );
/* The first axis should be a SpecFrame. See if this is so. If not annul
the specframe pointer. */
specax = 1;
specframe = astPickAxes( fs, 1, &specax, NULL );
if( !astIsASpecFrame( specframe ) ) specframe = astAnnul( specframe );
}
/* If the above did not yield a SpecFrame, use the FITS-WCS headers in the
FITS extension of the input NDF. Take a copy of the FITS header (so that
the contents of the header are not changed), and then read a FrameSet
out of it. */
if( !specframe ) {
fc = astCopy( hdr->fitshdr );
astClear( fc, "Card" );
fs = astRead( fc );
/* Extract the SpecFrame that describes the spectral axis from the current
Frame of this FrameSet. This is assumed to be the third WCS axis (NB
the different axis number). */
specax = 3;
specframe = astPickAxes( fs, 1, &specax, NULL );
}
/* Split off the 1D Mapping for this single axis from the 3D Mapping for
the whole WCS. This results in "specmap" holding the Mapping from
SpecFrame value to GRID value. */
fsmap = astGetMapping( fs, AST__CURRENT, AST__BASE );
astMapSplit( fsmap, 1, &specax, pixax, &specmap );
/* Invert the Mapping for the spectral axis so that it goes from input GRID
coord to spectral coord. */
astInvert( specmap );
/* Get a Mapping that converts values in the input spectral system to the
corresponding values in the output spectral system. */
fs = astConvert( specframe, ospecfrm, "" );
/* Concatenate these Mappings with the supplied spectral Mapping to get
a Mapping from the input spectral grid axis (pixel axis 1) to the
output spectral grid axis (pixel axis 3). Simplify the Mapping. */
ssmap = astCmpMap( astCmpMap( specmap, astGetMapping( fs, AST__BASE,
AST__CURRENT ),
1, " " ),
ospecmap, 1, " " );
ssmap = astSimplify( ssmap );
/* Create a table with one element for each channel in the input array,
holding the index of the nearest corresponding output channel. */
nchan = (data->dims)[ 0 ];
spectab = astMalloc( sizeof( *spectab )*nchan );
if( spectab ) {
for( ichan = 0; ichan < nchan; ichan++ ) spectab[ ichan ] = ichan + 1;
astTran1( ssmap, nchan, spectab, 1, spectab );
for( ichan = 0; ichan < nchan; ichan++ ) {
if( spectab[ ichan ] != AST__BAD ) {
iz = floor( spectab[ ichan ] + 0.5 );
if( iz >= 1 && iz <= dim[ 2 ] ) {
spectab[ ichan ] = iz;
} else {
spectab[ ichan ] = 0;
}
} else {
spectab[ ichan ] = 0;
}
}
}
/* Allocate work arrays big enough to hold the coords of all the
detectors in the current input file.*/
xin = astMalloc( (data->dims)[ 1 ] * sizeof( *xin ) );
yin = astMalloc( (data->dims)[ 1 ] * sizeof( *yin ) );
xout = astMalloc( (data->dims)[ 1 ] * sizeof( *xout ) );
yout = astMalloc( (data->dims)[ 1 ] * sizeof( *yout ) );
/* Initialise a string to point to the name of the first detector for which
data is available */
name = hdr->detname;
/* Store input coords for the detectors. Axis 1 is the detector index, and
axis 2 is a dummy axis that always has the value 1. */
for( irec = 0; irec < (data->dims)[ 1 ]; irec++ ) {
xin[ irec ] = irec + 1.0;
yin[ irec ] = 1.0;
/* If a group of detectors to be used was supplied, search the group for
the name of the current detector. If not found, set the GRID coords bad. */
if( detgrp ) {
found = grpIndex( name, detgrp, 1, status );
if( !found ) {
xin[ irec ] = AST__BAD;
yin[ irec ] = AST__BAD;
}
}
/* Move on to the next available detector name. */
name += strlen( name ) + 1;
}
/* Find the constant factor associated with the current input file. This
is the squared backend degradation factor, divided by the noise bandwidth.
Get the required FITS headers, checking they were found. */
if( astGetFitsF( hdr->fitshdr, "BEDEGFAC", &k ) &&
astGetFitsS( hdr->fitshdr, "FFT_WIN", &fftwin ) ){
/* Get a Mapping that converts values in the input spectral system to
topocentric frequency in Hz, and concatenate this Mapping with the
Mapping from input GRID coord to the input spectral system. The result
is a Mapping from input GRID coord to topocentric frequency in Hz. */
specframe2 = astCopy( specframe );
astSet( specframe2, "system=freq,stdofrest=topo,unit=Hz" );
fmap = astCmpMap( specmap, astGetMapping( astConvert( specframe,
specframe2,
"" ),
AST__BASE, AST__CURRENT ),
1, " " );
/* Differentiate this Mapping at the mid channel position to get the width
of an input channel in Hz. */
at = 0.5*nchan;
dnew = astRate( fmap, &at, 1, 1 );
/* Modify the channel width to take account of the effect of the FFT windowing
function. Allow undef value because FFT_WIN for old data had a broken value
in hybrid subband modes. */
if( dnew != AST__BAD ) {
dnew = fabs( dnew );
if( !strcmp( fftwin, "truncate" ) ) {
dnew *= 1.0;
} else if( !strcmp( fftwin, "hanning" ) ) {
dnew *= 1.5;
} else if( !strcmp( fftwin, "<undefined>" ) ) {
/* Deal with broken data - make an assumption */
dnew *= 1.0;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSetc( "W", fftwin );
errRep( FUNC_NAME, "FITS header FFT_WIN has unknown value "
"'^W' (programming error).", status );
}
/* Form the required constant. */
fcon2 = k*k/dnew;
} else {
fcon2 = VAL__BADD;
}
} else {
fcon2 = VAL__BADD;
}
/* Return the factor needed for calculating Tsys from the variance. */
if( first ) {
*fcon = fcon2;
} else if( fcon2 != *fcon ) {
*fcon = VAL__BADD;
}
/* Initialise a pointer to the next time slice index to be used. */
nexttime = ptime;
/* Loop round all the time slices in the input file. */
for( itime = 0; itime < (data->dims)[ 2 ] && *status == SAI__OK; itime++ ) {
/* If this time slice is not being pasted into the output cube, pass on. */
if( nexttime ){
if( *nexttime != itime ) continue;
nexttime++;
}
/* Store a pointer to the first input data value in this time slice. */
pdata = ( (float *) (data->pntr)[ 0 ] ) + itime*timeslice_size;
/* Get a FrameSet describing the spatial coordinate systems associated with
the current time slice of the current input data file. The base frame in
the FrameSet will be a 2D Frame in which axis 1 is detector number and
axis 2 is unused. The current Frame will be a SkyFrame (the SkyFrame
System may be any of the JCMT supported systems). The Epoch will be
set to the epoch of the time slice. */
smf_tslice_ast( data, itime, 1, NO_FTS, status );
swcsin = hdr->wcs;
/* Note the total exposure time (texp) for all the input spectra produced by
this time slice. */
ton = hdr->state->acs_exposure;
if( ton == 0.0 ) ton = VAL__BADR;
toff = hdr->state->acs_offexposure;
if( toff == 0.0 ) toff = VAL__BADR;
if( ton != VAL__BADR && toff != VAL__BADR ) {
texp = ton + toff;
teff = 4*ton*toff/( ton + toff );
} else {
texp = VAL__BADR;
teff = VAL__BADR;
}
/* If output variances are being calculated on the basis of Tsys values
in the input, find the constant factor associated with the current
time slice. */
tcon = AST__BAD;
if( genvar == 2 && fcon2 != AST__BAD && texp != VAL__BADR ) {
tcon = fcon2*( 1.0/ton + 1.0/toff );
/* Get a pointer to the start of the Tsys values for this time slice. */
tsys = hdr->tsys + hdr->ndet*itime;
}
/* We now create a Mapping from detector index to position in oskyframe. */
astInvert( swcsin );
ibasein = astGetI( swcsin, "Base" );
fs = astConvert( swcsin, oskyframe, "SKY" );
astSetI( swcsin, "Base", ibasein );
astInvert( swcsin );
if( fs == NULL ) {
if( *status == SAI__OK ) {
if (data->file) {
smf_smfFile_msg(data->file, "FILE", 1, "<unknown>");
} else {
msgSetc( "FILE", "<unknown>" );
}
*status = SAI__ERROR;
errRep( FUNC_NAME, "The spatial coordinate system in ^FILE "
"is not compatible with the spatial coordinate "
"system in the first input file.", status );
}
break;
}
/* Transform the positions of the detectors from input GRID to oskyframe
coords. */
astTran2( fs, (data->dims)[ 1 ], xin, yin, 1, xout, yout );
/* Loop round all detectors. */
for( irec = 0; irec < (data->dims)[ 1 ]; irec++ ) {
/* If the detector has a valid position, see if it produced any good
data values. */
if( xout[ irec ] != AST__BAD && yout[ irec ] != AST__BAD ) {
qdata = pdata;
good = 0;
for( ichan = 0; ichan < nchan; ichan++ ){
if( *(qdata++) != VAL__BADR ) {
good = 1;
break;
}
}
/* If it did, calculate the variance associated with each detector
sample (if required), based on the input Tsys values, and copy the
spectrum to the output NDF. */
if( good ) {
if( *ispec < dim[ 0 ] ){
rtsys = tsys ? (float) tsys[ irec ] : VAL__BADR;
if( rtsys <= 0.0 ) rtsys = VAL__BADR;
if( tcon != AST__BAD && genvar == 2 && rtsys != VAL__BADR ) {
var_array[ *ispec ] = tcon*rtsys*rtsys;
} else if( var_array ) {
var_array[ *ispec ] = VAL__BADR;
}
if( texp != VAL__BADR ) {
texp_array[ *ispec ] = texp;
teff_array[ *ispec ] = teff;
}
for( ichan = 0; ichan < nchan; ichan++, pdata++ ) {
iz = spectab[ ichan ] - 1;
if( iz >= 0 && iz < dim[ 2 ] ) {
iv = *ispec + dim[ 0 ]*iz;
data_array[ iv ] = *pdata;
}
}
(*ispec)++;
} else if( *status == SAI__OK ){
*status = SAI__ERROR;
msgSeti( "DIM", dim[ 0 ] );
errRep( " ", "Too many spectra (more than ^DIM) for "
"the output NDF (programming error).", status );
break;
}
/* If this detector does not have any valid data values, increment the data
pointer to point at the first sample for the next detector. */
} else {
pdata += nchan;
}
/* If this detector does not have a valid position, increment the data
pointer to point at the first sample for the next detector. */
} else {
pdata += nchan;
}
}
/* For efficiency, explicitly annul the AST Objects created in this tight
loop. */
fs = astAnnul( fs );
}
/* Free resources */
spectab = astFree( spectab );
xin = astFree( xin );
yin = astFree( yin );
xout = astFree( xout );
yout = astFree( yout );
/* End the AST context. This will annul all AST objects created within the
context (except for those that have been exported from the context). */
astEnd;
}
void smurf_unmakecube( int *status ) {
/* Local Variables */
AstFrame *tfrm = NULL; /* Current Frame from input WCS */
AstFrameSet *wcsin = NULL; /* WCS Frameset for input cube */
AstMapping *tmap = NULL; /* Base->current Mapping from input WCS */
AstSkyFrame *iskyfrm = NULL; /* SkyFrame from the input WCS Frameset */
Grp *detgrp = NULL; /* Group of detector names */
Grp *igrp1 = NULL; /* Group of input sky cube files */
Grp *igrp2 = NULL; /* Group of input template files */
Grp *ogrp = NULL; /* Group containing output file */
NdgProvenance *oprov = NULL;/* Provenance for the output NDF */
SkyCube *sky_cubes = NULL; /* Pointer to array of sky cube descriptions */
SkyCube *skycube = NULL; /* Pointer to next sky cube description */
char pabuf[ 10 ]; /* Text buffer for parameter value */
double params[ 4 ]; /* astResample parameters */
int axes[ 2 ]; /* Indices of selected axes */
int blank; /* Was a blank line just output? */
int flag; /* Was the group expression flagged? */
int ifile; /* Input file index */
int interp = 0; /* Pixel interpolation method */
int iskycube; /* Index of current sky cube */
int nel; /* Number of elements in 3D array */
int nparam = 0; /* No. of parameters required for interpolation scheme */
int ondf; /* Output time series NDF identifier */
int outax[ 2 ]; /* Indices of corresponding output axes */
int overlap; /* Does time series overlap sky cube? */
int sdim[3]; /* Array of significant pixel axes */
int usedetpos; /* Should the detpos array be used? */
size_t ndet; /* Number of detectors supplied for "DETECTORS" */
size_t nskycube; /* Number of supplied sky cubes */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Pointer to data struct */
void *in_data = NULL; /* Pointer to the input cube data array */
void *out_data = NULL; /* Pointer to the output cube data array */
#if defined(FPTRAP)
feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW);
#endif
/* Check inherited status */
if( *status != SAI__OK ) return;
/* We have not yet displayed a blank line on stdout. */
blank = 0;
/* Begin an AST context */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Get a group holding the input sky cubes. */
kpg1Rgndf( "IN", 0, 1, "", &igrp1, &nskycube, status );
/* Create an array of structures to hold information about each input sky
cube. */
sky_cubes = astMalloc( sizeof( SkyCube )*(size_t) nskycube );
/* Store a description of each sky cube. */
if( sky_cubes ) {
for( iskycube = 0; iskycube < nskycube; iskycube++ ) {
skycube = sky_cubes + iskycube;
/* Get an NDF identifier for the next sky cube. */
ndgNdfas( igrp1, iskycube + 1, "READ", &(skycube->indf), status );
/* Get the WCS FrameSet from the sky cube, together with its pixel index
bounds. */
kpg1Asget( skycube->indf, 3, 0, 1, 1, sdim, skycube->slbnd,
skycube->subnd, &wcsin, status );
/* Get the base->current Mapping from the input WCS FrameSet, and split it
into two Mappings; one (iskymap) that maps the first 2 GRID axes into
celestial sky coordinates, and one (ispecmap) that maps the third GRID
axis into a spectral coordinate. Also extract the SpecFrame and
SkyFrame from the current Frame. */
tmap = astGetMapping( wcsin, AST__BASE, AST__CURRENT );
tfrm = astGetFrame( wcsin, AST__CURRENT );
axes[ 0 ] = 1;
axes[ 1 ] = 2;
astMapSplit( tmap, 2, axes, outax, &(skycube->iskymap) );
iskyfrm = astPickAxes( tfrm, 2, outax, NULL );
axes[ 0 ] = 3;
astMapSplit( tmap, 1, axes, outax, &(skycube->ispecmap) );
skycube->ispecfrm = astPickAxes( tfrm, 1, outax, NULL );
/* Create a copy of "iskyfrm" representing absolute coords rather than
offsets. We assume the target is moving if the cube represents offsets. */
skycube->abskyfrm = astCopy( iskyfrm );
astClear( skycube->abskyfrm, "SkyRefIs" );
skycube->moving = ( *status == SAI__OK &&
!strcmp( astGetC( iskyfrm, "SkyRefIs" ),
"Origin" ) ) ? 1 : 0;
/* Invert the Mappings (for the convenience of smf_resamplecube), so
that they go from current Frame to grid axis. */
astInvert( skycube->ispecmap );
astInvert( skycube->iskymap );
/* For efficiency, annul manually the unneeded AST objects created in
this loop. */
wcsin = astAnnul( wcsin );
tmap = astAnnul( tmap );
tfrm = astAnnul( tfrm );
iskyfrm = astAnnul( iskyfrm );
}
}
/* See if the detector positions are to be read from the RECEPPOS array
in the template NDFs. Otherwise, they are calculated on the basis of
the FPLANEX/Y arrays. */
parGet0l( "USEDETPOS", &usedetpos, status );
/* Get the detectors to use. If a null value is supplied, annull the
error. Otherwise, make the group case insensitive. */
detgrp = NULL;
if( *status == SAI__OK ) {
kpg1Gtgrp( "DETECTORS", &detgrp, &ndet, status );
if( *status == PAR__NULL ) {
errAnnul( status );
if (detgrp) {
grpDelet( &detgrp, status );
}
} else {
grpSetcs( detgrp, 0, status );
}
}
/* Get the pixel interpolation scheme to use. */
parChoic( "INTERP", "NEAREST", "NEAREST,LINEAR,SINC,"
"SINCSINC,SINCCOS,SINCGAUSS,SOMB,SOMBCOS",
1, pabuf, 10, status );
if( !strcmp( pabuf, "NEAREST" ) ) {
interp = AST__NEAREST;
nparam = 0;
} else if( !strcmp( pabuf, "LINEAR" ) ) {
interp = AST__LINEAR;
nparam = 0;
} else if( !strcmp( pabuf, "SINC" ) ) {
interp = AST__SINC;
nparam = 1;
} else if( !strcmp( pabuf, "SINCSINC" ) ) {
interp = AST__SINCSINC;
nparam = 2;
} else if( !strcmp( pabuf, "SINCCOS" ) ) {
interp = AST__SINCCOS;
nparam = 2;
} else if( !strcmp( pabuf, "SINCGAUSS" ) ) {
interp = AST__SINCGAUSS;
nparam = 2;
} else if( !strcmp( pabuf, "SOMB" ) ) {
interp = AST__SOMB;
nparam = 1;
} else if( !strcmp( pabuf, "SOMBCOS" ) ) {
interp = AST__SOMBCOS;
nparam = 2;
} else if( *status == SAI__OK ) {
nparam = 0;
*status = SAI__ERROR;
msgSetc( "V", pabuf );
errRep( "", "Support not available for INTERP = ^V (programming "
"error)", status );
}
/* Get an additional parameter vector if required. */
if( nparam > 0 ) parExacd( "PARAMS", nparam, params, status );
/* Get a group of reference time series files to use as templates for
the output time series files.*/
ndgAssoc( "REF", 1, &igrp2, &size, &flag, status );
/* Create a group holding the names of the corresponding output NDFs. */
ndgCreat ( "OUT", igrp2, &ogrp, &outsize, &flag, status );
if( outsize != size && *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "O", outsize );
msgSeti( "I", size );
errRep( "", "Numbers of input reference cubes (^I) and output "
"cubes (^O) differ.", status );
}
/* Loop round all the template time series files. */
for( ifile = 1; ifile <= size && *status == SAI__OK; ifile++ ) {
/* Start a new NDF context. */
ndfBegin();
/* Obtain information about the current template NDF, but do not map the
arrays. */
smf_open_file( igrp2, ifile, "READ", SMF__NOCREATE_DATA, &data, status );
/* Issue a suitable message and abort if anything went wrong. */
if( *status != SAI__OK ) {
errRep( FUNC_NAME, "Could not open input template file.", status );
break;
} else {
if( data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( data->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
}
}
/* Report the name of the input template. */
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSeti( "THISFILE", ifile );
msgSeti( "NUMFILES", size );
msgOutif( MSG__NORM, " ", "Simulating ^THISFILE/^NUMFILES ^FILE",
status );
/* Create the output NDF by propagation from the input template NDF.
Everything is copied except for the array components and any PROVENANCE
extension. */
ndgNdfpr( data->file->ndfid, "TITLE,LABEL,UNITS,AXIS,WCS,HISTORY,"
"NOEXTENSION(PROVENANCE)", ogrp, ifile, &ondf, status );
/* Ensure the output NDF has a history component. */
ndfHcre( ondf, status );
/* Get a pointer to the mapped output data array. Set all values bad. */
ndfMap( ondf, "DATA", "_REAL", "WRITE/BAD", &out_data, &nel, status );
/* If the detector positions are to calculated on the basis of FPLANEX/Y
rather than detpos, then free the detpos array in the templates smfHead
structure. This will cause smf_tslice_ast to use the fplanex/y values. */
if( !usedetpos && data->hdr->detpos ) {
astFree( (double *) data->hdr->detpos );
data->hdr->detpos = NULL;
}
/* Get a pointer to a structure holding provenance information for the
output time series. */
oprov = ndgReadProv( ondf, "SMURF:UNMAKECUBE", status );
/* Record details of the template in the provenance structure for the
output time series. */
ndgPutProv( oprov, data->file->ndfid, NULL, 0, status );
/* Loop round all input sky cubes. */
for( iskycube = 0; iskycube < nskycube; iskycube++ ) {
skycube = sky_cubes + iskycube;
/* Record details of the input cube in the provenance extension of the
output time series. */
ndgPutProv( oprov, skycube->indf, NULL, 0, status );
/* See if the current time series overlaps the current sky cube. */
smf_resampcube( data, skycube->abskyfrm,
skycube->iskymap, skycube->ispecfrm,
skycube->ispecmap, detgrp, skycube->moving,
skycube->slbnd, skycube->subnd, interp,
params, NULL, NULL, &overlap, status );
/* If not, pass on to the next sky cube. */
if( overlap ) {
/* Report the name of the sky cube. */
ndfMsg( "NDF", skycube->indf );
msgOutif( MSG__NORM, " ", " Re-sampling ^NDF", status );
/* Map the data array in the current sky cube. */
ndfMap( skycube->indf, "DATA", "_REAL", "READ", &in_data, &nel,
status );
/* Resample the cube data into the output time series. */
smf_resampcube( data, skycube->abskyfrm,
skycube->iskymap, skycube->ispecfrm,
skycube->ispecmap, detgrp, skycube->moving,
skycube->slbnd, skycube->subnd, interp,
params, in_data, out_data, &overlap, status );
/* Unmap the data array. */
ndfUnmap( skycube->indf, "DATA", status );
}
}
/* Write the provenance structure to the output NDF, and then free it. */
ndgWriteProv( oprov, ondf, 1, status );
oprov =ndgFreeProv( oprov, status );
/* Close the input time series file. */
if( data != NULL ) {
smf_close_file( &data, status );
data = NULL;
}
/* End the NDF context. */
ndfEnd( status );
}
/* Close any input data file that is still open due to an early exit from
the above loop. */
if( data != NULL ) {
smf_close_file( &data, status );
data = NULL;
}
/* Free remaining resources. */
if( detgrp != NULL) grpDelet( &detgrp, status);
if( igrp1 != NULL) grpDelet( &igrp1, status);
if( igrp2 != NULL) grpDelet( &igrp2, status);
if( ogrp != NULL) grpDelet( &ogrp, status);
sky_cubes = astFree( sky_cubes );
/* End the NDF context. */
ndfEnd( status );
/* End the tile's AST context. */
astEnd;
/* Issue a status indication.*/
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ",TASK_NAME " succeeded, time series written.", status);
} else {
msgOutif(MSG__VERB," ",TASK_NAME " failed.", status);
}
}
static void smf1_jsadicer( int indfo, int *olbnd, int *oubnd,
AstMapping *tile_map, AstFrame *tile_frm,
AstMapping *p2pmap, void *ipd, void *ipv,
unsigned char *ipq, int *status ){
/*
* Name:
* smf1_jsadicer
* Purpose:
* Copy one tile from the input NDF into a specified output NDF.
* Language:
* Starlink ANSI C
* Type of Module:
* C function
* Invocation:
* void smf1_jsadicer( int indfo, int *olbnd, int *oubnd,
* AstMapping *tile_map, AstFrame *tile_frm,
* AstMapping *p2pmap, void *ipd, void *ipv,
* unsigned char *ipq, int *status )
* Arguments:
* indfo = int (Given)
* An identifier for the NDF in which the copied data is to be
* stored. It's original pixel bounds are used as the bounds of the
* ipd, ipv and ipq arrays.
* olbnd = int * (Given)
* The new lower pixel bounds required for the output NDF. The bounds
* of the supplied NDF are changed to match these values.
* oubnd = int * (Given)
* The new upper pixel bounds required for the output NDF. The bounds
* of the supplied NDF are changed to match these values.
* tile_map = AstMapping * (Given)
* The mapping from pixel coords in the output NDF to WCS coords.
* tile_frm = AstMapping * (Given)
* The WCS Frame for the output NDF.
* p2pmap = AstMapping * (Given)
* The mapping from pixel coords in the input NDF to pixel coords in
* the output NDF.
* ipd = void * (Given)
* Pointer to the start of the input data array. If this is NULL,
* the existing contents of the NDF are used as input.
* ipv = void * (Given)
* Pointer to the start of the input variance array. Should be NULL
* if no variances are available.
* ipq = unsigned char * (Given)
* Pointer to the start of the input quality array. Should be NULL
* if no quality is available.
* status = int * (Given)
* Pointer to the inherited status variable.
*/
/* Local Variables: */
AstFrame *use_frm = NULL;
AstFrameSet *owcs;
AstMapping *use_map = NULL;
AstMapping *use_p2pmap = NULL;
AstShiftMap *sm;
char type[ NDF__SZTYP + 1 ];
double shifts[ 3 ];
int axes[ 2 ];
int axout[ NDF__MXDIM ];
int free_arrays;
int isreal;
int lbnd_tile[ 3 ];
int ndim;
int nel;
int nin;
int there;
int ubnd_tile[ 3 ];
unsigned char *ipq_out = NULL;
void *ipd_out = NULL;
void *ipv_out = NULL;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* Get the NDF data type - _REAL or _DOUBLE. */
ndfType( indfo, "Data", type, sizeof(type), status );
isreal = !strcmp( type, "_REAL" );
/* Get the existing bounds of the NDF. */
ndfBound( indfo, 3, lbnd_tile, ubnd_tile, &ndim, status );
/* If no data array has been supplied, take a copy of the original Data,
Quality and Variance arrays and use these as the input arrays. */
if( !ipd ) {
free_arrays = 1;
ndfMap( indfo, "Data", type, "Read", &ipd_out, &nel, status );
ipd = astStore( NULL, ipd_out,
nel*(isreal?sizeof(float):sizeof(double)) );
ndfUnmap( indfo, "Data", status );
ndfState( indfo, "Variance", &there, status );
if( there ) {
ndfMap( indfo, "Variance", type, "Read", &ipv_out, &nel, status );
ipv = astStore( NULL, ipv_out,
nel*(isreal?sizeof(float):sizeof(double)) );
ndfUnmap( indfo, "Variance", status );
} else {
ipv = NULL;
}
ndfState( indfo, "Quality", &there, status );
if( there ) {
ndfMap( indfo, "Quality", "_UBYTE", "Read", (void **) &ipq_out,
&nel, status );
ipq = astStore( NULL, ipq_out, nel*sizeof(*ipq) );
ndfUnmap( indfo, "Quality", status );
} else {
ipq = NULL;
}
} else {
free_arrays = 0;
}
/* Set the bounds of the NDF to the required values. */
ndfSbnd( ndim, olbnd, oubnd, indfo, status );
/* Erase the existing WCS FrameSet and then get the default WCS FrameSet. */
ndfReset( indfo, "WCS", status );
ndfGtwcs( indfo, &owcs, status );
/* If the supplied mapping and Frame have two many axes, strip some off.
The orering of pixel axes in the output JSA tile is hardwired by SMURF
as (ra,dec,spec). */
nin = astGetI( tile_map, "Nin" );
if( nin == 3 && ndim == 2 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
astMapSplit( tile_map, 2, axes, axout, &use_map );
if( use_map ) {
use_frm = astPickAxes( tile_frm, 2, axout, NULL );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "smf1_jsadicer: cannot split mapping (programming "
"error).", status );
}
astMapSplit( p2pmap, 2, axes, axout, &use_p2pmap );
if( !use_p2pmap && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "smf1_jsadicer: cannot split mapping (programming "
"error).", status );
}
} else if( nin == ndim ) {
use_p2pmap = astClone( p2pmap );
use_map = astClone( tile_map );
use_frm = astClone( tile_frm );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "smf1_jsadicer: unexpected combination of nin (%d) and "
"ndim (%d) (programming error).", status, nin, ndim );
}
/* Add the tile WCS Frame into the output NDF's WCS FrameSet, using "tilemap"
to connect it to the PIXEL Frame (NDF ensure Frame 2 is the PIXEL
Frame). */
astAddFrame( owcs, 2, use_map, use_frm );
/* The astResample function is odd in that it assumes that pixel coords
are defined such that the centre of pixel "I" has integral pixel
coord "I" (rather than "I-0.5" as is usual in Starlink). So we need to
use a half-pixel ShiftMap at start and end of the p2pmap Mapping to
account for this. */
shifts[ 0 ] = -0.5;
shifts[ 1 ] = -0.5;
shifts[ 2 ] = -0.5;
sm = astShiftMap( ndim, shifts, " " );
use_p2pmap = (AstMapping *) astCmpMap( sm, use_p2pmap, 1, " " );
astInvert( sm );
use_p2pmap = (AstMapping *) astCmpMap( use_p2pmap, sm, 1, " " );
/* Store this modified WCS FrameSet in the output NDF. */
ndfPtwcs( owcs, indfo, status );
/* Map the required arrays of the output NDF. */
ndfMap( indfo, "Data", type, "Write", &ipd_out, &nel, status );
if( ipv ) ndfMap( indfo, "Variance", type, "Write", &ipv_out, &nel,
status );
if( ipq ) ndfMap( indfo, "Quality", "_UBYTE", "Write",
(void **) &ipq_out, &nel, status );
/* Copy the input data values to the output, using nearest neighbour
interpolation (the mapping should always map input pixel centres onto
output pixel centres). We can set the "tol" argument non-zero (e.g. 0.1)
without introducing any error because the the p2pmap mapping will be
piecewise linear. This gives a factor of about 5 decrease in the time
spent within astResample. */
if( !strcmp( type, "_REAL" ) ) {
(void) astResampleF( use_p2pmap, ndim, lbnd_tile, ubnd_tile, (float *) ipd,
(float *) ipv, AST__NEAREST, NULL, NULL,
AST__USEBAD, 0.1, 1000, VAL__BADR, ndim,
olbnd, oubnd, olbnd, oubnd,
(float *) ipd_out, (float *) ipv_out );
} else {
(void) astResampleD( use_p2pmap, ndim, lbnd_tile, ubnd_tile, (double *) ipd,
(double *) ipv, AST__NEAREST, NULL, NULL,
AST__USEBAD, 0.1, 1000, VAL__BADD, ndim,
olbnd, oubnd, olbnd, oubnd,
(double *) ipd_out, (double *) ipv_out );
}
if( ipq ) {
(void) astResampleUB( use_p2pmap, ndim, lbnd_tile, ubnd_tile, ipq, NULL,
AST__NEAREST, NULL, NULL, 0, 0.1, 1000, 0,
ndim, olbnd, oubnd, olbnd, oubnd, ipq_out,
NULL );
}
/* Unmap everything the output NDF. */
ndfUnmap( indfo, "*", status );
/* Free the input arrays if they were allocated in this function. */
if( free_arrays ) {
ipd = astFree( ipd );
ipv = astFree( ipv );
ipq = astFree( ipq );
}
/* End the AST context. */
astEnd;
}
void atlGetPixelParams( AstFrameSet *fset, int *dims, int degs,
double *crpix, double *crval, double *cdelt,
double *crota, int *status ){
/*
*+
* Name:
* atlGetPixelParams
* Purpose:
* Find typical values for "FITS-like" parameters describing a FrameSet.
* Invocation:
* void atlGetPixelParams( AstFrameSet *fset, int *dims, int degs,
* double *crpix, double *crval, double *cdelt,
* double *crota, int *status )
* Description:
* This function finds values that resemble the the FITS keywords
* CRVAL1/2/3.., CRPIX1/2/3..., CRDELT1/2/3... and CROTA2, on the
* assumption that the base Frame in the supplied FrameSet describe
* GRID coords (i.e. FITS pixel coords), and the current Frame describe
* the required WCS. It is not restricted to 2D FrameSets.
*
* If the FrameSet can be written to a FitsChan successfully using
* FITS-WCS encoding, the the resulting keyword values are returned.
* Otherwise, the values are estimated by transforming closely spaced
* pixel positions along each axis. If the current Frame contains a
* SkyFrame, and the SkyFrame has a defined reference position, then
* this position specifies the returned CRVAL values. Otherwise, the
* reference position is assumed to be at the central pixel.
* Arguments:
* fset
* The FrameSet.
* dims
* Pointer to an array supplied holding the number of pixels along
* each edge of the pixel array. The number of elements in this array
* should match the number of axes in the base Frame of "fset".
* degs
* If non-zero, then the crval, cdelt and crota values for sky axes
* are returned in units of degrees. Otherwise they are returned in
* radians.
* crpix
* Pointer to an array returned holding the position of the
* reference pixel in the base Frame of "fset". The number of
* elements in this array should match the number of axes in the base
* Frame of "fset".
* crval
* Pointer to an array returned holding the position of the
* reference pixel in the current Frame of "fset". The number of
* elements in this array should match the number of axes in the
* current Frame of "fset".
* cdelt
* Pointer to an array returned holding the geodesic distance
* along each edge of the reference pixel, measured within the
* current Frame of "fset". The number of elements in this array
* should match the number of axes in the base Frame of "fset".
* crota
* Pointer to a double in which to return the angle from north in
* the current frame of "fset" to the second spatial pixel axis,
* measured positive through east. This will be returned set to
* AST__BAD if the current frame of "fset" does not contain a SkyFrame.
* status
* The global status.
* Copyright:
* Copyright (C) 2013 Science & Technology Facilities Council.
* All Rights Reserved.
* Licence:
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street,Fifth Floor, Boston, MA
* 02110-1301, USA
* Authors:
* DSB: David S. Berry (JAC, Hawaii)
* {enter_new_authors_here}
* History:
* 13-DEC-2013 (DSB):
* Original version.
* {enter_further_changes_here}
*-
*/
/* Local Variables: */
AstFitsChan *fc;
AstMapping *map;
int npix;
int nwcs;
int lataxis;
int lonaxis;
char name[20];
const char *cval;
int ipix;
double dval1;
double dval2;
int ival;
int iwcs;
double pixpos[ ATL__MXDIM ];
double wcspos[ ATL__MXDIM ];
int pixaxes[ ATL__MXDIM ];
int wcsaxes[ ATL__MXDIM ];
int skyaxis1;
int skyaxis2;
/* Initialise returned values. */
*crota = AST__BAD;
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Begin an AST context so that all AST objects created in this function
are freed automatically when the context is ended. */
astBegin;
/* Get the number of pixel axes (base frame) and wcs axes (current
frame). */
npix = astGetI( fset, "Nin" );
if( npix > ATL__MXDIM && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: Too many pixel axes (%d). Must be "
"no more than %d.", status, npix, ATL__MXDIM );
}
nwcs = astGetI( fset, "Nout" );
if( nwcs > ATL__MXDIM && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: Too many WCS axes (%d). Must be "
"no more than %d.", status, nwcs, ATL__MXDIM );
}
/* Attempt to find a pair of sky axes in the current Frame by checking
the "Domain" value for each WCS axis. */
lataxis = -1;
lonaxis = -1;
skyaxis1 = -1;
skyaxis2 = -1;
for( iwcs = 0; iwcs < nwcs; iwcs++ ) {
sprintf( name, "Domain(%d)", iwcs + 1 );
cval = astGetC( fset, name );
if( cval && !strcmp( cval, "SKY" ) ) {
/* Determine if this sky axis is a longitude or latitude axis, and record
the zero-based indicies of the longitude and latitude axes. */
sprintf( name, "IsLatAxis(%d)", iwcs + 1 );
ival = astGetI( fset, name );
if( ival ) {
lataxis = iwcs;
} else {
lonaxis = iwcs;
}
}
}
/* If a pair of sky axes were found in the current Frame, get the indices
of the corresponding pair of pixel axes. */
if( lonaxis >= 0 && lataxis >= 0 ) {
/* If there are only two pixel axes, they must be the sky axes. */
if( nwcs == 2 ) {
skyaxis1 = 0;
skyaxis2 = 1;
/* If there are more than two pixel axes, we need to work harder. */
} else {
/* Use astMapSplit to find the two pixel axes that feed the two sky axes.
astMapSplit identifes outputs corresponding to specified mapping inputs,
so we need to invert the FrameSet first so that the WCS Frame becomes
the input (i.e. base Frame). Remember to un-invert the FrameSet
afterwards. */
astInvert( fset );
wcsaxes[ 0 ] = lataxis + 1;
wcsaxes[ 1 ] = lonaxis + 1;
astMapSplit( fset, 2, wcsaxes, pixaxes, &map );
astInvert( fset );
/* If the wcs->pixel mapping was split succesfully, the pixaxes array
will contain the one-based pixel axes that feed the sky axes. Convert
them to zero-based and note the lowest and highest. */
if( map && astGetI( map, "Nout" ) == 2 ) {
if( pixaxes[ 0 ] < pixaxes[ 1 ] ) {
skyaxis1 = pixaxes[ 0 ] - 1;
skyaxis2 = pixaxes[ 1 ] - 1;
} else {
skyaxis1 = pixaxes[ 1 ] - 1;
skyaxis2 = pixaxes[ 0 ] - 1;
}
/* If it could not be split, it means the spatial and non-spatial axes are
tangle up by the pixel->wcs mapping to such an extent that they cannot
be separated. */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: Cannot separate the spatial "
"axes from the non-spatial axes.", status );
}
}
}
/* Attempt to write the supplied FrameSet to FitsChan using FITS-WCS
encoding. If successful, retrieve the required values. Convert sky
values from degrees to radians if required. */
fc = astFitsChan( NULL, NULL, "Encoding=FITS-WCS" );
if( astWrite( fc, fset ) == 1 ) {
for( ipix = 0; ipix < npix; ipix++ ) {
sprintf( name, "CRPIX%d", ipix + 1 );
if( !astGetFitsF( fc, name, crpix + ipix ) && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: %s not found in FitsChan "
"(possible programming error).", status, name );
}
sprintf( name, "CDELT%d", ipix + 1 );
if( !astGetFitsF( fc, name, cdelt + ipix ) && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: %s not found in FitsChan "
"(possible programming error).", status, name );
}
if( !degs && ( ipix == skyaxis1 || ipix == skyaxis2 ) ){
cdelt[ ipix ] *= AST__DD2R;
}
}
for( iwcs = 0; iwcs < nwcs; iwcs++ ) {
sprintf( name, "CRVAL%d", iwcs + 1 );
if( !astGetFitsF( fc, name, crval + iwcs ) && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: %s not found in FitsChan "
"(possible programming error).", status, name );
}
if( !degs && ( iwcs == lonaxis || iwcs == lataxis ) ){
crval[ iwcs ] *= AST__DD2R;
}
}
/* Derive the position angle (within the sky frame) of the second spatial
pixel axis, based on the PCi_j rotation matrix elements. Note, there is
no assumption here that the latitude and longitude axes are orthogonal
in the pixel frame. FITS-WCS allows for shear, so this value says
nothing about the orientation of the first spatial pixel axis. But in
practice images nearly always have no shear. */
if( lataxis >= 0 && lonaxis >= 0 ) {
sprintf( name, "PC%d_%d", lonaxis + 1, skyaxis1 + 1 );
if( !astGetFitsF( fc, name, &dval1 ) && *status == SAI__OK ) {
dval1 = ( lonaxis == skyaxis1 ) ? 1.0 : 0.0;
}
sprintf( name, "PC%d_%d", lonaxis + 1, skyaxis2 + 1 );
if( !astGetFitsF( fc, name, &dval2 ) && *status == SAI__OK ) {
dval2 = ( lonaxis == skyaxis2 ) ? 1.0 : 0.0;
}
*crota = atan2( dval2, dval1 );
if( *crota < 0.0 ) *crota += 2*AST__DPI;
if( degs ) *crota *= AST__DR2D;
}
/* If the supplied FrameSet could not be converted to a set of
FITS-WCS keywords, we derive similar values by looking at small
increments of pixel position. */
} else {
/* First job is to decide on the reference position. By default we use
the central pixel. Store the corresponding pixel coords. */
for( ipix = 0; ipix < npix; ipix++ ) {
crpix[ ipix ] = ( 1.0 + dims[ ipix ] )/2.0;
}
/* Convert this pixel position to the WCS Frame. */
astTranN( fset, 1, npix, 1, crpix, 1, nwcs, 1, crval );
/* If the current Frame contains a pair of sky axes, then the associated
SkyFrame may include a reference position. If so, we will use it
instead of the central pixel. First test to see if the SkyFrame has a
reference position. If so get the reference longitude and latitude in
radians, and convert the new reference position back to pixel coords. */
if( lonaxis >= 0 && lataxis >= 0 ) {
sprintf( name, "SkyRef(%d)", lonaxis + 1 );
if( astTest( fset, name ) ) {
crval[ lonaxis ] = astGetD( fset, name );
sprintf( name, "SkyRef(%d)", lataxis + 1 );
crval[ lataxis ] = astGetD( fset, name );
astTranN( fset, 1, nwcs, 1, crval, 0, npix, 1, crpix );
/* If we have sky axes but the skyframe has no reference position, we
need to check that the central pixel is a good default. For instance,
it may be off the edge of an all-sky map, in which case it is no good
as a reference position. */
} else if( ( crval[ lonaxis ] == AST__BAD ||
crval[ lataxis ] == AST__BAD ) && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "atlGetPixelParams: No reference position can be "
"determined.", status );
}
}
/* Normalize the reference position. */
astNorm( fset, crval );
/* Now we find the pixel size on each pixel axis. First take a copy of
the pixel reference position. */
memcpy( pixpos, crpix, npix*sizeof( *pixpos ) );
for( ipix = 0; ipix < npix; ipix++ ) {
/* Store a pixel position which is offset away from the reference position
by one pixel along the current pixel axis, and then transform it into
the WCS Frame. */
pixpos[ ipix ] += 1.0;
astTranN( fset, 1, npix, 1, pixpos, 1, nwcs, 1, wcspos );
pixpos[ ipix ] -= 1.0;
/* Find the geodesic distance between this WCS position and the reference
position. */
cdelt[ ipix ] = astDistance( fset, crval, wcspos );
}
/* Find the crota value if we have a pair of sky axes. */
if( lonaxis >= 0 && lataxis >= 0 ){
/* Get a WCS position about one arc-second north of the reference position. */
memcpy( wcspos, crval, nwcs*sizeof( *wcspos ) );
wcspos[ lataxis ] += 5.0E-6;
/* Transform to pixel coordinates. */
astTranN( fset, 1, nwcs, 1, wcspos, 0, npix, 1, pixpos );
/* Get the required angle. */
*crota = atan2( pixpos[ skyaxis1 ] - crpix[ skyaxis1 ],
pixpos[ skyaxis1 ] - crpix[ skyaxis2 ] );
if( *crota < 0.0 ) *crota += 2*AST__DPI;
if( !degs ) *crota *= AST__DR2D;
}
/* Convert the returned angles to degrees if required. */
if( !degs && ( lonaxis >= 0 && lataxis >= 0 ) ){
crval[ lataxis ] *= AST__DR2D;
crval[ lonaxis ] *= AST__DR2D;
cdelt[ skyaxis1 ] *= AST__DR2D;
cdelt[ skyaxis2 ] *= AST__DR2D;
}
}
/* End the AST context. This will annull all AST objects created in this
function. */
astEnd;
}
