unsigned char *smf_get_mask( ThrWorkForce *wf, smf_modeltype mtype,
AstKeyMap *config, smfDIMMData *dat, int flags,
int *status ) {
/* Local Variables: */
AstCircle *circle; /* AST Region used to mask a circular area */
AstKeyMap *akm; /* KeyMap holding AST config values */
AstKeyMap *subkm; /* KeyMap holding model config values */
char refparam[ DAT__SZNAM ];/* Name for reference NDF parameter */
char words[100]; /* Buffer for variable message words */
const char *cval; /* The ZERO_MASK string value */
const char *modname; /* The name of the model being masked */
const char *skyrefis; /* Pointer to SkyRefIs attribute value */
dim_t i; /* Pixel index */
double *pd; /* Pointer to next element of map data */
double *predef; /* Pointer to mask defined by previous run */
double *ptr; /* Pointer to NDF Data array */
double *pv; /* Pointer to next element of map variance */
double centre[ 2 ]; /* Coords of circle centre in radians */
double meanhits; /* Mean hits in the map */
double radius[ 1 ]; /* Radius of circle in radians */
double zero_circle[ 3 ]; /* LON/LAT/Radius of circular mask */
double zero_lowhits; /* Fraction of mean hits at which to threshold */
double zero_snr; /* Higher SNR at which to threshold */
double zero_snrlo; /* Lower SNR at which to threshold */
int *ph; /* Pointer to next hits value */
int have_mask; /* Did a mask already exist on entry? */
int imask; /* Index of next mask type */
int indf1; /* Id. for supplied reference NDF */
int indf2; /* Id. for used section of reference NDF */
int isstatic; /* Are all used masks static? */
int lbnd_grid[ 2 ]; /* Lower bounds of map in GRID coords */
int mask_types[ NTYPE ]; /* Identifier for the types of mask to use */
int munion; /* Use union of supplied masks */
int nel; /* Number of mapped NDF pixels */
int nmask; /* The number of masks to be combined */
int nsource; /* No. of source pixels in final mask */
int skip; /* No. of iters for which AST is not subtracted */
int thresh; /* Absolute threshold on hits */
int ubnd_grid[ 2 ]; /* Upper bounds of map in GRID coords */
int zero_c_n; /* Number of zero circle parameters read */
int zero_mask; /* Use the reference NDF as a mask? */
int zero_niter; /* Only mask for the first "niter" iterations. */
int zero_notlast; /* Don't zero on last iteration? */
size_t ngood; /* Number good samples for stats */
smf_qual_t *pq; /* Pinter to map quality */
unsigned char **mask; /* Address of model's mask pointer */
unsigned char *newmask; /* Individual mask work space */
unsigned char *pm; /* Pointer to next returned mask pixel */
unsigned char *pn; /* Pointer to next new mask pixel */
unsigned char *result; /* Returned mask pointer */
/* Initialise returned values */
result = NULL;
/* Check inherited status. Also check that a map is being created. */
if( *status != SAI__OK || !dat || !dat->map ) return result;
/* Begin an AST context. */
astBegin;
/* Get the sub-keymap containing the configuration parameters for the
requested model. Also get a pointer to the mask array to use (there is
one for each maskable model)*/
if( mtype == SMF__COM ) {
modname = "COM";
mask = &(dat->com_mask);
} else if( mtype == SMF__AST ) {
modname = "AST";
mask = &(dat->ast_mask);
} else if( mtype == SMF__FLT ) {
modname = "FLT";
mask = &(dat->flt_mask);
} else {
modname = NULL;
mask = NULL;
*status = SAI__ERROR;
errRepf( " ", "smf_get_mask: Unsupported model type %d supplied - "
"must be COM, FLT or AST.", status, mtype );
}
subkm = NULL;
astMapGet0A( config, modname, &subkm );
/* Get the "ast.skip" value - when considering "zero_niter" and
"zero_freeze", we only count iterations for which the AST model
is subtracted (i.e. the ones following the initial "ast.skip"
iterations). */
astMapGet0A( config, "AST", &akm );
astMapGet0I( akm, "SKIP", &skip );
akm = astAnnul( akm );
/* Get the number of iterations over which the mask is to be applied. Zero
means all. Return with no mask if this number of iterations has
already been performed. */
zero_niter = 0;
astMapGet0I( subkm, "ZERO_NITER", &zero_niter );
if( zero_niter == 0 || dat->iter < zero_niter + skip ) {
/* Only return a mask if this is not the last iteration, or if ZERO_NOTLAST
is unset. */
zero_notlast = 0;
astMapGet0I( subkm, "ZERO_NOTLAST", &zero_notlast );
if( !( flags & SMF__DIMM_LASTITER ) || !zero_notlast ) {
/* Create a list of the mask types to be combined to get the final mask by
looking for non-default values for the corresponding configuration
parameters in the supplied KeyMap. Static masks (predefined, circles
or external NDFs) may be used on any iteration, but dynamic masks
(lowhits, snr) will only be avialable once the map has been determined
at the end of the first iteration. This means that when masking anything
but the AST model (which is determined after the map), the dynamic masks
cannot be used on the first iteration. Make a note if all masks being
used are static. */
isstatic = 1;
nmask = 0;
zero_lowhits = 0.0;
astMapGet0D( subkm, "ZERO_LOWHITS", &zero_lowhits );
if( zero_lowhits > 0.0 ) {
if( mtype == SMF__AST || !( flags & SMF__DIMM_FIRSTITER ) ) {
mask_types[ nmask++] = LOWHITS;
isstatic = 0;
}
} else if( zero_lowhits < 0.0 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad value for config parameter %s.ZERO_LOWHITS (%g) - "
"it must not be negative.", status, modname, zero_lowhits );
}
if( astMapGet1D( subkm, "ZERO_CIRCLE", 3, &zero_c_n, zero_circle ) ) {
if( zero_c_n == 1 || zero_c_n == 3 ) {
mask_types[ nmask++] = CIRCLE;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad number of values (%d) for config parameter "
"%s.ZERO_CIRCLE - must be 1 or 3.", status, zero_c_n,
modname );
}
}
cval = NULL;
astMapGet0C( subkm, "ZERO_MASK", &cval );
if( cval ) {
if( !astChrMatch( cval, "REF" ) &&
!astChrMatch( cval, "MASK2" ) &&
!astChrMatch( cval, "MASK3" ) ) {
astMapGet0I( subkm, "ZERO_MASK", &zero_mask );
cval = ( zero_mask > 0 ) ? "REF" : NULL;
}
if( cval ) {
strcpy( refparam, cval );
astChrCase( NULL, refparam, 1, 0 );
mask_types[ nmask++] = REFNDF;
}
}
zero_snr = 0.0;
astMapGet0D( subkm, "ZERO_SNR", &zero_snr );
if( zero_snr > 0.0 ) {
if( mtype == SMF__AST || !( flags & SMF__DIMM_FIRSTITER ) ) {
mask_types[ nmask++] = SNR;
isstatic = 0;
}
} else if( zero_snr < 0.0 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad value for config parameter %s.ZERO_SNR (%g) - "
"it must not be negative.", status, modname, zero_snr );
}
if( astMapHasKey( subkm, "ZERO_MASK_POINTER" ) ) {
astMapGet0P( subkm, "ZERO_MASK_POINTER", (void **) &predef );
if( predef ) mask_types[ nmask++] = PREDEFINED;
}
/* No need to create a mask if no masking was requested or possible. */
if( nmask > 0 ) {
/* Decide if we are using the union or intersection of the masks. */
astMapGet0I( subkm, "ZERO_UNION", &munion );
/* Note if a mask existed on entry. If not, create a mask now, and
initialise it to hold the mask defined by the initial sky map. */
if( *mask == NULL ) {
have_mask = 0;
if( dat->initqual ) {
*mask = astMalloc( dat->msize*sizeof( **mask ) );
if( *mask ) {
pm = *mask;
pq = dat->initqual;
for( i = 0; i < dat->msize; i++ ) {
*(pm++) = ( *(pq++) != 0 );
}
}
} else{
*mask = astCalloc( dat->msize, sizeof( **mask ) );
}
} else {
have_mask = 1;
}
/* If we are combining more than one mask, we need work space to hold
an individual mask independently of the total mask. If we are using
only one mask, then just use the main mask array. */
if( nmask > 1 ) {
newmask = astMalloc( dat->msize*sizeof( *newmask ) );
} else {
newmask = *mask;
}
/* Get the number of iterations after which the mask is to be frozen.
Zero means "never freeze the mask". */
int zero_freeze = 0;
astMapGet0I( subkm, "ZERO_FREEZE", &zero_freeze );
/* Loop round each type of mask to be used. */
for( imask = 0; imask < nmask && *status == SAI__OK; imask++ ){
/* If the mask is now frozen, we just return the existing mask. So leave the
loop. */
if( zero_freeze != 0 && dat->iter > zero_freeze + skip ) {
break;
/* Low hits masking... */
} else if( mask_types[ imask ] == LOWHITS ) {
/* Set hits pixels with 0 hits to VAL__BADI so that stats1 ignores them */
ph = dat->hitsmap;
for( i = 0; i < dat->msize; i++,ph++ ) {
if( *ph == 0 ) *ph = VAL__BADI;
}
/* Find the mean hits in the map */
smf_stats1I( dat->hitsmap, 1, dat->msize, NULL, 0, 0, &meanhits,
NULL, NULL, &ngood, status );
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: mean hits = %lf, ngood "
"= %zd", status, meanhits, ngood );
/* Create the mask */
thresh = meanhits*zero_lowhits;
ph = dat->hitsmap;
pn = newmask;
for( i = 0; i < dat->msize; i++,ph++ ) {
*(pn++) = ( *ph != VAL__BADI && *ph < thresh ) ? 1 : 0;
}
/* Report masking info. */
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: masking %s "
"model at hits = %d.", status, modname, thresh );
/* Circle masking... */
} else if( mask_types[ imask ] == CIRCLE ) {
/* If we had a mask on entry, then there is no need to create a new one
since it will not have changed. But we need to recalculate the circle
mask if are combining it with any non-static masks. */
if( ! have_mask || ! isstatic ) {
/* If only one parameter supplied it is radius, assume reference
LON/LAT from the frameset to get the centre. If the SkyFrame
represents offsets from the reference position (i.e. the source is
moving), assume the circle is to be centred on the origin. */
if( zero_c_n == 1 ) {
zero_circle[ 2 ] = zero_circle[ 0 ];
skyrefis = astGetC( dat->outfset, "SkyRefIs" );
if( skyrefis && !strcmp( skyrefis, "Origin" ) ) {
zero_circle[ 0 ] = 0.0;
zero_circle[ 1 ] = 0.0;
} else {
zero_circle[ 0 ] = astGetD( dat->outfset, "SkyRef(1)" );
zero_circle[ 1 ] = astGetD( dat->outfset, "SkyRef(2)" );
}
zero_circle[ 0 ] *= AST__DR2D;
zero_circle[ 1 ] *= AST__DR2D;
}
/* The supplied bounds are for pixel coordinates... we need bounds for grid
coordinates which have an offset */
lbnd_grid[ 0 ] = 1;
lbnd_grid[ 1 ] = 1;
ubnd_grid[ 0 ] = dat->ubnd_out[ 0 ] - dat->lbnd_out[ 0 ] + 1;
ubnd_grid[ 1 ] = dat->ubnd_out[ 1 ] - dat->lbnd_out[ 1 ] + 1;
/* Coordinates & radius of the circular region converted from degrees
to radians */
centre[ 0 ] = zero_circle[ 0 ]*AST__DD2R;
centre[ 1 ] = zero_circle[ 1 ]*AST__DD2R;
radius[ 0 ] = zero_circle[ 2 ]*AST__DD2R;
/* Create the Circle, defined in the current Frame of the FrameSet (i.e.
the sky frame). */
circle = astCircle( astGetFrame( dat->outfset, AST__CURRENT), 1,
centre, radius, NULL, " " );
/* Fill the mask with zeros. */
memset( newmask, 0, sizeof( *newmask )*dat->msize );
/* Get the mapping from the sky frame (current) to the grid frame (base),
and then set the mask to 1 for all of the values outside this circle */
astMaskUB( circle, astGetMapping( dat->outfset, AST__CURRENT,
AST__BASE ),
0, 2, lbnd_grid, ubnd_grid, newmask, 1 );
/* Report masking info. */
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model will"
" be masked %s using a circle of "
"radius %g arc-secs, centred at %s=%s, %s=%s.",
status, modname, words, radius[0]*AST__DR2D*3600,
astGetC( dat->outfset, "Symbol(1)" ),
astFormat( dat->outfset, 1, centre[ 0 ] ),
astGetC( dat->outfset, "Symbol(2)" ),
astFormat( dat->outfset, 2, centre[ 1 ] ) );
}
/* Reference NDF masking... */
} else if( mask_types[ imask ] == REFNDF ) {
/* If we had a mask on entry, then there is no need to create a new one
since it will not have changed. But we need to recalculate the NDF
mask if are combining it with any non-static masks. */
if( ! have_mask || ! isstatic ) {
/* Begin an NDF context. */
ndfBegin();
/* Get an identifier for the NDF using the associated ADAM parameter. */
ndfAssoc( refparam, "READ", &indf1, status );
/* Get a section from this NDF that matches the bounds of the map. */
ndfSect( indf1, 2, dat->lbnd_out, dat->ubnd_out, &indf2,
status );
/* Map the section. */
ndfMap( indf2, "DATA", "_DOUBLE", "READ", (void **) &ptr,
&nel, status );
/* Check we can use the pointer safely. */
if( *status == SAI__OK ) {
/* Find bad pixels in the NDF and set those pixels to 1 in the mask. */
pn = newmask;
for( i = 0; i < dat->msize; i++ ) {
*(pn++) = ( *(ptr++) == VAL__BADD ) ? 1 : 0;
}
/* Report masking info. */
ndfMsg( "N", indf2 );
msgSetc( "M", modname );
if( zero_niter == 0 ) {
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The ^M "
"model will be masked on each iteration "
"using the bad pixels in NDF '^N'.",
status );
} else {
msgSeti( "I", zero_niter );
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The ^M "
"model will be masked for ^I iterations "
"using the bad pixels in NDF '^N'.",
status );
}
}
/* End the NDF context. */
ndfEnd( status );
}
/* SNR masking... */
} else if( mask_types[ imask ] == SNR ) {
/* Get the lower SNR limit. */
zero_snrlo = 0.0;
astMapGet0D( subkm, "ZERO_SNRLO", &zero_snrlo );
if( zero_snrlo <= 0.0 ) {
zero_snrlo = zero_snr;
} else if( zero_snrlo > zero_snr && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( " ", "Bad value for config parameter "
"%s.ZERO_SNRLO (%g) - it must not be higher "
"than %s.ZERO_SNR (%g).", status, modname,
zero_snrlo, modname, zero_snr );
}
/* If the higher and lower SNR limits are equal, just do a simple
threshold on the SNR values to get the mask. */
if( zero_snr == zero_snrlo ) {
pd = dat->map;
pv = dat->mapvar;
pn = newmask;
for( i = 0; i < dat->msize; i++,pd++,pv++ ) {
*(pn++) = ( *pd != VAL__BADD && *pv != VAL__BADD &&
*pv >= 0.0 && *pd < zero_snr*sqrt( *pv ) ) ? 1 : 0;
}
/* Report masking info. */
if( !have_mask ) {
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model "
"will be masked %s using an SNR limit of %g.",
status, modname, words, zero_snr );
}
/* If the higher and lower SNR limits are different, create an initial
mask by thresholding at the ZERO_SNR value, and then extend the source
areas within the mask down to an SNR limit of ZERO_SNRLO. */
} else {
smf_snrmask( wf, dat->map, dat->mapvar, dat->mdims,
zero_snr, zero_snrlo, newmask, status );
/* Report masking info. */
if( !have_mask ) {
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model "
"will be masked %s using an SNR limit of %g "
"extended down to %g.", status, modname,
words, zero_snr, zero_snrlo );
}
}
/* Predefined masking... */
} else if( mask_types[ imask ] == PREDEFINED ) {
/* If we had a mask on entry, then there is no need to create a new one
since it will not have changed. But we need to recalculate the
mask if are combining it with any non-static masks. */
if( ! have_mask || ! isstatic ) {
/* Find bad pixels in the predefined array and set those pixels to 1 in
the mask. */
pn = newmask;
for( i = 0; i < dat->msize; i++ ) {
*(pn++) = ( *(predef++) == VAL__BADD ) ? 1 : 0;
}
/* Report masking info. */
if( zero_niter == 0 ) {
sprintf( words, "on each iteration" );
} else {
sprintf( words, "for %d iterations", zero_niter );
}
msgOutiff( MSG__DEBUG, " ", "smf_get_mask: The %s model "
"will be masked %s using a smoothed form of "
"the final mask created with the previous map.",
status, modname, words );
}
}
/* If required, add the new mask into the returned mask. If this is the
first mask, we just copy the new mask to form the returned mask.
Otherwise, we combine it with the existing returned mask. */
if( ! have_mask || ! isstatic ) {
if( nmask > 1 ) {
if( imask == 0 ) {
memcpy( *mask, newmask, dat->msize*sizeof(*newmask));
} else {
pm = *mask;
pn = newmask;
if( munion ) {
for( i = 0; i < dat->msize; i++,pm++ ) {
if( *(pn++) == 0 ) *pm = 0;
}
} else {
for( i = 0; i < dat->msize; i++,pm++ ) {
if( *(pn++) == 1 ) *pm = 1;
}
}
}
}
}
}
/* Free the individual mask work array if it was used. */
if( nmask > 1 ) newmask = astFree( newmask );
/* Check that the mask has some source pixels (i.e. pixels that have non-bad data values -
we do not also check variance values since they are not available until the second
iteration). */
if( *status == SAI__OK ) {
nsource = 0;
pm = *mask;
pd = dat->map;
for( i = 0; i < dat->msize; i++,pd++,pv++,pm++ ) {
if( *pd != VAL__BADD && *pm == 0 ) nsource++;
}
if( nsource < 5 && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "The %s mask being used has fewer than 5 "
"source pixels.", status, modname );
if( zero_snr > 0.0 ) {
errRepf( "", "Maybe your zero_snr value (%g) is too high?",
status, zero_snr );
}
}
}
/* Return the mask pointer if all has gone well. */
if( *status == SAI__OK ) result = *mask;
}
}
}
/* End the AST context, annulling all AST Objects created in the context. */
astEnd;
/* Return the pointer to the boolean mask. */
return result;
}
void smurf_unmakemap( int *status ) {
/* Local Variables */
AstFrameSet *wcsin = NULL; /* WCS Frameset for input cube */
AstMapping *skymap; /* GRID->SkyFrame Mapping from input WCS */
AstSkyFrame *abskyfrm; /* Input SkyFrame (always absolute) */
AstSkyFrame *skyfrm = NULL;/* SkyFrame from the input WCS Frameset */
Grp *igrp1 = NULL; /* Group of input sky files */
Grp *igrp2 = NULL; /* Group of input template files */
Grp *igrpc = NULL; /* Group of input COM files */
Grp *igrpg = NULL; /* Group of input GAI files */
Grp *igrpq = NULL; /* Group of input Q sky files */
Grp *igrpu = NULL; /* Group of input U sky files */
Grp *ogrp = NULL; /* Group containing output file */
HDSLoc *cloc = NULL; /* HDS locator for component ipdata structure */
HDSLoc *iploc = NULL; /* HDS locator for top level ipdata structure */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
char ipdata[ 200 ]; /* Text buffer for IPDATA value */
char pabuf[ 10 ]; /* Text buffer for parameter value */
char subarray[ 5 ]; /* Name of SCUBA-2 subarray (s8a,s8b,etc) */
dim_t iel; /* Index of next element */
dim_t ndata; /* Number of elements in array */
dim_t ntslice; /* Number of time slices in array */
double *ang_data = NULL; /* Pointer to the FP orientation angles */
double *angc_data = NULL; /* Pointer to the instrumental ANGC data */
double *c0_data = NULL; /* Pointer to the instrumental C0 data */
double *gai_data = NULL; /* Pointer to the input GAI map */
double *in_data = NULL; /* Pointer to the input I sky map */
double *inc_data = NULL; /* Pointer to the input COM data */
double *inq_data = NULL; /* Pointer to the input Q sky map */
double *inu_data = NULL; /* Pointer to the input U sky map */
double *outq_data = NULL; /* Pointer to the Q time series data */
double *outu_data = NULL; /* Pointer to the U time series data */
double *p0_data = NULL; /* Pointer to the instrumental P0 data */
double *p1_data = NULL; /* Pointer to the instrumental P1 data */
double *pd; /* Pointer to next element */
double *pq = NULL; /* Pointer to next Q time series value */
double *pu = NULL; /* Pointer to next U time series value */
double *qinst_data = NULL; /* Pointer to the instrumental Q data */
double *uinst_data = NULL; /* Pointer to the instrumental U data */
double amp16; /* Amplitude of 16 Hz signal */
double amp2; /* Amplitude of 2 Hz signal */
double amp4; /* Amplitude of 4 Hz signal */
double angrot; /* Angle from focal plane X axis to fixed analyser */
double paoff; /* WPLATE value corresponding to POL_ANG=0.0 */
double params[ 4 ]; /* astResample parameters */
double phase16; /* Phase of 16 Hz signal */
double phase2; /* Phase of 2 Hz signal */
double phase4; /* Phase of 4 Hz signal */
double sigma; /* Standard deviation of noise to add to output */
int alignsys; /* Align data in the map's system? */
int cdims[ 3 ]; /* Common-mode NDF dimensions */
int dims[ NDF__MXDIM ]; /* NDF dimensions */
int flag; /* Was the group expression flagged? */
int gdims[ 3 ]; /* GAI model NDF dimensions */
int harmonic; /* The requested harmonic */
int ifile; /* Input file index */
int indf; /* Input sky map NDF identifier */
int indfangc; /* IP ANGC values NDF identifier */
int indfc0; /* IP C0 values NDF identifier */
int indfc; /* Input COM NDF identifier */
int indfcs; /* NDF identifier for matching section of COM */
int indfg; /* Input GAI NDF identifier */
int indfin; /* Input template cube NDF identifier */
int indfiq; /* Input instrumental Q NDF */
int indfiu; /* Input instrumental U NDF */
int indfout; /* Output cube NDF identifier */
int indfp0; /* IP P0 values NDF identifier */
int indfp1; /* IP P1 values NDF identifier */
int indfq; /* Input Q map NDF identifier */
int indfu; /* Input U map NDF identifier */
int interp = 0; /* Pixel interpolation method */
int lbndc[ 3 ]; /* Array of lower bounds of COM NDF */
int moving; /* Is the telescope base position changing? */
int ndim; /* Number of pixel axes in NDF */
int ndimc; /* Number of pixel axes in common-mode NDF */
int ndimg; /* Number of pixel axes in GAI NDF */
int nel; /* Number of elements in array */
int nelc; /* Number of elements in COM array */
int nelg; /* Number of elements in GAI array */
int nelqu; /* Number of elements in Q or U array */
int ngood; /* No. of good values in putput cube */
int nparam = 0; /* No. of parameters required for interpolation scheme */
int pasign; /* Indicates sense of POL_ANG value */
int sdim[ 2 ]; /* Array of significant pixel axes */
int slbnd[ 2 ]; /* Array of lower bounds of input map */
int subnd[ 2 ]; /* Array of upper bounds of input map */
int ubndc[ 3 ]; /* Array of upper bounds of COM NDF */
size_t ncom; /* Number of com files */
size_t ngai; /* Number of gai files */
size_t nskymap; /* Number of supplied sky cubes */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
smfData *odata = NULL; /* Pointer to output data struct */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Get an identifier for the input NDF. We use NDG (via kpg1Rgndf)
instead of calling ndfAssoc directly since NDF/HDS has problems with
file names containing spaces, which NDG does not have. */
kpg1Rgndf( "IN", 1, 1, "", &igrp1, &nskymap, status );
ndgNdfas( igrp1, 1, "READ", &indf, status );
/* Map the data array in the input sky map. */
ndfMap( indf, "DATA", "_DOUBLE", "READ", (void **) &in_data, &nel,
status );
/* Get the WCS FrameSet from the sky map, together with its pixel index
bounds. */
kpg1Asget( indf, 2, 0, 1, 1, sdim, slbnd, subnd, &wcsin, status );
/* Check the current Frame is a SKY frame. */
skyfrm = astGetFrame( wcsin, AST__CURRENT );
if( !astIsASkyFrame( skyfrm ) && *status == SAI__OK ) {
ndfMsg( "N", indf );
*status = SAI__ERROR;
errRep( " ", " Current Frame in ^N is not a SKY Frame.", status );
}
/* Get a copy of the current frame that represents absolute coords rather
than offsets. We assume the target is moving if the map represents
offsets. */
moving = ( *status == SAI__OK &&
!strcmp( astGetC( skyfrm, "SkyRefIs" ), "Origin" ) ) ? 1 : 0;
abskyfrm = astCopy( skyfrm );
astClear( abskyfrm, "SkyRefIs" );
/* If the ALIGNSYS parameter is TRUE then we align the raw data with the
map in the current system of the map, rather than the default ICRS. */
parGet0l( "ALIGNSYS", &alignsys, status );
if( alignsys ) astSetC( abskyfrm, "AlignSystem", astGetC( abskyfrm,
"System" ) );
/* Get the Mapping from the Sky Frame to grid axis in the iput map. */
skymap = astGetMapping( wcsin, AST__CURRENT, AST__BASE );
/* Get the pixel interpolation scheme to use. */
parChoic( "INTERP", "NEAREST", "NEAREST,LINEAR,SINC,"
"SINCSINC,SINCCOS,SINCGAUSS,SOMB,SOMBCOS",
1, pabuf, 10, status );
if( !strcmp( pabuf, "NEAREST" ) ) {
interp = AST__NEAREST;
nparam = 0;
} else if( !strcmp( pabuf, "LINEAR" ) ) {
interp = AST__LINEAR;
nparam = 0;
} else if( !strcmp( pabuf, "SINC" ) ) {
interp = AST__SINC;
nparam = 1;
} else if( !strcmp( pabuf, "SINCSINC" ) ) {
interp = AST__SINCSINC;
nparam = 2;
} else if( !strcmp( pabuf, "SINCCOS" ) ) {
interp = AST__SINCCOS;
nparam = 2;
} else if( !strcmp( pabuf, "SINCGAUSS" ) ) {
interp = AST__SINCGAUSS;
nparam = 2;
} else if( !strcmp( pabuf, "SOMB" ) ) {
interp = AST__SOMB;
nparam = 1;
} else if( !strcmp( pabuf, "SOMBCOS" ) ) {
interp = AST__SOMBCOS;
nparam = 2;
} else if( *status == SAI__OK ) {
nparam = 0;
*status = SAI__ERROR;
msgSetc( "V", pabuf );
errRep( "", "Support not available for INTERP = ^V (programming "
"error)", status );
}
/* Get an additional parameter vector if required. */
if( nparam > 0 ) parExacd( "PARAMS", nparam, params, status );
/* Get a group of reference time series files to use as templates for
the output time series files.*/
ndgAssoc( "REF", 1, &igrp2, &size, &flag, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp2, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Get he noise level to add to the output data. */
parGet0d( "SIGMA", &sigma, status );
/* Get any Q and U input maps. */
if( *status == SAI__OK ) {
kpg1Rgndf( "QIN", 1, 1, "", &igrpq, &nskymap, status );
ndgNdfas( igrpq, 1, "READ", &indfq, status );
ndfMap( indfq, "DATA", "_DOUBLE", "READ", (void **) &inq_data, &nelqu,
status );
if( nelqu != nel && *status == SAI__OK ) {
ndfMsg( "Q", indfq );
*status = SAI__ERROR;
errRep( "", "Q image '^Q' is not the same size as the I image.",
status );
}
kpg1Rgndf( "UIN", 1, 1, "", &igrpu, &nskymap, status );
ndgNdfas( igrpu, 1, "READ", &indfu, status );
ndfMap( indfu, "DATA", "_DOUBLE", "READ", (void **) &inu_data, &nelqu,
status );
if( nelqu != nel && *status == SAI__OK ) {
ndfMsg( "U", indfu );
*status = SAI__ERROR;
errRep( "", "U image '^U' is not the same size as the I image.",
status );
}
if( *status == PAR__NULL ) {
ndfAnnul( &indfq, status );
ndfAnnul( &indfu, status );
inq_data = NULL;
inu_data = NULL;
errAnnul( status );
} else {
parGet0d( "ANGROT", &angrot, status );
parGet0d( "PAOFF", &paoff, status );
parGet0l( "PASIGN", &pasign, status );
}
}
/* Get any common-mode files. */
if( *status == SAI__OK ) {
kpg1Rgndf( "COM", size, size, "", &igrpc, &ncom, status );
if( *status == PAR__NULL ) {
errAnnul( status );
ncom = 0;
}
}
/* Get any GAI files. */
if( *status == SAI__OK ) {
kpg1Rgndf( "GAI", size, size, "", &igrpg, &ngai, status );
if( *status == PAR__NULL ) {
errAnnul( status );
ngai = 0;
}
}
/* Get any instrumental polarisation files. */
if( *status == SAI__OK ) {
/* First see if the user wants to use the "INSTQ/INSTU" scheme for
specifying instrumental polarisation. */
ndfAssoc( "INSTQ", "Read", &indfiq, status );
ndfAssoc( "INSTU", "Read", &indfiu, status );
if( *status == PAR__NULL ) {
ndfAnnul( &indfiq, status );
ndfAnnul( &indfiu, status );
errAnnul( status );
} else {
msgOut( " ", "Using user-defined IP model", status );
ndfDim( indfiq, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfiq );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfiq, "DATA", "_DOUBLE", "READ", (void **) &qinst_data,
&nel, status );
}
ndfDim( indfiu, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfiu );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfiu, "DATA", "_DOUBLE", "READ", (void **) &uinst_data,
&nel, status );
}
}
/* If not, see if the user wants to use the Johnstone/Kennedy instrumental
polarisation model. The IPDATA parameter gives the path to an HDS
container file contining NDFs holding the required IP data for all
subarrays. */
if( !qinst_data ) {
parGet0c( "IPDATA", ipdata, sizeof(ipdata), status );
if( *status == PAR__NULL ) {
errAnnul( status );
} else {
msgOutf( " ", "Using Johnstone/Kennedy IP model in %s",
status, ipdata );
hdsOpen( ipdata, "READ", &iploc, status );
}
}
}
/* Loop round all the template time series files. */
for( ifile = 1; ifile <= (int) size && *status == SAI__OK; ifile++ ) {
/* Start a new NDF context. */
ndfBegin();
/* Create the output NDF by propagating everything from the input, except
for quality and variance. */
ndgNdfas( igrp2, ifile, "READ", &indfin, status );
ndfMsg( "FILE", indfin );
msgSeti( "THISFILE", ifile );
msgSeti( "NUMFILES", size );
msgOutif( MSG__NORM, " ", "Simulating ^THISFILE/^NUMFILES ^FILE",
status );
ndgNdfpr( indfin, "DATA,HISTORY,LABEL,TITLE,WCS,UNITS,EXTENSION(*)",
ogrp, ifile, &indfout, status );
ndfAnnul( &indfin, status );
ndfAnnul( &indfout, status );
/* We now re-open the output NDF and then modify its data values. */
smf_open_file( wf, ogrp, ifile, "UPDATE", 0, &odata, status );
/* Issue a suitable message and abort if anything went wrong. */
if( *status != SAI__OK ) {
errRep( FUNC_NAME, "Could not open input template file.", status );
break;
} else {
if( odata->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( odata->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
}
}
/* Check the reference time series contains double precision values. */
smf_dtype_check_fatal( odata, NULL, SMF__DOUBLE, status );
/* Get the total number of data elements, and the number of time slices. */
smf_get_dims( odata, NULL, NULL, NULL, &ntslice, &ndata, NULL,
NULL, status );
/* Get the subarray name */
smf_fits_getS( odata->hdr, "SUBARRAY", subarray, sizeof(subarray),
status );
/* If we are using the Johnstone/Kennedy IP model, open and map the
relevant parameter NDFs within the IPDATA container file. */
if( iploc ) {
datFind( iploc, subarray, &cloc, status );
ndfFind( cloc, "C0", &indfc0, status );
ndfDim( indfc0, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfc0 );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfc0, "DATA", "_DOUBLE", "READ", (void **) &c0_data,
&nel, status );
}
ndfFind( cloc, "P0", &indfp0, status );
ndfDim( indfp0, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfp0 );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfp0, "DATA", "_DOUBLE", "READ", (void **) &p0_data,
&nel, status );
}
ndfFind( cloc, "P1", &indfp1, status );
ndfDim( indfp1, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfp1 );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfp1, "DATA", "_DOUBLE", "READ", (void **) &p1_data,
&nel, status );
}
ndfFind( cloc, "ANGC", &indfangc, status );
ndfDim( indfangc, 2, dims, &ndim, status );
if( dims[ 0 ] != 32 || dims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "N", indfangc );
errRep( " ", "Instrumental polarisation file ^N has bad "
"dimensions - should be 32x40.", status );
} else {
ndfMap( indfangc, "DATA", "_DOUBLE", "READ", (void **) &angc_data,
&nel, status );
}
}
/* Open any COM file. */
if( ncom ) {
ndgNdfas( igrpc, ifile, "READ", &indfc, status );
ndfDim( indfc, 3, cdims, &ndimc, status );
/* Check its dimensions. */
if( *status == SAI__OK ) {
if( ndimc == 1 ) {
if( cdims[ 0 ] < (int) ntslice ) {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
ndfMsg( "R", indfin );
msgSeti( "N", cdims[ 0 ] );
msgSeti( "M", ntslice );
errRep( " ", "Supplied COM file (^C) has ^N time-slices, but "
"the reference NDF (^R) has ^M time-slices.", status );
} else {
ndfBound( indfc, 3, lbndc, ubndc, &ndimc, status );
ubndc[ 0 ] = lbndc[ 0 ] + ntslice - 1;
ndfSect( indfc, 1, lbndc, ubndc, &indfcs, status );
}
} else if( ndimc == 3 ) {
if( cdims[ 0 ] != 1 || cdims[ 1 ] != 1 ) {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
errRep( " ", "Supplied 3D COM file (^C) has bad "
"dimensions for axis 1 and/or 2 (should "
"both be 1 pixel long).", status );
} else if( cdims[ 2 ] < (int) ntslice ) {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
ndfMsg( "R", indfin );
msgSeti( "N", cdims[ 2 ] );
msgSeti( "M", ntslice );
errRep( " ", "Supplied COM file (^C) has ^N time-slices, but "
"the reference NDF (^R) has ^M time-slices.", status );
} else {
ndfBound( indfc, 3, lbndc, ubndc, &ndimc, status );
ubndc[ 2 ] = lbndc[ 2 ] + ntslice - 1;
ndfSect( indfc, 3, lbndc, ubndc, &indfcs, status );
}
} else {
*status = SAI__ERROR;
ndfMsg( "C", indfc );
msgSeti( "N", ndimc );
errRep( " ", "Supplied COM file (^C) has ^N dimensions - "
"must be 3.", status );
}
}
ndfMap( indfcs, "DATA", "_DOUBLE", "READ", (void **) &inc_data,
&nelc, status );
} else {
indfcs = NDF__NOID;
inc_data = NULL;
}
/* Open any GAI files. */
if( ngai ) {
ndgNdfas( igrpg, ifile, "READ", &indfg, status );
ndfDim( indfg, 3, gdims, &ndimg, status );
/* Check its dimensions, and map it if OK. */
if( *status == SAI__OK ) {
if( ndimg != 2 ) {
*status = SAI__ERROR;
ndfMsg( "C", indfg );
msgSeti( "N", ndimg );
errRep( " ", "Supplied GAI file (^C) has ^N dimensions - "
"must be 2.", status );
} else if( gdims[ 0 ] != 32 || gdims[ 1 ] != 40 ) {
*status = SAI__ERROR;
ndfMsg( "C", indfg );
errRep( " ", "Supplied GAI file (^C) has has bad "
"dimensions - should be 32x40.", status );
}
}
ndfMap( indfg, "DATA", "_DOUBLE", "READ", (void **) &gai_data,
&nelg, status );
} else {
indfg = NDF__NOID;
gai_data = NULL;
}
/* Fill the output with bad values. */
if( *status == SAI__OK ) {
pd = odata->pntr[ 0 ];
for( iel = 0; iel < ndata; iel++ ) *(pd++) = VAL__BADD;
}
/* Resample the sky map data into the output time series. */
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, in_data, odata->pntr[ 0 ],
NULL, &ngood, status );
/* Add on any COM data. */
smf_addcom( wf, odata, inc_data, status );
/* Issue a wrning if there is no good data in the output cube. */
if( ngood == 0 ) msgOutif( MSG__NORM, " ", " Output contains no "
"good data values.", status );
/* If Q and U maps have been given, allocate room to hold resampled Q and
U values, and fill them with bad values. */
if( inq_data && inu_data ) {
pq = outq_data = astMalloc( ndata*sizeof( *outq_data ) );
pu = outu_data = astMalloc( ndata*sizeof( *outu_data ) );
if( *status == SAI__OK ) {
for( iel = 0; iel < ndata; iel++ ) {
*(pu++) = VAL__BADD;
*(pq++) = VAL__BADD;
}
}
/* Determine the harmonic to use. */
parGet0i( "HARMONIC", &harmonic, status );
/* If producing the normal 8 Hz harmonic, get the amplitude and phase of a
other signals to add onto the 8 Hz signal. */
if( harmonic == 4 ) {
parGet0d( "AMP2", &2, status );
parGet0d( "PHASE2", &phase2, status );
parGet0d( "AMP4", &4, status );
parGet0d( "PHASE4", &phase4, status );
parGet0d( "AMP16", &16, status );
parGet0d( "PHASE16", &phase16, status );
} else {
amp2 = 0.0;
phase2 = 0.0;
amp4 = 0.0;
phase4 = 0.0;
amp16 = 0.0;
phase16 = 0.0;
}
/* Allocate room for an array to hold the angle from the Y pixel axis
in the sky map to the focal plane Y axis, in radians, at each time
slice. Positive rotation is in the same sense as rotation from
focal plane X to focal plane Y. */
ang_data = astMalloc( ntslice*sizeof( *ang_data ) );
/* Resample them both into 3D time series. These Q/U values arw with
respect to the sky image Y axis. */
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, inq_data, outq_data,
ang_data, &ngood, status );
smf_resampmap( wf, odata, abskyfrm, skymap, moving, slbnd, subnd,
interp, params, sigma, inu_data, outu_data,
NULL, &ngood, status );
/* Combine these time series with the main output time series so that the
main output is analysed intensity. */
smf_uncalc_iqu( wf, odata, odata->pntr[ 0 ], outq_data, outu_data,
ang_data, pasign, AST__DD2R*paoff, AST__DD2R*angrot,
amp2, AST__DD2R*phase2, amp4, AST__DD2R*phase4,
amp16, AST__DD2R*phase16, qinst_data, uinst_data,
c0_data, p0_data, p1_data, angc_data, harmonic,
status );
/* Release work space. */
outq_data = astFree( outq_data );
outu_data = astFree( outu_data );
ang_data = astFree( ang_data );
}
/* Factor in any GAI data. */
smf_addgai( wf, odata, gai_data, status );
/* Close the output time series file. */
smf_close_file( wf, &odata, status );
/* Close the IP data container for the current subarray, if it is open. */
if( cloc ) datAnnul( &cloc, status );
/* End the NDF context. */
ndfEnd( status );
}
/* Close any input data file that is still open due to an early exit from
the above loop. */
if( odata != NULL ) {
smf_close_file( wf, &odata, status );
odata = NULL;
}
/* Free remaining resources. */
if( igrp1 != NULL) grpDelet( &igrp1, status);
if( igrp2 != NULL) grpDelet( &igrp2, status);
if( igrpq != NULL) grpDelet( &igrpq, status);
if( igrpu != NULL) grpDelet( &igrpu, status);
if( igrpc != NULL) grpDelet( &igrpc, status);
if( igrpg != NULL) grpDelet( &igrpg, status);
if( ogrp != NULL) grpDelet( &ogrp, status);
if( iploc ) datAnnul( &iploc, status );
/* End the NDF context. */
ndfEnd( status );
/* End the tile's AST context. */
astEnd;
/* Issue a status indication.*/
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ",TASK_NAME " succeeded, time series written.", status);
} else {
msgOutif(MSG__VERB," ",TASK_NAME " failed.", status);
}
}
/* 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;
}
int smf_initial_sky( ThrWorkForce *wf, AstKeyMap *keymap, smfDIMMData *dat,
int *iters, int *status ) {
/* Local Variables: */
char refparam[ DAT__SZNAM ];/* Name for reference NDF parameter */
const char *cval; /* The IMPORTSKY string value */
double *ptr; /* Pointer to NDF Data array */
double *vptr; /* Pointer to NDF Variance array */
int indf1; /* Id. for supplied reference NDF */
int indf2; /* Id. for used section of reference NDF */
int nel; /* Number of mapped NDF pixels */
int result; /* Returned flag */
int there; /* Is there a smurf extension in the NDF? */
int update; /* Was NDF opened for UPDATE access? */
size_t i; /* Loop count */
size_t junk; /* Unused value */
/* Initialise the returned value to indicate no sky has been subtractred. */
result = 0;
/* Assume the sky map was not created by an interupted previous run of
makemap. */
*iters = -1;
/* Check inherited status. */
if( *status != SAI__OK ) return result;
/* Begin an AST context. */
astBegin;
/* The IMPORTSKY config parameter should have the name of the ADAM
parameter to use for acquiring the NDF that contains the initial sky
estimate. If IMPORTSKY is "1", use REF. */
cval = NULL;
astMapGet0C( keymap, "IMPORTSKY", &cval );
if( cval ) {
if( !astChrMatch( cval, "REF" ) &&
!astChrMatch( cval, "MASK2" ) &&
!astChrMatch( cval, "MASK3" ) ) {
astMapGet0I( keymap, "IMPORTSKY", &result );
cval = ( result > 0 ) ? "REF" : NULL;
}
if( cval ) {
result = 1;
strcpy( refparam, cval );
astChrCase( NULL, refparam, 1, 0 );
}
}
/* Do nothing more if we are not subtracting an initial sky from the data. */
if( result && *status == SAI__OK ) {
/* Begin an NDF context. */
ndfBegin();
/* Get an identifier for the NDF using the associated ADAM parameter.
First try UPDATE access. If this fails try READ access. */
ndfAssoc( refparam, "UPDATE", &indf1, status );
if( *status != SAI__OK ) {
errAnnul( status );
ndfAssoc( refparam, "READ", &indf1, status );
update = 0;
} else {
update = 1;
}
/* Tell the user what we are doing. */
ndfMsg( "N", indf1 );
msgOut( "", "Using ^N as the initial guess at the sky", status );
/* Get a section from this NDF that matches the bounds of the map. */
ndfSect( indf1, 2, dat->lbnd_out, dat->ubnd_out, &indf2, status );
/* Ensure masked values are not set bad in the mapped data array. */
ndfSbb( 0, indf2, status );
/* Map the data array section, and copy it into the map buffer. */
ndfMap( indf2, "DATA", "_DOUBLE", "READ", (void **) &ptr, &nel, status );
if( *status == SAI__OK ) {
memcpy( dat->map, ptr, dat->msize*sizeof(*ptr));
}
/* Map the variance array section, and copy it into the map buffer. */
ndfState( indf2, "VARIANCE", &there, status );
if( there ) {
ndfMap( indf2, "VARIANCE", "_DOUBLE", "READ", (void **) &vptr, &nel, status );
if( *status == SAI__OK ) {
memcpy( dat->mapvar, vptr, dat->msize*sizeof(*vptr));
}
}
/* If the NDF was created by a previous run of makemap that was interupted
using control-C, it will contain a NUMITER item in the smurf extension,
which gives the number of iterations that were completed before the
map was created. Obtain and return this value, if it exists. */
ndfXstat( indf1, SMURF__EXTNAME, &there, status );
if( there ) ndfXgt0i( indf1, SMURF__EXTNAME, "NUMITER", iters,
status );
/* If the NDF has a Quality component, import it and create initial AST,
FLT, PCA, SSN and COM masks from it. These will often be over-ridden by
new masks calculated with smf_calcmodel_ast below, but will not be
over-written if the masks have been frozen by xxx.zero_freeze. */
ndfState( indf2, "Quality", &there, status );
if( there && dat->mapqual ) {
smf_qual_t *qarray = smf_qual_map( wf, indf2, "Read", NULL, &junk,
status );
if( *status == SAI__OK ) {
smf_qual_t *pq = qarray;
for( i = 0; i < dat->msize; i++,pq++ ) {
if( *pq & SMF__MAPQ_AST ) {
if( !dat->ast_mask ) dat->ast_mask = astCalloc( dat->msize,
sizeof( *(dat->ast_mask) ) );
(dat->ast_mask)[ i ] = 1;
}
if( *pq & SMF__MAPQ_FLT ) {
if( !dat->flt_mask ) dat->flt_mask = astCalloc( dat->msize,
sizeof( *(dat->flt_mask) ) );
(dat->flt_mask)[ i ] = 1;
}
if( *pq & SMF__MAPQ_COM ) {
if( !dat->com_mask ) dat->com_mask = astCalloc( dat->msize,
sizeof( *(dat->com_mask) ) );
(dat->com_mask)[ i ] = 1;
}
if( *pq & SMF__MAPQ_SSN ) {
if( !dat->ssn_mask ) dat->ssn_mask = astCalloc( dat->msize,
sizeof( *(dat->ssn_mask) ) );
(dat->ssn_mask)[ i ] = 1;
}
if( *pq & SMF__MAPQ_PCA ) {
if( !dat->pca_mask ) dat->pca_mask = astCalloc( dat->msize,
sizeof( *(dat->pca_mask) ) );
(dat->pca_mask)[ i ] = 1;
}
}
}
qarray = astFree( qarray );
}
/* Indicate the map arrays within the supplied smfDIMMData structure now
contain usable values. We need to do this before calling
smf_calcmodel_ast below so that the right mask gets used in
smf_calcmodel_ast. */
dat->mapok = 1;
/* Apply any existinction correction to the cleaned bolometer data. */
if( dat->ext ) smf_calcmodel_ext( wf, dat, 0, keymap, dat->ext, 0,
status);
/* Sample the above map at the position of each bolometer sample and
subtract the sampled value from the cleaned bolometer value. */
smf_calcmodel_ast( wf, dat, 0, keymap, NULL, SMF__DIMM_PREITER, status);
/* Remove any existinction correction to the modifed bolometer data. */
if( dat->ext ) smf_calcmodel_ext( wf, dat, 0, keymap, dat->ext,
SMF__DIMM_INVERT, status);
/* If the NDF was opened with UPDATE access, update the quality array in
the NDF to reflect the AST mask created by smf_calcmodel_ast above. */
if( update ) {
smf_qual_t *qarray = astStore( NULL, dat->mapqual, dat->msize*sizeof(*qarray) );
qarray = smf_qual_unmap( wf, indf2, SMF__QFAM_MAP, qarray, status );
}
/* End the NDF context. */
ndfEnd( status );
}
/* End the AST context. */
astEnd;
/* Return the pointer to the boolean mask. */
return result;
}