void smf_rebincube_ast( ThrWorkForce *wf, smfData *data, int first, int last,
int *ptime, dim_t nchan, dim_t ndet, dim_t nslice,
dim_t nel, dim_t nxy, dim_t nout, dim_t dim[3],
AstMapping *ssmap, AstSkyFrame *abskyfrm,
AstMapping *oskymap, Grp *detgrp, int moving,
int usewgt, int spread, const double params[],
int genvar, double tfac, double fcon,
float *data_array, float *var_array,
double *wgt_array, float *texp_array,
float *teff_array, int *good_tsys, int *nused,
int *status ){
/* Local Variables */
AstCmpMap *detmap = NULL; /* Mapping from 1D det. index to 2D i/p "grid" coords */
AstMapping *dtotmap = NULL; /* 1D det index->o/p GRID Mapping */
AstMapping *fullmap = NULL; /* WCS->GRID LutMap from input WCS FrameSet */
AstMapping *lutmap = NULL; /* Mapping that identifies detectors to be used */
AstMapping *splut = NULL; /* Spatial LutMap */
AstMapping *sslut = NULL; /* Spectral LutMap */
AstMapping *totmap = NULL; /* WCS->GRID Mapping from input WCS FrameSet */
AstPermMap *pmap; /* Mapping to rearrange output axes */
const char *name = NULL; /* Pointer to current detector name */
const double *tsys = NULL; /* Pointer to Tsys value for first detector */
dim_t iv; /* Vector index into output 3D array */
double *detlut = NULL; /* Work space for detector mask */
double blk_bot[ 2*MAXTHREADS + 1 ]; /* First o/p channel no. in each block */
double con; /* Constant value */
double dtemp; /* Temporary value */
double tcon; /* Variance factor for whole time slice */
float *detwork = NULL; /* Work array for detector values */
float *tdata = NULL; /* Pointer to start of input time slice data */
float *varwork = NULL; /* Work array holding variances for 1 slice/channel */
float *vp = NULL; /* Pointer to next "varwork" element */
float invar; /* Input variance */
float rtsys; /* Tsys value */
float teff; /* Effective integration time */
float texp; /* Total time ( = ton + toff ) */
int *nexttime; /* Pointer to next time slice index to use */
int ast_flags; /* Basic flags to use with astRebinSeq */
int blk_size; /* Number of channels processed by a single thread */
int found; /* Was current detector name found in detgrp? */
int iblock; /* Index of current spectral block */
dim_t ichan; /* Index of current channel */
dim_t idet; /* detector index */
int ignore; /* Ignore this time slice? */
int inperm[ 3 ]; /* Input axis permutation array */
dim_t itime; /* Index of current time slice */
int junk; /* Unused parameter */
int lbnd_in[ 2 ]; /* Lower input bounds on receptor axis */
int ldim[ 3 ]; /* Output array lower GRID bounds */
int maxthreads; /* Max no. of threads to use when re-binning */
int nblock; /* Number of spectral blocks */
int nthreads; /* Number of threads to use when re-binning */
int outperm[ 3 ]; /* Output axis permutation array */
int timeslice_size; /* Number of elements in a time slice */
int ubnd_in[ 2 ]; /* Upper input bounds on receptor axis */
int uddim[ 1 ]; /* Detector array upper GRID bounds */
int udim[ 3 ]; /* Output array upper GRID bounds */
smfHead *hdr = NULL; /* Pointer to data header for this time slice */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Store a pointer to the input NDFs smfHead structure. */
hdr = data->hdr;
/* Fill an array with the lower grid index bounds of the output. */
ldim[ 0 ] = 1;
ldim[ 1 ] = 1;
ldim[ 2 ] = 1;
/* Integer upper grid index bounds of the output. */
udim[ 0 ] = dim[ 0 ];
udim[ 1 ] = dim[ 1 ];
udim[ 2 ] = dim[ 2 ];
/* Integer upper bounds of detector array. */
uddim[ 0 ] = ndet;
/* Store the size of an input time slice. */
timeslice_size = nel/nslice;
/* Create a LutMap that holds the output spectral axis GRID value at
the centre of each input spectral axis pixel. LutMaps are faster to
evaluate, and so astRebinSeq will go faster. We can use LutMaps without
loosing accuracy since astRebinSeq only ever transforms the GRID
values at input pixel centres (i.e. integer GRID values), and so the
LutMap will always return a tabulated value rather than an
interpolated value. */
atlTolut( (AstMapping *) ssmap, 1.0, (double) nchan, 1.0, "LutInterp=1",
&sslut, status );
/* If this is the first pass through this file, initialise the arrays. */
if( first ) smf_rebincube_init( 0, nxy, nout, genvar, data_array, var_array,
wgt_array, texp_array, teff_array, &junk, status );
/* Initialisation the flags for astRebinSeq (we do not include flag
AST__REBININIT because the arrays have been initialised). */
ast_flags = AST__USEBAD;
if( usewgt ) ast_flags = ast_flags | AST__VARWGT;
if( genvar == 1 ) {
ast_flags = ast_flags | AST__GENVAR;
} else if( genvar == 2 ) {
ast_flags = ast_flags | AST__USEVAR;
}
/* If required, allocate a work array to hold all the input variances for a
single time slice. */
if( usewgt || genvar == 2 ) varwork = astMalloc( timeslice_size * sizeof( float ) );
/* Allocate a work array to hold the exposure time for each detector. */
detwork = astMalloc( ndet * sizeof( float ) );
/* If we are dealing with more than 1 detector, create a LutMap that holds
the input GRID index of every detector to be included in the output, and
AST__BAD for every detector that is not to be included in the output cube.
First allocate the work space for the LUT. */
if( ndet > 1 ) {
detlut = astMalloc( ndet*sizeof( double ) );
/* Initialise a string to point to the name of the first detector for which
data is available */
name = hdr->detname;
/* Loop round all detectors for which data is available. */
for( idet = 0; idet < ndet; idet++ ) {
/* Store the input GRID coord of this detector. GRID coords start at 1,
not 0. */
detlut[ idet ] = idet + 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 coord bad.
This will cause astRebinSeq to ignore data from the detector. */
if( detgrp ) {
found = grpIndex( name, detgrp, 1, status );
if( !found ) detlut[ idet ] = AST__BAD;
}
/* Move on to the next available detector name. */
name += strlen( name ) + 1;
}
/* Create the LutMap. */
lutmap = (AstMapping *) astLutMap( ndet, detlut, 1.0, 1.0,
"LutInterp=1" );
/* If we only have 1 detector, use a UnitMap instead of a LutMap (lutMaps
must have 2 or more table entries). */
} else {
lutmap = (AstMapping *) astUnitMap( 1, " " );
}
/* Combine the above LutMap with a 1-input, 2-output PermMap that copies its
input to create its first output, and assigns a constant value of 1.0 to
its second output. We need to do this because smf_tslice returns a 2D
GRID system (even though the second GRID axis is not actually used). */
inperm[ 0 ] = 1;
outperm[ 0 ] = 1;
outperm[ 1 ] = -1;
con = 1.0;
detmap = astCmpMap( lutmap, astPermMap( 1, inperm, 2, outperm, &con, " " ),
1, " " );
/* Store the bounds of a single time slice grid. */
lbnd_in[ 0 ] = 1;
ubnd_in[ 0 ] = nchan;
lbnd_in[ 1 ] = 1;
ubnd_in[ 1 ] = ndet;
/* Create a PermMap that can be used to re-order the output axes so that
channel number is axis 3. */
outperm[ 0 ] = 2;
outperm[ 1 ] = 3;
outperm[ 2 ] = 1;
inperm[ 0 ] = 3;
inperm[ 1 ] = 1;
inperm[ 2 ] = 2;
pmap = astPermMap( 3, inperm, 3, outperm, NULL, " " );
/* If we are using multiple threads to rebin spectral blocks in parallel,
calculate the number of channels that are processed by each thread,
and the number of threads to use. The whole output spectrum is divided
up into blocks. The number of blocks is two times the number of
threads, and each thread rebins two adjacent blocks. Alternate blocks
are re-binned simultanously. First, the odd numbered blocks are re-binned
(one by each thread). When all odd numbered blocks have been re-binned,
the even numbered blocks are re-binned. We ensure that the number of
threads used results in a block size that is larger than the spreading
width produced by the requested spreading scheme. This means that no
pair of simultanously executing threads will ever try to write to the
same channel of the output spectrum. */
maxthreads = wf ? wf->nworker : 1;
if( maxthreads > MAXTHREADS ) maxthreads = MAXTHREADS;
if( maxthreads > 1 ) {
/* Find the largest number of threads into which each output spectrum can
be split. The limit is imposes by the requirement that each block is
larger than the pixel spreading produced by the requested spreading
scheme. */
nthreads = ( ( dim[ 2 ] + 1 )/2 )/smf_spreadwidth( spread, params,
status );
/* If the spectral range is less than twice the spreading width, we
cannot use multiple threads. */
if( nthreads > 1 ) {
/* Restrict the number of threads to be no more than the number of workers
available in the work force. */
if( nthreads > maxthreads ) nthreads = maxthreads;
/* Find the number of output channels in each spectral block. */
blk_size = ( dim[ 2 ] - 1 )/( 2*nthreads ) + 1;
/* Set up the first output channel number within each block. */
nblock = 2*nthreads;
for( iblock = 0; iblock < nblock; iblock++ ) {
blk_bot[ iblock ] = (double) ( iblock*blk_size + 1 );
}
/* Add in the first channel number beyond the last block. */
blk_bot[ nblock ] = blk_bot[ nblock - 1 ] + blk_size;
/* If the output spectrum is too short to guarantee that there are any
independent blocks of output channels, we process the whole spectrum
in a single thread. */
} else {
nthreads = 1;
nblock = 1;
blk_bot[ 0 ] = 1.0;
blk_bot[ 1 ] = (double) ( dim[ 2 ] + 1 );
}
/* If multiple threads are not available, we process the whole spectrum
in a single thread. */
} else {
nthreads = 1;
nblock = 1;
blk_bot[ 0 ] = 1.0;
blk_bot[ 1 ] = (double) ( dim[ 2 ] + 1 );
}
/* Convert the block boundaries from output channel numbers into input
channel numbers. */
astTran1( ssmap, nblock + 1, blk_bot, 0, blk_bot );
/* Ensure they are in increasing order, and are not outside the bounds of
the input array. */
if( blk_bot[ 0 ] > blk_bot[ 1 ] ) {
for( iblock = 0; iblock < ( nblock + 1 )/2; iblock++ ) {
dtemp = blk_bot[ nblock - iblock ];
blk_bot[ nblock - iblock ] = blk_bot[ iblock ];
blk_bot[ iblock ] = dtemp;
}
}
for( iblock = 0; iblock <= nblock; iblock++ ) {
if( blk_bot[ iblock ] < 1 ) {
blk_bot[ iblock ] = 1.0;
} else if( blk_bot[ iblock ] > nchan ) {
blk_bot[ iblock ] = nchan;
}
}
/* Initialise a pointer to the next time slice index to be used. */
nexttime = ptime;
/* Initialise the progress meter. */
smf_reportprogress( nslice, status );
/* Loop round all time slices in the input NDF. */
for( itime = 0; itime < nslice && *status == SAI__OK; itime++ ) {
/* If this time slice is not being pasted into the output cube, pass on. */
if( nexttime ){
if( *nexttime != (int) itime ) continue;
nexttime++;
}
/* Store a pointer to the first input data value in this time slice. */
tdata = ( (float *) (data->pntr)[ 0 ] ) + itime*timeslice_size;
/* Begin an AST context. Having this context within the time slice loop
helps keep the number of AST objects in use to a minimum. */
astBegin;
/* Get a Mapping from the spatial GRID axes in the input the spatial
GRID axes in the output for the current time slice. Note this has
to be done first since it stores details of the current time slice
in the "smfHead" structure inside "data", and this is needed by
subsequent functions. */
totmap = smf_rebin_totmap( data, itime, abskyfrm, oskymap, moving,
status );
if( !totmap ) break;
/* Get the effective exposure time, the total exposure time, and the
Tsys->Variance onversion factor for this time slice. Also get a
pointer to the start of the Tsys array. */
tsys = smf_rebincube_tcon( hdr, itime, fcon, &texp, &teff, &tcon,
status );
/* So "totmap" is a 2-input, 2-output Mapping that transforms the input
spatial GRID coords into output spatial GRID coords. In order to speed
up astRebinSeq we represent this by a pair of parallel LutMaps. To do
this (using atlTolut) we need a Mapping which only has 1 input, so we
preceed "totmap" with "detmap" (which also has the effect of exluding
data from unrequired detectors). We then combine this Mapping in
parallel with the spectral LutMap to get a 2-input (channel number,
detector index) and 3-output (output grid coords) Mapping. We finally
add a PermMap to re-arrange the output axes so that channel number is
axis 3 in the output. */
dtotmap = (AstMapping *) astCmpMap( detmap, totmap, 1, " " );
if( ndet > 1 ) {
atlTolut( dtotmap, 1.0, (double) ndet, 1.0, "LutInterp=1", &splut,
status );
} else {
splut = astClone( dtotmap );
}
fullmap = astSimplify( astCmpMap( astCmpMap( sslut, splut, 0, " " ),
pmap, 1, " " ) );
/* If required calculate the variance associated with each value in the
current time slice. based on the input Tsys values. If they are
needed, but not available, ignored the time slice. */
ignore = 0;
if( varwork ) {
ignore = 1;
vp = varwork;
for( idet = 0; idet < ndet; idet++ ) {
invar = VAL__BADR;
rtsys = tsys ? (float) tsys[ idet ] : VAL__BADR;
if( rtsys <= 0.0 ) rtsys = VAL__BADR;
if( rtsys != VAL__BADR ) {
*good_tsys = 1;
if( tcon != VAL__BADD ) {
invar = tcon*rtsys*rtsys;
ignore = 0;
}
}
for( ichan = 0; ichan < nchan; ichan++ ) *(vp++) = invar;
}
}
/* Unless we are ignoring this time slice, paste it into the 3D output
cube. The smf_rebincube_seqf function is a wrapper for astRebinSeqF
that splits the total job up between "nthreads" threads running in
parallel. */
if( !ignore ) {
smf_rebincube_seqf( wf, nthreads, blk_bot, fullmap, 0.0, 2, lbnd_in,
ubnd_in, tdata, varwork, spread, params,
ast_flags, 0.0, 50, VAL__BADR, 3, ldim, udim,
lbnd_in, ubnd_in, data_array, var_array,
wgt_array, nused, status );
/* Now we update the total exposure time array. Scale the exposure time
of this time slice in order to reduce its influence on the output
expsoure times if it does not have much spectral overlap with the
output cube. then fill the 1D work array with this constant value and
paste it into the 2D texp_array using the spatial mapping. Note we
want the simple sum of the exposure times, with no normalisation. SO
we use the AST__NONORM flag which means we do not need to supply a
weights array. */
if( texp != VAL__BADR ) {
texp *= tfac;
for( iv = 0; iv < ndet; iv++ ) detwork[ iv ] = texp;
astRebinSeqF( splut, 0.0, 1, ldim, uddim, detwork, NULL,
spread, params, AST__NONORM, 0.0, 50,
VAL__BADR, 2, ldim, udim, ldim, uddim, texp_array,
NULL, NULL, NULL );
}
/* Now do the same with the effective exposure time. */
if( teff != VAL__BADR ) {
teff *= tfac;
for( iv = 0; iv < ndet; iv++ ) detwork[ iv ] = teff;
astRebinSeqF( splut, 0.0, 1, ldim, uddim, detwork, NULL,
spread, params, AST__NONORM, 0.0, 50, VAL__BADR, 2,
ldim, udim, ldim, uddim, teff_array, NULL, NULL,
NULL );
}
}
/* Update the progress meter. */
smf_reportprogress( 0, status );
/* End the AST context. */
astEnd;
}
/* If this is the final pass through this function, normalise the returned
data and variance values. */
if( last ) {
/* Create a dummy mapping that can be used with astRebinSeq (it is not
actually used for anything since we are not adding any more data into the
output arrays). */
fullmap = (AstMapping *) astPermMap( 2, NULL, 3, NULL, NULL, " " );
/* Normalise the data values. We do not normalise the exposure time arrays. */
astRebinSeqF( fullmap, 0.0, 2, lbnd_in,
ubnd_in, NULL, NULL, spread, params,
AST__REBINEND | ast_flags, 0.0, 50, VAL__BADR, 3,
ldim, udim, lbnd_in, ubnd_in, data_array, var_array,
wgt_array, nused );
fullmap = astAnnul(fullmap);
}
/* Free resources. */
detlut = astFree( detlut );
detwork = astFree( detwork );
varwork = astFree( varwork );
}
smfDetposWcsCache *smf_detpos_wcs( smfHead *hdr, int index, double dut1,
const double telpos[3],
AstFrameSet **fset, smfDetposWcsCache *cache,
int *status ) {
/* Local Variables: */
AstCmpMap *cmap1 = NULL; /* Parallel CmpMap holding both LutMaps */
AstLutMap *latmap = NULL; /* LutMap holding latitude values */
AstLutMap *lonmap = NULL; /* LutMap holding longitude values */
AstMapping *map = NULL; /* GRID->SKY Mapping */
AstSkyFrame *csky = NULL; /* SkyFrame to put in returned FrameSet */
const double *p1; /* Pointer to next lon or lat value to copy */
double *p2; /* Pointer to next lon value */
double *p3; /* Pointer to next lat value */
int i; /* Index of current detector */
int nrec; /* Number of detectors */
int outperm[ 2 ]; /* Axis permutation */
smfDetposWcsCache *result; /* Pointer to returned cache structure */
/* If a negative index was supplied just free the allocated resources and
return. */
if( index < 0 && cache ) {
if( cache->latlut ) cache->latlut = astFree( cache->latlut );
if( cache->lonlut ) cache->lonlut = astFree( cache->lonlut );
if( cache->pmap ) cache->pmap = astAnnul( cache->pmap );
if( cache->grid ) cache->grid = astAnnul( cache->grid );
if( cache->sky ) cache->sky = astAnnul( cache->sky );
cache = astFree( cache );
return NULL;
}
/* Check inherited status */
result = cache;
if( *status != SAI__OK) return result;
/* If no cache structure was supplied, allocate and initialise one now. */
if( !cache ) {
cache = astMalloc( sizeof( *cache ) );
if( cache ) {
cache->latlut = NULL;
cache->lonlut = NULL;
cache->pmap = NULL;
cache->grid = NULL;
cache->sky = NULL;
result = cache;
} else {
*status = SAI__ERROR;
errRep( FUNC_NAME, FUNC_NAME": Can't allocate memory for cache.",
status);
return NULL;
}
}
/* Get the number of detectors. */
nrec = hdr->ndet;
/* Get a pointer to the start of the detpos values for the requested
time slice. */
p1 = hdr->detpos + 2*nrec*index;
/* Check there is more than 1 detector. */
if( nrec > 1 ) {
/* It is possible that we have not allocated enough memory since
this memory is allocated for the first file but subsequent files
may have more receptors. So we use astGrow. */
/* If required, allocate memory to hold the individual look up tables for
lon and lat vaues. */
cache->lonlut = astGrow( cache->lonlut, nrec, sizeof( double ) );
cache->latlut = astGrow( cache->latlut, nrec, sizeof( double ) );
/* Check the memory was allocated succesfully. */
if( cache->lonlut && cache->latlut ) {
/* Copy the lon and lat values for the requested time slice from the
smfHead structure to the local lut arrays. */
p2 = cache->lonlut;
p3 = cache->latlut;
for( i = 0; i < nrec; i++ ) {
*(p2++) = *(p1++);
*(p3++) = *(p1++);
}
/* Create the Mapping from GRID to SKY positions. This is a PermMap to
duplicate the detector index, followed by 2 LutMaps in parallel to
generate the lon and lat values. Set the LutInterpattribute in these
LutMaps so that they use nearest neighbour interpolation. */
lonmap = astLutMap( nrec, cache->lonlut, 1.0, 1.0, "LutInterp=1" );
latmap = astLutMap( nrec, cache->latlut, 1.0, 1.0, "LutInterp=1" );
cmap1 = astCmpMap( lonmap, latmap, 0, " " );
latmap = astAnnul( latmap );
lonmap = astAnnul( lonmap );
if( !cache->pmap ) {
outperm[ 0 ] = 1;
outperm[ 1 ] = 1;
cache->pmap = astPermMap( 2, NULL, 2, outperm, NULL, " " );
astExempt( cache->pmap );
}
map = (AstMapping *) astCmpMap( cache->pmap, cmap1, 1, " " );
cache->pmap = astAnnul( cache->pmap );
cmap1 = astAnnul( cmap1 );
}
/* If thre is only one detector, use a PermMap to describe this one
position. rather than a LutMap (LutMaps cannot describe a single
position). */
} else {
outperm[ 0 ] = -1;
outperm[ 1 ] = -2;
map = (AstMapping *) astPermMap( 2, NULL, 2, outperm, p1, " " );
}
/* Create two Frames to put in the FrameSet. */
if( !cache->grid ) {
cache->grid = astFrame( 2, "Domain=GRID" );
astExempt( cache->grid );
}
if( !cache->sky ) {
cache->sky = astSkyFrame( "System=AzEl" );
astSetD( cache->sky, "ObsLon", -telpos[ 0 ] );
astSetD( cache->sky, "ObsLat", telpos[ 1 ] );
astExempt( cache->sky );
/* If the detpos positions are referred to the TRACKING frame, change
the SkyFrame from AZEL to the AST equivalent of the TRACKING Frame. */
if( !hdr->dpazel ) {
astSetC( cache->sky, "System", sc2ast_convert_system( hdr->state->tcs_tr_sys,
status ) );
}
}
/* Take a copy of the skyframe, and then modify its Epoch attribute. We take a
copy since otherwise all FrameSets returned by this function would share
the same current Frame, and so the attribute change would affect them all.
Always use TCS_TAI. smf_open_file corrects the JCMTState structure
if TCS_TAI is missing. Remember to convert from TAI to TDB (as required by
the Epoch attribute). */
csky = astClone( cache->sky );
astSet( csky, "Epoch=MJD %.*g, dut1=%.*g",
DBL_DIG, hdr->state->tcs_tai + 32.184/SPD,
DBL_DIG, dut1 );
/* Create the FrameSet */
*fset = astFrameSet( cache->grid, " " );
astAddFrame( *fset, AST__BASE, map, csky );
/* Free resources */
map =astAnnul( map );
csky =astAnnul( csky );
/* Exempt the FrameSet pointer from the AST context system rather because
we do not know when, or in which context, it will be used. It will be
annulled either in smf_tslice_ast or in smf_close_file. */
astExempt( *fset );
return result;
}
/* Main entry */
void smf_jsadicer( int indf, const char *base, int trim, smf_inst_t instrument,
smf_jsaproj_t proj, size_t *ntile, Grp *grp, int *status ){
/* Local Variables: */
AstBox *box;
AstFitsChan *fc;
AstFrame *specfrm = NULL;
AstFrame *tile_frm = NULL;
AstFrameSet *iwcs;
AstFrameSet *tfs = NULL;
AstFrameSet *tile_wcs;
AstMapping *ndf_map = NULL;
AstMapping *p2pmap = NULL;
AstMapping *specmap = NULL;
AstMapping *tile_map = NULL;
AstRegion *region;
Grp *grpt = NULL;
char *path;
char dtype[ NDF__SZFTP + 1 ];
char jsatile_comment[45];
char type[ NDF__SZTYP + 1 ];
const char *dom = NULL;
const char *keyword;
const char *latsys = NULL;
const char *lonsys = NULL;
double *pd;
double dlbnd[3];
double dubnd[3];
double gcen[3];
double lbnd_in[3];
double lbnd_out[3];
double ubnd_in[3];
double ubnd_out[3];
float *pf;
int *created_tiles = NULL;
int *tiles;
int axlat;
int axlon;
int axspec;
int bbox[ 6 ];
int i;
int ifrm;
int igrid;
int indfo;
int indfs;
int indfx;
int inperm[3];
int ipixel;
int ishpx;
int isxph;
int itile;
int ix;
int iy;
int iz;
int junk;
int latax = -1;
int lbnd[3];
int lbnd_tile[ 3 ];
int lbndx[ NDF__MXDIM ];
int lonax = -1;
int nbase;
int ndim;
int ndimx;
int nfrm;
int nsig;
int ntiles;
int olbnd[ 3 ];
int oubnd[ 3 ];
int outperm[ 3 ];
int place;
int qual;
int tile_index;
int tile_lbnd[2];
int tile_ubnd[2];
int ubnd[3];
int ubnd_tile[ 3 ];
int ubndx[ NDF__MXDIM ];
int var;
size_t iext;
size_t size;
smfJSATiling tiling;
unsigned char *ipq = NULL;
void *ipd = NULL;
void *ipv = NULL;
/* Initialise */
*ntile = 0;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Note the used length of the supplied base string. If it ends with
".sdf", reduce it by 4. */
nbase = astChrLen( base );
if( !strcmp( base + nbase - 4, ".sdf" ) ) nbase -= 4;
/* Allocate a buffer large enough to hold the full path for an output NDF. */
path = astMalloc( nbase + 25 );
/* Get the WCS from the NDF. */
kpg1Gtwcs( indf, &iwcs, status );
/* Note if the NDF projection is HPX or XPH. */
ishpx = astChrMatch( astGetC( iwcs, "Projection" ), "HEALPix" );
isxph = astChrMatch( astGetC( iwcs, "Projection" ), "polar HEALPix" );
/* Report an error if the NDFs projection is neither of these. */
if( !ishpx && !isxph && *status == SAI__OK ) {
ndfMsg( "N", indf );
*status = SAI__ERROR;
errRep( "", "The input NDF (^N) does not appear to be gridded "
"on the JSA all-sky pixel grid.", status );
}
/* Get the bounds of the NDF in pixel indices and the the corresponding
double precision GRID bounds (reduce the size of the grid by a small
amount to avoid problems with tiles that are on the edge of the valid sky
regions - astMapRegion can report an error for such tiles). Also store
the GRID coords of the centre. Also count the number of significant
pixel axes. */
ndfBound( indf, 3, lbnd, ubnd, &ndim, status );
nsig = 0;
for( i = 0; i < ndim; i++ ) {
dlbnd[ i ] = 0.5 + 0.1;
dubnd[ i ] = ubnd[ i ] - lbnd[ i ] + 1.5 - 0.1;
gcen[ i ] = 0.5*( dlbnd[ i ] + dubnd[ i ] );
if( ubnd[ i ] > lbnd[ i ] ) nsig++;
}
/* Find the one-based indices of the RA, Dec and spectral axes in the
current Frame of the NDF. */
axlon = 0;
if( astGetI( iwcs, "IsLonAxis(1)" ) ) {
axlon = 1;
lonsys = astGetC( iwcs, "System(1)" );
} else if( astGetI( iwcs, "IsLonAxis(2)" ) ) {
axlon = 2;
lonsys = astGetC( iwcs, "System(2)" );
} else if( ndim == 3 && astGetI( iwcs, "IsLonAxis(3)" ) ) {
axlon = 3;
lonsys = astGetC( iwcs, "System(3)" );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_jsadicer: Cannot find the longitude axis in the "
"input NDF.", status );
}
axlat = 0;
if( astGetI( iwcs, "IsLatAxis(1)" ) ) {
axlat = 1;
latsys = astGetC( iwcs, "System(1)" );
} else if( astGetI( iwcs, "IsLatAxis(2)" ) ) {
axlat = 2;
latsys = astGetC( iwcs, "System(2)" );
} else if( ndim == 3 && astGetI( iwcs, "IsLatAxis(3)" ) ) {
axlat = 3;
latsys = astGetC( iwcs, "System(3)" );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_jsadicer: Cannot find the latitude axis in the "
"input NDF.", status );
}
axspec = 6 - axlon - axlat;
/* Report an error if the spatial axes are not ICRS RA and Dec. */
if( ( lonsys && strcmp( lonsys, "ICRS" ) ) ||
( latsys && strcmp( latsys, "ICRS" ) ) ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "N", indf );
errRep( "", "smf_jsadicer: The spatial axes in '^N' are not "
"ICRS RA and Dec.", status );
}
}
/* Create a Box describing the region covered by the NDF pixel grid in
GRID coords. */
box = astBox( astGetFrame( iwcs, AST__BASE ), 1, dlbnd, dubnd,
AST__NULL, " " );
/* Map this Box into the current WCS Frame of the NDF. */
region = astMapRegion( box, iwcs, iwcs );
/* If no instrument was specified, we will determine the instrument from
the contexts of the FITS extension. Copy the NDF FITS extension to a
FitsChan. Annul the error if the NDF no FITS extension. */
if( instrument == SMF__INST_NONE && *status == SAI__OK ) {
kpgGtfts( indf, &fc, status );
if( *status == KPG__NOFTS ) {
errAnnul( status );
fc = NULL;
}
} else {
fc = NULL;
}
/* Get the parameters of the required tiling scheme. */
smf_jsainstrument( NULL, fc, instrument, &tiling, status );
/* Get a list of the JSA tiles touched by the supplied NDF. */
tiles = smf_jsatiles_region( region, &tiling, &ntiles, status );
if( ntiles == 0 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_jsadicer: No JSA tiles found touching supplied NDF "
"(programming error).", status );
}
/* Does the input NDF have a Variance component? */
ndfState( indf, "Variance", &var, status );
/* Does the input NDF have a Quality component? */
ndfState( indf, "Quality", &qual, status );
/* Decide on the data type to use: _REAL or _DOUBLE. */
ndfMtype( "_REAL,_DOUBLE", indf, indf, "Data", type, sizeof(type), dtype,
sizeof(dtype), status );
/* Tell the user what is happening. */
msgBlank( status );
msgOutf( "", "Dicing %s into JSA tiles:", status,
( nsig == 2 ) ? "map" : "cube" );
/* Loop round all tiles that overlap the supplied NDF. */
for( itile = 0; itile < ntiles && *status == SAI__OK; itile++ ) {
tile_index = tiles[ itile ];
/* Get the spatial pixel bounds of the current tile within the requested
JSA all-sky projection. Also get the (2D) WCS FrameSet for the tile. */
smf_jsatile( tile_index, &tiling, 0, proj, NULL, &tile_wcs, NULL,
tile_lbnd, tile_ubnd, status );
/* Extract the tile pixel->WCS mapping and WCS Frame. We know the indices
of the required Frames because they are hard-wired in smf_jsatile. */
tile_map = astGetMapping( tile_wcs, 3, 2 );
tile_frm = astGetFrame( tile_wcs, 2 );
/* Find the indices of the grid and pixel frames in the input NDF. */
ipixel = -1;
igrid = astGetI( iwcs, "Base" );
nfrm = astGetI( iwcs, "NFrame" );
for( ifrm = 0; ifrm < nfrm; ifrm++ ) {
dom = astGetC( astGetFrame( iwcs, ifrm + 1 ), "Domain" );
if( astChrMatch( dom, "PIXEL" ) ) ipixel = ifrm + 1;
}
/* If required, extract the pixel->spectral mapping and spectral frame in
the input NDF, and add it in parallel with the above tile mapping. */
if( ndim == 3 ) {
astSetI( iwcs, "Base", ipixel );
tfs = atlFrameSetSplit( iwcs, "DSBSPECTRUM SPECTRUM", NULL,
NULL, status );
astSetI( iwcs, "Base", igrid );
if( tfs ) {
specmap = astGetMapping( tfs, AST__BASE, AST__CURRENT );
specfrm = astGetFrame( tfs, AST__CURRENT );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
ndfMsg( "N", indf );
errRep( "", "smf_jsadicer: Cannot find the spectral axis "
"in '^N'.", status );
}
tile_map = (AstMapping *) astCmpMap( tile_map, specmap, 0, " " );
tile_frm = (AstFrame *) astCmpFrame( tile_frm, specfrm, " " );
}
/* Ensure the Epoch is inherited form the input NDF. */
astSetD( tile_frm, "Epoch", astGetD( iwcs, "Epoch" ) );
/* Currently tile axis 1 is RA, axis 2 is Dec and axis 3 (if present) is
spectral. Append a PermMap that re-orders these tile WCS axes to match
those of the NDF. */
outperm[ axlon - 1 ] = 1;
outperm[ axlat - 1 ] = 2;
outperm[ axspec - 1 ] = 3;
inperm[ 0 ] = axlon;
inperm[ 1 ] = axlat;
inperm[ 2 ] = axspec;
tile_map = (AstMapping *) astCmpMap( tile_map, astPermMap( ndim, inperm,
ndim, outperm,
NULL, " " ),
1, " " );
tile_map = astSimplify( tile_map );
/* Also re-order the WCS axes in the tile frame. */
astPermAxes( tile_frm, outperm );
/* We want the zero-based indicies of the input pixel axes corresponding
to ra, dec and spectral. So find the indicies of the pixel axes in the
supplied NDF that are most closely aligned with each WCS axis. */
atlPairAxes( iwcs, NULL, gcen, NULL, inperm, status );
if( inperm[ 0 ] == axlon ) {
lonax = 0;
} else if( inperm[ 1 ] == axlon ) {
lonax = 1;
} else {
lonax = 2;
}
if( inperm[ 0 ] == axlat ) {
latax = 0;
} else if( inperm[ 1 ] == axlat ) {
latax = 1;
} else {
latax = 2;
}
/* To get the mapping from pixel coords in the input NDF to pixel coords
in the output NDF, we invert the above mapping so that it goes from WCS
to pixel, and append it to the end of the NDF pixel->WCS mapping. */
ndf_map = astGetMapping( iwcs, ipixel, AST__CURRENT );
astInvert( tile_map );
p2pmap = (AstMapping *) astCmpMap( ndf_map, tile_map, 1, " " );
p2pmap = astSimplify( p2pmap );
astInvert( tile_map );
/* Show the bounds of the tile within the input NDF. */
msgOutiff( MSG__DEBUG, "", " tile %d has bounds (%d:%d,%d:%d) "
"within the output NDF.", status, tile_index,
tile_lbnd[ 0 ], tile_ubnd[ 0 ], tile_lbnd[ 1 ],
tile_ubnd[ 1 ] );
/* Next job is to find the pixel bounds of the output NDF to create
which will hold data for the current tile. First map the pixel bounds
of the whole tile from output to input. */
lbnd_in[ 0 ] = tile_lbnd[ 0 ] - 0.5;
lbnd_in[ 1 ] = tile_lbnd[ 1 ] - 0.5;
lbnd_in[ 2 ] = lbnd[ 2 ] - 0.5;
ubnd_in[ 0 ] = tile_ubnd[ 0 ] - 0.5;
ubnd_in[ 1 ] = tile_ubnd[ 1 ] - 0.5;
ubnd_in[ 2 ] = ubnd[ 2 ] - 0.5;
astMapBox( p2pmap, lbnd_in, ubnd_in, 0, 1, lbnd_out + 0,
ubnd_out + 0, NULL, NULL );
astMapBox( p2pmap, lbnd_in, ubnd_in, 0, 2, lbnd_out + 1,
ubnd_out + 1, NULL, NULL );
if( ndim == 3 ) astMapBox( p2pmap, lbnd_in, ubnd_in, 0, 3,
lbnd_out + 2, ubnd_out + 2, NULL,
NULL );
lbnd_tile[ 0 ] = floor( lbnd_out[ 0 ] ) + 1;
lbnd_tile[ 1 ] = floor( lbnd_out[ 1 ] ) + 1;
lbnd_tile[ 2 ] = floor( lbnd_out[ 2 ] ) + 1;
ubnd_tile[ 0 ] = floor( ubnd_out[ 0 ] ) + 1;
ubnd_tile[ 1 ] = floor( ubnd_out[ 1 ] ) + 1;
ubnd_tile[ 2 ] = floor( ubnd_out[ 2 ] ) + 1;
/* Show the bounds of the tile within the input NDF. */
msgOutiff( MSG__DEBUG, "", " tile %d has bounds (%d:%d,%d:%d) "
"within the input NDF.", status, tile_index,
lbnd_tile[ 0 ], ubnd_tile[ 0 ], lbnd_tile[ 1 ],
ubnd_tile[ 1 ] );
/* If required, trim the bounds to the extent of the input NDF. */
if( trim ) {
if( lbnd_tile[ 0 ] < lbnd[ 0 ] ) lbnd_tile[ 0 ] = lbnd[ 0 ];
if( lbnd_tile[ 1 ] < lbnd[ 1 ] ) lbnd_tile[ 1 ] = lbnd[ 1 ];
if( lbnd_tile[ 2 ] < lbnd[ 2 ] ) lbnd_tile[ 2 ] = lbnd[ 2 ];
if( ubnd_tile[ 0 ] > ubnd[ 0 ] ) ubnd_tile[ 0 ] = ubnd[ 0 ];
if( ubnd_tile[ 1 ] > ubnd[ 1 ] ) ubnd_tile[ 1 ] = ubnd[ 1 ];
if( ubnd_tile[ 2 ] > ubnd[ 2 ] ) ubnd_tile[ 2 ] = ubnd[ 2 ];
}
/* Check there is some overlap. */
if( lbnd_tile[ 0 ] <= ubnd_tile[ 0 ] &&
lbnd_tile[ 1 ] <= ubnd_tile[ 1 ] &&
lbnd_tile[ 2 ] <= ubnd_tile[ 2 ] ){
/* Now need to check if this section of the input NDF contains any good
values. We also find the bounding box of the good values (within the
input pixel coordinate system). So first obtain and map the required
section of the input NDF. */
ndfSect( indf, ndim, lbnd_tile, ubnd_tile, &indfs, status );
ndfMap( indfs, "Data", type, "Read", &ipd, &junk, status );
if( var ) ndfMap( indfs, "Variance", type, "Read", &ipv, &junk, status );
if( qual ) ndfMap( indfs, "Quality", "_UBYTE", "Read", (void **) &ipq,
&junk, status );
/* Initialise the pixel bounds (within the input NDF) of the box holding
good data values for the current tile. */
bbox[ 0 ] = INT_MAX;
bbox[ 1 ] = INT_MAX;
bbox[ 2 ] = INT_MAX;
bbox[ 3 ] = -INT_MAX;
bbox[ 4 ] = -INT_MAX;
bbox[ 5 ] = -INT_MAX;
/* Loop round all pixels in the section. */
if( *status == SAI__OK ) {
if( !strcmp( type, "_REAL" ) ) {
pf = (float *) ipd;
for( iz = lbnd_tile[ 2 ]; iz <= ubnd_tile[ 2 ]; iz++ ) {
for( iy = lbnd_tile[ 1 ]; iy <= ubnd_tile[ 1 ]; iy++ ) {
for( ix = lbnd_tile[ 0 ]; ix <= ubnd_tile[ 0 ]; ix++ ) {
if( *(pf++) != VAL__BADR ) {
if( ix < bbox[ 0 ] ) bbox[ 0 ] = ix;
if( iy < bbox[ 1 ] ) bbox[ 1 ] = iy;
if( iz < bbox[ 2 ] ) bbox[ 2 ] = iz;
if( ix > bbox[ 3 ] ) bbox[ 3 ] = ix;
if( iy > bbox[ 4 ] ) bbox[ 4 ] = iy;
if( iz > bbox[ 5 ] ) bbox[ 5 ] = iz;
}
}
}
}
} else {
pd = (double *) ipd;
for( iz = lbnd_tile[ 2 ]; iz <= ubnd_tile[ 2 ]; iz++ ) {
for( iy = lbnd_tile[ 1 ]; iy <= ubnd_tile[ 1 ]; iy++ ) {
for( ix = lbnd_tile[ 0 ]; ix <= ubnd_tile[ 0 ]; ix++ ) {
if( *(pd++) != VAL__BADD ) {
if( ix < bbox[ 0 ] ) bbox[ 0 ] = ix;
if( iy < bbox[ 1 ] ) bbox[ 1 ] = iy;
if( iz < bbox[ 2 ] ) bbox[ 2 ] = iz;
if( ix > bbox[ 3 ] ) bbox[ 3 ] = ix;
if( iy > bbox[ 4 ] ) bbox[ 4 ] = iy;
if( iz > bbox[ 5 ] ) bbox[ 5 ] = iz;
}
}
}
}
}
/* Skip empty tiles. */
if( bbox[ 0 ] != INT_MAX ) {
msgOutf( "", " tile %d", status, tile_index );
/* If required, trim the bounds to the edges of the bounding box. */
if( trim >= 2 ) {
olbnd[ 0 ] = bbox[ 0 ];
olbnd[ 1 ] = bbox[ 1 ];
olbnd[ 2 ] = bbox[ 2 ];
oubnd[ 0 ] = bbox[ 3 ];
oubnd[ 1 ] = bbox[ 4 ];
oubnd[ 2 ] = bbox[ 5 ];
} else {
olbnd[ 0 ] = lbnd_tile[ 0 ];
olbnd[ 1 ] = lbnd_tile[ 1 ];
olbnd[ 2 ] = lbnd_tile[ 2 ];
oubnd[ 0 ] = ubnd_tile[ 0 ];
oubnd[ 1 ] = ubnd_tile[ 1 ];
oubnd[ 2 ] = ubnd_tile[ 2 ];
}
/* Modify these pixel bounds so that they refer to the output NDF. */
lbnd_in[ 0 ] = olbnd[ 0 ] - 0.5;
lbnd_in[ 1 ] = olbnd[ 1 ] - 0.5;
lbnd_in[ 2 ] = olbnd[ 2 ] - 0.5;
ubnd_in[ 0 ] = oubnd[ 0 ] - 0.5;
ubnd_in[ 1 ] = oubnd[ 1 ] - 0.5;
ubnd_in[ 2 ] = oubnd[ 2 ] - 0.5;
astMapBox( p2pmap, lbnd_in, ubnd_in, 1, 1, lbnd_out + 0,
ubnd_out + 0, NULL, NULL );
astMapBox( p2pmap, lbnd_in, ubnd_in, 1, 2, lbnd_out + 1,
ubnd_out + 1, NULL, NULL );
if( ndim == 3 ) astMapBox( p2pmap, lbnd_in, ubnd_in, 1, 3,
lbnd_out + 2, ubnd_out + 2, NULL,
NULL );
olbnd[ 0 ] = floor( lbnd_out[ 0 ] ) + 1;
olbnd[ 1 ] = floor( lbnd_out[ 1 ] ) + 1;
olbnd[ 2 ] = floor( lbnd_out[ 2 ] ) + 1;
oubnd[ 0 ] = floor( ubnd_out[ 0 ] ) + 1;
oubnd[ 1 ] = floor( ubnd_out[ 1 ] ) + 1;
oubnd[ 2 ] = floor( ubnd_out[ 2 ] ) + 1;
/* Get the full path to the output NDF for the current tile, and create an
NDF placeholder for it. */
sprintf( path, "%.*s_%d", nbase, base, tile_index );
ndfPlace( NULL, path, &place, status );
/* Create a new output NDF by copying the meta-data from the input NDF
section. */
ndfScopy( indfs, "Units", &place, &indfo, status );
/* Set the pixel bounds of the output NDF to the values found above and copy
the input data for the current tile into it. */
smf1_jsadicer( indfo, olbnd, oubnd, tile_map, tile_frm, p2pmap,
ipd, ipv, ipq, status );
/* Add the name of this output NDF to the group holding the names of the
output NDFs that have actually been created. */
if( grp ) grpPut1( grp, path, 0, status );
/* Add a TILENUM header to the output FITS extension. */
kpgGtfts( indfo, &fc, status );
if( *status == KPG__NOFTS ) {
errAnnul( status );
fc = astFitsChan( NULL, NULL, " " );
/* If the last card is "END", remove it. */
} else {
astSetI( fc, "Card", astGetI( fc, "NCARD" ) );
keyword = astGetC( fc, "CardName" );
if( keyword && !strcmp( keyword, "END" ) ) astDelFits( fc );
}
one_snprintf(jsatile_comment, 45, "JSA all-sky tile index (Nside=%i)",
status, tiling.ntpf);
atlPtfti( fc, "TILENUM", tile_index, jsatile_comment, status );
kpgPtfts( indfo, fc, status );
fc = astAnnul( fc );
/* Now store an STC-S polygon that describes the shortest boundary
enclosing the good data in the output NDF, and store it as an NDF extension. */
kpgPutOutline( indfo, 0.5, 1, status );
/* We now reshape any extension NDFs contained within the output NDF to
have the same spatial bounds as the main NDF (but only for extension
NDFs that originally have the same spatial bounds as the supplied NDF).
Get a group containing paths to all extension NDFs in the output NDF. */
ndgMoreg( indfo, &grpt, &size, status );
/* Loop round each output extension NDF. */
for( iext = 1; iext <= size && *status == SAI__OK; iext++ ) {
ndgNdfas( grpt, iext, "Update", &indfx, status );
/* Get its bounds. */
ndfBound( indfx, NDF__MXDIM, lbndx, ubndx, &ndimx, status );
/* See if this extension NDF has the same bounds on the spatial axes as
the supplied NDF. */
if( ndimx > 1 && lbndx[ lonax ] == lbnd[ lonax ] &&
lbndx[ latax ] == lbnd[ latax ] &&
ubndx[ lonax ] == ubnd[ lonax ] &&
ubndx[ latax ] == ubnd[ latax ] ) {
/* If so, change the bounds of the output extension NDF so that they are
the same as the main NDF on the spatial axes, and map the original
contents of the NDF onto the new pixel grid. */
smf1_jsadicer( indfx, olbnd, oubnd, tile_map, tile_frm, p2pmap,
NULL, NULL, NULL, status );
}
/* Annul the extension NDF identifier. */
ndfAnnul( &indfx, status );
}
/* Free resources associated with the current tile. */
grpDelet( &grpt, status );
ndfAnnul( &indfo, status );
/* Issue warnings about empty tiles. */
} else {
msgOutiff( MSG__VERB, "", " tile %d is empty and so will not be "
"created", status, tile_index );
}
}
/* Free the section of the input NDF. */
ndfAnnul( &indfs, status );
/* Append the index of this tile in the list of tiles to be created. */
created_tiles = astGrow( created_tiles, ++(*ntile),
sizeof( *created_tiles ) );
if( *status == SAI__OK ) created_tiles[ *ntile - 1 ] = tile_index;
} else {
msgOutiff( MSG__DEBUG, "", " Tile %d does not overlap the input "
"NDF after trimming.", status, tile_index );
}
}
msgBlank( status );
/* Write the indicies of the created tiles out to a parameter. */
if( *ntile ) parPut1i( "JSATILELIST", *ntile, created_tiles, status );
/* Free resources. */
created_tiles = astFree( created_tiles );
tiles = astFree( tiles );
path = astFree( path );
/* End the NDF context. */
ndfEnd( status );
/* End the AST context. */
astEnd;
}
void smf_addpolanal( AstFrameSet *fset, smfHead *hdr, AstKeyMap *config,
int *status ){
/* Local Variables */
AstCmpMap *tmap;
AstFrame *cfrm;
AstFrame *pfrm;
AstFrame *tfrm;
AstFrameSet *tfs;
AstPermMap *pm;
char *polnorth = NULL;
const char *cursys;
const char *trsys;
int aloff;
int icurr;
int inperm[2];
int outperm[2];
int pol2fp;
/* Check inherited status, and also check the supplied angle is not bad. */
if( *status != SAI__OK ) return;
/* Begin an AST object context. */
astBegin;
/* Get the value of the POLNORTH FITS keyword from the supplied header.
The rest only happens if the keyword is found. */
if( astGetFitsS( hdr->fitshdr, "POLNORTH", &polnorth ) ) {
/* Normally, we do not allow maps to be made from Q/U time streams that
use focal plane Y as the reference direction (because of the problems
of sky rotation). Therefore we report an error. However, we do need to
make such maps as part of the process of determining the parameters of
the Instrumental Polarisation (IP) model. So only report the error if
"pol2fp" config parameter is non-zero. */
if( !strcmp( polnorth, "FPLANE" ) ) {
astMapGet0I( config, "POL2FP", &pol2fp );
if( pol2fp ) {
msgBlank( status );
msgOut( "", "WARNING: The input NDFs hold POL-2 Q/U data specified "
"with respect to focal plane Y.",status );
msgOut( "", "Maps should normally be made from POL-2 data specified "
"with respect to celestial north.",status );
msgOut( "", "The output map will not contain a POLANAL Frame and "
"so will be unusable by POLPACK applications.",status );
msgBlank( status );
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "The input NDFs hold POL-2 Q/U data specified with "
"respect to focal plane Y.",status );
errRep( "", "Maps can only be made from POL-2 data specified with "
"respect to celestial north.",status );
}
/* If the ref. direction is celestial north, create a suitable Frame and
Mapping and add them into the supplied FrameSet. */
} else {
/* Check the current Frame is a SkyFrame. */
cfrm = astGetFrame( fset, AST__CURRENT );
if( astIsASkyFrame( cfrm ) ) {
/* Create a POLANAL Frame. */
pfrm = astFrame( 2, "Domain=POLANAL" );
astSet( pfrm, "Title=Polarimetry reference frame" );
astSet( pfrm, "Label(1)=Polarimetry reference direction" );
astSet( pfrm, "Label(2)=" );
/* Create a PermMap that ensures that axis 1 of the POLANAL Frame is parallel
to the latitude axis (i.e. north) of the curent Frame (the current Frame axes
may have been swapped). */
outperm[ 0 ] = astGetI( cfrm, "LatAxis" );
outperm[ 1 ] = astGetI( cfrm, "LonAxis" );
inperm[ outperm[ 0 ] - 1 ] = 1;
inperm[ outperm[ 1 ] - 1 ] = 2;
pm = astPermMap( 2, inperm, 2, outperm, NULL, " " );
/* Record the index of the original current Frame. */
icurr = astGetI( fset, "Current" );
/* Determine the system to use. */
if( !strcmp( polnorth, "TRACKING" ) ) {
trsys = sc2ast_convert_system( hdr->state->tcs_tr_sys, status );
} else {
trsys = polnorth;
}
/* If the current Frame in the supplied FrameSet has this system. Then we
use the above PermMap to connect the POLANAL Frame directly to the current
Frame. */
cursys = astGetC( cfrm, "System" );
if( trsys && cursys && !strcmp( cursys, trsys ) ) {
astAddFrame( fset, AST__CURRENT, pm, pfrm );
/* Otherwise we need to get a Mapping from the current Frame to the
required frame. */
} else {
/* Take a copy of the current Frame (in order to pick up epoch, observatory
position, etc), and set its System to the required system. */
tfrm = astCopy( cfrm );
astSetC( tfrm, "System", trsys );
/* Get the Mapping from the original current Frame to this modified copy.
Ensure alignment happens in absolute coords (alignment in offset
coords is always a unit mapping and so no rotation occurs). */
aloff = astGetI( cfrm, "AlignOffset" );
if( aloff ) {
astSetI( cfrm, "AlignOffset", 0 );
astSetI( tfrm, "AlignOffset", 0 );
}
tfs = astConvert( cfrm, tfrm, "SKY" );
if( aloff ) {
astSetI( cfrm, "AlignOffset", 1 );
astSetI( tfrm, "AlignOffset", 1 );
}
if( tfs ) {
/* Use it, in series with with the above PermMap, to connect the POLANAL frame
to the current Frame. */
tmap = astCmpMap( astGetMapping( tfs, AST__BASE,
AST__CURRENT ),
pm, 1, " " );
astAddFrame( fset, AST__CURRENT, astSimplify( tmap ),
pfrm );
/* Report an error if the mapping from current to required system could
not be found. */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "smf_addpolanal: Could not convert Frame "
"from %s to %s (prgramming error).", status,
cursys, trsys );
}
}
/* Re-instate the original current Frame. */
astSetI( fset, "Current", icurr );
/* Report an error if the current Frame is not a SkyFrame. */
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( "", "smf_addpolanal: The current Frame in the "
"supplied FrameSet is not a SkyFrame (prgramming "
"error).", status );
}
}
}
/* End the AST object context. */
astEnd;
}
