// create a new NDF (simple) structure
static PyObject*
pyndf_new(NDF *self, PyObject *args)
{
// use ultracam defaults
const char *ftype = "_REAL";
int ndim;
PyObject* lb;
PyObject* ub;
if(!PyArg_ParseTuple(args, "siOO:pyndf_new", &ftype, &ndim, &lb, &ub))
return NULL;
if(ndim < 0 || ndim > 7)
return NULL;
// TODO: check for ftype here
int status = SAI__OK;
PyArrayObject* lower = (PyArrayObject*) PyArray_FROM_OTF(lb, NPY_UINT, NPY_IN_ARRAY | NPY_FORCECAST);
PyArrayObject* upper = (PyArrayObject*) PyArray_FROM_OTF(ub, NPY_UINT, NPY_IN_ARRAY | NPY_FORCECAST);
if (!lower || !upper)
return NULL;
if(PyArray_SIZE(lower) != ndim || PyArray_SIZE(upper) != ndim)
return NULL;
errBegin(&status);
ndfNew(ftype,ndim,(int*)PyArray_DATA(lower),(int*)PyArray_DATA(upper),&self->_place,&self->_ndfid,&status); // placeholder annulled by this routine
Py_DECREF(lower);
Py_DECREF(upper);
if (raiseNDFException(&status))
return NULL;
Py_RETURN_NONE;
}
void smf_open_ndfname( const HDSLoc *loc, const char accmode[],
const char extname[], const char state[], const char dattype[],
const int ndims, const int lbnd[], const int ubnd[],
const char datalabel[], const char dataunits[],
const AstFrameSet* wcs,
smfData **ndfdata,
int *status) {
/* Local variables */
void *datarr[] = { NULL, NULL }; /* Pointers for data */
int dims[NDF__MXDIM]; /* Extent of each dimension */
smf_dtype dtype; /* Data type */
int flags = 0; /* Flags for creating smfDA, smfFile and
smfHead components in the output smfData */
int i;
int ndat; /* Number of elements mapped in the requested NDF */
char ndfaccmode[NDF__SZMMD+1];/* Access mode to use to open the file */
int ndimsmapped; /* Number of dimensions in mapped NDF */
int ndfid; /* NDF identifier */
AstFrameSet *ndfwcs = NULL; /* Copy of input FrameSet to write to NDF */
smfFile *newfile = NULL; /* New smfFile with details of requested NDF */
int place; /* Placeholder for NDF */
int updating = 0; /* True if the extension is being updated */
/* Initialize the output smfData to NULL pointer */
*ndfdata = NULL;
if ( *status != SAI__OK ) return;
/* Check to see if the HDS Locator is null and retrieve the NDF id */
if ( loc == NULL ) {
errRep( FUNC_NAME, "Given HDS locator is NULL", status );
return;
}
/* Start be assuming the requested access mode can be used for mapping
and file opening */
one_strlcpy( ndfaccmode, accmode, sizeof(ndfaccmode), status );
/* Note: write access clears the contents of the NDF */
if ( strncmp( accmode, "WRITE", 5 ) == 0 ) {
msgOutif(MSG__DEBUG," ", "Opening NDF with WRITE access: this will clear the current contents if the NDF exists.", status);
updating = 1;
/* We can have WRITE/ZERO or WRITE/BAD so we need to force WRITE
into the NDF open access mode */
one_strlcpy( ndfaccmode, "WRITE", sizeof(ndfaccmode), status );
} else if ( strncmp( accmode, "UPDATE", 6) == 0) {
updating = 1;
}
ndfOpen( loc, extname, ndfaccmode, state, &ndfid, &place, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME,
"Call to ndfOpen failed: unable to obtain an NDF identifier",
status );
return;
}
/* No placeholder => NDF exists */
if ( place != NDF__NOPL ) {
/* Define properties of NDF */
ndfNew( dattype, ndims, lbnd, ubnd, &place, &ndfid, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Unable to create a new NDF", status );
return;
}
}
/* Convert the data type string to SMURF dtype */
dtype = smf_dtype_fromstring( dattype, status );
/* First step is to create an empty smfData with no extra components */
flags |= SMF__NOCREATE_DA;
flags |= SMF__NOCREATE_FTS;
flags |= SMF__NOCREATE_HEAD;
flags |= SMF__NOCREATE_FILE;
*ndfdata = smf_create_smfData( flags, status);
/* Set the requested data type */
(*ndfdata)->dtype = dtype;
/* OK, now map the data array */
ndfMap( ndfid, "DATA", dattype, accmode, &datarr[0], &ndat, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Unable to map data array: invalid NDF identifier?", status );
}
/* Retrieve dimensions of mapped array */
ndfDim( ndfid, NDF__MXDIM, dims, &ndimsmapped, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Problem identifying dimensions of requested NDF", status );
}
/* Consistency check */
if ( ndimsmapped != ndims ) {
if ( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Number of dimensions in new NDF not equal to number of dimensions specified", status );
}
}
if (*status == SAI__OK) {
for (i=0; i<ndims; i++) {
((*ndfdata)->dims)[i] = dims[i];
((*ndfdata)->lbnd)[i] = lbnd[i];
}
}
/* Allow for label, units and WCS to be written */
if (updating) {
if (datalabel) ndfCput( datalabel, ndfid, "Label", status );
if (dataunits) ndfCput( dataunits, ndfid, "Unit", status );
if (wcs) {
/* Take a copy of the input WCS and modify if necessary that
before writing to the NDF */
ndfwcs = astCopy( wcs );
smf_set_moving( (AstFrame *) ndfwcs, NULL, status );
ndfPtwcs( ndfwcs, ndfid, status );
if (ndfwcs) ndfwcs = astAnnul( ndfwcs );
}
}
/* Create the smfFile */
newfile = smf_construct_smfFile( newfile, ndfid, 0, 0, NULL, status );
if ( *status != SAI__OK ) {
errRep( FUNC_NAME, "Unable to construct new smfFile", status );
}
/* And populate the new smfData */
*ndfdata = smf_construct_smfData( *ndfdata, newfile, NULL, NULL, NULL, dtype,
datarr, NULL, SMF__QFAM_NULL, NULL, 0, 1,
(*ndfdata)->dims, (*ndfdata)->lbnd, ndims,
0, 0, NULL, NULL, status );
}
static double *smf1_calc_mapcoord1( smfData *data, dim_t nbolo,
dim_t ntslice, AstSkyFrame *oskyfrm,
int *indf, int axis, int *status ){
/*
* Name:
* smf1_calc_mapcoord1
* Purpose:
* Create and map an NDF to receive the longitude or latitude values
* at every sample.
* Language:
* Starlink ANSI C
* Type of Module:
* C function
* Invocation:
* double *smf1_calc_mapcoord1( smfData *data, dim_t nbolo,
* dim_t ntslice, AstFrame *oskyfrm,
* int *indf, int axis, int *status )
* Arguments:
* data = smfData* (Given)
* Pointer to smfData struct
* nbolo = dim_t (Given)
* The number of bolometers.
* ntslice = dim_t (Given)
* The number of time slices.
* oskyfrm = AstFrame * (Given)
* Pointer to the SkyFrame describing the output spatial cords.
* indf = int * (Returned)
* Address ayt which to return the identifier for the new NDF.
* axis = int (Given)
* Axis of the SkyFrame to use (1 or 2).
* status = int* (Given and Returned)
* Pointer to global status.
* Returned Value:
* Pointer to the mapped DATA array.
* Description:
* This function creates a new NDF with a named formed by appending
* the axis symbol from oskyframe to the end of the file name associated
* with the supplied smfData. The firts pixel axis spans bolometer
* index and the second spans time slice index. The NDF character
* components are set to describe the requested ais values.
*/
/* Local Variables: */
char name[SMF_PATH_MAX+1];
char sym[ 100 ];
const char *label = NULL;
const char *ttl = NULL;
double *result = NULL;
int el;
int place;
int pos_lbnd[2];
int pos_ubnd[2];
/* Check inherited status */
if( *status != SAI__OK ) return result;
/* Check the input file path is known. */
if( data->file ) {
/* Remove any DIMM suffix, and any leading directory from the file path. */
smf_stripsuffix( data->file->name, SMF__DIMM_SUFFIX, name, status );
/* Get the Frame title, and axis label. */
ttl = astGetC( oskyfrm, "Title" );
label = astGetC( oskyfrm, ( axis == 1 ) ? "Label(1)" : "Label(2)" );
/* Get a lower case copy of the axis symbol. */
astChrCase( astGetC( oskyfrm,
( axis == 1 ) ? "Symbol(1)" : "Symbol(2)" ), sym,
0, sizeof(sym) );
/* Append the lower case axis symbol to the file base name. */
one_strlcat( name, "_", SMF_PATH_MAX + 1, status );
one_strlcat( name, sym, SMF_PATH_MAX + 1, status );
/* Store the pixel bounds for the NDF. */
pos_lbnd[ 0 ] = pos_lbnd[ 1 ] = 0;
pos_ubnd[ 0 ] = nbolo - 1;
pos_ubnd[ 1 ] = ntslice - 1;
/* Create the NDF and map its Data array. */
ndfPlace( NULL, name, &place, status );
ndfNew( "_DOUBLE", 2, pos_lbnd, pos_ubnd, &place, indf, status );
ndfMap( *indf, "DATA", "_DOUBLE", "WRITE", (void **) &result, &el,
status );
/* Set the NDF character components. */
ndfCput( ttl, *indf, "TITLE", status );
ndfCput( label, *indf, "LABEL", status );
ndfCput( "deg", *indf, "UNITS", status );
ndfAcput( "Bolometer index", *indf, "LABEL", 1, status );
ndfAcput( "Time slice index", *indf, "LABEL", 2, status );
}
/* Return the pointer to the mapped data array. */
return result;
}
void cupidGCNdfClump( HDSLoc **obj, double sum, double *par, double rms,
int ndim, int *lbox, int *ubox, int list_size,
double *mlist, int *plist, int *lbnd, int iclump,
int *dax, AstKeyMap *extra, int bad, int *status ){
/*
*+
* Name:
* cupidGCNdfClump
* Purpose:
* Create an NDF containing a description of a single clump.
* Language:
* Starlink C
* Synopsis:
* void cupidGCNdfClump( HDSLoc **obj, double sum, double *par, double rms,
* int ndim, int *lbox, int *ubox, int list_size,
* double *mlist, int *plist, int *lbnd, int iclump,
* int *dax, AstKeyMap *extra, int bad,
* int *status )
* Description:
* This function creates a temporary NDF and stores the integrated
* intensity of the clump in its Data component. The bounds of the NDF
* will be the smallest possible which still encompass the clump. In
* addition, if required it will create a Cupid extension in the NDF
* containing
*
* - The parameters of a Gaussian approximation to the clump (if supplied).
* - Any supplied extra information.
* Parameters:
* obj
* A pointer to a locator for an HDS array of NDF objects. The array
* will be extended to accomodate the new NDF. If NULL is supplied a
* new temporary HDS object is created, and the locator stored at the
* given address.
* sum
* The integrated intensity in the clump. Note, unlike par[0] and
* par[1], this value should not be normalised to the RMS noise.
* par
* Pointer to an array holding the parameters of a Gaussian
* approximation to the clump, or NULL. How many of these are used
* depends on the value of "ndim": if "ndim" is 1 only elements 0 to
* 3 are used, if "ndim" is 2 only elements 0 to 6 are used, if "ndim"
* is 3 all elements are used. All axis values are represented in GRID
* pixels:
*
* par[0]: Peak intensity of clump (in units of the RMS noise level).
* par[1]: Constant intensity offset (in units of the RMS noise level).
* par[2]: Model centre on internal axis 0 (in pixels)
* par[3]: Intrinsic FWHM on axis 0 (in pixels)
* par[4]: Model centre on internal axis 1 (in pixels)
* par[5]: Intrinsic FWHM on axis 1 (in pixels)
* par[6]: Spatial orientation angle (in radians, positive from
* +ve GRID1 axis to +ve GRID2 axis).
* par[7]: Model centre on internal axis 3 (velocity) (in pixels)
* par[8]: Intrinsic FWHM on velocity axis (in pixels)
* par[9]: Axis 0 of internal velocity gradient vector (in velocity
* pixels per spatial pixel).
* par[10]: Axis 1 of internal velocity gradient vector (in
* velocity pixels per spatial pixel).
* rms
* The RMS noise level.
* ndim
* The number of pixel axes in the array.
* lbox
* The lower grid index bounds of the area containing the clump
* (using internal axis numbering).
* ubox
* The upper grid index bounds of the area containing the clump
* (using internal axis numbering).
* list_size
* The number of values supplied in mlist and plist.
* mlist
* An array of "list_size" elements containing the clump values at
* each pixel.
* plist
* An array of "ndim*list_size" elements in which each group of
* "ndim" adjacent values forms the grid indices of the corresponding
* value in "mlist". This uses external axis ordering.
* lbnd
* Pointer to array holding the pixel indices of the first pixel in
* the user-supplied NDF (using external axis numbering).
* iclump
* The index of the current clump.
* dax
* Array holding external axis number indexed by internal axis number.
* extra
* An AstKeyMap holding extra diagnositic information to add to the
* clump structure.
* bad
* Set the Unit component of the NDF to "BAD". This is used as a
* flag to indicate that the clump touches too many areas of bad
* pixels.
* status
* Pointer to the inherited status value.
* Copyright:
* Copyright (C) 2009 Science and Technology Facilities Council.
* Copyright (C) 2005,2007 Particle Physics & Astronomy Research 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
* TIMJ: Tim Jenness (JAC, Hawaii)
* {enter_new_authors_here}
* History:
* 10-NOV-2005 (DSB):
* Original version.
* 5-MAR-2007 (DSB):
* Initiaslise "exloc" locator to NULL before calling datFind.
* 13-JAN-2009 (TIMJ):
* DO NOT CAST int* to size_t* since that is not going to work for long.
* 26-JAN-2011 (DSB):
* Ensure the "m" pointer is incremented even if the currrent model pixel
* is off the edge of the NDF. Previously, this bug caused a stripey
* "aliasing" type effect if the supplied model data extends outside the
* bounds of the NDF.
* 25-MAY-2017 (DSB):
* Switch off group history and provenance recording during this
* function. This is because it can inflate the time taken to run
* findclumps enormously if there are many thousands of clumps.
* {enter_further_changes_here}
* Bugs:
* {note_any_bugs_here}
*-
*/
/* Local Variables: */
const char *cen[] = { "CENTRE1", "CENTRE2", "CENTRE3" };
const char *fwhm[] = { "FWHM1", "FWHM2", "FWHM3" };
const char *vgrad[] = { "VGRAD1", "VGRAD2", "VGRAD3" };
HDSLoc *cloc; /* Cell locator */
HDSLoc *dloc; /* Component locator */
HDSLoc *xloc; /* Extension locator */
HDSLoc *exloc; /* Locator for structure holding extra info */
const char *key; /* KeyMap key name */
double *ipd; /* Pointer to Data array */
double *m; /* Pointer to next data value */
double dval; /* Double value to store */
int *p; /* Pointer to next grid axis value */
int el; /* Number of elements mapped */
int elb[ 3 ]; /* The lower NDF limit on each external axis */
int elbox[ 3 ]; /* The lower box limit on each external axis */
int estep[ 3 ]; /* The step size on each external axis */
int eub[ 3 ]; /* The upper NDF limit on each external axis */
int eubox[ 3 ]; /* The upper box limit on each external axis */
int i; /* Point index */
int indf; /* NDF identifier */
int iv; /* 1D vector index for current data value */
int j; /* Axis index */
int lb[ 3 ]; /* Lower pixel index bounds of NDF */
int nex; /* No. of extra items of information */
int ok; /* Pixel within clump NDF? */
int old_ghstate; /* Non-zero if group history recording is switched on */
int old_pvstate; /* Non-zero if provenance recording is switched on */
int place; /* NDF place holder */
int pv; /* Pixel offset */
size_t oldsize; /* Size of original NDF */
hdsdim size[1]; /* No of elements in NDF array */
int step[ 3 ]; /* The step size on each internal axis */
int ub[ 3 ]; /* Upper pixel index bounds of NDF */
/* Abort if an error has already occurred. */
if( *status != SAI__OK ) return;
/* If no array was supplied create one of length 1. */
if( !(*obj) ) {
size[0] = 1;
datTemp( "NDF", 1, size, obj, status );
/* Otherwise, get the number of NDFs already in the supplied array of
NDFs, and increase it by 1. */
} else {
datSize( *obj, &oldsize, status );
size[0] = oldsize + 1;
datAlter( *obj, 1, size, status );
}
/* Get a locator for the new cell. */
cloc = NULL;
datCell( *obj, 1, size, &cloc, status );
/* Begin an NDF context */
ndfBegin();
/* Temporaily switch off group history and provenance recording since there
can be thousands of clump NDFs. */
ndgHltgh( 0, &old_ghstate, status );
ndgHltpv( 0, &old_pvstate, status );
/* Find the pixel index bounds of the NDF and the step between adjacent
pixels on each axis. */
lb[ 0 ] = lbox[ 0 ] - 1 + lbnd[ dax[ 0 ] ];
ub[ 0 ] = ubox[ 0 ] - 1 + lbnd[ dax[ 0 ] ];
step[ 0 ] = 1;
for( i = 1; i < ndim; i++ ) {
lb[ i ] = lbox[ i ] - 1 + lbnd[ dax[ i ] ];
ub[ i ] = ubox[ i ] - 1 + lbnd[ dax[ i ] ];
step[ i ] = ( ub[ i - 1 ] - lb[ i - 1 ] + 1 )*step[ i - 1 ];
}
/* Convert lbox, lb, ub and step from internal axis numbering to external axis
numbering. */
for( i = 0; i < ndim; i++ ) {
elbox[ dax[ i ] ] = lbox[ i ];
eubox[ dax[ i ] ] = ubox[ i ];
elb[ dax[ i ] ] = lb[ i ];
eub[ dax[ i ] ] = ub[ i ];
estep[ dax[ i ] ] = step[ i ];
}
/* Create a place holder for the new NDF within the new cell. The NDF will be
copied to its final resting place before the program exits. */
ndfPlace( cloc, " ", &place, status );
/* Create the NDF to receive the clump values. The size of this NDF is the
minimum needed to contain the clump. */
ndfNew( "_DOUBLE", ndim, elb, eub, &place, &indf, status );
/* Map the NDFs Data array, filling it with bad values. */
ndfMap( indf, "DATA", "_DOUBLE", "WRITE/BAD", (void *) &ipd, &el, status );
if( ipd ) {
/* Store every supplied model value in the NDF data array. */
m = mlist;
p = plist;
for( i = 0; i < list_size; i++,m++ ) {
/* Find the 1D vector index into the NDF data array corresponding to the
grid indices (within the user supplied NDF) of the current point.*/
pv = *(p++);
iv = pv - elbox[ 0 ];
ok = ( pv >= elbox[ 0 ] && pv <= eubox[ 0 ] );
for( j = 1; j < ndim; j++ ) {
pv = *(p++);
iv += ( pv - elbox[ j ] )*estep[ j ];
if( pv < elbox[ j ] || pv > eubox[ j ] ) ok = 0;
}
/* Store the value. */
if( ok ) ipd[ iv ] = *m;
}
/* Unmap the NDFs Data array. */
ndfUnmap( indf, "DATA", status );
}
/* If required, create a Cupid extension in the NDF. */
if( par || extra ) {
xloc = NULL;
ndfXnew( indf, "CUPID", "CUPID_EXT", 0, NULL, &xloc, status );
/* First do Gaussian parameters. */
if( par ) {
/* Store the integrated intensity in the clump. */
dloc = NULL;
datNew( xloc, "SUM", "_DOUBLE", 0, NULL, status );
datFind( xloc, "SUM", &dloc, status );
datPutD( dloc, 0, NULL, &sum, status );
datAnnul( &dloc, status );
/* Store the parameters of the Gaussian approximation, taking out the
normalisation by the RMS noise level.*/
datNew( xloc, "PEAK", "_DOUBLE", 0, NULL, status );
datFind( xloc, "PEAK", &dloc, status );
dval = rms*par[ 0 ];
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
datNew( xloc, "OFFSET", "_DOUBLE", 0, NULL, status );
datFind( xloc, "OFFSET", &dloc, status );
dval = rms*par[ 1 ];
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
datNew( xloc, cen[ dax[ 0 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, cen[ dax[ 0 ] ], &dloc, status );
dval = par[ 2 ] + lbnd[ dax[ 0 ] ] - 1.5;
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
datNew( xloc, fwhm[ dax[ 0 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, fwhm[ dax[ 0 ] ], &dloc, status );
datPutD( dloc, 0, NULL, par + 3, status );
datAnnul( &dloc, status );
if( ndim > 1 ) {
datNew( xloc, cen[ dax[ 1 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, cen[ dax[ 1 ] ], &dloc, status );
dval = par[ 4 ] + lbnd[ dax[ 1 ] ] - 1.5;
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
datNew( xloc, fwhm[ dax[ 1 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, fwhm[ dax[ 1 ] ], &dloc, status );
datPutD( dloc, 0, NULL, par + 5, status );
datAnnul( &dloc, status );
datNew( xloc, "ANGLE", "_DOUBLE", 0, NULL, status );
datFind( xloc, "ANGLE", &dloc, status );
dval = par[ 6 ]*AST__DR2D;
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
if( ndim > 2 ) {
datNew( xloc, cen[ dax[ 2 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, cen[ dax[ 2 ] ], &dloc, status );
dval = par[ 7 ] + lbnd[ dax[ 2 ] ] - 1.5;
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
datNew( xloc, fwhm[ dax[ 2 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, fwhm[ dax[ 2 ] ], &dloc, status );
datPutD( dloc, 0, NULL, par + 8, status );
datAnnul( &dloc, status );
datNew( xloc, vgrad[ dax[ 0 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, vgrad[ dax[ 0 ] ], &dloc, status );
datPutD( dloc, 0, NULL, par + 9, status );
datAnnul( &dloc, status );
datNew( xloc, vgrad[ dax[ 1 ] ], "_DOUBLE", 0, NULL, status );
datFind( xloc, vgrad[ dax[ 1 ] ], &dloc, status );
datPutD( dloc, 0, NULL, par + 10, status );
datAnnul( &dloc, status );
}
}
}
/* Now store any extra diagnostic information. */
if( extra ) {
datNew( xloc, "EXTRA", "EXTRA", 0, NULL, status );
exloc = NULL;
datFind( xloc, "EXTRA", &exloc, status );
nex = astMapSize( extra );
for( i = 0; i < nex; i++ ) {
key = astMapKey( extra, i );
if( astMapGet0D( extra, key, &dval ) ) {
datNew( exloc, key, "_DOUBLE", 0, NULL, status );
datFind( exloc, key, &dloc, status );
datPutD( dloc, 0, NULL, &dval, status );
datAnnul( &dloc, status );
}
}
datAnnul( &exloc, status );
}
/* Release the extension locator. */
datAnnul( &xloc, status );
}
/* If required set the Unit component to "BAD". */
if( bad ) ndfCput( "BAD", indf, "Unit", status );
/* Switch group history and provenance recording back to their original
states. */
ndgHltgh( old_ghstate, NULL, status );
ndgHltpv( old_pvstate, NULL, status );
/* End the NDF context */
ndfEnd( status );
/* Release the cell locator. */
datAnnul( &cloc, status );
}
void smurf_jsatileinfo( int *status ) {
/* Local Variables */
AstCmpRegion *overlap;
AstFitsChan *fc;
AstFrameSet *fs;
AstObject *obj;
AstRegion *region;
AstRegion *target;
HDSLoc *cloc = NULL;
HDSLoc *xloc = NULL;
char *jcmt_tiles;
char *tilendf = NULL;
char text[ 200 ];
double dec[ 8 ];
double dist;
double dlbnd[ 2 ];
double dubnd[ 2 ];
double gx[ 8 ];
double gy[ 8 ];
double maxdist;
double norm_radec[2];
double point1[ 2 ];
double point2[ 2 ];
double ra[ 8 ];
double ra0;
double dec0;
int *ipntr;
int axes[ 2 ];
int create;
int dirlen;
int el;
int exists;
int flag;
int i;
int indf1;
int indf2;
int indf3;
int itile;
int iv;
int jtile;
int lbnd[ 2 ];
int local_origin;
int nc;
int place;
int tlbnd[ 2 ];
int tubnd[ 2 ];
int ubnd[ 2 ];
smf_jsaproj_t proj;
int xt;
int yt;
smfJSATiling skytiling;
void *pntr;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Start a new AST context. */
astBegin;
/* Get the instrument to use abnd get the parameters describing the
layout of its JSA tiles. */
smf_jsainstrument( "INSTRUMENT", NULL, SMF__INST_NONE, &skytiling,
status );
/* Return the maximum tile index. */
parPut0i( "MAXTILE", skytiling.ntiles - 1, status );
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Decide what sort of projection to use. */
parChoic( "PROJ", "HPX", "HPX,HPX12,XPHN,XPHS", 1, text, sizeof(text),
status );
proj = smf_jsaproj_fromstr( text, 1, status );
/* If required, create an all-sky NDF in which each pixel covers the area
of a single tile, and holds the integer tile index. The NDF has an
initial size of 1x1 pixels, but is expanded later to the required size. */
lbnd[ 0 ] = ubnd[ 0 ] = lbnd[ 1 ] = ubnd[ 1 ] = 1;
ndfCreat( "ALLSKY", "_INTEGER", 2, lbnd, ubnd, &indf3, status );
/* If a null (!) value was supplied for parameter ALLSKY, annull the
error and pass on. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, create a FrameSet describing the whole sky in which each
pixel corresponds to a single tile. */
} else {
smf_jsatile( -1, &skytiling, 0, proj, NULL, &fs, NULL, lbnd, ubnd,
status );
/* Change the bounds of the output NDF. */
ndfSbnd( 2, lbnd, ubnd, indf3, status );
/* Store the FrameSet in the NDF. */
ndfPtwcs( fs, indf3, status );
/* Map the data array. */
ndfMap( indf3, "Data", "_INTEGER", "WRITE/BAD", (void **) &ipntr, &el,
status );
/* Create all-sky map using XPH projection. */
if( *status == SAI__OK ) {
/* Loop round every tile index. */
for( jtile = 0; jtile < skytiling.ntiles; jtile++ ) {
/* Get the zero-based (x,y) indices of the tile within an HPX projection.
This flips the bottom left half-facet up to the top right. */
smf_jsatilei2xy( jtile, &skytiling, &xt, &yt, NULL, status );
/* Convert these HPX indices to the corresponding indices within the
required projection. Note, the lower left facet is split by the above
call to smf_jsatilei2xy tile (i.e. (xt,yt) indices are *not* in the
"raw" mode). For instance, (0,0) is not a valid tile. */
smf_jsatilexyconv( &skytiling, proj, xt, yt, 0, &xt, &yt, status );
/* Get the vector index of the corresponding element of the all-sky NDF. */
if( proj == SMF__JSA_HPX || proj == SMF__JSA_HPX12 ) {
iv = xt + 5*skytiling.ntpf*yt;
} else {
iv = xt + 4*skytiling.ntpf*yt;
}
/* Report an error if this element has already been assigned a tile
index. Otherwise, store the tile index. */
if( ipntr[ iv ] == VAL__BADI ) {
ipntr[ iv ] = jtile;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "%s projection assigns multiple tiles to "
"pixel (%d,%d).", status, text, xt, yt );
break;
}
}
}
/* Store NDF title. */
sprintf( text, "JSA tile indices for %s data", skytiling.name );
ndfCput( text, indf3, "TITLE", status );
/* Store the instrument as a component in the SMURF extension. */
ndfXnew( indf3, "SMURF", "INSTRUMENT", 0, 0, &xloc, status );
ndfXpt0c( skytiling.name, indf3, "SMURF", "INSTRUMENT", status );
datAnnul( &xloc, status );
/* Close the NDF. */
ndfAnnul( &indf3, status );
}
/* Abort if an error has occurred. */
if( *status != SAI__OK ) goto L999;
/* Get the zero-based index of the required tile. If a null value is
supplied, annull the error and skip to the end. */
parGdr0i( "ITILE", 0, 0, skytiling.ntiles - 1, 0, &itile, status );
if( *status == PAR__NULL ) {
errAnnul( status );
goto L999;
}
/* See if the pixel origin is to be at the centre of the tile. */
parGet0l( "LOCAL", &local_origin, status );
/* Display the tile number. */
msgBlank( status );
msgSeti( "ITILE", itile );
msgSeti( "MAXTILE", skytiling.ntiles - 1);
msgOut( " ", " Tile ^ITILE (from 0 to ^MAXTILE):", status );
/* Get the FITS header, FrameSet and Region defining the tile, and the tile
bounds in pixel indices. */
smf_jsatile( itile, &skytiling, local_origin, proj, &fc, &fs, ®ion,
lbnd, ubnd, status );
/* Write the FITS headers out to a file, annulling the error if the
header is not required. */
if( *status == SAI__OK ) {
atlDumpFits( "HEADER", fc, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* If required, write the Region out to a text file. */
if( *status == SAI__OK ) {
atlCreat( "REGION", (AstObject *) region, status );
if( *status == PAR__NULL ) errAnnul( status );
}
/* Store the lower and upper pixel bounds of the tile. */
parPut1i( "LBND", 2, lbnd, status );
parPut1i( "UBND", 2, ubnd, status );
/* Display pixel bounds on the screen. */
msgSeti( "XL", lbnd[ 0 ] );
msgSeti( "XU", ubnd[ 0 ] );
msgSeti( "YL", lbnd[ 1 ] );
msgSeti( "YU", ubnd[ 1 ] );
msgOut( " ", " Pixel bounds: (^XL:^XU,^YL:^YU)", status );
/* Get the RA,Dec at the tile centre. */
if( astTest( fs, "SkyRef" ) ) {
ra0 = astGetD( fs, "SkyRef(1)" );
dec0 = astGetD( fs, "SkyRef(2)" );
/* Format the central RA and Dec. and display. Call astNorm on the
coordinates provided that the frame set has the correct number of
axes (which it should as it comes from smf_jsatile). */
norm_radec[0] = ra0;
norm_radec[1] = dec0;
if (astGetI(fs, "Naxes") == 2) astNorm(fs, norm_radec);
msgSetc( "RACEN", astFormat( fs, 1, norm_radec[ 0 ] ));
msgSetc( "DECCEN", astFormat( fs, 2, norm_radec[ 1 ] ));
msgOut( " ", " Centre (ICRS): RA=^RACEN DEC=^DECCEN", status );
/* Transform a collection of points on the edge of the region (corners and
side mid-points) from GRID coords to RA,Dec. */
point1[ 0 ] = 0.5;
point1[ 1 ] = 0.5;
point2[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
point2[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
gx[ 0 ] = point1[ 0 ]; /* Bottom left */
gy[ 0 ] = point1[ 1 ];
gx[ 1 ] = point1[ 0 ]; /* Centre left */
gy[ 1 ] = gy[ 0 ];
gx[ 2 ] = point1[ 0 ]; /* Top left */
gy[ 2 ] = point2[ 1 ];
gx[ 3 ] = gx[ 0 ]; /* Top centre */
gy[ 3 ] = point2[ 1 ];
gx[ 4 ] = point2[ 0 ]; /* Top right */
gy[ 4 ] = point2[ 1 ];
gx[ 5 ] = point2[ 0 ]; /* Centre right */
gy[ 5 ] = gy[ 0 ];
gx[ 6 ] = point2[ 0 ]; /* Bottom right */
gy[ 6 ] = point1[ 1 ];
gx[ 7 ] = gx[ 0 ]; /* Bottom centre */
gy[ 7 ] = point1[ 1 ];
astTran2( fs, 8, gx, gy, 1, ra, dec );
/* Find the arc-distance from the centre to the furthest point from the
centre. */
point1[ 0 ] = ra0;
point1[ 1 ] = dec0;
maxdist = -1.0;
for( i = 1; i < 8; i++ ) {
if( ra[ i ] != AST__BAD && dec[ i ] != AST__BAD ) {
point2[ 0 ] = ra[ i ];
point2[ 1 ] = dec[ i ];
dist = astDistance( fs, point1, point2 );
if( dist > maxdist ) maxdist = dist;
}
}
/* Convert from radius to diameter. */
maxdist *= 2.0;
/* Format this size as a dec value (i.e. arc-distance) and display it. */
if( maxdist > 0.0 ) {
msgSetc( "SIZE", astFormat( fs, 2, maxdist ) );
msgOut( " ", " Size: ^SIZE", status );
} else {
maxdist = AST__BAD;
msgOut( " ", " Size: <unknown>", status );
}
/* If a discontinuity passes through the tile, the centre and size may be
unknown. */
} else {
ra0 = AST__BAD;
dec0 = AST__BAD;
maxdist = AST__BAD;
msgOut( " ", " Centre (ICRS): RA=<unknown> DEC=<unknown>", status );
msgOut( " ", " Size: <unknown>", status );
}
/* Write the tile centre ra and dec in radians to the output parameters. */
parPut0d( "RACEN", norm_radec[ 0 ], status );
parPut0d( "DECCEN", norm_radec[ 1 ], status );
/* Write the size to the output parameter as radians. */
parPut0d( "SIZE", maxdist, status );
/* Get the translation of the environment variable JSA_TILE_DIR. */
jcmt_tiles = getenv( "JSA_TILE_DIR" );
/* Initialise the path to the tile's NDF to hold the root directory.
Use the current working directory if JSA_TILE_DIR is undefined. */
if( jcmt_tiles ) {
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
} else {
nc = 512;
jcmt_tiles = astMalloc( nc );
while( !getcwd( jcmt_tiles, nc ) ) {
nc *= 2;
jcmt_tiles = astRealloc( jcmt_tiles, nc );
}
nc = 0;
tilendf = astAppendString( tilendf, &nc, jcmt_tiles );
jcmt_tiles = astFree( jcmt_tiles );
}
/* Complete the path to the tile's NDF. */
tilendf = astAppendString( tilendf, &nc, "/" );
tilendf = astAppendString( tilendf, &nc, skytiling.subdir );
dirlen = nc;
sprintf( text, "/tile_%d.sdf", itile );
tilendf = astAppendString( tilendf, &nc, text );
/* Write it to the output parameter. */
parPut0c( "TILENDF", tilendf, status );
/* See if the NDF exists, and store the flag in the output parameter. */
exists = access( tilendf, F_OK ) ? 0 : 1;
parPut0l( "EXISTS", exists, status );
/* If the NDF does not exist, create it if required. */
parGet0l( "CREATE", &create, status );
if( !exists && create && *status == SAI__OK ) {
/* Write the NDF info to the screen. */
msgSetc( "NDF", tilendf );
msgOutif( MSG__NORM, " ", " NDF: ^NDF (created)", status );
/* Temporarily terminate the NDF path at the end of the subdirectory. */
tilendf[ dirlen ] = 0;
/* Create the required directory (does nothing if the directory
already exists). It is given read/write/search permissions for owner
and group, and read/search permissions for others. */
(void) mkdir( tilendf, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH );
/* Replace the character temporarily overwritten above. */
tilendf[ dirlen ] = '/';
/* Now create the tile's NDF. */
ndfPlace( NULL, tilendf, &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf1, status );
/* Fill its data array with zeros. */
ndfMap( indf1, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
/* Store the WCS FrameSet. */
ndfPtwcs( fs, indf1, status );
/* If the instrument jsatiles.have variance, fill the variance array with zeros. */
if( skytiling.var ) {
ndfMap( indf1, "Variance", skytiling.type, "WRITE/ZERO", &pntr,
&el, status );
}
/* Create a SMURF extension. */
ndfXnew( indf1, SMURF__EXTNAME, SMURF__EXTTYPE, 0, NULL, &xloc, status );
/* Store the tile number and instrument name in the extension. */
datNew0I( xloc, "TILE", status );
datFind( xloc, "TILE", &cloc, status );
datPut0I( cloc, itile, status );
datAnnul( &cloc, status );
datNew0C( xloc, "INSTRUMENT", strlen( skytiling.name ), status );
datFind( xloc, "INSTRUMENT", &cloc, status );
datPut0C( cloc, skytiling.name, status );
datAnnul( &cloc, status );
/* Create a weights NDF within the SMURF extension, and fill its data
array with zeros. */
ndfPlace( xloc, "WEIGHTS", &place, status );
ndfNew( skytiling.type, 2, lbnd, ubnd, &place, &indf2, status );
ndfMap( indf2, "Data", skytiling.type, "WRITE/ZERO", &pntr, &el,
status );
ndfPtwcs( fs, indf2, status );
ndfAnnul( &indf2, status );
/* Annul the extension locator and the main NDF identifier. */
datAnnul( &xloc, status );
ndfAnnul( &indf1, status );
/* Write the NDF info to the screen. */
} else {
msgSetc( "NDF", tilendf );
msgSetc( "E", exists ? "exists" : "does not exist" );
msgOut( " ", " NDF: ^NDF (^E)", status );
}
/* Initialise TBND and TLBND to indicate no overlap. */
tlbnd[ 0 ] = 1;
tlbnd[ 1 ] = 1;
tubnd[ 0 ] = 0;
tubnd[ 1 ] = 0;
/* Attempt to to get an AST Region (assumed to be in some 2D sky coordinate
system) using parameter "TARGET". */
if( *status == SAI__OK ) {
kpg1Gtobj( "TARGET", "Region",
(void (*)( void )) F77_EXTERNAL_NAME(ast_isaregion),
&obj, status );
/* Annul the error if none was obtained. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* Otherwise, use the supplied object. */
} else {
target = (AstRegion *) obj;
/* If the target Region is 3-dimensional, remove the third axis, which
is assumed to be a spectral axis. */
if( astGetI( target, "Naxes" ) == 3 ) {
axes[ 0 ] = 1;
axes[ 1 ] = 2;
target = astPickAxes( target, 2, axes, NULL );
}
/* See if there is any overlap between the target and the tile. */
overlap = NULL;
flag = astOverlap( region, target );
if( flag == 0 ) {
msgOut( "", " Cannot convert between the coordinate system of the "
"supplied target and the tile.", status );
} else if( flag == 1 || flag == 6 ) {
msgOut( "", " There is no overlap between the target and the tile.",
status );
} else if( flag == 2 ) {
msgOut( "", " The tile is contained within the target.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( flag == 3 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 4 ) {
overlap = astCmpRegion( region, target, AST__AND, " " );
} else if( flag == 5 ) {
msgOut( "", " The target and tile are identical.",
status );
tlbnd[ 0 ] = lbnd[ 0 ];
tlbnd[ 1 ] = lbnd[ 1 ];
tubnd[ 0 ] = ubnd[ 0 ];
tubnd[ 1 ] = ubnd[ 1 ];
} else if( *status == SAI__OK ) {
*status = SAI__OK;
errRepf( "", "Unexpected value %d returned by astOverlap "
"(programming error).", status, flag );
}
/* If a region containing the intersection of the tile and target was
created above, map it into the grid coordinate system of the tile. */
if( overlap ) {
overlap = astMapRegion( overlap, astGetMapping( fs, AST__CURRENT,
AST__BASE ),
astGetFrame( fs, AST__BASE ) );
/* Get its GRID bounds. */
astGetRegionBounds( overlap, dlbnd, dubnd );
/* Convert to integer. */
tlbnd[ 0 ] = ceil( dlbnd[ 0 ] - 0.5 );
tlbnd[ 1 ] = ceil( dlbnd[ 1 ] - 0.5 );
tubnd[ 0 ] = ceil( dubnd[ 0 ] - 0.5 );
tubnd[ 1 ] = ceil( dubnd[ 1 ] - 0.5 );
/* Convert to PIXEL indices within the tile. */
tlbnd[ 0 ] += lbnd[ 0 ] - 1;
tlbnd[ 1 ] += lbnd[ 1 ] - 1;
tubnd[ 0 ] += lbnd[ 0 ] - 1;
tubnd[ 1 ] += lbnd[ 1 ] - 1;
msgOutf( "", " The target overlaps section (%d:%d,%d:%d).",
status, tlbnd[ 0 ], tubnd[ 0 ], tlbnd[ 1 ], tubnd[ 1 ] );
}
}
}
/* Store the pixel index bounds of the tiles overlap with the target. */
parPut1i( "TLBND", 2, tlbnd, status );
parPut1i( "TUBND", 2, tubnd, status );
/* Arrive here if an error occurs. */
L999:;
/* Free resources. */
tilendf = astFree( tilendf );
/* End the AST context. */
astEnd;
/* Issue a status indication.*/
msgBlank( status );
if( *status == SAI__OK ) {
msgOutif( MSG__VERB, "", "JSATILEINFO succeeded.", status);
} else {
msgOutif( MSG__VERB, "", "JSATILEINFO failed.", status);
}
}
void smf_store_image( smfData *data, HDSLoc *scu2redloc, int cycle, int ndim,
int dims[], int nsampcycle, int vxmin, int vymin,
double *image, double *zero, int *status) {
smfHead *hdr = NULL; /* Pointer to header struct */
HDSLoc *bz_imloc = NULL; /* HDS locator */
int bzindf; /* NDF identifier for bolometer zero points */
double *bzptr = NULL; /* Pointer to mapped space for zero points */
int el; /* Number of elements mapped */
int frame; /* Mean timeslice index for image */
AstFitsChan *imfits=NULL; /* FITS header for each reconstructed image */
char imname[DAT__SZNAM]; /* Name of structure for image */
double *imptr = NULL; /* Pointer to mapped space for image */
int j; /* Loop counter */
int lbnd[2]; /* Lower dimension bounds */
int ntot; /* Total number of elements */
int place; /* NDF placeholder */
char prvname[2*PAR__SZNAM +1]; /* Provenance creator */
int seqend; /* End index */
int seqstart; /* Starting index */
int slice; /* Index of current time slice */
int strnum; /* Structure element number */
sc2ast_subarray_t subnum; /* Subarray index number */
int ubnd[2]; /* Upper dimension bounds */
int uindf; /* NDF identifier */
AstFrameSet *wcs = NULL; /* WCS info */
if ( *status != SAI__OK ) return;
seqstart = cycle * nsampcycle;
seqend = seqstart + nsampcycle - 1;
slice = (int)( (seqstart + seqend ) /2);
smf_tslice_ast( data, slice, 1, status);
astBegin;
/* Old beginning */
/* Get structure for nth constructed image */
strnum = cycle + 1;
sprintf ( imname, "I%d", strnum );
ntot = 1;
for ( j=0; j<ndim; j++ ) {
lbnd[j] = 1;
ubnd[j] = lbnd[j] + dims[j] - 1;
ntot *= dims[j];
}
ndfPlace ( scu2redloc, imname, &place, status );
ndfNew ( "_DOUBLE", ndim, lbnd, ubnd, &place, &uindf, status );
ndfHcre ( uindf, status );
/* Map the data array */
ndfMap ( uindf, "DATA", "_DOUBLE", "WRITE", (void *)&imptr, &el,
status );
/* Copy image array */
if ( *status == SAI__OK ) {
memcpy( imptr, image, ntot*sizeof(*imptr));
}
/* Derive WCS */
hdr = data->hdr;
smf_find_subarray(hdr, NULL, 0, &subnum, status );
sc2ast_createwcs( subnum, hdr->state, hdr->instap, hdr->telpos, &wcs, status );
/* Shift the coord frame is either vxmin or vymin is non-zero */
if ( vxmin != 0 || vymin != 0 ) {
sc2ast_moveframe ( -(double)vxmin, -(double)vymin, wcs, status );
}
/* This should probably be a user-option but ICRS is probably a safe
assumption */
sc2ast_set_output_system( hdr->state->tcs_tr_sys, wcs, status );
/* Sort out provenance. */
smf_get_taskname( NULL, prvname, status );
smf_updateprov( uindf, data, NDF__NOID, prvname, NULL, status );
/* Store world coordinate transformations */
ndfPtwcs ( wcs, uindf, status );
/* Store the bolometer zero points as an NDF in the extension */
if (zero) {
ndfXnew ( uindf, "BOLZERO", "SCUBA2_ZER_ARR", 0, 0, &bz_imloc,
status );
ndfPlace ( bz_imloc, "ZERO", &place, status );
/* Create the array for bolometer zeros */
lbnd[0] = SC2STORE__BOL_LBND;
ubnd[0] = lbnd[0] + dims[0] - 1;
lbnd[1] = SC2STORE__BOL_LBND;
ubnd[1] = lbnd[1] + dims[1] - 1;
ndfNew ( "_DOUBLE", 2, lbnd, ubnd, &place, &bzindf, status );
ndfHcre ( bzindf, status );
/* Map the data array */
ndfMap ( bzindf, "DATA", "_DOUBLE", "WRITE", (void *)&bzptr, &el,
status );
/* Copy image array */
if ( *status == SAI__OK ) {
memcpy( bzptr, zero, dims[0]*dims[1]*sizeof(*zero));
}
/* Unmap the data array */
ndfUnmap ( bzindf, "DATA", status );
ndfAnnul ( &bzindf, status );
/* Free the locators for the frame */
datAnnul ( &bz_imloc, status );
}
/* Store the FITS headers */
frame = (int)( (seqstart + seqend ) /2);
/* Quick and dirty method - just copy the full FITS header */
imfits = astCopy( hdr->fitshdr );
astSetFitsI( imfits, "SUBSCAN", strnum,
"Subscan number of reconstructed image", 0);
kpgPtfts( uindf, imfits, status );
/* Unmap the data array */
ndfUnmap ( uindf, "DATA", status );
ndfAnnul ( &uindf, status );
astEnd;
}
void smf_calc_iqu( ThrWorkForce *wf, smfData *data, int block_start,
int block_end, int ipolcrd, int qplace, int uplace,
int iplace, NdgProvenance *oprov, AstFitsChan *fc,
int pasign, double paoff, double angrot, int submean,
int *status ){
/* Local Variables: */
AstFrameSet *wcs; /* WCS FrameSet for output NDFs */
AstWinMap *wm; /* Mapping to reverse the X GRID axis */
const JCMTState *state; /* JCMTState info for current time slice */
dim_t nbolo; /* No. of bolometers */
dim_t ncol; /* No. of columns of bolometers */
dim_t nrow; /* No. of rows of bolometers */
dim_t ntslice; /* Number of time-slices in data */
double *ipi; /* Pointer to output I array */
double *ipq; /* Pointer to output Q array */
double *ipu; /* Pointer to output U array */
double ina[ 2 ]; /* Bolometer coords at bottom left */
double inb[ 2 ]; /* Bolometer coords at top right */
double outa[ 2 ]; /* NDF GRID coords at bottom left */
double outb[ 2 ]; /* NDF GRID coords at top right */
int bstep; /* Bolometer step between threads */
int el; /* Number of mapped array elements */
int indfi; /* Identifier for NDF holding I values */
int indfq; /* Identifier for NDF holding Q values */
int indfu; /* Identifier for NDF holding Q values */
int itime; /* Time slice index */
int iworker; /* Index of a worker thread */
int lbnd[ 2 ]; /* Lower pixel bounds of output NDF */
int ntime; /* Time slices to check */
int nworker; /* No. of worker threads */
int old; /* Data has old-style POL_ANG values? */
int ubnd[ 2 ]; /* Upper pixel bounds of output NDF */
size_t bstride; /* Stride between adjacent bolometer values */
size_t tstride; /* Stride between adjacent time slice values */
smfCalcIQUJobData *job_data = NULL; /* Pointer to all job data */
smfCalcIQUJobData *pdata = NULL;/* Pointer to next job data */
smfHead *hdr; /* Pointer to data header this time slice */
double *mean;
int tstep; /* Time slice step between threads */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Convenience pointers. */
hdr = data->hdr;
/* Obtain number of time slices - will also check for 3d-ness. Also get
the dimensions of the bolometer array and the strides between adjacent
bolometer values. */
smf_get_dims( data, &nrow, &ncol, &nbolo, &ntslice, NULL, &bstride,
&tstride, status );
/* Report an error if the block of time slices extends of either end. */
if( block_start < 0 || block_end >= (int) ntslice ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "S", block_start );
msgSeti( "E", block_end );
msgSeti( "N", ntslice );
errRep( " ", "smf_calc_iqu: invalid block of time slices - ^S to "
"^E (^N time slices are available).", status );
}
}
/* Create the output NDFs. Each one is a 2D array with dimensions
equal to the bolometer array. */
lbnd[ 0 ] = 1;
lbnd[ 1 ] = 1;
ubnd[ 0 ] = ncol;
ubnd[ 1 ] = nrow;
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &qplace, &indfq, status );
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &uplace, &indfu, status );
if( iplace != NDF__NOPL ) {
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &iplace, &indfi, status );
} else {
indfi = NDF__NOID;
}
/* Store any supplied provenance in all NDFs. */
if( oprov ) {
ndgWriteProv( oprov, indfq, 1, status );
ndgWriteProv( oprov, indfu, 1, status );
if( indfi != NDF__NOID ) ndgWriteProv( oprov, indfi, 1, status );
}
/* Store any supplied FITS headers in all NDFs.*/
if( fc && astGetI( fc, "NCard" ) > 0 ) {
kpgPtfts( indfq, fc, status );
kpgPtfts( indfu, fc, status );
if( indfi != NDF__NOID ) kpgPtfts( indfi, fc, status );
}
/* Store the WCS frameSet in all NDFs. First get the FrameSet for the
central time slice in the block, and set its current Frame to the
tracking frame. */
smf_tslice_ast( data, ( block_start + block_end )/2, 1, status);
astSetC( hdr->wcs, "System",
sc2ast_convert_system( (data->hdr->allState)[0].tcs_tr_sys,
status ) );
/* Take a copy and then reverse the X axis of the GRID Frame by remaping the
base Frame using a WinMap. This produces a pixel grid such as you would
see by looking up at the sky from underneath the array, rather than looking
down at the ground from above the array. */
wcs = astCopy( hdr->wcs );
ina[ 0 ] = 1.0;
inb[ 0 ] = ncol;
ina[ 1 ] = 1.0;
inb[ 1 ] = nrow;
outa[ 0 ] = ncol;
outb[ 0 ] = 1.0;
outa[ 1 ] = 1.0;
outb[ 1 ] = nrow;
wm = astWinMap( 2, ina, inb, outa, outb, " " );
astRemapFrame( wcs, AST__BASE, wm );
wm = astAnnul( wm );
/* Store the FrameSet in the output NDFs, then annull the copy. */
ndfPtwcs( wcs, indfq, status );
ndfPtwcs( wcs, indfu, status );
if( indfi != NDF__NOID ) ndfPtwcs( wcs, indfi, status );
wcs = astAnnul( wcs );
/* Map the Data array in each NDF. */
ndfMap( indfq, "Data", "_DOUBLE", "WRITE", (void **) &ipq, &el, status );
ndfMap( indfu, "Data", "_DOUBLE", "WRITE", (void **) &ipu, &el, status );
if( indfi != NDF__NOID ) {
ndfMap( indfi, "Data", "_DOUBLE", "WRITE", (void **) &ipi, &el, status );
} else {
ipi = NULL;
}
/* If required, allocate memory to hold the mean bolometer value at each
time slice. */
mean = submean ? astMalloc( ntslice*sizeof( *mean ) ) : NULL;
/* Create structures used to pass information to the worker threads. */
nworker = wf ? wf->nworker : 1;
job_data = astMalloc( nworker*sizeof( *job_data ) );
/* Check the above pointers can be used safely. */
if( *status == SAI__OK ) {
/* Go through the first thousand POL_ANG values to see if they are in
units of radians (new data) or arbitrary encoder units (old data).
They are assumed to be in radians if no POL_ANG value is larger than
20. */
old = 0;
state = hdr->allState;
ntime = ( ntslice > 1000 ) ? 1000 : ntslice;
for( itime = 0; itime < ntime; itime++,state++ ) {
if( state->pol_ang > 20 ) {
old = 1;
msgOutif( MSG__VERB, ""," POL2 data contains POL_ANG values "
"in encoder units - converting to radians.", status );
break;
}
}
/* If required, find the mean bolometer value at each time slice. */
if( submean ) {
/* Determine which time-slices are to be processed by which threads. */
tstep = ntslice/nworker;
if( tstep < 1 ) tstep = 1;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->block_start = iworker*tstep;
if( iworker < nworker - 1 ) {
pdata->block_end = pdata->block_start + tstep - 1;
} else {
pdata->block_end = ntslice - 1;
}
}
/* Store all the other info needed by the worker threads, and submit the
jobs to calculate the Q and U values in each bolo, and then wait for
them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->bstride = bstride;
pdata->dat = data->pntr[0];
pdata->nbolo = nbolo;
pdata->qua = smf_select_qualpntr( data, NULL, status );;
pdata->tstride = tstride;
pdata->mean = mean;
pdata->action = 1;
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_calc_iqu_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
}
/* Determine which bolometers are to be processed by which threads. */
bstep = nbolo/nworker;
if( bstep < 1 ) bstep = 1;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->b1 = iworker*bstep;
pdata->b2 = pdata->b1 + bstep - 1;
}
/* Ensure that the last thread picks up any left-over bolometers */
pdata->b2 = nbolo - 1;
/* Store all the other info needed by the worker threads, and submit the
jobs to calculate the Q and U values in each bolo, and then wait for
them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->bstride = bstride;
pdata->dat = data->pntr[0];;
pdata->nbolo = nbolo;
pdata->qua = smf_select_qualpntr( data, NULL, status );;
pdata->tstride = tstride;
pdata->allstates = hdr->allState;
pdata->ipq = ipq;
pdata->ipu = ipu;
pdata->ipi = ipi;
pdata->ipolcrd = ipolcrd;
pdata->block_start = block_start;
pdata->block_end = block_end;
pdata->old = old;
pdata->ncol = ncol;
pdata->pasign = pasign ? +1: -1;
pdata->paoff = paoff;
pdata->angrot = angrot;
pdata->action = 0;
pdata->mean = mean;
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_calc_iqu_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
}
/* Add POLANAL Frames to the WCS FrameSet in each output NDF. This Frame
is used by POLPACK to determine the reference direction of the Stokes
vectors (focal plane Y in this case, i.e. zero-based axis 1 ). */
smf_polext( indfq, 0, 0.0, "FPLANE", 1, status );
smf_polext( indfu, 0, 0.0, "FPLANE", 1, status );
if( ipi ) smf_polext( indfi, 0, 0.0, "FPLANE", 1, status );
/* Free the two output NDFs. */
ndfAnnul( &indfq, status );
ndfAnnul( &indfu, status );
if( ipi ) ndfAnnul( &indfi, status );
/* Free other resources. */
job_data = astFree( job_data );
mean = astFree( mean );
}
void smf_calc_iqu( ThrWorkForce *wf, smfData *data, int block_start,
int block_end, int ipolcrd, int qplace, int uplace,
int iplace, NdgProvenance *oprov, AstFitsChan *fc,
int pasign, double paoff, double angrot, int submean,
int harmonic, int *status ){
/* Local Variables: */
AstCmpMap *cm1;
AstCmpMap *cm2;
AstFrameSet *wcs; /* WCS FrameSet for output NDFs */
AstMapping *fpmap1;
AstMapping *fpmap2;
AstMapping *oskymap;
AstMapping *totmap;
AstSkyFrame *oskyfrm;
AstWinMap *wm; /* Mapping to reverse the X GRID axis */
const JCMTState *state; /* JCMTState info for current time slice */
const char *usesys; /* Used system string */
dim_t itime; /* Time slice index */
dim_t nbolo; /* No. of bolometers */
dim_t ncol; /* No. of columns of bolometers */
dim_t nrow; /* No. of rows of bolometers */
dim_t ntime; /* Time slices to check */
dim_t ntslice; /* Number of time-slices in data */
double *ipi; /* Pointer to output I array */
double *ipiv; /* Pointer to output I variance array */
double *ipq; /* Pointer to output Q array */
double *ipqv; /* Pointer to output Q variance array */
double *ipu; /* Pointer to output U array */
double *ipuv; /* Pointer to output U variance array */
double *mean;
double ang_data[2];
double fox[2];
double foy[2];
double fpr0;
double fprinc;
double fx[2];
double fy[2];
double ina[ 2 ]; /* Bolometer coords at bottom left */
double inb[ 2 ]; /* Bolometer coords at top right */
double outa[ 2 ]; /* NDF GRID coords at bottom left */
double outb[ 2 ]; /* NDF GRID coords at top right */
int bstep; /* Bolometer step between threads */
int el; /* Number of mapped array elements */
int gotvar; /* Were any output variances created? */
int indfi; /* Identifier for NDF holding I values */
int indfq; /* Identifier for NDF holding Q values */
int indfu; /* Identifier for NDF holding Q values */
int iworker; /* Index of a worker thread */
int lbnd[ 2 ]; /* Lower pixel bounds of output NDF */
int moving;
int nworker; /* No. of worker threads */
int old; /* Data has old-style POL_ANG values? */
int tstep; /* Time slice step between threads */
int ubnd[ 2 ]; /* Upper pixel bounds of output NDF */
size_t bstride; /* Stride between adjacent bolometer values */
size_t tstride; /* Stride between adjacent time slice values */
smfCalcIQUJobData *job_data = NULL; /* Pointer to all job data */
smfCalcIQUJobData *pdata = NULL;/* Pointer to next job data */
smfHead *hdr; /* Pointer to data header this time slice */
/* Check the inherited status. */
if( *status != SAI__OK ) return;
/* Convenience pointers. */
hdr = data->hdr;
/* Obtain number of time slices - will also check for 3d-ness. Also get
the dimensions of the bolometer array and the strides between adjacent
bolometer values. */
smf_get_dims( data, &nrow, &ncol, &nbolo, &ntslice, NULL, &bstride,
&tstride, status );
/* Report an error if the block of time slices extends of either end. */
if( block_start < 0 || block_end >= (int) ntslice ) {
if( *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "S", block_start );
msgSeti( "E", block_end );
msgSeti( "N", ntslice );
errRep( " ", "smf_calc_iqu: invalid block of time slices - ^S to "
"^E (^N time slices are available).", status );
}
}
/* Create the output NDFs. Each one is a 2D array with dimensions
equal to the bolometer array. */
lbnd[ 0 ] = 1;
lbnd[ 1 ] = 1;
ubnd[ 0 ] = ncol;
ubnd[ 1 ] = nrow;
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &qplace, &indfq, status );
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &uplace, &indfu, status );
if( iplace != NDF__NOPL ) {
ndfNew( "_DOUBLE", 2, lbnd, ubnd, &iplace, &indfi, status );
} else {
indfi = NDF__NOID;
}
/* Store any supplied provenance in all NDFs. */
if( oprov ) {
ndgWriteProv( oprov, indfq, 1, status );
ndgWriteProv( oprov, indfu, 1, status );
if( indfi != NDF__NOID ) ndgWriteProv( oprov, indfi, 1, status );
}
/* Store any supplied FITS headers in all NDFs.*/
if( fc && astGetI( fc, "NCard" ) > 0 ) {
kpgPtfts( indfq, fc, status );
kpgPtfts( indfu, fc, status );
if( indfi != NDF__NOID ) kpgPtfts( indfi, fc, status );
}
/* Store the WCS frameSet in all NDFs. First get the FrameSet for the
central time slice in the block, and set its current Frame to the
tracking frame. */
smf_tslice_ast( data, ( block_start + block_end )/2, 1, NO_FTS, status);
usesys = sc2ast_convert_system( (data->hdr->allState)[0].tcs_tr_sys,
status );
astSetC( hdr->wcs, "System", usesys );
/* Get the Mapping from focal plane coords to bolometer grid coords. This
is the same for all time slices. sc2ast ensures that frame 3 is FPLANE. */
fpmap1 = astGetMapping( hdr->wcs, 3, AST__BASE );
/* Take a copy and then reverse the X axis of the GRID Frame by remaping the
base Frame using a WinMap. This produces a pixel grid such as you would
see by looking up at the sky from underneath the array, rather than looking
down at the ground from above the array. */
wcs = astCopy( hdr->wcs );
ina[ 0 ] = 1.0;
inb[ 0 ] = ncol;
ina[ 1 ] = 1.0;
inb[ 1 ] = nrow;
outa[ 0 ] = ncol;
outb[ 0 ] = 1.0;
outa[ 1 ] = 1.0;
outb[ 1 ] = nrow;
wm = astWinMap( 2, ina, inb, outa, outb, " " );
astRemapFrame( wcs, AST__BASE, wm );
wm = astAnnul( wm );
/* Get the Mapping from output grid coords to focal plane coords. */
fpmap2 = astGetMapping( wcs, AST__BASE, 3 );
/* If the target is moving (assumed to be the case if the tracking
system is AZEL or GAPPT), make the FrameSet current Frame represent
offsets from the reference position (i.e. the moving target), and
indicate that the offset coord system should be used for alignment. */
if( !strcmp( usesys, "AZEL" ) || !strcmp( usesys, "GAPPT" ) ){
astSet( wcs, "SkyRefIs=Origin,AlignOffset=1" );
moving = 1;
} else {
moving = 0;
}
/* Store the FrameSet in the output NDFs. */
ndfPtwcs( wcs, indfq, status );
ndfPtwcs( wcs, indfu, status );
if( indfi != NDF__NOID ) ndfPtwcs( wcs, indfi, status );
/* Map the Data array in each NDF. */
ndfMap( indfq, "Data", "_DOUBLE", "WRITE", (void **) &ipq, &el, status );
ndfMap( indfu, "Data", "_DOUBLE", "WRITE", (void **) &ipu, &el, status );
if( indfi != NDF__NOID ) {
ndfMap( indfi, "Data", "_DOUBLE", "WRITE", (void **) &ipi, &el, status );
} else {
ipi = NULL;
}
/* Map the Variance array in each NDF. */
ndfMap( indfq, "Variance", "_DOUBLE", "WRITE", (void **) &ipqv, &el, status );
ndfMap( indfu, "Variance", "_DOUBLE", "WRITE", (void **) &ipuv, &el, status );
if( indfi != NDF__NOID ) {
ndfMap( indfi, "Variance", "_DOUBLE", "WRITE", (void **) &ipiv, &el, status );
} else {
ipiv = NULL;
}
/* If required, allocate memory to hold the mean bolometer value at each
time slice. */
mean = submean ? astMalloc( ntslice*sizeof( *mean ) ) : NULL;
/* Create structures used to pass information to the worker threads. */
nworker = wf ? wf->nworker : 1;
job_data = astMalloc( nworker*sizeof( *job_data ) );
/* Check the above pointers can be used safely. */
if( *status == SAI__OK ) {
/* Go through the first thousand POL_ANG values to see if they are in
units of radians (new data) or arbitrary encoder units (old data).
They are assumed to be in radians if no POL_ANG value is larger than
20. */
old = 0;
state = hdr->allState;
ntime = ( ntslice > 1000 ) ? 1000 : ntslice;
for( itime = 0; itime < ntime; itime++,state++ ) {
if( state->pol_ang > 20 ) {
old = 1;
msgOutif( MSG__VERB, ""," POL2 data contains POL_ANG values "
"in encoder units - converting to radians.", status );
break;
}
}
/* If required, find the mean bolometer value at each time slice. */
if( submean ) {
/* Determine which time-slices are to be processed by which threads. */
tstep = ntslice/nworker;
if( tstep < 1 ) tstep = 1;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->block_start = iworker*tstep;
if( iworker < nworker - 1 ) {
pdata->block_end = pdata->block_start + tstep - 1;
} else {
pdata->block_end = ntslice - 1;
}
}
/* Store all the other info needed by the worker threads, and submit the
jobs to calculate the Q and U values in each bolo, and then wait for
them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->bstride = bstride;
pdata->dat = data->pntr[0];
pdata->nbolo = nbolo;
pdata->qua = smf_select_qualpntr( data, NULL, status );;
pdata->tstride = tstride;
pdata->mean = mean;
pdata->action = 1;
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_calc_iqu_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
}
/* Get the Frame representing absolute sky coords in the output NDF,
and the Mapping from sky to grid in the output NDF. */
oskyfrm = astCopy( astGetFrame( wcs, AST__CURRENT ) );
astSet( oskyfrm, "SkyRefIs=Ignored" );
oskymap = astGetMapping( wcs, AST__CURRENT, AST__BASE );
wcs = astAnnul( wcs );
/* Find the first and last time slices, calculate the angle between the
focal pane Y axis at the time slice, and the focal plane Y axis in
the output NDF. For intervening time-slices, the angle is found by
linear interpolation between the extreme time slices. */
for( el = 0; el < 2; el++ ) {
/* Get the mapping from GRID coords in the input time slice to GRID
coords in the output. */
totmap = smf_rebin_totmap( data, el?ntslice-1:0, oskyfrm, oskymap,
moving, NO_FTS, status );
/* Modify it to be the Mapping from focal plane coords in the input time
slice to focal plane coords in the output. */
cm1 = astCmpMap( fpmap1, totmap, 1, " " );
cm2 = astCmpMap( cm1, fpmap2, 1, " " );
/* Use this Mapping to convert two points on the focal plane Y axis from
the input to the output. */
fx[0] = 0.0;
fy[0] = 0.0;
fx[1] = 0.0;
fy[1] = 4.0;
astTran2( cm2, 2, fx, fy, 1, fox, foy );
/* The angle from the focal plane Y axis in the output to the focal plane
Y axis in the input time slice, measured positive in sense of rotation
from Fy to Fx. */
ang_data[ el ] = atan2( fox[1]-fox[0], foy[1]-foy[0] );
/* Free resources for this time slice. */
totmap = astAnnul( totmap );
cm1 = astAnnul( cm1 );
cm2 = astAnnul( cm2 );
}
/* Annul objects. */
oskymap = astAnnul( oskymap );
oskyfrm = astAnnul( oskyfrm );
fpmap1 = astAnnul( fpmap1 );
fpmap2 = astAnnul( fpmap2 );
/* Get the constants of the linear relationship between focal plane
rotation and time slice index "fpr = fpr0 + itime*fprinc". */
fpr0 = ang_data[ 0 ];
fprinc = ( ang_data[ 1 ] - fpr0 )/( ntslice - 1 );
/* Determine which bolometers are to be processed by which threads. */
bstep = nbolo/nworker;
if( bstep < 1 ) bstep = 1;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->b1 = iworker*bstep;
pdata->b2 = pdata->b1 + bstep - 1;
}
/* Ensure that the last thread picks up any left-over bolometers */
pdata->b2 = nbolo - 1;
/* Store all the other info needed by the worker threads, and submit the
jobs to calculate the Q and U values in each bolo, and then wait for
them to complete. */
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
pdata->bstride = bstride;
pdata->dat = data->pntr[0];;
pdata->nbolo = nbolo;
pdata->qua = smf_select_qualpntr( data, NULL, status );;
pdata->tstride = tstride;
pdata->allstates = hdr->allState;
pdata->ipq = ipq;
pdata->ipu = ipu;
pdata->ipi = ipi;
pdata->ipqv = ipqv;
pdata->ipuv = ipuv;
pdata->ipiv = ipiv;
pdata->ipolcrd = ipolcrd;
pdata->block_start = block_start;
pdata->block_end = block_end;
pdata->old = old;
pdata->ncol = ncol;
pdata->pasign = pasign ? +1: -1;
pdata->paoff = paoff;
pdata->angrot = angrot;
pdata->fpr0 = fpr0;
pdata->fprinc = fprinc;
pdata->angfac = harmonic/4.0;
pdata->action = 0;
pdata->mean = mean;
/* Pass the job to the workforce for execution. */
thrAddJob( wf, THR__REPORT_JOB, pdata, smf1_calc_iqu_job, 0, NULL,
status );
}
/* Wait for the workforce to complete all jobs. */
thrWait( wf, status );
/* See if any thread produced non-bad variance values. */
gotvar = 0;
for( iworker = 0; iworker < nworker; iworker++ ) {
pdata = job_data + iworker;
if( pdata->gotvar ) gotvar = 1;
}
/* If no variances were created, erase the Variance component and tell
the user. */
ndfUnmap( indfq, "*", status );
ndfUnmap( indfu, "*", status );
if( ipi ) ndfUnmap( indfi, "*", status );
if( !gotvar ) {
ndfReset( indfq, "Variance", status );
ndfReset( indfu, "Variance", status );
if( ipi ) ndfReset( indfi, "Variance", status );
msgOut( "", "Warning: Insufficient input data to produce variances",
status );
}
}
/* Add POLANAL Frames to the WCS FrameSet in each output NDF. This Frame
is used by POLPACK to determine the reference direction of the Stokes
vectors (focal plane Y in this case, i.e. zero-based axis 1 ). */
smf_polext( indfq, 0, 0.0, "FPLANE", 1, status );
smf_polext( indfu, 0, 0.0, "FPLANE", 1, status );
if( ipi ) smf_polext( indfi, 0, 0.0, "FPLANE", 1, status );
/* Free the two output NDFs. */
ndfAnnul( &indfq, status );
ndfAnnul( &indfu, status );
if( ipi ) ndfAnnul( &indfi, status );
/* Free other resources. */
job_data = astFree( job_data );
mean = astFree( mean );
}
void smf_export_noi( smfData *noi, const char *name, int boxsize, int *status ){
/* Local Variables */
HDSLoc *xloc = NULL;
dim_t ntslice;
dim_t nrows;
dim_t ncols;
dim_t nbolo;
double *ip;
double *dataptr;
double *dp;
double *pd;
int el;
int ibolo;
int indf;
int itime;
int lbnd[ 3 ];
int nz;
int place;
int ubnd[ 3 ];
size_t bstride;
size_t tstride;
int iz;
/* Check inherited status. */
if( *status != SAI__OK ) return;
/* Report an error if the number of time slices that share a single NOI
value is not known. */
if( boxsize == 0 ) {
*status = SAI__ERROR;
errRep( "", "smf_export_noi: noise boxsize is not yet known "
"(programming error).", status );
return;
}
/* Get the dimensions of the NOI model. */
smf_get_dims( noi, &nrows, &ncols, &nbolo, &ntslice, NULL, &bstride,
&tstride, status );
/* Determine the number of boxes to use. This is the length of 3rd axis.
of the new NDF. */
if( ntslice == 1 ) {
nz = 1;
} else {
nz = ntslice / boxsize;
}
if( nz <= 0 && *status == SAI__OK ){
*status = SAI__ERROR;
errRepf("", "smf_export_noi: boxsize (%d) and ntslice (%d) are "
"inconsistent (programming error).", status, boxsize,
(int) ntslice );
}
/* Get a pointer to the NOI data values. */
dataptr = noi->pntr[ 0 ];
/* Create the NDF. Use the axis ordering needed by smf_model_create. This
avoid re-ordering the values every time it is read in. */
ndfPlace( NULL, name, &place, status );
lbnd[ 0 ] = 1;
lbnd[ 1 ] = 1;
lbnd[ 2 ] = 1;
ubnd[ 0 ] = nz;
ubnd[ 1 ] = ncols;
ubnd[ 2 ] = nrows;
ndfNew( "_DOUBLE", 3, lbnd, ubnd, &place, &indf, status );
/* Map the Data array of the NDF and copy the NOI values into it. */
ndfMap( indf, "DATA", "_DOUBLE", "WRITE", (void **) &ip, &el, status );
if( *status == SAI__OK ) {
/* Initialise the time slice at the middle of the current box in the model. */
itime = ( nz == 1 ) ? 0 : boxsize/2;
/* We step sequentially through teh NDF pixels. Initialise a pointer to
the first pixel value. */
pd = ip;
/* Loop round each bolometer. */
for( ibolo = 0; ibolo < (int) nbolo; ibolo++ ) {
/* Get a pointer to the noise value for the current bolometer at the
centre of the first box. */
dp = dataptr + ibolo*bstride + itime*tstride;
/* Now loop round each box of time slices. */
for( iz = 0; iz < nz; iz++ ) {
/* The NOI model is filled with 1.0 values by smf_model_create, and can also
be set to zero to indicate missing values. Therefore convert both these
values into VAL__BADD. */
*(pd++) = (*dp == 0.0 || *dp == 1.0) ? VAL__BADD : *dp;
/* Move the input pointer on to the next box. */
dp += boxsize*tstride;
}
}
/* Store the box size as an extension item in the NDF. */
ndfXnew( indf, SMURF__EXTNAME, SMURF__EXTTYPE, 0, NULL, &xloc, status );
ndfXpt0i( boxsize, indf, SMURF__EXTNAME, "NOI_BOXSIZE", status );
datAnnul( &xloc, status );
}
/* Annul the NDF identifier. */
ndfAnnul( &indf, status );
}
int write_ndf( int argc, void *argv[]) {
/*
** Declare variables
*/
void *arr; /* Pointer to the data array */
int n_dims; /* The number of dimensions */
int *arr_bnds; /* The dimensions */
IDL_STRING *ndf_name; /* The name of the NDF to be created */
IDL_STRING *comp; /* The component name */
IDL_STRING *type; /* The HDS type of the NDF to be created */
int badset; /* Whether bad value is set */
void *bad_value; /* Pointer to the bad value */
int status; /* Starlink status */
int lbnd[5]={1L,1L,1L,1L,1L}; /* Lower bounds array */
int ndf; /* NDF identifier */
int place; /* NDF placeholder */
int npix; /* Number of pixels */
void *ptr[3]; /* Pointer to mapped NDF data Fortran style */
size_t nbytes; /* Number of bytes in NDF */
int bpix=1; /* Number of bits/pixel */
int idltype=1; /* Pixel type code */
int fstat; /* Final status (before errLoad) */
int errn=0; /* Error sequence number */
char param[ERR__SZPAR]; /* Error message parameter name */
int parlen; /* Length of error message parameter name */
char opstr[ERR__SZMSG]; /* Error message */
int oplen; /* Length of error message */
/*
** Start Error context
*/
status = SAI__OK;
errMark();
/*
** Check that the correct number of arguments were passed in
*/
if(argc != 8) {
/*
** Print an error message and return
*/
status = SAI__ERROR;
errRep( " ", "write_ndf: Incorrect number of arguments", &status );
} else {
/*
** Extract the arguments to comprehensible names
*/
arr = argv[0];
n_dims = *(int *)argv[1];
arr_bnds = (int *)argv[2];
ndf_name = (IDL_STRING *)argv[3];
comp = (IDL_STRING *)argv[4];
type = (IDL_STRING *)argv[5];
badset = *(int *)argv[6];
bad_value = (void *)argv[7];
/*
** Enable NDF calls
*/
ndfBegin();
if ( !strcmp( comp->s, "DATA" ) ) {
/*
** Create the NDF
*/
ndfOpen( NULL, ndf_name->s, "WRITE", "NEW", &ndf, &place, &status );
ndfNew( type->s, n_dims, lbnd, arr_bnds, &place, &ndf, &status );
} else {
if ( !strcmp( comp->s, "QUALITY") && strcmp(type->s, "_UBYTE")) {
status = SAI__ERROR;
errRep( " ", "write_ndf: Incorrect type for QUALITY", &status );
}
/*
** Open existing NDF
*/
ndfOpen( NULL, ndf_name->s, "UPDATE", "OLD", &ndf, &place, &status );
}
/*
** Check the number of pixels is same in given array and NDF for QUALITY
** and VARIANCE.
*/
if ( strcmp( comp->s, "DATA" ) ) {
ndfSize( ndf, &npix, &status );
if ( ( status == SAI__OK ) && ( npix != arr_bnds[n_dims+1] ) ) {
/*
** Array size and NDF size do not agree
*/
status = SAI__ERROR;
errRep( " ",
"write_ndf: Incorrect number elements supplied", &status );
}
}
/*
** Obtain mapped access to the array component of the NDF
*/
ndfMap( ndf, comp->s, type->s, "WRITE", ptr, &npix, &status );
/*
** Now copy the values from ARR into the mapped NDF
*/
if ( status == SAI__OK ) {
/*
** First check the returned pointer is good
*/
if ( ptr[0] == NULL ) {
/*
** Fortran to C pointer conversion failed
*/
status = SAI__ERROR;
errRep( " ",
"write_ndf: Fortran to C pointer conversion failed", &status );
} else {
/*
** then get the IDL type code and number of bytes per pixel
*/
if (!strcmp(type->s, "_REAL")) {
idltype = 4;
bpix = 4;
} else if (!strcmp(type->s, "_INTEGER")) {
idltype = 3;
bpix = 4;
} else if (!strcmp(type->s, "_WORD")) {
idltype = 2;
bpix = 2;
} else if (!strcmp(type->s, "_DOUBLE")) {
idltype = 5;
bpix = 8;
} else if (!strcmp(type->s, "_UBYTE")) {
idltype = 1;
bpix = 1;
} else {
status = SAI__ERROR;
msgSetc( "TYPE", type->s );
errRep( " ", "Illegal type ^TYPE", &status );
}
/*
** Now copy the data from the array to the NDF.
** If we need to check for bad values in the array, use copybadout.
** If any bad values are found copybadout will replace them with the
** appropriate PRIMDAT bad value. The NDF bad pixel flag is then set
** depending on whether copybadout detected any bad values.
** If we need not check for bad pixels just copy the whole lot;
*/
if ( status == SAI__OK ) {
if ( badset ) {
if ( !copybadout( ptr[0], arr, npix, idltype, bad_value ) )
ndfSbad( 0, ndf, comp->s, &status);
} else {
nbytes = bpix * npix;
memcpy( ptr[0], arr, nbytes );
}
}
}
}
/*
** Close NDF
*/
ndfEnd( &status );
}
/*
** Report any error messages
** Adding Starlink-style !! and ! prefix
*/
fstat = status;
while ( status != SAI__OK ) {
errLoad(
param, ERR__SZPAR, &parlen, opstr, ERR__SZMSG, &oplen, &status );
if ( status != SAI__OK )
printf( "%s %s\r\n", errn++?"! ":"!!", opstr );
}
errRlse();
/*
** That's it, return to the calling routine
*/
return( fstat == SAI__OK );
}
