AstKeyMap *smf_subinst_keymap( smf_subinst_t subinst, const smfData * indata,
const Grp * igrp, size_t idx, int * status ) {
const smfHead * hdr = NULL; /* Header of file to be examined */
size_t i;
smfData * sub_data = NULL; /* File to be examined */
AstKeyMap * sub_instruments; /* Keymap to be filled */
if (*status != SAI__OK) return NULL;
if (subinst == SMF__SUBINST_NONE && !indata && !igrp) {
*status = SAI__ERROR;
errRep( "", "Must supply either a subinst, a smfData or a Grp"
" (possible programming error)", status );
return NULL;
}
/* Create new keymap */
sub_instruments = astKeyMap( " " );
/* prefill with the list of known sub-instruments. */
for (i = 0; i < SMF__SUBINST_NSUBINST; i++ ) {
const char * substr = smf_subinst_str( i, status );
if (substr) astMapPut0I( sub_instruments, substr, 0, NULL );
}
/* If the current sub-instrument has not been supplied, get it from the file.
Use indata in preference to the group */
if( subinst == SMF__SUBINST_NONE ) {
if (indata) {
hdr = indata->hdr;
} else {
smf_open_file( igrp, idx, "READ", SMF__NOCREATE_DATA, &sub_data, status );
if (sub_data) {
hdr = sub_data->hdr;
}
}
if (hdr) subinst = smf_calc_subinst( hdr, status );
}
/* flag this as being the relevant sub-instrument */
if (subinst != SMF__SUBINST_NSUBINST ) {
const char * substr = smf_subinst_str( subinst, status );
if (substr) {
astMapPut0I( sub_instruments, substr, 1, NULL );
}
}
if (sub_data) smf_close_file( &sub_data, status );
/* Free the keymap if we have bad status */
if (*status != SAI__OK && sub_instruments) {
sub_instruments = astAnnul( sub_instruments );
}
return sub_instruments;
}
void smurf_rawrewrtsc2wcs( int * status ) {
size_t i;
Grp *igrp = NULL; /* Input group */
size_t size; /* Number of files in input group */
if (*status != SAI__OK) return;
ndfBegin();
/* Read the input file group */
kpg1Rgndf( "NDF", 0, 1, "", &igrp, &size, status );
for (i=1; i<=size && ( *status == SAI__OK ); i++) {
int indf = NDF__NOID;
smfData *data = NULL;
AstFrameSet * fixedwcs = NULL;
int isok = 1;
/* First open in READ mode as a sanity check */
smf_open_file( igrp, i, "READ", 0, &data, status );
if (*status != SAI__OK) break;
if (data->hdr->instrument != INST__SCUBA2) {
isok = 0;
msgOut( "", "This command only works on SCUBA-2 data files", status );
}
/* Get a fixed WCS frameset */
if (isok) {
smf_create_tswcs( data->hdr, &fixedwcs, status );
}
/* close up and skip if this is not a good file */
smf_close_file( &data, status );
if (!isok) continue;
/* Now we try to update the file using NDF */
ndgNdfas( igrp, i, "UPDATE", &indf, status );
ndfPtwcs( fixedwcs, indf, status );
ndfAnnul( &indf, status );
}
/* Cleanup */
grpDelet( &igrp, status);
ndfEnd( status );
}
/* Main entry */
void smurf_checkcoords( int *status ) {
/* Local Variables */
Grp *igrp = NULL;
size_t i;
size_t size;
smfData *data = NULL;
/* Check inherited status */
if (*status != SAI__OK) return;
/* begin an NDF context. */
ndfBegin();
/* Get a group of input files */
kpg1Rgndf( "IN", 0, 1, " Give more NDFs...", &igrp, &size, status );
/* Loop round each one. */
for( i = 1; i <= size; i++ ) {
/* Open the file. */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
/* Check the detector positions (for ACSIS data). */
msgBlank( status );
smf_check_detpos( data, 1, status );
/* Calculate and display statistics of the AZEL <> TRACKING separations
in the current file. */
smf_check_coords( data, status );
/* Close the file. */
smf_close_file( NULL, &data, status);
}
/* Free resources. */
grpDelet( &igrp, status );
/* End the NDF context. */
ndfEnd( status );
/* If anything went wrong issue a context message. */
if( *status != SAI__OK ) msgOutif( MSG__VERB, " ", "CHECKCOORDS failed.",
status );
}
void smurf_sc2expandmodel( int *status ) {
smf_expmodelptr expptr=NULL;/* Pointer to current model calc function */
size_t i=0; /* Counter, index */
smfData *idata=NULL; /* Input data */
Grp *igrp = NULL; /* Input group of files */
smfData *odata=NULL; /* Output data */
Grp *ogrp = NULL; /* Output group of files */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
/* Main routine */
ndfBegin();
/* Read the input file */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Loop over input files */
for( i=1; (*status==SAI__OK) && (i<=size); i++ ) {
/* Open file */
smf_open_file(NULL, igrp, i, "READ", 0, &idata, status);
/* Check to see if this is a DIMM model component before expanding */
if( idata && idata->hdr && (idata->hdr->mtype != SMF__NUL) ) {
expptr = smf_model_getexpptr( idata->hdr->mtype, status );
if( *status == SAI__OK ) {
(*expptr)( idata, &odata, status );
smf_write_smfData( NULL, odata, NULL, NULL, ogrp, i, 0,
MSG__VERB, 0, NULL, NULL, status );
}
}
}
/* Cleanup */
grpDelet( &igrp, status);
grpDelet( &ogrp, status);
ndfEnd( status );
}
void smf_open_asdouble( const Grp *igrp, size_t index, const smfArray* darks,
const smfArray* flatramps, AstKeyMap * heateffmap,
int ensureflat, smfData **data, int *status ) {
if( *status != SAI__OK ) return;
/* Load data, flatfielding and/or opening raw as double as necessary */
if( ensureflat ) {
smf_open_and_flatfield( igrp, NULL, index, darks, flatramps, heateffmap,
data, status );
} else {
/* open as raw if raw else just open as whatever we have */
smfData *tmpdata = NULL;
smf_open_file( igrp, index, "READ", SMF__NOCREATE_DATA, &tmpdata, status );
if (tmpdata && tmpdata->file && tmpdata->file->isSc2store) {
smf_open_raw_asdouble( igrp, index, darks, data, status );
} else {
smf_open_and_flatfield( igrp, NULL, index, darks, flatramps, heateffmap,
data, status );
}
smf_close_file( &tmpdata, status );
}
}
void smurf_fts2_transcorr(int* status)
{
if( *status != SAI__OK ) { return; }
char filename[GRP__SZNAM+1]; /* Filename */
char *pname = NULL; /* Pointer to filename */
int bolCount = 0; /* Number of bolometers */
int bolIndex = 0; /* Bolometer index */
int count;
int dims[NDF__MXDIM];
int debug = 0; /* If not debug, include dry component */
int ftsExists = 0;
int index = 0;
int indf; /* NDF identifier for TAU file */
int KERNELLENGTH = 101;
int nbolX = 0; /* Width of the source subarray */
int nbolY = 0; /* Height of the source subarray */
int ndfTau;
int ndim;
int nPWV = 0;
int nWN = 0;
int N = 0; /* Sample count */
int i = 0; /* Index */
int j = 0; /* Index */
int k = 0; /* Index */
int place;
double AM = 0.0; /* Airmass at ZPD */
double DELTAPWV = 0.0;
double PWV0 = 0.0;
double PWV = 0.0; /* PWV at ZPD */
double wnFact = 0.0; /* Wave number factor */
double* inPntr = NULL; /* Pointer to the input data */
double* outPntr = NULL; /* Pointer to the output data */
double* wnScan = NULL;
double* wnTau = NULL;
double* TAtm = NULL;
double* TAtmNew = NULL;
double* GAUSSIANKERNEL = NULL;
double* PWVARR = NULL;
double* PWVNEW = NULL;
double* TAUNEW = NULL;
double* TAUWET = NULL;
double* TMPARR = NULL;
Grp* inGrp = NULL; /* Input group */
Grp* outGrp = NULL; /* Output group */
Grp* tauGrp = NULL; /* TAU WET group */
HDSLoc* loc = NULL; /* HDS location */
size_t fIndex = 0; /* File loop counter */
size_t inSize = 0; /* Size of the input group */
size_t outSize = 0; /* Size of the output group */
size_t tauSize = 0; /* Size of the tau group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
smfData* tauData = NULL; /* Pointer to tau dry data */
void* TAU[] = {NULL, NULL}; /* {dry, wet} */
const double SQRT2PI = 2.50662827463100050242;
const double SQRT2LN2 = 1.17741002251547469101;
// GET INPUT GROUP
kpg1Rgndf("IN", 0, 1, "", &inGrp, &inSize, status);
// GET OUTPUT GROUP
kpg1Wgndf("OUT", outGrp, inSize, inSize,
"Equal number of input and output files expected!",
&outGrp, &outSize, status);
// GET TAU GROUP
kpg1Gtgrp("TAU", &tauGrp, &tauSize, status);
parGet0l("DEBUG", &debug, status);
ndfBegin();
// ===========================================================================
// GET TAU INFORMATION
// ===========================================================================
int dryOK = 0;
int wetOK = 0;
pname = filename;
grpGet(tauGrp, 1, 1, &pname, sizeof(filename), status);
ndgNdfas(tauGrp, 1, "READ", &indf, status );
if (indf == NDF__NOID) {
*status = SAI__ERROR;
msgSetc("FILE", filename);
errRep("", FUNC_NAME ": Could not locate file ^FILE", status);
return;
}
ndfXstat(indf, "FTS2", &ftsExists, status);
if(*status == SAI__OK && ftsExists) {
ndfXloc(indf, "FTS2", "READ", &loc, status);
if(*status == SAI__OK && loc != NULL) {
// DRY COMPONENT
ndfOpen(loc, "DRY", "READ", "UNKNOWN", &ndfTau, &place, status);
if(*status == SAI__OK && ndfTau != NDF__NOID) {
ndfDim(ndfTau, NDF__MXDIM, dims, &ndim, status);
if(*status == SAI__OK && ndim == 1) {
ndfMap(ndfTau, "DATA", "_DOUBLE", "READ", &TAU[0], &count, status);
dryOK = 1;
}
}
// WET COMPONENT
ndfOpen(loc, "WET", "READ", "UNKNOWN", &ndfTau, &place, status);
if(*status == SAI__OK && ndfTau != NDF__NOID) {
ndfDim(ndfTau, NDF__MXDIM, dims, &ndim, status);
if(*status == SAI__OK && ndim == 2) {
ndfMap(ndfTau, "DATA", "_DOUBLE", "READ", &TAU[1], &count, status);
wetOK = 1;
}
}
}
}
if(loc) { datAnnul(&loc, status); }
if(!(dryOK && wetOK)) {
*status = SAI__ERROR;
errRep("", FUNC_NAME ": Unable to obtain TAU values!", status);
return;
}
smf_open_file(NULL, tauGrp, 1, "READ", 0, &tauData, status);
smf_fits_getD(tauData->hdr, "PWV0", &PWV0, status);
smf_fits_getD(tauData->hdr, "DELTAPWV", &DELTAPWV, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep("", FUNC_NAME ": Unable to obtain PWV value(s)!", status);
return;
}
nWN = dims[0];
nPWV = dims[1];
PWVARR = astMalloc(nPWV * sizeof(*PWVARR));
for(i = 0; i < nPWV; i++) {
PWVARR[i] = PWV0 + i * DELTAPWV;
}
PWVNEW = astMalloc(1 * sizeof(*PWVNEW));
TAUNEW = astMalloc(1 * sizeof(*TAUNEW));
// ===========================================================================
// LOOP THROUGH EACH NDF FILE IN THE INPUT GROUP
// ===========================================================================
for(fIndex = 1; fIndex <= inSize; fIndex++) {
// OPEN INPUT FILE
smf_open_file(NULL, inGrp, fIndex, "READ", 0, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open source file!", status);
break;
}
outData = smf_deepcopy_smfData(NULL, inData, 0, SMF__NOCREATE_DATA, 0, 0, status);
if(*status == SAI__OK) {
inPntr = inData->pntr[0];
nbolX = inData->dims[0];
nbolY = inData->dims[1];
N = inData->dims[2];
bolCount = nbolX * nbolY;
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = inData->dims[0];
outData->dims[1] = inData->dims[1];
outData->dims[2] = inData->dims[2];
outData->lbnd[0] = outData->lbnd[0];
outData->lbnd[1] = outData->lbnd[1];
outData->lbnd[2] = outData->lbnd[2];
outData->pntr[0] = (double*) astMalloc( (N * bolCount)*sizeof(double) );
outPntr = outData->pntr[0];
// DETERMINE WAVENUMBER FACTOR FROM FITS
smf_fits_getD(inData->hdr, "WNFACT", &wnFact, status);
if(*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to find wave number factor!", status);
smf_close_file( NULL,&inData, status);
break;
}
// TODO
// DETERMINE AIRMASS AT ZPD
// TODO
// DETERMINE PWV AT ZPD
PWVNEW[0] = PWV;
// GET TAU WET FOR CORRESPONDING PWV
TAUWET = astMalloc(nWN * sizeof(*TAUWET));
TMPARR = astMalloc(nWN * sizeof(*TMPARR));
for(k = 0; k < nWN; k++) {
for(j = 0; j < nPWV; j++) {
TMPARR[j] = *((double*) TAU[1] + j);
}
fts2_naturalcubicsplineinterpolator(PWVARR, TMPARR, nPWV, PWVNEW, TAUNEW, 1);
TAUWET[k] = TAUNEW[0];
}
astFree(TMPARR);
// COMPUTE ATMOSPHERIC TRANSMISSION
// TATM = EXP(-AIRMASS * (PWV * TAUWET + TAUDRY))
TAtm = astMalloc(nWN * sizeof(*TAtm));
if(!debug) {
for(i = 0; i < nWN; i++) {
TAtm[i] = exp(-AM * (PWV * TAUWET[i] + (*((double*) TAU[0] + i))));
}
} else {
for(i = 0; i < nWN; i++) {
TAtm[i] = exp(-AM * PWV * TAUWET[i]);
}
}
// SMOOTH ATMOSPHERIC TRANSMISSION VIA GAUSSIAN CONVOLUTION
// NEED TO TRIM FROM BOTH ENDS BY HALF OF (KERNELLENGTH - 1)
double OPDMAX = 1.0;
double FWHM = 1.0 / (2.0 * OPDMAX); // FWHM = 1 / (2 x OPDMAX)
double SDEV = 0.5 * FWHM / SQRT2LN2; // FWHM = 2 x SQRT(2ln2) x SDEV
double VAR = SDEV * SDEV;
double VAR2 = 2.0 * VAR;
double NORM = 1.0 / (SDEV * SQRT2PI);
double XMIN = -6 * SDEV;
double XMAX = 6 * SDEV;
double DX = (XMAX - XMIN) / (KERNELLENGTH - 1);
double X = XMIN;
for(i = 0; i < KERNELLENGTH; i++) {
X = XMIN + i * DX;
GAUSSIANKERNEL[i] = NORM * exp(-(X * X) / VAR2);
}
int M = nWN + KERNELLENGTH - 1;
TMPARR = astMalloc(M * sizeof(*TMPARR));
for(i = 0; i < nWN; i++) {
for(j = 0; j < KERNELLENGTH; j++) {
TMPARR[i + j] += (TAtm[i] * GAUSSIANKERNEL[j]);
}
}
int OFFSET = (KERNELLENGTH - 1) >> 1;
for(i = 0; i < nWN; i++) {
TAtm[i] = TMPARR[i + OFFSET];
}
astFree(TMPARR);
// INTERPOLATE ATMOSPHERIC TRANSMISSION ONTO SCAN RESOLUTION
wnTau = astMalloc(nWN * sizeof(*wnTau));
wnScan = astMalloc(N * sizeof(*wnScan));
TAtmNew = astMalloc(N * sizeof(*TAtmNew));
for(i = 0; i < N; i++) {
wnScan[i] = i * wnFact;
}
for(i = 0; i < nWN; i++) {
wnTau[i] = i;
}
fts2_naturalcubicsplineinterpolator(wnTau, TAtm, nWN, wnScan, TAtmNew, N);
// TSOURCE = TOBS / TATM
for(i = 0; i < nbolY; i++) {
for(j = 0; j < nbolX; j++) {
bolIndex = i + j * nbolY;
for(k = 0; k < N; k++) {
index = bolIndex + bolCount * k;
outPntr[index] = inPntr[index] / TAtmNew[k];
}
}
}
astFree(wnTau);
astFree(wnScan);
astFree(TAtm);
astFree(TAtmNew);
smf_write_smfData(NULL, outData, NULL, NULL, outGrp, fIndex, 0, MSG__VERB,
0, status);
smf_close_file( NULL,&outData, status);
smf_close_file( NULL,&inData, status);
} else {
void smurf_dreamweights ( int *status ) {
/* Local Variables */
Grp *confgrp = NULL; /* Group containing configuration file */
smfData *data = NULL; /* Input data */
const int defgridminmax[] = { -4, 4, -4, 4 }; /* Default extent xmin,xmax,ymin,ymax */
int gridminmax[4]; /* Extent of grid points array */
int gridpts[DREAM__MXGRID][2]; /* Array of points for reconstruction grid */
double gridstep; /* Size of reconstruction grid in arcsec */
size_t i; /* Loop counter */
Grp *igrp = NULL; /* Input group of NDFs */
size_t size; /* Size of input Grp of files */
AstKeyMap *keymap = NULL; /* Pointer to keymap of config settings */
size_t ksize; /* Size of group containing CONFIG file */
int ngrid; /* Number of points in reconstruction grid */
Grp *ogrp = NULL; /* Group of output weights files */
size_t outsize; /* Size of output Grp of files */
/* Main routine */
ndfBegin();
/* Get group of input raw data NDFs */
kpg1Rgndf( "NDF", 0, 1, "", &igrp, &size, status );
/* Get group of output files from user: assume 1 output file for
every input file */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Read configuration settings into keymap */
if (*status == SAI__OK) {
kpg1Gtgrp( "CONFIG", &confgrp, &ksize, status );
if (*status == PAR__NULL) {
/* NULL value so provide defaults */
errAnnul( status );
msgOutif(MSG__VERB, " ", "No config file specified - assuming default configuration parameters", status);
keymap = astKeyMap(" " );
astMapPut1I( keymap, "GRIDMINMAX", 4, (int*)defgridminmax, " " );
astMapPut0D( keymap, "GRIDSTEP", 6.28, " " );
} else {
kpg1Kymap( confgrp, &keymap, status );
}
if( confgrp ) grpDelet( &confgrp, status );
}
/* Determine grid parameters from inputs given above */
smf_dream_getgrid( keymap, &gridstep, &ngrid, gridminmax, gridpts, status);
/* Annul keymap immediately as it is no longer required */
if (keymap) keymap = astAnnul( keymap );
/* Loop over number of files */
for ( i=1; (i<= size) && (*status == SAI__OK); i++) {
/* Open file */
smf_open_file( NULL, igrp, i, "READ", 0, &data, status );
/* Calculate weights based on this file */
smf_dream_calcweights( data, ogrp, i, gridstep, ngrid, gridminmax,
&(gridpts[0]), status);
/* Immediately check status on return and abort if an error occured */
if ( *status != SAI__OK ) {
msgSeti("I",i);
msgSeti("N",size);
errRep(FUNC_NAME, "Unable to determine DREAM weights for file ^I of ^N",
status);
}
smf_close_file( NULL, &data, status );
}
/* Free up resources */
if ( ogrp != NULL ) {
grpDelet( &ogrp, status);
}
if ( igrp != NULL ) {
grpDelet( &igrp, status);
}
ndfEnd( status );
msgOutif(MSG__VERB," ", "DREAM weights calculation completed successfully",
status);
}
void smf_getrefwcs( const char *param, Grp *igrp, AstFrameSet **specwcs,
AstFrameSet **spacewcs, int *isjsa, int *status ){
/* Local Variables */
AstFrame *frm = NULL;
AstFrameSet *refwcs = NULL; /* The WCS FrameSet from the reference NDF */
AstRegion *circle;
char text[ 255 ]; /* Parameter value */
int *tiles;
int i;
int jsatiles;
int lbnd[2]; /* Lower pixel index bounds of mid tile */
int ntile;
int perm[ 2 ];
int refndf; /* NDF identifier for the refence NDF */
int ubnd[2]; /* Upper pixel index bounds of mid tile */
size_t code;
smfData *data = NULL; /* Structure describing 1st input file */
smfJSATiling skytiling;
smf_inst_t inst = SMF__INST_NONE;
smf_jsaproj_t proj; /* Specific JSA projection to use */
smf_subinst_t subinst;
/* Initialise the returned values. */
*specwcs = NULL;
*spacewcs = NULL;
*isjsa = 0;
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Begin an AST context. */
astBegin;
/* If the JSAILES parameter is TRUE, then we use the JSA all-sky pixel
grid regardless of the setting of REF. */
parGet0l( "JSATILES", &jsatiles, status );
if( jsatiles ) {
strcpy( text, "JSA" );
*isjsa = 1;
/* Otherwise, first get the parameter value as a string. Use subpar to avoid problem
caused by interpretion of the text within the parameter system. */
} else {
subParFindpar( param, &code, status );
subParGetname( code, text, sizeof(text), status );
}
/* If no value was supplied, annul the error and do nothing more. */
if( *status == PAR__NULL ) {
errAnnul( status );
/* If it is "JSA", or one of the JSA projection codes, we return WCS that
describes one of the the JSA all-sky pixel grids. */
} else if( *status == SAI__OK ) {
proj = smf_jsaproj_fromstr( text, 0, status );
if( astChrMatch( text, "JSA" ) || proj != SMF__JSA_NULL ) {
*isjsa = 1;
/* Report an error if the instrument cannot be determined. */
if( !igrp ) {
*status = SAI__ERROR;
errRep( "", "smf_getrefwcs: Cannot use the JSA all-sky pixel "
"grid since no input group has been supplied (possibly "
"programming error).", status );
} else {
/* Open the first input file. */
smf_open_file( NULL, igrp, 1, "READ", SMF__NOCREATE_DATA, &data,
status );
if( *status == SAI__OK ) {
/* Get the instrument. */
if( data->hdr->instrument == INST__SCUBA2 ) {
subinst = smf_calc_subinst( data->hdr, status );
if( subinst == SMF__SUBINST_850 ) {
inst = SMF__INST_SCUBA_2_850;
} else {
inst = SMF__INST_SCUBA_2_450;
}
} else if( data->hdr->instrument == INST__ACSIS ) {
inst = SMF__INST_ACSIS;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
if( data->file ) {
smf_smfFile_msg( data->file, "FILE", 1, "one or more of "
"the input data files" );
} else {
msgSetc( "FILE", "one or more of the input data files" );
}
errRep( "", "No tiles are yet defined for the instrument that "
"created ^FILE.", status );
}
/* Get the parameters that define the layout of sky tiles for the
instrument. */
smf_jsatiling( inst, &skytiling, status );
/* For "JSA" - choose the best projection. */
if( astChrMatch( text, "JSA" ) ) {
/* Use the FITS headers in the first raw data file to create an AST Circle
describing the approximate area of the observation within the tracking
system. */
circle = smf_mapregion_approx( igrp, status );
/* Convert the circle to ICRS (as used by the JSA all-sky grid). */
astSetC( circle, "System", "ICRS" );
/* Get a list of the tiles that touch this circle. */
tiles = smf_jsatiles_region( circle, &skytiling,
&ntile, status );
/* Choose the best projection (i.e. the projection that puts the circle
furthest away from any singularities). */
proj = smf_jsaproj( ntile, tiles, &skytiling, status);
/* Free resources. */
tiles = astFree( tiles );
circle = astAnnul( circle );
/* If a good projection was specified, use it. Otherwise report an error. */
} else if( proj == SMF__JSA_NULL && *status == SAI__OK ) {
*status = SAI__ERROR;
errRepf( "", "Bad value '%s' supplied for parameter %s.",
status, text, param );
}
/* Report the projection type. */
msgOutf( " ", "The %s will be created on the JSA %s "
"pixel grid.", status,
(data->hdr->instrument==INST__ACSIS)?"cube":"map",
smf_jsaproj_tostr( proj ) );
/* All tiles within the same JSA projection use the same WCS, so we get
the WCS FrameSet for an arbitrary central tile, and use it for the
full map. The exception is that tiles within the HPX facet that is
split between bottom-left and top-right, use a different WCS (they
have different reference points). But our choice of projection should
mean that the map never falls in that facet. The base Frame will be
GRID coords within the tile, and the current Frame will be ICRS
(RA,Dec). */
smf_jsatile( ((skytiling.ntpf * skytiling.ntpf - 1) * 2) / 3,
&skytiling, 0, proj, NULL, spacewcs, NULL, lbnd,
ubnd, status );
/* Change the base Frame to be PIXEL. */
for( i = 1; i <= astGetI( *spacewcs, "NFrame" ); i++ ) {
frm = astGetFrame( *spacewcs, i );
if( astChrMatch( astGetC( frm, "Domain" ), "PIXEL" ) ) {
astSetI( *spacewcs, "Base", i );
}
frm = astAnnul( frm );
}
}
/* Close the current input data file. */
smf_close_file( NULL, &data, status);
}
/* Otherwise get the parameter value as an NDF. */
} else {
ndfAssoc( param, "READ", &refndf, status );
/* Get the WCS FrameSet from the reference NDF. */
ndfGtwcs( refndf, &refwcs, status );
/* Attempt to extract a new FrameSet from this WCS FrameSet, in which the
current Frame is a SkyFrame, and the base Frame is a 2D PIXEL Frame.
Since the NDF library sets the GRID Frame to be the Base Frame, we need
to make the PIXEL Frame the base Frame first. The NDF library ensures
that the pixel Frame is Frame 2. */
astSetI( refwcs, "Base", 2 );
*spacewcs = atlFrameSetSplit( refwcs, "SKY", NULL, NULL, status );
if( !(*spacewcs) ) {
if( *status == SAI__OK ) {
ndfMsg( "N", refndf );
*status = SAI__ERROR;
errRep( "", "The supplied reference NDF (^N) either has no "
"celestial WCS axes, or the celestial axes cannot "
"be separated from the non-celestial axes.", status );
}
/* The rest of makemap assumes that the sky frame axes are in the default
order (lon,lat). If this is not the case, permute them. */
} else if( astGetI( *spacewcs, "IsLatAxis(1)" ) ) {
perm[ 0 ] = 2;
perm[ 1 ] = 1;
astPermAxes( *spacewcs, perm );
}
/* Now look for the spectral WCS (described by a DSBSpecFrame). */
smf_getspectralwcs( refwcs, 1, specwcs, status );
/* We no longer need the NDF so annul it. */
ndfAnnul( &refndf, status );
}
}
/* If no error has occurred, export any returned FrameSet pointers from
the current AST context so that it will not be annulled when the AST
context is ended. Otherwise, ensure a null pointer is returned. */
if( *status == SAI__OK ) {
if( *spacewcs ) astExport( *spacewcs );
if( *specwcs ) astExport( *specwcs );
} else {
if( *spacewcs ) *spacewcs = astAnnul( *spacewcs );
if( *specwcs ) *specwcs = astAnnul( *specwcs );
}
/* End the AST context. This will annul all AST objects created within the
context (except for those that have been exported from the context). */
astEnd;
}
void smurf_unmakecube( int *status ) {
/* Local Variables */
AstFrame *tfrm = NULL; /* Current Frame from input WCS */
AstFrameSet *wcsin = NULL; /* WCS Frameset for input cube */
AstMapping *tmap = NULL; /* Base->current Mapping from input WCS */
AstSkyFrame *iskyfrm = NULL; /* SkyFrame from the input WCS Frameset */
Grp *detgrp = NULL; /* Group of detector names */
Grp *igrp1 = NULL; /* Group of input sky cube files */
Grp *igrp2 = NULL; /* Group of input template files */
Grp *ogrp = NULL; /* Group containing output file */
NdgProvenance *oprov = NULL;/* Provenance for the output NDF */
SkyCube *sky_cubes = NULL; /* Pointer to array of sky cube descriptions */
SkyCube *skycube = NULL; /* Pointer to next sky cube description */
char pabuf[ 10 ]; /* Text buffer for parameter value */
double params[ 4 ]; /* astResample parameters */
int axes[ 2 ]; /* Indices of selected axes */
int blank; /* Was a blank line just output? */
int flag; /* Was the group expression flagged? */
int ifile; /* Input file index */
int interp = 0; /* Pixel interpolation method */
int iskycube; /* Index of current sky cube */
int nel; /* Number of elements in 3D array */
int nparam = 0; /* No. of parameters required for interpolation scheme */
int ondf; /* Output time series NDF identifier */
int outax[ 2 ]; /* Indices of corresponding output axes */
int overlap; /* Does time series overlap sky cube? */
int sdim[3]; /* Array of significant pixel axes */
int usedetpos; /* Should the detpos array be used? */
size_t ndet; /* Number of detectors supplied for "DETECTORS" */
size_t nskycube; /* Number of supplied sky cubes */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Pointer to data struct */
void *in_data = NULL; /* Pointer to the input cube data array */
void *out_data = NULL; /* Pointer to the output cube data array */
#if defined(FPTRAP)
feenableexcept(FE_DIVBYZERO|FE_INVALID|FE_OVERFLOW);
#endif
/* Check inherited status */
if( *status != SAI__OK ) return;
/* We have not yet displayed a blank line on stdout. */
blank = 0;
/* Begin an AST context */
astBegin;
/* Begin an NDF context. */
ndfBegin();
/* Get a group holding the input sky cubes. */
kpg1Rgndf( "IN", 0, 1, "", &igrp1, &nskycube, status );
/* Create an array of structures to hold information about each input sky
cube. */
sky_cubes = astMalloc( sizeof( SkyCube )*(size_t) nskycube );
/* Store a description of each sky cube. */
if( sky_cubes ) {
for( iskycube = 0; iskycube < nskycube; iskycube++ ) {
skycube = sky_cubes + iskycube;
/* Get an NDF identifier for the next sky cube. */
ndgNdfas( igrp1, iskycube + 1, "READ", &(skycube->indf), status );
/* Get the WCS FrameSet from the sky cube, together with its pixel index
bounds. */
kpg1Asget( skycube->indf, 3, 0, 1, 1, sdim, skycube->slbnd,
skycube->subnd, &wcsin, status );
/* Get the base->current Mapping from the input WCS FrameSet, and split it
into two Mappings; one (iskymap) that maps the first 2 GRID axes into
celestial sky coordinates, and one (ispecmap) that maps the third GRID
axis into a spectral coordinate. Also extract the SpecFrame and
SkyFrame from the current Frame. */
tmap = astGetMapping( wcsin, AST__BASE, AST__CURRENT );
tfrm = astGetFrame( wcsin, AST__CURRENT );
axes[ 0 ] = 1;
axes[ 1 ] = 2;
astMapSplit( tmap, 2, axes, outax, &(skycube->iskymap) );
iskyfrm = astPickAxes( tfrm, 2, outax, NULL );
axes[ 0 ] = 3;
astMapSplit( tmap, 1, axes, outax, &(skycube->ispecmap) );
skycube->ispecfrm = astPickAxes( tfrm, 1, outax, NULL );
/* Create a copy of "iskyfrm" representing absolute coords rather than
offsets. We assume the target is moving if the cube represents offsets. */
skycube->abskyfrm = astCopy( iskyfrm );
astClear( skycube->abskyfrm, "SkyRefIs" );
skycube->moving = ( *status == SAI__OK &&
!strcmp( astGetC( iskyfrm, "SkyRefIs" ),
"Origin" ) ) ? 1 : 0;
/* Invert the Mappings (for the convenience of smf_resamplecube), so
that they go from current Frame to grid axis. */
astInvert( skycube->ispecmap );
astInvert( skycube->iskymap );
/* For efficiency, annul manually the unneeded AST objects created in
this loop. */
wcsin = astAnnul( wcsin );
tmap = astAnnul( tmap );
tfrm = astAnnul( tfrm );
iskyfrm = astAnnul( iskyfrm );
}
}
/* See if the detector positions are to be read from the RECEPPOS array
in the template NDFs. Otherwise, they are calculated on the basis of
the FPLANEX/Y arrays. */
parGet0l( "USEDETPOS", &usedetpos, status );
/* Get the detectors to use. If a null value is supplied, annull the
error. Otherwise, make the group case insensitive. */
detgrp = NULL;
if( *status == SAI__OK ) {
kpg1Gtgrp( "DETECTORS", &detgrp, &ndet, status );
if( *status == PAR__NULL ) {
errAnnul( status );
if (detgrp) {
grpDelet( &detgrp, status );
}
} else {
grpSetcs( detgrp, 0, status );
}
}
/* Get the pixel interpolation scheme to use. */
parChoic( "INTERP", "NEAREST", "NEAREST,LINEAR,SINC,"
"SINCSINC,SINCCOS,SINCGAUSS,SOMB,SOMBCOS",
1, pabuf, 10, status );
if( !strcmp( pabuf, "NEAREST" ) ) {
interp = AST__NEAREST;
nparam = 0;
} else if( !strcmp( pabuf, "LINEAR" ) ) {
interp = AST__LINEAR;
nparam = 0;
} else if( !strcmp( pabuf, "SINC" ) ) {
interp = AST__SINC;
nparam = 1;
} else if( !strcmp( pabuf, "SINCSINC" ) ) {
interp = AST__SINCSINC;
nparam = 2;
} else if( !strcmp( pabuf, "SINCCOS" ) ) {
interp = AST__SINCCOS;
nparam = 2;
} else if( !strcmp( pabuf, "SINCGAUSS" ) ) {
interp = AST__SINCGAUSS;
nparam = 2;
} else if( !strcmp( pabuf, "SOMB" ) ) {
interp = AST__SOMB;
nparam = 1;
} else if( !strcmp( pabuf, "SOMBCOS" ) ) {
interp = AST__SOMBCOS;
nparam = 2;
} else if( *status == SAI__OK ) {
nparam = 0;
*status = SAI__ERROR;
msgSetc( "V", pabuf );
errRep( "", "Support not available for INTERP = ^V (programming "
"error)", status );
}
/* Get an additional parameter vector if required. */
if( nparam > 0 ) parExacd( "PARAMS", nparam, params, status );
/* Get a group of reference time series files to use as templates for
the output time series files.*/
ndgAssoc( "REF", 1, &igrp2, &size, &flag, status );
/* Create a group holding the names of the corresponding output NDFs. */
ndgCreat ( "OUT", igrp2, &ogrp, &outsize, &flag, status );
if( outsize != size && *status == SAI__OK ) {
*status = SAI__ERROR;
msgSeti( "O", outsize );
msgSeti( "I", size );
errRep( "", "Numbers of input reference cubes (^I) and output "
"cubes (^O) differ.", status );
}
/* Loop round all the template time series files. */
for( ifile = 1; ifile <= size && *status == SAI__OK; ifile++ ) {
/* Start a new NDF context. */
ndfBegin();
/* Obtain information about the current template NDF, but do not map the
arrays. */
smf_open_file( igrp2, ifile, "READ", SMF__NOCREATE_DATA, &data, status );
/* Issue a suitable message and abort if anything went wrong. */
if( *status != SAI__OK ) {
errRep( FUNC_NAME, "Could not open input template file.", status );
break;
} else {
if( data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( data->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
}
}
/* Report the name of the input template. */
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSeti( "THISFILE", ifile );
msgSeti( "NUMFILES", size );
msgOutif( MSG__NORM, " ", "Simulating ^THISFILE/^NUMFILES ^FILE",
status );
/* Create the output NDF by propagation from the input template NDF.
Everything is copied except for the array components and any PROVENANCE
extension. */
ndgNdfpr( data->file->ndfid, "TITLE,LABEL,UNITS,AXIS,WCS,HISTORY,"
"NOEXTENSION(PROVENANCE)", ogrp, ifile, &ondf, status );
/* Ensure the output NDF has a history component. */
ndfHcre( ondf, status );
/* Get a pointer to the mapped output data array. Set all values bad. */
ndfMap( ondf, "DATA", "_REAL", "WRITE/BAD", &out_data, &nel, status );
/* If the detector positions are to calculated on the basis of FPLANEX/Y
rather than detpos, then free the detpos array in the templates smfHead
structure. This will cause smf_tslice_ast to use the fplanex/y values. */
if( !usedetpos && data->hdr->detpos ) {
astFree( (double *) data->hdr->detpos );
data->hdr->detpos = NULL;
}
/* Get a pointer to a structure holding provenance information for the
output time series. */
oprov = ndgReadProv( ondf, "SMURF:UNMAKECUBE", status );
/* Record details of the template in the provenance structure for the
output time series. */
ndgPutProv( oprov, data->file->ndfid, NULL, 0, status );
/* Loop round all input sky cubes. */
for( iskycube = 0; iskycube < nskycube; iskycube++ ) {
skycube = sky_cubes + iskycube;
/* Record details of the input cube in the provenance extension of the
output time series. */
ndgPutProv( oprov, skycube->indf, NULL, 0, status );
/* See if the current time series overlaps the current sky cube. */
smf_resampcube( data, skycube->abskyfrm,
skycube->iskymap, skycube->ispecfrm,
skycube->ispecmap, detgrp, skycube->moving,
skycube->slbnd, skycube->subnd, interp,
params, NULL, NULL, &overlap, status );
/* If not, pass on to the next sky cube. */
if( overlap ) {
/* Report the name of the sky cube. */
ndfMsg( "NDF", skycube->indf );
msgOutif( MSG__NORM, " ", " Re-sampling ^NDF", status );
/* Map the data array in the current sky cube. */
ndfMap( skycube->indf, "DATA", "_REAL", "READ", &in_data, &nel,
status );
/* Resample the cube data into the output time series. */
smf_resampcube( data, skycube->abskyfrm,
skycube->iskymap, skycube->ispecfrm,
skycube->ispecmap, detgrp, skycube->moving,
skycube->slbnd, skycube->subnd, interp,
params, in_data, out_data, &overlap, status );
/* Unmap the data array. */
ndfUnmap( skycube->indf, "DATA", status );
}
}
/* Write the provenance structure to the output NDF, and then free it. */
ndgWriteProv( oprov, ondf, 1, status );
oprov =ndgFreeProv( oprov, status );
/* Close the input time series file. */
if( data != NULL ) {
smf_close_file( &data, status );
data = NULL;
}
/* End the NDF context. */
ndfEnd( status );
}
/* Close any input data file that is still open due to an early exit from
the above loop. */
if( data != NULL ) {
smf_close_file( &data, status );
data = NULL;
}
/* Free remaining resources. */
if( detgrp != NULL) grpDelet( &detgrp, status);
if( igrp1 != NULL) grpDelet( &igrp1, status);
if( igrp2 != NULL) grpDelet( &igrp2, status);
if( ogrp != NULL) grpDelet( &ogrp, status);
sky_cubes = astFree( sky_cubes );
/* End the NDF context. */
ndfEnd( status );
/* End the tile's AST context. */
astEnd;
/* Issue a status indication.*/
if( *status == SAI__OK ) {
msgOutif(MSG__VERB," ",TASK_NAME " succeeded, time series written.", status);
} else {
msgOutif(MSG__VERB," ",TASK_NAME " failed.", status);
}
}
void smf_mapbounds( int fast, Grp *igrp, int size, const char *system,
AstFrameSet *spacerefwcs, int alignsys, int *lbnd_out,
int *ubnd_out, AstFrameSet **outframeset, int *moving,
smfBox ** boxes, fts2Port fts_port, int *status ) {
/* Local Variables */
AstSkyFrame *abskyframe = NULL; /* Output Absolute SkyFrame */
int actval; /* Number of parameter values supplied */
AstMapping *bolo2map = NULL; /* Combined mapping bolo->map
coordinates, WCS->GRID Mapping from
input WCS FrameSet */
smfBox *box = NULL; /* smfBox for current file */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
double dlbnd[ 2 ]; /* Floating point lower bounds for output map */
drcntrl_bits drcntrl_mask = 0;/* Mask to use for DRCONTROL on this instrument */
double dubnd[ 2 ]; /* Floating point upper bounds for output map */
AstMapping *fast_map = NULL; /* Mapping from tracking to absolute map coords */
smfFile *file = NULL; /* SCUBA2 data file information */
int first; /* Is this the first good subscan ? */
AstFitsChan *fitschan = NULL;/* Fits channels to construct WCS header */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
smfHead *hdr = NULL; /* Pointer to data header this time slice */
int i; /* Loop counter */
dim_t j; /* Loop counter */
AstSkyFrame *junksky = NULL; /* Unused SkyFrame argument */
dim_t k; /* Loop counter */
int lbnd0[ 2 ]; /* Defaults for LBND parameter */
double map_pa=0; /* Map PA in output coord system (rads) */
dim_t maxloop; /* Number of times to go round the time slice loop */
dim_t nbadt = 0; /* Number of bad time slices */
dim_t ngoodt = 0; /* Number of good time slices */
double par[7]; /* Projection parameters */
double shift[ 2 ]; /* Shifts from PIXEL to GRID coords */
AstMapping *oskymap = NULL; /* Mapping celestial->map coordinates,
Sky <> PIXEL mapping in output
FrameSet */
AstSkyFrame *oskyframe = NULL;/* Output SkyFrame */
char *refsys = NULL; /* Sky system from supplied reference FrameSet */
dim_t textreme[4]; /* Time index corresponding to minmax TCS posn */
AstFrame *skyin = NULL; /* Sky Frame in input FrameSet */
double skyref[ 2 ]; /* Values for output SkyFrame SkyRef attribute */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
AstMapping *tmap; /* Temporary Mapping */
int trim; /* Trim borders of bad pixels from o/p image? */
int ubnd0[ 2 ]; /* Defaults for UBND parameter */
double x_array_corners[4]; /* X-Indices for corner bolos in array */
double x_map[4]; /* Projected X-coordinates of corner bolos */
double y_array_corners[4]; /* Y-Indices for corner pixels in array */
double y_map[4]; /* Projected X-coordinates of corner bolos */
/* Main routine */
if (*status != SAI__OK) return;
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Initialize pointer to output FrameSet and moving-source flag */
*outframeset = NULL;
*moving = 0;
/* initialize double precision output bounds and the proj pars */
for( i = 0; i < 7; i++ ) par[ i ] = AST__BAD;
dlbnd[ 0 ] = VAL__MAXD;
dlbnd[ 1 ] = VAL__MAXD;
dubnd[ 0 ] = VAL__MIND;
dubnd[ 1 ] = VAL__MIND;
/* If we have a supplied reference WCS we can use that directly
without having to calculate it from the data. Replace the requested
system with the system from the reference FrameSet (take a copy of the
string since astGetC may re-use its buffer). */
if (spacerefwcs) {
oskyframe = astGetFrame( spacerefwcs, AST__CURRENT );
int nc = 0;
refsys = astAppendString( NULL, &nc, astGetC( oskyframe, "System" ) );
system = refsys;
}
/* Create array of returned smfBox structures and store a pointer
to the next one to be initialised. */
*boxes = astMalloc( sizeof( smfBox ) * size );
box = *boxes;
astBegin;
/* Loop over all files in the Grp */
first = 1;
for( i=1; i<=size; i++, box++ ) {
/* Initialise the spatial bounds of section of the the output cube that is
contributed to by the current ionput file. */
box->lbnd[ 0 ] = VAL__MAXD;
box->lbnd[ 1 ] = VAL__MAXD;
box->ubnd[ 0 ] = VAL__MIND;
box->ubnd[ 1 ] = VAL__MIND;
/* Read data from the ith input file in the group */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
if (*status != SAI__OK) {
msgSeti( "I", i );
errRep( "smf_mapbounds", "Could not open data file no ^I.", status );
break;
} else {
if( *status == SAI__OK ) {
if( data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
break;
} else if( data->hdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with smfData.",
status );
break;
} else if( data->hdr->fitshdr == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No FITS header associated with smfHead.",
status );
break;
}
}
}
/* convenience pointers */
file = data->file;
hdr = data->hdr;
/* report name of the input file */
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti("I", i);
msgSeti("N", size);
msgOutif(MSG__VERB, " ",
"SMF_MAPBOUNDS: Processing ^I/^N ^FILE",
status);
/* Check that there are 3 pixel axes. */
if( data->ndims != 3 ) {
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti( "NDIMS", data->ndims );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE has ^NDIMS pixel axes, should be 3.",
status );
break;
}
/* Check that the data dimensions are 3 (for time ordered data) */
if( *status == SAI__OK ) {
/* If OK Decide which detectors (GRID coord) to use for
checking bounds, depending on the instrument in use. */
switch( hdr->instrument ) {
case INST__SCUBA2:
drcntrl_mask = DRCNTRL__POSITION;
/* 4 corner bolometers of the subarray */
x_array_corners[0] = 1;
x_array_corners[1] = 1;
x_array_corners[2] = (data->dims)[0];
x_array_corners[3] = (data->dims)[0];
y_array_corners[0] = 1;
y_array_corners[1] = (data->dims)[1];
y_array_corners[2] = 1;
y_array_corners[3] = (data->dims)[1];
break;
case INST__AZTEC:
/* Rough guess for extreme bolometers around the edge */
x_array_corners[0] = 22;
x_array_corners[1] = 65;
x_array_corners[2] = 73;
x_array_corners[3] = 98;
y_array_corners[0] = 1; /* Always 1 for AzTEC */
y_array_corners[1] = 1;
y_array_corners[2] = 1;
y_array_corners[3] = 1;
break;
case INST__ACSIS:
smf_find_acsis_corners( data, x_array_corners, y_array_corners,
status);
break;
default:
*status = SAI__ERROR;
errRep(FUNC_NAME, "Don't know how to calculate mapbounds for data created with this instrument", status);
}
}
if( *status == SAI__OK) {
size_t goodidx = SMF__BADSZT;
/* Need to build up a frameset based on good telescope position.
We can not assume that we the first step will be a good TCS position
so we look for one. If we can not find anything we skip to the
next file. */
maxloop = (data->dims)[2];
for (j=0; j<maxloop; j++) {
JCMTState state = (hdr->allState)[j];
if (state.jos_drcontrol >= 0 && state.jos_drcontrol & drcntrl_mask ) {
/* bad TCS - so try again */
} else {
/* Good tcs */
goodidx = j;
break;
}
}
if (goodidx == SMF__BADSZT) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>");
msgOutif( MSG__QUIET, "", "No good telescope positions found in file ^FILE. Ignoring",
status );
smf_close_file( NULL, &data, status );
continue;
}
/* If we are dealing with the first good file, create the output
SkyFrame. */
if( first ) {
first = 0;
/* Create output SkyFrame if it has not come from a reference */
if ( oskyframe == NULL ) {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &oskyframe, skyref,
moving, status );
/* Get the orientation of the map vertical within the output celestial
coordinate system. This is derived form the MAP_PA FITS header, which
gives the orientation of the map vertical within the tracking system. */
map_pa = smf_calc_mappa( hdr, system, skyin, status );
/* Provide a sensible default for the pixel size based on wavelength */
par[4] = smf_calc_telres( hdr->fitshdr, status );
par[4] *= AST__DD2R/3600.0;
par[5] = par[4];
/* Calculate the projection parameters. We do not enable autogrid determination
for SCUBA-2 so we do not need to obtain all the data before calculating
projection parameters. */
smf_get_projpar( oskyframe, skyref, *moving, 0, 0, NULL, 0,
map_pa, par, NULL, NULL, status );
if (skyin) skyin = astAnnul( skyin );
/* If the output skyframe has been supplied, we still need to
determine whether the source is moving or not, and set the
reference position. */
} else {
/* smf_tslice_ast only needs to get called once to set up framesets */
if( hdr->wcs == NULL ) {
smf_tslice_ast( data, goodidx, 1, fts_port, status);
}
/* Retrieve input SkyFrame */
skyin = astGetFrame( hdr->wcs, AST__CURRENT );
smf_calc_skyframe( skyin, system, hdr, alignsys, &junksky, skyref,
moving, status );
/* Store the sky reference position. If the target is moving,
ensure the returned SkyFrame represents offsets from the
reference position rather than absolute coords. */
astSetD( oskyframe, "SkyRef(1)", skyref[ 0 ] );
astSetD( oskyframe, "SkyRef(2)", skyref[ 1 ] );
if( *moving ) astSet( oskyframe, "SkyRefIs=Origin" );
/* Ensure the Epoch attribute in the map is set to the date of
the first data in the map, rather than the date in supplied
reference WCS. */
astSetD( oskyframe, "Epoch", astGetD( junksky, "Epoch" ) );
}
if ( *outframeset == NULL && oskyframe != NULL && (*status == SAI__OK)){
/* Now created a spatial Mapping. Use the supplied reference frameset
if supplied */
if (spacerefwcs) {
oskymap = astGetMapping( spacerefwcs, AST__BASE, AST__CURRENT );
} else {
/* Now populate a FitsChan with FITS-WCS headers describing
the required tan plane projection. The longitude and
latitude axis types are set to either (RA,Dec) or (AZ,EL)
to get the correct handedness. */
fitschan = astFitsChan ( NULL, NULL, " " );
smf_makefitschan( astGetC( oskyframe, "System"), &(par[0]),
&(par[2]), &(par[4]), par[6], fitschan, status );
astClear( fitschan, "Card" );
fs = astRead( fitschan );
/* Extract the output PIXEL->SKY Mapping. */
oskymap = astGetMapping( fs, AST__BASE, AST__CURRENT );
/* Tidy up */
fs = astAnnul( fs );
}
/* Create the output FrameSet */
*outframeset = astFrameSet( astFrame(2, "Domain=GRID"), " " );
/* Now add the SkyFrame to it */
astAddFrame( *outframeset, AST__BASE, oskymap, oskyframe );
/* Now add a POLANAL Frame if required (i.e. if the input time
series are POL-2 Q/U values). */
smf_addpolanal( *outframeset, hdr, status );
/* Invert the oskymap mapping */
astInvert( oskymap );
} /* End WCS FrameSet construction */
}
/* Get a copy of the output SkyFrame and ensure it represents
absolute coords rather than offset coords. */
abskyframe = astCopy( oskyframe );
astClear( abskyframe, "SkyRefIs" );
astClear( abskyframe, "AlignOffset" );
maxloop = (data->dims)[2];
if (fast) {
/* For scan map we scan through looking for largest telescope moves.
For dream/stare we just look at the start and end time slices to
account for sky rotation. */
if (hdr->obsmode != SMF__OBS_SCAN) {
textreme[0] = 0;
textreme[1] = (data->dims)[2] - 1;
maxloop = 2;
} else {
const char *tracksys;
double *ac1list, *ac2list, *bc1list, *bc2list, *p1, *p2, *p3, *p4;
double flbnd[4], fubnd[4];
JCMTState state;
/* If the output and tracking systems are different, get a
Mapping between them. */
tracksys = sc2ast_convert_system( (hdr->allState)[goodidx].tcs_tr_sys,
status );
if( strcmp( system, tracksys ) ) {
AstSkyFrame *tempsf = astCopy( abskyframe );
astSetC( tempsf, "System", tracksys );
AstFrameSet *tempfs = astConvert( tempsf, abskyframe, "" );
tmap = astGetMapping( tempfs, AST__BASE, AST__CURRENT );
fast_map = astSimplify( tmap );
tmap = astAnnul( tmap );
tempsf = astAnnul( tempsf );
tempfs = astAnnul( tempfs );
} else {
fast_map = NULL;
}
/* Copy all ac1/2 positions into two array, and transform them
from tracking to absolute output sky coords. */
ac1list = astMalloc( maxloop*sizeof( *ac1list ) );
ac2list = astMalloc( maxloop*sizeof( *ac2list ) );
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_ac1;
*(p2++) = state.tcs_tr_ac2;
}
if( fast_map ) astTran2( fast_map, maxloop, ac1list, ac2list, 1,
ac1list, ac2list );
}
/* If the target is moving, we need to adjust these ac1/2 values
to represent offsets from the base position. */
if( *moving ) {
/* Copy all bc1/2 positions into two arrays. */
bc1list = astMalloc( maxloop*sizeof( *bc1list ) );
bc2list = astMalloc( maxloop*sizeof( *bc2list ) );
if( *status == SAI__OK ) {
p1 = bc1list;
p2 = bc2list;
for( j = 0; j < maxloop; j++ ) {
state = (hdr->allState)[ j ];
*(p1++) = state.tcs_tr_bc1;
*(p2++) = state.tcs_tr_bc2;
}
/* Transform them from tracking to absolute output sky coords. */
if( fast_map ) astTran2( fast_map, maxloop, bc1list, bc2list,
1, bc1list, bc2list );
/* Replace each ac1/2 position with the offsets from the
corresponding base position. */
p1 = bc1list;
p2 = bc2list;
p3 = ac1list;
p4 = ac2list;
for( j = 0; j < maxloop; j++ ) {
smf_offsets( *(p1++), *(p2++), p3++, p4++, status );
}
}
/* We no longer need the base positions. */
bc1list = astFree( bc1list );
bc2list = astFree( bc2list );
}
/* Transform the ac1/2 position from output sky coords to
output pixel coords. */
astTran2( oskymap, maxloop, ac1list, ac2list, 1, ac1list, ac2list );
/* Find the bounding box containing these pixel coords and the
time slices at which the boresight touches each edge of this
box. */
flbnd[ 0 ] = VAL__MAXD;
flbnd[ 1 ] = VAL__MAXD;
fubnd[ 0 ] = VAL__MIND;
fubnd[ 1 ] = VAL__MIND;
for( j = 0; j < 4; j++ ) textreme[ j ] = (dim_t) VAL__BADI;
if( *status == SAI__OK ) {
p1 = ac1list;
p2 = ac2list;
for( j = 0; j < maxloop; j++,p1++,p2++ ) {
if( *p1 != VAL__BADD && *p2 != VAL__BADD ){
if ( *p1 < flbnd[0] ) { flbnd[0] = *p1; textreme[0] = j; }
if ( *p2 < flbnd[1] ) { flbnd[1] = *p2; textreme[1] = j; }
if ( *p1 > fubnd[0] ) { fubnd[0] = *p1; textreme[2] = j; }
if ( *p2 > fubnd[1] ) { fubnd[1] = *p2; textreme[3] = j; }
}
}
}
maxloop = 4;
msgSetd("X1", textreme[0]);
msgSetd("X2", textreme[1]);
msgSetd("X3", textreme[2]);
msgSetd("X4", textreme[3]);
msgOutif( MSG__DEBUG, " ",
"Extrema time slices are ^X1, ^X2, ^X3 and ^X4",
status);
ac1list = astFree( ac1list );
ac2list = astFree( ac2list );
}
}
/* Get the astrometry for all the relevant time slices in this data file */
for( j=0; j<maxloop; j++ ) {
dim_t ts; /* Actual time slice to use */
/* if we are doing the fast loop, we need to read the time slice
index from textreme. Else we just use the index */
if (fast) {
/* get the index but make sure it is good */
ts = textreme[j];
if (ts == (dim_t)VAL__BADI) continue;
} else {
ts = j;
}
/* Calculate the bolo to map-pixel transformation for this tslice */
bolo2map = smf_rebin_totmap( data, ts, abskyframe, oskymap,
*moving, fts_port, status );
if ( *status == SAI__OK ) {
/* skip if we did not get a mapping this time round */
if (!bolo2map) continue;
/* Check corner pixels in the array for their projected extent
on the sky to set the pixel bounds */
astTran2( bolo2map, 4, x_array_corners, y_array_corners, 1,
x_map, y_map );
/* Update min/max for this time slice */
for( k=0; k<4; k++ ) {
if( x_map[k] != AST__BAD && y_map[k] != AST__BAD ) {
if( x_map[k] < dlbnd[0] ) dlbnd[0] = x_map[k];
if( y_map[k] < dlbnd[1] ) dlbnd[1] = y_map[k];
if( x_map[k] > dubnd[0] ) dubnd[0] = x_map[k];
if( y_map[k] > dubnd[1] ) dubnd[1] = y_map[k];
if( x_map[k] < box->lbnd[0] ) box->lbnd[0] = x_map[k];
if( y_map[k] < box->lbnd[1] ) box->lbnd[1] = y_map[k];
if( x_map[k] > box->ubnd[0] ) box->ubnd[0] = x_map[k];
if( y_map[k] > box->ubnd[1] ) box->ubnd[1] = y_map[k];
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Extreme positions are bad.", status );
break;
}
}
}
/* Explicitly annul these mappings each time slice for reduced
memory usage */
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fs) fs = astAnnul( fs );
/* Break out of loop over time slices if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* Annul any remaining Ast objects before moving on to the next file */
if (fs) fs = astAnnul( fs );
if (bolo2map) bolo2map = astAnnul( bolo2map );
}
/* Close the data file */
smf_close_file( NULL, &data, status);
/* Break out of loop over data files if bad status */
if (*status != SAI__OK) goto CLEANUP;
}
/* make sure we got values - should not be possible with good status */
if (dlbnd[0] == VAL__MAXD || dlbnd[1] == VAL__MAXD) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRep( " ", "Unable to find any valid map bounds", status );
}
}
if (nbadt > 0) {
msgOutf( "", " Processed %zu time slices to calculate bounds,"
" of which %zu had bad telescope data and were skipped",
status, (size_t)(ngoodt+nbadt), (size_t)nbadt );
}
/* If spatial reference wcs was supplied, store par values that result in
no change to the pixel origin. */
if( spacerefwcs ){
par[ 0 ] = 0.5;
par[ 1 ] = 0.5;
}
/* Need to re-align with the interim GRID coordinates */
lbnd_out[0] = ceil( dlbnd[0] - par[0] + 0.5 );
ubnd_out[0] = ceil( dubnd[0] - par[0] + 0.5 );
lbnd_out[1] = ceil( dlbnd[1] - par[1] + 0.5 );
ubnd_out[1] = ceil( dubnd[1] - par[1] + 0.5 );
/* Do the same with the individual input file bounding boxes */
box = *boxes;
for (i = 1; i <= size; i++, box++) {
box->lbnd[0] = ceil( box->lbnd[0] - par[0] + 0.5);
box->ubnd[0] = ceil( box->ubnd[0] - par[0] + 0.5);
box->lbnd[1] = ceil( box->lbnd[1] - par[1] + 0.5);
box->ubnd[1] = ceil( box->ubnd[1] - par[1] + 0.5);
}
/* Apply a ShiftMap to the output FrameSet to re-align the GRID
coordinates */
shift[0] = 2.0 - par[0] - lbnd_out[0];
shift[1] = 2.0 - par[1] - lbnd_out[1];
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
/* Set the dynamic defaults for lbnd/ubnd */
lbnd0[ 0 ] = lbnd_out[ 0 ];
lbnd0[ 1 ] = lbnd_out[ 1 ];
parDef1i( "LBND", 2, lbnd0, status );
ubnd0[ 0 ] = ubnd_out[ 0 ];
ubnd0[ 1 ] = ubnd_out[ 1 ];
parDef1i( "UBND", 2, ubnd0, status );
parGet1i( "LBND", 2, lbnd_out, &actval, status );
if( actval == 1 ) lbnd_out[ 1 ] = lbnd_out[ 0 ];
parGet1i( "UBND", 2, ubnd_out, &actval, status );
if( actval == 1 ) ubnd_out[ 1 ] = ubnd_out[ 0 ];
/* Ensure the bounds are the right way round. */
if( lbnd_out[ 0 ] > ubnd_out[ 0 ] ) {
int itmp = lbnd_out[ 0 ];
lbnd_out[ 0 ] = ubnd_out[ 0 ];
ubnd_out[ 0 ] = itmp;
}
if( lbnd_out[ 1 ] > ubnd_out[ 1 ] ) {
int itmp = lbnd_out[ 1 ];
lbnd_out[ 1 ] = ubnd_out[ 1 ];
ubnd_out[ 1 ] = itmp;
}
/* If borders of bad pixels are being trimmed from the output image,
then do not allow the user-specified bounds to extend outside the
default bounding box (since we know that the default bounding box
encloses all available data). */
parGet0l( "TRIM", &trim, status );
if( trim ) {
if( lbnd_out[ 0 ] < lbnd0[ 0 ] ) lbnd_out[ 0 ] = lbnd0[ 0 ];
if( lbnd_out[ 1 ] < lbnd0[ 1 ] ) lbnd_out[ 1 ] = lbnd0[ 1 ];
if( ubnd_out[ 0 ] > ubnd0[ 0 ] ) ubnd_out[ 0 ] = ubnd0[ 0 ];
if( ubnd_out[ 1 ] > ubnd0[ 1 ] ) ubnd_out[ 1 ] = ubnd0[ 1 ];
}
/* Modify the returned FrameSet to take account of the new pixel origin. */
shift[ 0 ] = lbnd0[ 0 ] - lbnd_out[ 0 ];
shift[ 1 ] = lbnd0[ 1 ] - lbnd_out[ 1 ];
if( shift[ 0 ] != 0.0 || shift[ 1 ] != 0.0 ) {
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
}
/* Report the pixel bounds of the cube. */
if( *status == SAI__OK ) {
msgOutif( MSG__NORM, " ", " ", status );
msgSeti( "XL", lbnd_out[ 0 ] );
msgSeti( "YL", lbnd_out[ 1 ] );
msgSeti( "XU", ubnd_out[ 0 ] );
msgSeti( "YU", ubnd_out[ 1 ] );
msgOutif( MSG__NORM, " ", " Output map pixel bounds: ( ^XL:^XU, ^YL:^YU )",
status );
if( ( ubnd_out[ 0 ] - lbnd_out[ 0 ] + 1 ) > MAX_DIM ||
( ubnd_out[ 1 ] - lbnd_out[ 1 ] + 1 ) > MAX_DIM ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": The map is too big. Check your list of input "
"data files does not include widely separated observations.",
status );
}
}
/* If no error has occurred, export the returned FrameSet pointer from the
current AST context so that it will not be annulled when the AST
context is ended. Otherwise, ensure a null pointer is returned. */
if( *status == SAI__OK ) {
astExport( *outframeset );
} else {
*outframeset = astAnnul( *outframeset );
}
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to calculate map bounds",
status, smf_timerupdate( &tv1, &tv2, status ) );
/* Clean Up */
CLEANUP:
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to determine map bounds", status);
}
if (oskymap) oskymap = astAnnul( oskymap );
if (bolo2map) bolo2map = astAnnul( bolo2map );
if (fitschan) fitschan = astAnnul( fitschan );
if( data != NULL )
smf_close_file( NULL, &data, status );
refsys = astFree( refsys );
astEnd;
}
void smf_check_pol2( Grp *igrp, int size, int raw, int *status ) {
/* Local Variables */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
int i; /* Loop counter */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Loop over all files in the Grp */
for( i = 1; i <= size && *status == SAI__OK; i++ ) {
/* Read header info from the ith input file in the group */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data,
status );
/* Check there is a file. */
if( *status == SAI__OK && data->file == NULL ) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfFile associated with smfData.",
status );
/* Check there is a header. */
} else if( *status == SAI__OK && data->hdr == NULL ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
*status = SAI__ERROR;
errRep( FUNC_NAME, "No smfHead associated with ^FILE.",
status );
}
/* Check that there are 3 pixel axes. */
if( *status == SAI__OK && data->ndims != 3) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSeti( "NDIMS", data->ndims );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE has ^NDIMS pixel axes, should be 3.",
status );
}
/* Check that POL2 is in the beam. */
if( *status == SAI__OK && !(data->hdr->inbeam & SMF__INBEAM_POL) ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
*status = SAI__ERROR;
errRep( FUNC_NAME, "^FILE does not contain POL2 data.",
status );
}
/* For raw data check that the NDF Label component is "Q" or "U". */
if( *status == SAI__OK ) {
if( raw ) {
if( strcmp( data->hdr->dlabel, "Signal" ) ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSetc( "L", data->hdr->dlabel );
*status = SAI__ERROR;
errRep( FUNC_NAME, "File ^FILE does not contain POL2 "
"analysed intensity data (NDF label is '^L' "
"but should be 'Signal').", status );
}
/* For Q/U data check that the NDF Label component is "Q" or "U". */
} else {
if( strcmp( data->hdr->dlabel, "Q" ) &&
strcmp( data->hdr->dlabel, "U" ) ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSetc( "L", data->hdr->dlabel );
*status = SAI__ERROR;
errRep( FUNC_NAME, "File ^FILE does not contain POL2 "
"Q or U data (NDF label is '^L' but should be "
"'Q' or 'U').", status );
}
}
}
/* Close the data file */
smf_close_file( NULL, &data, status);
}
}
void
smf_flat_params( const smfData * refdata, const char resistpar[],
const char methpar[], const char orderpar[], const char snrminpar[],
double * refohms, double **resistance, int * outrows,
int * outcols, smf_flatmeth *flatmeth,
int * order, double * snrmin, smfData ** heateff,
int * status ) {
dim_t datarows = 0; /* Number of rows in refdata */
dim_t datacols = 0; /* Number of columns in refdata */
size_t j = 0; /* Counter, index */
char method[SC2STORE_FLATLEN]; /* flatfield method string */
size_t nbols; /* Number of bolometers */
double refohmsval = 0.0; /* Internal version of refohms */
AstKeyMap * resmap = NULL; /* Resistor map */
AstKeyMap * subarrays = NULL; /* Subarray lookup table */
char thissub[32]; /* This sub-instrument string */
if (resistance) *resistance = NULL;
if (*status != SAI__OK) return;
if (!refdata) {
*status = SAI__ERROR;
errRep( "", "Must provide reference data file to calculate flatfield parameters"
" (possible programming error)", status );
return;
}
/* Based on refdata we now need to calculate the default reference
resistance and retrieve the correct heater efficiency file for each array.
We need the unique subarray string so that we can set up a look up keymap.
There is no code in SMURF to return all the known subarrays but
we need to know all the options in order to use kpg1Config. */
subarrays = astKeyMap( " " );
astMapPut0I( subarrays, "CG450MK2_M0907D0501", 0, NULL );
astMapPut0I( subarrays, "CG850MK2_M0904D0503", 0, NULL );
astMapPut0I( subarrays, "SG850_M0906D1005", 0, NULL );
astMapPut0I( subarrays, "SG850_M1002D1006", 0, NULL );
astMapPut0I( subarrays, "SG850_M1005D1007", 0, NULL );
astMapPut0I( subarrays, "SG850_M1003D1004", 0, NULL );
astMapPut0I( subarrays, "SG450_M1004D1000", 0, NULL );
astMapPut0I( subarrays, "SG450_M1007D1002", 0, NULL );
astMapPut0I( subarrays, "SG450_M1006D1003", 0, NULL );
astMapPut0I( subarrays, "SG450_M1009D1008", 0, NULL );
/* and indicate which subarray we are interested in (uppercased) */
smf_fits_getS( refdata->hdr, "ARRAYID", thissub, sizeof(thissub), status );
{ /* need to uppercase */
size_t l = strlen(thissub);
for (j=0;j<l;j++) {
thissub[j] = toupper(thissub[j]);
}
}
astMapPut0I( subarrays, thissub, 1, NULL );
/* Read the config file */
resmap = kpg1Config( resistpar, "$SMURF_DIR/smurf_calcflat.def",
subarrays, 1, status );
subarrays = astAnnul( subarrays );
if (*status != SAI__OK) goto CLEANUP;
/* Read the reference resistance */
astMapGet0D( resmap, "REFRES", &refohmsval );
if (refohms && *status == SAI__OK) {
*refohms = refohmsval;
msgOutiff(MSG__VERB, "",
"Read reference resistance for subarray %s of %g ohms\n",
status, thissub, *refohms );
}
/* We no longer want to read per-bolometer resistor values from the
config file. To retain backwards compatibility with the current
implementation of smf_flat_standardpow we simply fill the
per-bol resistance array with the reference resistance which
effectively disables smf_flat_standardpow */
smf_get_dims( refdata, &datarows, &datacols, NULL, NULL, NULL, NULL, NULL, status );
nbols = datacols * datarows;
if (*status == SAI__OK && resistance ) {
*resistance = astMalloc( nbols*sizeof(**resistance) );
for (j = 0; j < (size_t)nbols; j++) {
(*resistance)[j] = refohmsval;
}
}
/* Get the heater efficiency file */
if (heateff && astMapHasKey( resmap, "HEATEFF" ) ) {
const char * heateffstr = NULL;
if (astMapGet0C( resmap, "HEATEFF", &heateffstr )) {
Grp * heateffgrp = NULL;
smfData * heatefftmp = NULL;
heateffgrp = grpNew( "heateff", status );
grpPut1( heateffgrp, heateffstr, 0, status );
smf_open_file( NULL, heateffgrp, 1, "READ", SMF__NOTTSERIES|SMF__NOFIX_METADATA, &heatefftmp, status );
/* Divorce the smfData from the underlying file. This file stays open for the entire
duration of the data processing and can some times lead to issues when we attempt
to close it an hour after we opened it (it's usually on an NFS disk) */
if (*status == SAI__OK) {
*heateff = smf_deepcopy_smfData( NULL, heatefftmp, 0,
SMF__NOCREATE_FILE | SMF__NOCREATE_FTS |
SMF__NOCREATE_DA,
0, 0, status );
smf_close_file(NULL, &heatefftmp, status);
}
/* Check the dimensions */
if (*status == SAI__OK) {
dim_t heatrows = 0;
dim_t heatcols = 0;
smf_get_dims( *heateff, &heatrows, &heatcols, NULL, NULL, NULL, NULL, NULL, status );
if (*status == SAI__OK) {
if ( datarows != heatrows || datacols != heatcols ) {
*status = SAI__ERROR;
errRepf( "", "Dimensions of heater efficiency file %s are (%zu, %zu)"
" but flatfield has dimensions (%zu, %zu)",
status, heateffstr, (size_t)heatrows, (size_t)heatcols,
(size_t)datarows, (size_t)datacols);
}
}
if (*status == SAI__OK) {
smf_dtype_check_fatal( *heateff, NULL, SMF__DOUBLE, status );
if (*status == SMF__BDTYP) {
errRepf("", "Heater efficiency data in %s should be double precision",
status, heateffstr);
}
}
if (*status == SAI__OK) {
char heateffarrid[32];
smf_fits_getS( refdata->hdr, "ARRAYID", heateffarrid, sizeof(heateffarrid), status );
if (*status != SAI__OK) errAnnul( status );
if (strcasecmp( thissub, heateffarrid ) != 0 ) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRepf("", "Subarray associated with heater efficiency image (%s)"
" does not match that of the data to be flatfielded (%s)",
status, heateffarrid, thissub );
}
}
}
}
if (heateffgrp) grpDelet( &heateffgrp, status );
}
}
if (methpar && flatmeth) {
/* See if we want to use TABLE or POLYNOMIAL mode */
parChoic( methpar, "POLYNOMIAL", "POLYNOMIAL, TABLE", 1,
method, sizeof(method), status );
*flatmeth = smf_flat_methcode( method, status );
if (*flatmeth == SMF__FLATMETH_POLY) {
/* need an order for the polynomial */
if (order && orderpar) {
parGdr0i( orderpar, 1, 1, 3, 1, order, status );
/* and if the order is 1 then we can ask for the snr min */
if (snrminpar && *order == 1) {
parGet0d( snrminpar, snrmin, status );
}
}
} else {
/* need an snr min for table mode responsivities */
if (snrminpar) parGet0d( snrminpar, snrmin, status );
}
}
if (outrows) *outrows = datarows;
if (outcols) *outcols = datacols;
CLEANUP:
resmap = astAnnul( resmap );
if (*status != SAI__OK) {
if (resistance && *resistance) *resistance = astFree( *resistance );
if (heateff && *heateff) smf_close_file( NULL, heateff, status );
}
return;
}
void smf_grp_related( const Grp *igrp, const size_t grpsize,
const int grouping, const int checksubinst,
double maxlen_s, double *srate_maxlen,
AstKeyMap *keymap, dim_t *maxconcatlen,
dim_t *maxfilelen, smfGroup **group,
Grp **basegrp, dim_t *pad, int *status ) {
/* Local variables */
size_t *chunk=NULL; /* Array of flags for continuous chunks */
dim_t * chunklen = NULL; /* Length of continuous chunk */
size_t currentindex = 0; /* Counter */
char cwave[10]; /* String containing wavelength */
smfData *data = NULL; /* Current smfData */
double downsampscale=0; /* Angular scale downsampling size */
double downsampfreq=0; /* Target downsampling frequency */
AstKeyMap * grouped = NULL; /* Primary AstKeyMap for grouping */
size_t i; /* Loop counter for index into Grp */
int isFFT=0; /* Set if data are 4d FFT */
size_t j; /* Loop counter */
int *keepchunk=NULL; /* Flag for chunks that will be kept */
dim_t maxconcat=0; /* Longest continuous chunk length */
dim_t maxflen=0; /* Max file length in time steps */
dim_t maxlen=0; /* Maximum concat length in samples */
int maxlen_scaled=0; /* Set once maxlen has been scaled, if needed */
dim_t maxpad=0; /* Maximum padding neeed for any input file */
size_t maxrelated = 0; /* Keep track of max number of related items */
size_t *new_chunk=NULL; /* keeper chunks associated with subgroups */
dim_t *new_tlen=NULL; /* tlens for new_subgroup */
size_t ngroups = 0; /* Counter for subgroups to be stored */
size_t nkeep = 0; /* Number of chunks to keep */
dim_t * piecelen = NULL; /* Length of single file */
smf_subinst_t refsubinst; /* Subinst of first file */
size_t **subgroups = NULL; /* Array containing index arrays to parent Grp */
smf_subinst_t subinst; /* Subinst of current file */
if ( *status != SAI__OK ) return;
if( maxlen_s < 0 ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": maxlen_s cannot be < 0!", status );
return;
}
/* Get downsampling parameters */
if( keymap ) {
smf_get_cleanpar( keymap, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &downsampscale, &downsampfreq,
NULL, NULL, NULL, NULL, status );
if( downsampscale && downsampfreq ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": both downsampscale and downsampfreq are set",
status );
return;
}
}
/* Initialize refcwave */
refsubinst = SMF__SUBINST_NONE;
/* Loop over files in input Grp: remember Grps are indexed from 1 */
grouped = astKeyMap( "SortBy=KeyUp" );
for (i=1; i<=grpsize; i++) {
char newkey[128];
char dateobs[81];
char subarray[10];
size_t nrelated = 0;
AstKeyMap * filemap = NULL;
AstKeyMap * indexmap = NULL;
/* First step: open file and harvest metadata */
smf_open_file( NULL, igrp, i, "READ", SMF__NOCREATE_DATA, &data, status );
if (*status != SAI__OK) break;
if( i==1 ) {
isFFT = smf_isfft( data, NULL, NULL, NULL, NULL, NULL, status );
} else if( smf_isfft(data, NULL, NULL, NULL, NULL, NULL, status) != isFFT ){
*status = SAI__ERROR;
errRep( "", FUNC_NAME
": mixture of time-series and FFT data encountered!",
status );
break;
}
/* If maxlen has not been set, do it here */
if( !maxlen && maxlen_s && data->hdr->steptime) {
maxlen = (dim_t) (maxlen_s / data->hdr->steptime );
}
/* Return srate_maxlen if requested: may want to know this number
even if maxlen_s is not set. Only calculate once, although it
gets overwritten once later if down-sampling. */
if( (i==1) && srate_maxlen && data->hdr->steptime ) {
*srate_maxlen = 1. / (double) data->hdr->steptime;
}
/* If requested check to see if we are mixing wavelengths */
if( checksubinst ) {
if( refsubinst == SMF__SUBINST_NONE ) {
refsubinst = smf_calc_subinst( data->hdr, status );
}
subinst = smf_calc_subinst( data->hdr, status );
if( subinst != refsubinst ) {
const char *refsubstr = smf_subinst_str( refsubinst, status );
const char *substr = smf_subinst_str( subinst, status );
*status = SAI__ERROR;
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
msgSetc( "REFSUB", refsubstr );
msgSetc( "SUB", substr );
errRep( "", FUNC_NAME
": ^FILE uses sub-instrument ^SUB which doesn't match "
"reference ^REFSUB", status );
}
}
/* Want to form a key that will be unique for a particular subscan
We know that DATE-OBS will be set for SCUBA-2 files and be the same
for a single set. Prefix by wavelength if we are grouping by wavelength.
*/
newkey[0] = '\0';
smf_find_subarray( data->hdr, subarray, sizeof(subarray), NULL, status );
if( grouping == 1 ) {
/* Group different wavelengths separately */
smf_fits_getS( data->hdr, "WAVELEN", cwave, sizeof(cwave), status);
one_strlcat( newkey, cwave, sizeof(newkey), status );
one_strlcat( newkey, "_", sizeof(newkey), status );
}
if( grouping == 2 ) {
/* Group different subarrays separately */
one_strlcat( newkey, subarray, sizeof(newkey), status );
}
smf_fits_getS( data->hdr, "DATE-OBS", dateobs, sizeof(dateobs), status );
one_strlcat( newkey, dateobs, sizeof(newkey), status );
/* Include the dimentionality of the time series in the primary key
so that we do not end up doing something confusing like relating
a truncated file with a full length file */
if (*status == SAI__OK) {
dim_t dims[3];
char formatted[32];
smf_get_dims( data, &dims[0], &dims[1], NULL, &dims[2], NULL, NULL, NULL,
status );
sprintf(formatted, "_%" DIM_T_FMT "_%" DIM_T_FMT "_%" DIM_T_FMT, dims[0], dims[1], dims[2]);
one_strlcat( newkey, formatted, sizeof(newkey), status );
}
/* May want to read the dimensionality of the file outside of loop
so that we can compare values when storing in the keymap */
/* Now we want to create a keymap based on this key */
if (!astMapGet0A( grouped, newkey, &filemap ) ) {
int itemp = 0;
double steptime = data->hdr->steptime;
dim_t ntslice = 0;
dim_t thispad; /* Padding neeed for current input file */
filemap = astKeyMap( " " );
astMapPut0A( grouped, newkey, filemap, NULL );
/* Fill up filemap with general information on this file */
smf_find_seqcount( data->hdr, &itemp, status );
astMapPut0I( filemap, "SEQCOUNT", itemp, NULL );
smf_fits_getI( data->hdr, "NSUBSCAN", &itemp, status );
astMapPut0I( filemap, "NSUBSCAN", itemp, NULL );
/* Number of time slices */
smf_get_dims( data, NULL, NULL, NULL, &ntslice, NULL, NULL, NULL,
status );
/* Find length of down-sampled data, new steptime and maxlen */
if( (downsampscale || downsampfreq) && data->hdr && (*status==SAI__OK) ) {
double scalelen;
if( downsampscale ) {
if( data->hdr->scanvel != VAL__BADD ) {
double oldscale = steptime * data->hdr->scanvel;
scalelen = oldscale / downsampscale;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
scalelen = VAL__BADD;
smf_smfFile_msg( data->file, "FILE", 1, "" );
errRep( "", FUNC_NAME ": can't resample ^FILE because it has "
"unknown scan velocity", status );
}
} else {
if( steptime ) {
double oldsampfreq = 1./steptime;
scalelen = downsampfreq / oldsampfreq;
} else {
*status = SAI__ERROR;
scalelen = VAL__BADD;
smf_smfFile_msg( data->file, "FILE", 1, "" );
errRep( "", FUNC_NAME ": can't resample ^FILE because it has "
"unknown sample rate", status );
}
}
/* only down-sample if it will be a reasonable factor */
if( (*status==SAI__OK) && (scalelen <= SMF__DOWNSAMPLIMIT) ) {
smf_smfFile_msg(data->file, "FILE", 1, "" );
msgOutiff( MSG__VERB, "", FUNC_NAME
": will down-sample file ^FILE from %5.1lf Hz to "
"%5.1lf Hz", status, (1./steptime), (scalelen/steptime) );
ntslice = round(ntslice * scalelen);
/* If maxlen has been requested, and we have not already worked
out a scaled version (just uses the sample rates for the first
file... should be close enough -- the alternative is a 2-pass
system). */
if( !maxlen_scaled ) {
maxlen = round(maxlen*scalelen);
maxlen_scaled = 1;
msgOutiff( MSG__VERB, "", FUNC_NAME
": requested maxlen %g seconds = %" DIM_T_FMT " down-sampled "
"time-slices", status, maxlen_s, maxlen );
/* Return updated srate_maxlen for down-sampling if requested */
if( srate_maxlen ) {
*srate_maxlen = scalelen/steptime;
}
}
}
}
/* Check that an individual file is too long (we assume related
files are all the same) */
if( maxlen && (ntslice > maxlen) && *status == SAI__OK) {
*status = SAI__ERROR;
msgSeti("NTSLICE",ntslice);
msgSeti("MAXLEN",maxlen);
smf_smfFile_msg( data->file, "FILE", 1, "" );
errRep(FUNC_NAME,
"Number of time steps in file ^FILE time exceeds maximum "
"(^NTSLICE>^MAXLEN)", status);
}
/* Scaled values of ntslice and maximum length */
astMapPut0I( filemap, "NTSLICE", ntslice, NULL );
/* Work out the padding needed for this file including downsampling. */
if( keymap ) {
thispad = smf_get_padding( keymap, 0, data->hdr, VAL__BADD, status );
if( thispad > maxpad ) maxpad = thispad;
} else {
thispad = 0;
}
astMapPut0I( filemap, "PADDING", thispad, NULL );
/* Update maxflen */
if( ntslice > maxflen ) {
maxflen = ntslice;
}
/* Store OBSID or OBSIDSS depending on whether we are grouping by wavelength */
if (grouping) {
astMapPut0C( filemap, "OBSID", data->hdr->obsidss, NULL );
} else {
char obsid[81];
smf_getobsidss( data->hdr->fitshdr, obsid, sizeof(obsid), NULL, 0, status );
astMapPut0C( filemap, "OBSID", obsid, NULL );
}
}
/* Store the file index in another keymap indexed by subarray */
if ( !astMapGet0A( filemap, "GRPINDICES", &indexmap ) ) {
indexmap = astKeyMap( "SortBy=KeyUp" );
astMapPut0A( filemap, "GRPINDICES", indexmap, NULL );
}
astMapPut0I( indexmap, subarray, i, NULL );
/* Need to track the largest number of related subarrays in a single slot */
nrelated = astMapSize( indexmap );
if (nrelated > maxrelated) maxrelated = nrelated;
/* Free resources */
filemap = astAnnul( filemap );
indexmap = astAnnul( indexmap );
smf_close_file( NULL, &data, status );
}
/* We now know how many groups there are */
ngroups = astMapSize( grouped );
/* Sort out chunking. The items are sorted by date and then by wavelength.
We define a continuous chunk if it has the same OBSID, the same SEQCOUNT
and NSUBSCAN increments by one from the previous entry.
Also count number of related items in each slot.
*/
if (*status == SAI__OK) {
typedef struct { /* somewhere to store the values easily */
char obsid[81];
char related[81]; /* for concatenated subarrays */
int nsubscan;
int seqcount;
} smfCompareSeq;
smfCompareSeq current;
smfCompareSeq previous;
dim_t totlen = 0;
size_t thischunk;
/* Get the chunk flags and also store the size of the chunk */
chunk = astCalloc( ngroups, sizeof(*chunk) );
chunklen = astCalloc( ngroups, sizeof(*chunklen) );
piecelen = astCalloc( ngroups, sizeof(*piecelen) );
thischunk = 0; /* The current chunk */
for (i=0; i<ngroups; i++) {
AstKeyMap * thismap = NULL;
AstKeyMap * grpindices = NULL;
const char * tempstr = NULL;
int thistlen = 0;
size_t nsubarrays = 0;
/* Get the keymap entry for this slot */
astMapGet0A( grouped, astMapKey(grouped, i), &thismap );
/* Get info for length limits */
astMapGet0I( thismap, "NTSLICE", &thistlen );
piecelen[i] = thistlen;
if (isFFT) {
/* Never concatenate FFT data */
thismap = astAnnul(thismap);
chunk[i] = i;
chunklen[i] = thistlen;
continue;
}
/* Get indices information and retrieve the sub-instrument names
in sort order to concatenate for comparison. We only store in
a continuous chunk if we have the same subarrays for the whole
chunk. */
astMapGet0A( thismap, "GRPINDICES", &grpindices );
nsubarrays = astMapSize( grpindices );
(current.related)[0] = '\0';
for (j = 0; j < nsubarrays; j++ ) {
one_strlcat( current.related, astMapKey(grpindices, j), sizeof(current.related), status );
}
grpindices = astAnnul( grpindices );
/* Fill in the current struct */
astMapGet0I( thismap, "SEQCOUNT", &(current.seqcount) );
astMapGet0I( thismap, "NSUBSCAN", &(current.nsubscan) );
astMapGet0C( thismap, "OBSID", &tempstr );
one_strlcpy( current.obsid, tempstr, sizeof(current.obsid), status );
/* First chunk is special, else compare */
if (i == 0) {
totlen = thistlen;
} else {
if ( ( current.seqcount == previous.seqcount ) &&
( current.nsubscan - previous.nsubscan == 1 ) &&
( strcmp( current.obsid, previous.obsid ) == 0 ) &&
( strcmp( current.related, previous.related ) == 0 ) ) {
/* continuous - check length */
totlen += thistlen;
if ( maxlen && totlen > maxlen ) {
thischunk++;
totlen = thistlen; /* reset length */
} else {
/* Continuous */
}
} else {
/* discontinuity */
thischunk++;
totlen = thistlen; /* Update length of current chunk */
}
}
chunklen[thischunk] = totlen;
chunk[i] = thischunk;
memcpy( &previous, ¤t, sizeof(current) );
thismap = astAnnul( thismap );
}
}
/* Decide if we are keeping a chunk by looking at the length. */
maxconcat = 0;
nkeep = 0;
keepchunk = astMalloc( ngroups*sizeof(*keepchunk) );
for (i=0; i<ngroups; i++) {
size_t thischunk;
thischunk = chunk[i];
if ( chunklen[thischunk] < SMF__MINCHUNKSAMP ) {
/* Warning message */
msgSeti("LEN",chunklen[thischunk]);
msgSeti("MIN",SMF__MINCHUNKSAMP);
msgOut( " ", "SMF_GRP_RELATED: ignoring short chunk (^LEN<^MIN)",
status);
keepchunk[i] = 0;
} else {
keepchunk[i] = 1;
if (maxconcat < chunklen[thischunk]) maxconcat = chunklen[thischunk];
nkeep++;
}
}
/* If no useful chunks generate an error */
if( (*status==SAI__OK) && (!nkeep) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": No useful chunks.", status );
goto CLEANUP;
}
/* Allocate a subgroup array of the right size and fill it. They keymap
is sorted by date (and wavelength) so we can always index into it by using
indices from the subgroup. */
subgroups = astCalloc( nkeep, sizeof(*subgroups) );
new_chunk = astCalloc( nkeep, sizeof(*new_chunk) );
new_tlen = astCalloc( nkeep, sizeof(*new_tlen) );
currentindex = 0;
for (i=0;i<ngroups;i++) {
AstKeyMap * thismap = NULL;
AstKeyMap * grpindices = NULL;
size_t nsubarrays = 0;
size_t *indices = astCalloc( maxrelated, sizeof(*indices) );
/* skip if we are dropping this chunk */
if (!keepchunk[i]) continue;
/* Get the keymap entry for this slot */
astMapGet0A( grouped, astMapKey(grouped, i), &thismap );
/* Get the indices keymap */
astMapGet0A( thismap, "GRPINDICES", &grpindices );
nsubarrays = astMapSize( grpindices );
for (j=0; j<nsubarrays; j++) {
int myindex;
astMapGet0I( grpindices, astMapKey(grpindices, j), &myindex );
indices[j] = myindex;
}
grpindices = astAnnul( grpindices );
thismap = astAnnul( thismap );
subgroups[currentindex] = indices;
new_chunk[currentindex] = chunk[i];
new_tlen[currentindex] = piecelen[i];
currentindex++;
}
/* Create the smfGroup */
*group = smf_construct_smfGroup( igrp, subgroups, new_chunk, new_tlen,
nkeep, maxrelated, 0, status );
/* Return maxfilelen if requested */
if( maxfilelen ) {
*maxfilelen = maxflen;
}
/* Return maxconcatlen if requested */
if( maxconcatlen ) {
*maxconcatlen = maxconcat;
}
/* Create a base group for output files if required */
/* Create a base group of filenames */
if (*status == SAI__OK && basegrp ) {
*basegrp = smf_grp_new( (*group)->grp, "Base Group", status );
/* Loop over time chunks */
for( i=0; (*status==SAI__OK)&&(i<(*group)->ngroups); i++ ) {
size_t idx;
/* Check for new continuous chunk */
if( i==0 || ( (*group)->chunk[i] != (*group)->chunk[i-1]) ) {
/* Loop over subarray */
for( idx=0; idx<(*group)->nrelated; idx++ ) {
size_t grpindex = (*group)->subgroups[i][idx];
if ( grpindex > 0 ) {
ndgCpsup( (*group)->grp, grpindex, *basegrp, status );
}
}
}
}
}
CLEANUP:
keepchunk = astFree( keepchunk );
chunk = astFree( chunk );
chunklen = astFree( chunklen );
piecelen = astFree( piecelen );
grouped = astAnnul( grouped );
if( *status != SAI__OK ) {
/* free the group */
if (basegrp && *basegrp) grpDelet( basegrp, status );
if (group && *group) {
smf_close_smfGroup( group, status );
} else {
/* have to clean up manually */
new_chunk = astFree( new_chunk );
new_tlen = astFree( new_tlen );
if( subgroups ) {
size_t isub;
for( isub=0; isub<nkeep; isub++ ) {
subgroups[isub] = astFree( subgroups[isub] );
}
subgroups = astFree( subgroups );
}
}
}
/* Return the maximum padding if required. */
if( pad ) *pad = maxpad;
}
void smf_import_array( smfData *refdata, const char *name, int bad,
int expand, double *dataptr, int *status ) {
/* Local Variables: */
Grp *igrp; /* Group holding NDF name */
dim_t nbolo; /* Number of bolometers */
dim_t ntslice; /* Number of time slices */
double *pin; /* Pointer to next input value */
double *pout; /* Pointer to next output value */
double mean; /* Mean value int he plane */
double vsum; /* Sum of good data values */
int nbad; /* Number of bad data values */
int ngood; /* Number of good data values */
size_t bstride; /* Stride between bolometer values */
size_t i; /* Loop count */
size_t j; /* Loop count */
dim_t nel; /* Number of elements in array */
size_t tstride; /* Stride between time slices */
smfData *data; /* Model for one sub-array */
/* Check inherited status. */
if( *status != SAI__OK ) return;
/* Attempt to open the NDF. */
igrp = grpNew( " ", status );
grpPut1( igrp, name, 0, status );
smf_open_file( igrp, 1, "READ", 0, &data, status );
grpDelet( &igrp, status );
/* Ensure the smfData read from the NDF uses the same data ordering as the
reference smfData. */
smf_dataOrder( data, refdata->isTordered, status );
if( *status == SAI__OK ) {
/* Check the data type and dimensions of the NDF are the same as the
reference NDF. */
if( data->dtype != SMF__DOUBLE ) {
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect data type - should be "
"DOUBLE PRECISION.", status, name );
} else if( data->ndims != refdata->ndims ) {
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' is %zu dimensional - must be %zu "
"dimensional.", status, name, data->ndims, refdata->ndims );
} else if( !expand || refdata->ndims != 3 ) {
expand = 0;
for( i = 0; i < refdata->ndims; i++ ) {
if( data->dims[i] != refdata->dims[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect dimension %zu on "
"pixel axis %zu - should be %zu.", status,
name, data->dims[i], i + 1, refdata->dims[i] );
} else if( data->lbnd[i] != refdata->lbnd[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect lower bound %d on "
"pixel axis %zu - should be %d.", status,
name, data->lbnd[i], i + 1, refdata->lbnd[i] );
}
}
} else {
for( i = 0; i < refdata->ndims; i++ ) {
if( data->dims[i] == 1 ) {
} else if( data->dims[i] != refdata->dims[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect dimension %zu on "
"pixel axis %zu - should be %zu.", status,
name, data->dims[i], i + 1, refdata->dims[i] );
} else if( data->lbnd[i] != refdata->lbnd[i] &&
*status == SAI__OK ){
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has incorrect lower bound %d on "
"pixel axis %zu - should be %d.", status,
name, data->lbnd[i], i + 1, refdata->lbnd[i] );
}
}
}
/* Get the smfData dimensions and strides. */
smf_get_dims( refdata, NULL, NULL, &nbolo, &ntslice, &nel, &bstride,
&tstride, status );
/* Copy the values into the model array, replacing bad values as required. */
if( *status == SAI__OK ) {
pin = data->pntr[0];
pout = dataptr;
if( data->ndims < 3 ) data->dims[2] = 1;
if( data->ndims < 2 ) data->dims[1] = 1;
/* Copy the data into the returned array unchanged. */
if( expand ) {
pin = (double *) data->pntr[0];
for( i = 0; i < ntslice; i++,pin++ ) {
pout = dataptr + i*tstride;
for( j = 0; j < nbolo; j++ ) {
if( *pin != VAL__BADD ) {
*pout = *pin;
} else {
*pout = VAL__BADD;
}
pout += bstride;
}
}
} else {
memcpy( pout, pin, nel*sizeof(*pin) );
}
/* Retain bad values. */
if( bad == 0 ) {
/* Replace bad values with zero. */
} else if( bad == 1 ) {
pout = dataptr;
for( i = 0; i < nel; i++,pout++ ) {
if( *pout == VAL__BADD ) *pout = 0.0;
}
/* Replace bad values with the mean value in the time slice. */
} else if( bad == 2 ) {
pout = dataptr;
mean = VAL__BADD;
for( i = 0; i < ntslice; i++ ) {
vsum = 0.0;
ngood = 0;
nbad = 0;
pout = dataptr + i*tstride;
for( j = 0; j < nbolo; j++ ) {
if( *pout != VAL__BADD ) {
vsum += *pout;
ngood++;
} else {
nbad++;
}
pout += bstride;
}
if( ngood > 0 ) mean = vsum/ngood;
if( nbad > 0 ) {
if( mean != VAL__BADD ) {
pout = dataptr + i*tstride;
for( j = 0; j < nbolo; j++ ) {
if( *pout == VAL__BADD ) *pout = mean;
pout += bstride;
}
} else {
*status = SAI__ERROR;
errRepf( " ", "NDF '%s' has no good values in plane "
"%zu.", status, name, i );
break;
}
}
}
}
}
/* Close the NDF. */
smf_close_file( &data, status );
}
}
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 *igrpq = NULL; /* Group of input Q sky files */
Grp *igrpu = NULL; /* Group of input U sky files */
Grp *ogrp = NULL; /* Group containing output file */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
char pabuf[ 10 ]; /* Text buffer for parameter value */
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 *in_data = NULL; /* Pointer to the input I sky map */
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 *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 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 sigma; /* Standard deviation of noise to add to output */
int alignsys; /* Align data in the map's system? */
int flag; /* Was the group expression flagged? */
int harmonic; /* The requested harmonic */
int ifile; /* Input file index */
int indf; /* Input sky map NDF identifier */
int indfin; /* Input template cube NDF identifier */
int indfout; /* Output cube NDF identifier */
int indfq; /* Input Q map NDF identifier */
int indfu; /* Input U map NDF identifier */
int interp = 0; /* Pixel interpolation method */
int moving; /* Is the telescope base position changing? */
int nel; /* Number of elements in 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 */
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 );
}
}
/* 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 );
/* 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 );
/* 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 );
/* Allocate room for an array to hold the anti-clockwise angle from the
focal plane Y axis to the Y pixel axis in the reference map, at each
time slice. */
ang_data = astMalloc( ntslice*sizeof( *ang_data ) );
/* Resample them both into 3D time series. */
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,
harmonic, status );
/* Release work space. */
outq_data = astFree( outq_data );
outu_data = astFree( outu_data );
ang_data = astFree( ang_data );
}
/* Close the output time series file. */
smf_close_file( wf, &odata, 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( ogrp != NULL) grpDelet( &ogrp, 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);
}
}
void smurf_fts2_spectrum(int* status)
{
if( *status != SAI__OK ) { return; }
const char* dataLabel = "Spectrum"; /* Data label */
Grp* gIn = NULL; /* Input group */
Grp* gOut = NULL; /* Output group */
Grp* gSfp = NULL; /* SFP group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
smfData* sfpData = NULL; /* Pointer to SFP data */
/*smfData* sfp = NULL;*/ /* Pointer to SFP index data */
int doSFP = 0; /* Only apply SFP if given */
int zeropad = 1; /* Determines whether to zeropad */
double resolution = 0.0; /* Spectral Resolution */
double resolutionin = 0.0; /* Spectral Resolution input */
double resolutionzp = 0.0; /* Spectral Resolution zero padded */
double resolution_override= 0.0; /* Spectral Resolution override */
int i = 0; /* Counter */
int j = 0; /* Counter */
int k = 0; /* Counter */
int l = 0; /* Counter */
double fNyquist = 0.0; /* Nyquist frequency */
double fNyquistin = 0.0; /* Nyquist frequency input */
double fNyquistzp = 0.0; /* Nyquist frequency zero padded */
double dSigma = 0.0; /* Spectral Sampling Interval */
double dSigmain = 0.0; /* Spectral Sampling Interval zero padded */
double dSigmazp = 0.0; /* Spectral Sampling Interval zero padded */
double* IFG = NULL; /* Interferogram */
double* SFP = NULL; /* Spectral Filter Profile for all pixels */
double* SFPij = NULL; /* Spectral Filter Profile for a single pixel */
double wavelen = 0.0; /* The central wave length of the subarray filter (m) */
double wnSfpFirst = 10.600; /* Starting 850 band SFP wave number */
double wnSfpLast = 12.800; /* Ending 850 band SFP wave number */
double wnSfp850First = 11.220; /* Starting 850 band SFP wave number */
double wnSfp850Last = 12.395; /* Ending 850 band SFP wave number */
/*double wnSfp850First = 10.600;*/ /* Starting 850 band SFP wave number */
/*double wnSfp850Last = 12.800;*/ /* Ending 850 band SFP wave number */
double wnSfp450First = 21.630; /* Starting 450 band SFP wave number */
double wnSfp450Last = 23.105; /* Ending 450 band SFP wave number */
double wnSfpFirst_override= 0.0; /* Starting SFP wave number override */
double wnSfpLast_override = 0.0; /* Ending SFP wave number override */
double wnSfpResolution = 0.025; /* The resolution of the SFP wave numbers (1/cm) */
double wnSfpF = 0.0; /* Starting SFP wave number */
double wnSfpL = 0.0; /* Ending SFP wave number */
double* WN = NULL; /* Wave Numbers from SFP */
double* DS = NULL; /* Double Sided Interferogram */
fftw_complex* DSIN = NULL; /* Double-Sided interferogram, FFT input */
fftw_complex* SPEC = NULL; /* Spectrum */
fftw_plan plan = NULL; /* fftw plan */
gsl_interp_accel* ACC = NULL; /* SFP interpolator */
gsl_spline* SPLINE = NULL; /* SFP interpolation spline */
size_t nFiles = 0; /* Size of the input group */
size_t nOutFiles = 0; /* Size of the output group */
size_t nSFPFiles = 0; /* Size of the SFP group */
size_t nSfp = 89; /* Number of SFP calibration file values */
size_t fIndex = 0; /* File index */
size_t nWidth = 32; /* Data cube width */
size_t nHeight = 40; /* Data cube height */
size_t nFrames = 0; /* Data cube depth */
size_t nPixels = nWidth*nHeight; /* Number of bolometers in the subarray */
double dIntensity = 0;
int N = 0;
int Nin = 0; /* N input */
int Nzp = 0; /* N zero padded */
int N2 = 0;
int N2in = 0; /* N/2 input */
int N2zp = 0; /* N/2 zero padded */
int bolIndex = 0;
int cubeIndex = 0;
int badPixel = 0;
int indexZPD = 0;
int indexZPDin = 0;
int indexZPDzp = 0;
int pad = 0; /* zero padding (difference between input and zero padded interferogram length) */
int pad2 = 0; /* zero padding / 2 */
double dx = 0.0; /* Delta x */
double dxin = 0.0; /* Delta x input */
double dxzp = 0.0; /* Delta x zero padded */
double OPDMax = 0.0; /* OPD max in cm */
double OPDMaxin = 0.0; /* OPD max in cm input */
double OPDMaxzp = 0.0; /* OPD max in cm zero padded */
double s = 0.0; /* spectrum value */
double f = 0.0; /* filter value */
#define DEBUG 0
/* Get Input & Output groups */
kpg1Rgndf("IN", 0, 1, "", &gIn, &nFiles, status);
kpg1Wgndf("OUT", gOut, nFiles, nFiles, "Equal number of input and output files expected!", &gOut, &nOutFiles, status);
kpg1Gtgrp("SFP", &gSfp, &nSFPFiles, status);
if(*status != SAI__OK) {
/* TODO: Check for any other possible error conditions */
/* Assume SFP calibration file not given, and proceed without it */
doSFP = 0;
*status = SAI__OK;
} else {
if(nSFPFiles > 0) doSFP = 1;
}
/* Read in ADAM parameters */
parGet0i("ZEROPAD", &zeropad, status);
/* Resolution */
parGet0d("RESOLUTION", &resolution_override, status);
if(doSFP) {
/* SFP WN Range overrides */
parGet0d("WNSFPFIRST", &wnSfpFirst_override, status);
if(*status != SAI__OK) {
*status = SAI__OK; /* Allow null */
wnSfpFirst_override = 0.0;
}
parGet0d("WNSFPLAST", &wnSfpLast_override, status);
if(*status != SAI__OK) {
*status = SAI__OK; /* Allow null */
wnSfpLast_override = 0.0;
}
}
/* BEGIN NDF */
ndfBegin();
/* Loop through each input file */
for(fIndex = 1; fIndex <= nFiles; fIndex++) {
/* Open Observation file */
smf_open_file(NULL, gIn, fIndex, "READ", SMF__NOFIX_METADATA, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the source file!", status);
goto CLEANUP;
}
/* Data cube dimensions */
nWidth = inData->dims[0];
nHeight = inData->dims[1];
nFrames = inData->dims[2];
nPixels = nWidth * nHeight;
/*printf("%s: nWidth=%d, nHeight=%d, nPixels=%d, nFrames=%d\n", TASK_NAME, nWidth, nHeight, nPixels, nFrames);*/
/* Check if the file is initialized for FTS2 processing */
if(!(inData->fts)) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "The file is NOT initialized for FTS2 data reduction!", status);
goto CLEANUP;
}
/* Read in the Nyquist frequency from FITS component */
smf_fits_getD(inData->hdr, "FNYQUIST", &fNyquist, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to find the Nyquist frequency in FITS component!", status);
goto CLEANUP;
}
/* Read in the wave length (m) from the FITS header to determine the band */
smf_fits_getD(inData->hdr, "WAVELEN", &wavelen, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to find the wavelen in the FITS header!", status);
goto CLEANUP;
}
/* Set WN SFP range according to band */
if(wavelen == 0.00085) {
wnSfpFirst = wnSfp850First;
wnSfpLast = wnSfp850Last;
} else if(wavelen == 0.00045) {
wnSfpFirst = wnSfp450First;
wnSfpLast = wnSfp450Last;
}
/*printf("%s: wnSfpFirst_override=%f, wnSfpLast_override=%f\n", TASK_NAME, wnSfpFirst_override, wnSfpLast_override);*/
/*printf("%s: wnSfpFirst=%f, wnSfpLast=%f\n", TASK_NAME, wnSfpFirst, wnSfpLast);*/
if(wnSfpFirst_override) {
wnSfpF = wnSfpFirst_override;
} else {
wnSfpF = wnSfpFirst;
}
if(wnSfpLast_override) {
wnSfpL = wnSfpLast_override;
} else {
wnSfpL = wnSfpLast;
}
/*printf("%s: wnSfpF=%f, wnSfpL=%f\n", TASK_NAME, wnSfpF, wnSfpL);*/
fNyquistin = fNyquistzp = 0.0;
dx = dxin = dxzp = 0.0;
N2 = N2in = N2zp = 0;
indexZPD = indexZPDin = indexZPDzp = 0;
N = Nin = Nzp = 0;
dSigma = dSigmain = dSigmazp = 0.0;
fNyquistin = fNyquist;
dxin = (1/(2*fNyquistin));
N2in = (nFrames / 2);
indexZPDin = N2in - 1;
Nin = 2 * N2in;
OPDMaxin = N2in * dxin;
if(resolution_override > 0.0) {
resolution = resolution_override;
resolutionin = resolution_override;
} else {
resolution = 1 / (2 * OPDMaxin);
resolutionin = resolution;
}
dSigmain = fNyquistin / N2in;
if(zeropad) {
if(DEBUG) {
/* Make the zero-padded array twice the size of the input */
fNyquistzp = fNyquist;
Nzp = N2in * 4;
N2zp = Nzp / 2;
dxzp = 1 / (2 * fNyquistzp);
OPDMaxzp = N2zp * dxzp;
dSigmazp = fNyquistzp / N2zp;
resolutionzp = 1 / (2 * OPDMaxzp);
} else {
/* Round Nyquist frequency down to nearest integer, for calculation convenience
fNyquistzp = floor(fNyquist);
smf_fits_updateD(inData->hdr, "FNYQUIST", fNyquistzp, "Nyquist frequency (cm^-1)", status);*/
/* Never change nyquist when zero padding */
fNyquistzp = fNyquist;
/* If resolution > 0.05, then round down to nearest 0.05 value, else set to 0.005 */
/* Calculate resolution as 1 / (2*OPDMax) */
/* Calculate OPDMax as N2 * dx */
if(resolution_override) {
resolutionzp = resolution_override;
} else {
if(resolution > 0.05) {
resolutionzp = floor(resolution/0.05) * 0.05;
} else {
resolutionzp = 0.005;
}
}
/* Calculate OPDMaxOut as 1 / (2 * resolutionzp) */
OPDMaxzp = 1 / (2 * resolutionzp);
/* Calculate N2 */
dxzp = (1/(2*fNyquistzp));
N2zp = (OPDMaxzp / dxzp);
indexZPDzp = N2zp - 1;
Nzp = 2 * N2zp;
dSigmazp = fNyquistzp / N2zp;
}
}
/*printf("%s: Nin=%d, Nzp=%d, N2in=%d, N2zp=%d, indexZPDin=%d, indexZPDzp=%d, dSigmain=%f, dSigmazp=%f, fNyquistin=%f, fNyquistzp=%f, dxin=%f, dxzp=%f, OPDMaxin=%f, OPDMaxzp=%f, resolutionin=%f, resolutionzp=%f\n",
TASK_NAME, Nin, Nzp, N2in, N2zp, indexZPDin, indexZPDzp, dSigmain, dSigmazp, fNyquistin, fNyquistzp, dxin, dxzp, OPDMaxin, OPDMaxzp, resolutionin, resolutionzp);*/
if(zeropad) {
N = Nzp;
N2 = N2zp;
indexZPD = indexZPDzp;
dSigma = dSigmazp;
fNyquist = fNyquistzp;
dx = dxzp;
OPDMax = OPDMaxzp;
resolution = resolutionzp;
} else {
N = Nin;
N2 = N2in;
indexZPD = indexZPDin;
dSigma = dSigmain;
fNyquist = fNyquistin;
dx = dxin;
OPDMax = OPDMaxin;
resolution = resolutionin;
}
/* Save wavenumber factor to FITS extension */
smf_fits_updateD(inData->hdr, "WNFACT", dSigma, "Wavenumber factor cm^-1", status);
/* TODO: Update mirror positions */
smf_fits_updateI(inData->hdr, "MIRSTART", 0, "Frame index in which the mirror starts moving", status);
smf_fits_updateI(inData->hdr, "MIRSTOP", N2, "Frame index in which the mirror stops moving", status);
/*smf_fits_updateD(inData->hdr, "OPDMIN", OPD_EVEN[0], "Minimum OPD", status);
smf_fits_updateD(inData->hdr, "OPDSTEP", dx, "OPD step size", status);*/
/* Copy input data into output data */
outData = smf_deepcopy_smfData(NULL, inData, 0, SMF__NOCREATE_DATA, 0, 0, status);
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = nWidth;
outData->dims[1] = nHeight;
outData->dims[2] = N2+1;
outData->pntr[0] = (double*) astMalloc((nPixels * (N2+1)) * sizeof(double));
if (dataLabel) { one_strlcpy(outData->hdr->dlabel, dataLabel, sizeof(outData->hdr->dlabel), status ); }
/* Allocate memory for arrays */
IFG = astCalloc(N, sizeof(*IFG));
DS = astCalloc(N, sizeof(*DS));
DSIN = fftw_malloc(N * sizeof(*DSIN));
SPEC = fftw_malloc(N * sizeof(*SPEC));
/* Initialize arrays */
for(k = 0; k < N; k++) { SPEC[k][0] = SPEC[k][1] = DSIN[k][0] = DSIN[k][1] = DS[k] = IFG[k] = 0.0; }
/* Open the SFP calibration file, if given */
if(doSFP) {
smf_open_file(NULL, gSfp, 1, "READ", SMF__NOCREATE_QUALITY, &sfpData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the SFP calibration file!", status);
goto CLEANUP;
}
/* Read in the number of data elements */
nSfp = sfpData->dims[1] / nPixels;
/* Allocate memory for arrays */
SFP = astCalloc(nSfp*nPixels, sizeof(*SFP));
SFPij = astCalloc(nSfp, sizeof(*SFP));
WN = astCalloc(nSfp, sizeof(*WN));
/* DEBUG: Dispay SFP data */
/*printf("smurf_fts2_spectrum ([%d,%d,%d] elements): WN, SFP\n", (int)sfpData->dims[0],(int)sfpData->dims[1],(int)sfpData->dims[2]);*/
for(k=0;k<nSfp;k++){
/* printf("WN:%.3f,SFP:%.10f\n", *((double*) (sfpData->pntr[0]) + i), *((double*) (sfpData->pntr[0]) + i+1)); */
/* Adjust starting and ending wave number ranges for 450 or 850 bands */
if(wavelen == 0.00085 || wavelen == 0.00045) {
WN[k] = wnSfpFirst + k * wnSfpResolution;
} else {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unexpected WAVELEN value found in the FITS header!", status);
goto CLEANUP;
}
/*printf("SFP WN[%d]=%f\n",k,WN[k]);*/
for(j=0;j<nHeight;j++) {
for(i=0;i<nWidth;i++) {
bolIndex = i + j * nWidth;
cubeIndex = bolIndex + k * nPixels;
SFP[cubeIndex] = *((double*) (sfpData->pntr[0]) + cubeIndex);
/*if(i==10 && j==20) printf("SFP i:%d,j:%d,k:%d,bolIndex:%d,cubeIndex:%d=%f\n",i,j,k,bolIndex,cubeIndex,SFP[cubeIndex]);*/
}
}
}
/*printf("smurf_fts2_spectrum DEBUG: early exiting!\n");
exit(0); */
/* Create a 2D SFP index array and store it in the file, if given
sfp = smf_create_smfData(SMF__NOCREATE_DA | SMF__NOCREATE_FTS, status);
sfp->dtype = SMF__INTEGER;
sfp->ndims = 2;
sfp->dims[0] = nSfp;
sfp->dims[1] = 2;
sfp->pntr[0] = (int*) astCalloc(nSfp*2, sizeof(double));
// By default set ZPD indices to a bad value
for(i = 0; i < nSfp; i++) {
for(j = 0; j < 2; j++) {
bolIndex = i + j * 2;
*((int*) (sfp->pntr[0]) + bolIndex) = VAL__BADI;
}
} */
/* Prepare GSL interpolator to convert SFP data to this spectrum's resolution */
ACC = gsl_interp_accel_alloc();
SPLINE = gsl_spline_alloc(gsl_interp_cspline, nSfp);
}
for(i = 0; i < nWidth; i++) {
for(j = 0; j < nHeight; j++) {
bolIndex = i + j * nWidth;
badPixel = 0;
for(k = 0; k < Nin; k++) {
dIntensity = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
if(dIntensity == VAL__BADD) {
badPixel = 1;
break;
}
}
/* If this is a bad pixel, go to next */
if(badPixel) {
for(k = 0; k <= N2in; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k * nPixels)) = VAL__BADD;
}
continue;
}
/* Double-Sided interferogram */
if(zeropad) {
pad = Nzp - Nin;
pad2 = pad / 2;
/* Copy the right half of the input into the left half of this IFG, zero padded in the middle */
for(k=indexZPDin; k<Nin; k++) {
/*printf("%s: IFG: indexZPDin=%d, indexZPDzp=%d, Nin=%d, Nzp=%d, k=%d, l=%d\n", TASK_NAME, indexZPDin, indexZPDzp, Nin, Nzp, k, l);*/
IFG[k - indexZPDin] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L<-R) IFG[k(%d)-indexZPDin(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %g\n",
TASK_NAME, i, j, k, indexZPDin, (k - indexZPDin), bolIndex, k, nPixels, (bolIndex + k * nPixels), IFG[k - indexZPDin]);
}*/
}
/* Copy the left half of the input into the right half of this IFG, zero padded in the middle */
for(k=0,l=0; k<indexZPDin; k++) {
IFG[Nzp - indexZPDin + k] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L->R) IFG[Nzp(%d)-indexZPDin(%d)+k(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %g\n",
TASK_NAME, i, j, Nzp, indexZPDin, k, (Nzp-indexZPDin+k), bolIndex, k, nPixels, (bolIndex+k*nPixels), IFG[Nzp-indexZPDin+k]);
}*/
}
} else {
/* Copy the right half of the input into the left half of this IFG */
for(k=indexZPD; k<N; k++) {
IFG[k - indexZPD] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L<-R) IFG[k(%d)-indexZPD(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %f\n",
TASK_NAME, i, j, k, indexZPD, (k - indexZPD), bolIndex, k, nPixels, (bolIndex + k * nPixels), IFG[k - indexZPD]);
}*/
}
/* Copy the left half of the input into the right half of this IFG */
for(k=0; k<indexZPD; k++) {
IFG[N - indexZPD + k] = *((double*)(inData->pntr[0]) + (bolIndex + k * nPixels));
/*if(i==16 && j==25) {
printf("%s: Pixel[%d,%d]: (L->R) IFG[N(%d)-indexZPD(%d)+k(%d)=%d] = inData->pntr[bolIndex(%d)+k(%d)*nPixels(%d)=%d] = %f\n",
TASK_NAME, i, j, N, indexZPD, k, (N - indexZPD + k), bolIndex, k, nPixels, (bolIndex + k * nPixels), IFG[N - indexZPD + k]);
}*/
}
}
/* DEBUG: Write out input data
for(k = 0; k < Nin; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + nPixels * k)) =
*((double*)( inData->pntr[0]) + (bolIndex + nPixels * k));
if(i==16 && j==25) {
printf("%s: inData[%d,%d,%d]=%g\n",TASK_NAME, i, j, k, *((double*)( inData->pntr[0]) + (bolIndex + nPixels * k)));
}
} */
/* DEBUG: Write out the shifted IFG
for(k = 0; k < N; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k* nPixels)) = IFG[k];
if(i==16 && j==25) {
printf("%s: IFG[%d,%d,%d]=%g\n",TASK_NAME, i, j, k, IFG[k]);
}
} */
/* Convert real-valued interferogram to complex-valued interferogram */
for(k = 0; k < N; k++) { DSIN[k][0] = IFG[k]; DSIN[k][1] = 0.0; }
/* DEBUG: Write out DSIN
for(k = 0; k < N; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k * nPixels)) = DSIN[k][0];
if(i==16 && j==25) {
printf("%s: DSIN[%d,%d,%d]=%g\n",TASK_NAME, i, j, k, DSIN[k][0]);
}
} */
/* FFT Double-sided complex-valued interferogram */
plan = fftw_plan_dft_1d(N, DSIN, SPEC, FFTW_FORWARD, FFTW_ESTIMATE);
fftw_execute(plan);
/* Normalize spectrum */
for(k=0;k<N;k++) { SPEC[k][0] = SPEC[k][0] / (double)(N * resolution); }
/* Apply SFP calibration, if given */
if(doSFP){
/* Get the SFP for this pixel */
for(k=0;k<nSfp;k++) { SFPij[k] = SFP[i + j*nWidth + k*nPixels]; }
/* Interpolate the SFP values from its original WN scale to the current spectrum scale */
gsl_spline_init(SPLINE, WN, SFPij, nSfp);
/* Divide the spectrum in the band pass region by the interpolated SFP value at each position */
for(k = 0; k < N; k++) {
/*if(k*dSigma >= WN[0] && k*dSigma <= WN[nSfp-1]) {*/
if(k*dSigma >= wnSfpF && k*dSigma <= wnSfpL) {
f = gsl_spline_eval(SPLINE, k*dSigma, ACC);
/*index = bolIndex + nPixels * k;*/
s = SPEC[k][0];
SPEC[k][0] = s / f;
/*if(i==10 && j==20) { printf("SFP i=%d, j=%d, k=%d, dSigma=%f, k*dSigma=%f, s=%f, f=%f, s/f=%f, \n", i, j, k, dSigma, k*dSigma, s, f, s/f); }*/
}
}
}
/* Write out the positive real component of the spectrum */
for(k = 0; k <= N2; k++) {
*((double*)(outData->pntr[0]) + (bolIndex + k * nPixels)) = SPEC[k][0];
/*if(i==16 && j==25) {
printf("%s: SPEC[%d,%d,%d]=%E\n",TASK_NAME, i, j, k, SPEC[k][0] / (double)(N * resolution));
}*/
}
/* Destroy each allocated plan */
if(plan) { fftw_destroy_plan(plan); }
}
}
/* Deallocate memory used by arrays */
if(IFG) { IFG = astFree(IFG); }
if(DS) { DS = astFree(DS); }
if(SFP) { SFP = astFree(SFP); }
if(SFPij) { SFPij = astFree(SFPij); }
if(WN) { WN = astFree(WN); }
if(DSIN) { fftw_free(DSIN); DSIN = NULL; }
if(SPEC) { fftw_free(SPEC); SPEC = NULL; }
if(ACC) { gsl_interp_accel_free(ACC); ACC = NULL; }
if(SPLINE) { gsl_spline_free(SPLINE); SPLINE = NULL; }
/* Close the file */
if(inData) {
smf_close_file( NULL,&inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to close the input file!", status);
goto CLEANUP;
}
}
/* Write output */
/* outData->fts = smf_construct_smfFts(NULL, sfp, fpm, sigma, status); // TODO: Add interpolated SFP to FITS header */
smf_write_smfData(NULL, outData, NULL, NULL, gOut, fIndex, 0,
MSG__VERB, 0, NULL, NULL, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to write the output file!", status);
goto CLEANUP;
}
smf_close_file( NULL,&outData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to close the output file!", status);
goto CLEANUP;
}
}
CLEANUP:
if(IFG) { IFG = astFree(IFG); }
if(DS) { DS = astFree(DS); }
if(SFP) { SFP = astFree(SFP); }
if(SFPij) { SFPij = astFree(SFPij); }
if(WN) { WN = astFree(WN); }
if(DSIN) { fftw_free(DSIN); DSIN = NULL; }
if(SPEC) { fftw_free(SPEC); SPEC = NULL; }
if(ACC) { gsl_interp_accel_free(ACC); ACC = NULL; }
if(SPLINE) { gsl_spline_free(SPLINE); SPLINE = NULL; }
/* Close files if still open */
if(inData) {
smf_close_file( NULL,&inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "CLEANUP: Unable to close the input file!", status);
}
}
if(outData) {
smf_close_file( NULL,&outData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "CLEANUP: Unable to close the output file!", status);
}
}
if(sfpData) {
smf_close_file( NULL,&sfpData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "CLEANUP: Unable to close the SFP file!", status);
}
}
/* END NDF */
ndfEnd(status);
/* Delete Groups */
if(gIn) grpDelet(&gIn, status);
if(gOut) grpDelet(&gOut, status);
if(gSfp) grpDelet(&gSfp, status);
}
void smurf_sc2filtermap( int *status ) {
Grp *fgrp = NULL; /* Output filter group */
smfFilter *filt=NULL; /* Filter */
double filt_edgehigh=0; /* High-pass filter */
double filt_edgelow=0; /* Low-pass filter */
size_t fsize; /* Number of files in fgrp */
size_t i; /* Loop (grp) counter */
smfData *idata; /* Pointer to input smfData */
Grp *igrp = NULL; /* Input group of files */
int isfft=0; /* Are data fft or real space? */
int *mask=NULL; /* Mask indicating where bad data are */
size_t ndata=0; /* Number of pixels in the map */
size_t ndims; /* Number of real space dimensions */
smfData *odata=NULL; /* Pointer to output smfData to be exported */
Grp *ogrp = NULL; /* Output group of files */
size_t outsize; /* Number of files in output group */
size_t size; /* Number of files in input group */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
smfData *wrefmap=NULL; /* Whitening reference map */
int whiten; /* Applying whitening filter? */
Grp *wgrp = NULL; /* Whitening reference map group */
size_t wsize; /* Size of wgrp */
int zerobad; /* Zero VAL__BADD before taking FFT? */
/* Main routine */
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 input file(s) */
kpg1Rgndf( "IN", 0, 1, "", &igrp, &size, status );
size = grpGrpsz( igrp, status );
if (size > 0) {
int parstate=0; /* ADAM parameter state */
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, size, "More output files required...",
&ogrp, &outsize, status );
/* Write out the filter? */
parState( "OUTFILTER", &parstate, status );
if( parstate != PAR__GROUND ) {
kpg1Wgndf( "OUTFILTER", igrp, size, size,
"More output filter files required...",
&fgrp, &fsize, status );
}
}
/* Are we going to zero bad values first? */
parGet0l( "ZEROBAD", &zerobad, status );
/* High/low-pass filters? */
parGet0d( "FILT_EDGEHIGH", &filt_edgehigh, status );
parGet0d( "FILT_EDGELOW", &filt_edgelow, status );
/* Are we applying a spatial whitening filter? */
parGet0l( "WHITEN", &whiten, status );
if( whiten ) {
/* We also need the reference map to measure the whitening filter. We
make a deep copy of it so that we can set bad values to 0 etc. */
smfData *tempdata=NULL;
kpg1Rgndf( "whiterefmap", 0, 1, "", &wgrp, &wsize, status );
if( (*status == SAI__OK) && (wsize != 1) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": WHITEREFMAP must be a single reference map",
status );
}
smf_open_file( wgrp, 1, "READ", SMF__NOTTSERIES, &tempdata, status );
wrefmap = smf_deepcopy_smfData( tempdata, 0, 0, 0, 0, status );
smf_close_file( &tempdata, status );
/* Set VAL__BADD to zero if requested */
if( (*status==SAI__OK) && zerobad ) {
double *d=NULL;
size_t j;
ndata=1;
for( j=0; j<wrefmap->ndims; j++ ) ndata *= wrefmap->dims[j];
d = wrefmap->pntr[0];
if( d ) {
for( j=0; j<ndata; j++ ) {
if( d[j] == VAL__BADD ) {
d[j] = 0;
}
}
}
}
}
for( i=1;(*status==SAI__OK)&&i<=size; i++ ) {
smf_open_file( igrp, i, "READ", SMF__NOTTSERIES, &idata, status );
isfft = smf_isfft( idata, NULL, NULL, NULL, NULL, &ndims, status);
if( (*status==SAI__OK) && isfft ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Input data are FFT, not real-space!\n",
status );
break;
}
if( (*status==SAI__OK) && (ndims != 2) ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": Input data not a 2D map!\n",
status );
break;
}
/* smf_filter_execute operates in-place, so first create the output
data as a copy of the input */
odata = smf_deepcopy_smfData( idata, 0, 0, 0, 0, status );
/* Set VAL__BADD to zero if requested */
if( (*status==SAI__OK) && zerobad ) {
double *d=NULL;
size_t j, k;
ndata=1;
for( j=0; j<odata->ndims; j++ ) ndata *= odata->dims[j];
mask = astCalloc( ndata, sizeof(*mask) );
/* Do both DATA and VARIANCE */
if( *status == SAI__OK ) {
for( k=0; k<2; k++ ) {
d = odata->pntr[k];
if( d ) {
for( j=0; j<ndata; j++ ) {
if( d[j] == VAL__BADD ) {
d[j] = 0;
mask[j] = 1;
}
}
}
}
}
}
/* Measure and apply the whitening filter. We need to do this
every time because the dimensions of filt need to match idata
(not the wrefmap) and they might be different each time. We
could try to be more clever in the future if this is too slow. */
filt = smf_create_smfFilter( idata, status );
/* Set to the identity in case no whitening is applied */
msgOut( "", TASK_NAME ": initializing filter", status );
smf_filter_ident( filt, 0, status );
if( whiten ) {
msgOut( "", TASK_NAME ": whitening the filter", status );
smf_filter2d_whiten( wf, filt, wrefmap, 0, 0, 3, status );
}
if( filt_edgelow ) {
msgOutf( "", TASK_NAME ": applying low-pass at < %lg 1/arcsec", status,
filt_edgelow );
smf_filter2d_edge( filt, filt_edgelow, 1, status );
}
if( filt_edgehigh ) {
msgOutf( "", TASK_NAME ": applying high-pass at >= %lg 1/arcsec", status,
filt_edgehigh );
smf_filter2d_edge( filt, filt_edgehigh, 0, status );
}
smf_filter_execute( wf, odata, filt, 0, 0, status );
/* Set bad values from the mask */
if( mask ) {
double *d=NULL;
size_t j, k;
/* Do both DATA and VARIANCE */
for( k=0; k<2; k++ ) {
d = odata->pntr[k];
if( d ) {
for( j=0; j<ndata; j++ ) {
if( mask[j] ) {
d[j] = VAL__BADD;
}
}
}
}
}
/* Export the data to a new file */
smf_write_smfData( odata, NULL, NULL, ogrp, i, 0, MSG__NORM, status );
/* Write out filters? */
if( fgrp ) smf_write_smfFilter( filt, NULL, fgrp, i, status );
if( filt ) smf_free_smfFilter( filt, status );
}
/* Tidy up after ourselves */
if( fgrp ) grpDelet( &fgrp, status);
if( igrp ) grpDelet( &igrp, status);
if( ogrp ) grpDelet( &ogrp, status);
if( wgrp ) grpDelet( &wgrp, status );
if( odata ) smf_close_file( &odata, status );
if( wrefmap ) smf_close_file( &wrefmap, status );
if( mask ) mask = astFree( mask );
ndfEnd( status );
/* Ensure that FFTW doesn't have any used memory kicking around */
fftw_cleanup();
}
void smurf_fts2_split(int* status)
{
if( *status != SAI__OK ) { return; }
const double STAGE_LENGTH = 450.0; /* mm */
int LR = 0; /* Treat as Low Resolution scan */
Grp* gIn = NULL; /* Input group */
Grp* gOut = NULL; /* Output group */
Grp* gTmp = NULL; /* Temporary group */
smfData* inData = NULL; /* Pointer to input data */
smfData* outData = NULL; /* Pointer to output data */
double* outData_pntr = NULL; /* Pointer to output data values array */
int nMirPos = 0; /* Number of frames where the mirror actually moves */
int nStart = 0; /* Frame index where the mirror starts moving */
int nStartNext = 0; /* Frame index where the mirror starts moving in the next scan */
int nStop = 0; /* Frame index where the mirror stops */
int lrStart = 0; /* Frame index where low resolution mirror limit starts */
int hrStop = 0; /* Frame index where high resolution mirror limit stops */
int hrStart = 0; /* Frame index where high resolution mirror limit starts */
int lrStop = 0; /* Frame index where low resolution mirror limit stops */
int lrCentre = 0; /* Frame index at centre of low resolution mirror positions */
int i = 0; /* Counter */
int j = 0; /* Counter */
int k = 0; /* Counter */
int n = 0; /* Counter */
double fNyquist = 0.0; /* Nyquist frequency */
double dz = 0.0; /* Step size in evenly spaced OPD grid */
double* MIRPOS = NULL; /* Mirror positions */
size_t nFiles = 0; /* Size of the input group */
size_t nOutFiles = 0; /* Size of the output group */
size_t fIndex = 0; /* File index */
size_t nWidth = 0; /* Data cube width */
size_t nHeight = 0; /* Data cube height */
size_t nFrames = 0; /* Data cube depth in input file */
size_t nFramesOut = 0; /* Data cube depth in output file */
size_t nFramesOutPrev = 0; /* Data cube depth in previous output file */
size_t hrFramesOut = 0; /* Data cube depth in high res output file */
size_t hrFramesOutPrev = 0; /* Data cube depth in previous high res output file */
size_t lrFramesOut = 0; /* Data cube depth in low res output file */
size_t lrFramesOutPrev = 0; /* Data cube depth in previous low res output file */
size_t nPixels = 0; /* Number of bolometers in the subarray */
char object[SZFITSTR];
char subarray[SZFITSTR];
char obsID[SZFITSTR];
char scanMode[SZFITSTR];
double scanVel = 0.0; /* Mirror speed in mm/sec */
double stepTime = 0.0; /* RTS step time, average sample rate */
double minOPD = 0; /* OPD minimum */
double maxOPD = 0; /* OPD maximum */
double ZPD = 0;
double lrmmBandPass = 0.0; /* low res mm +/- offset from centre */
int lrBandPassFrames = 0; /* Number of low res band pass frames from centre +/- length of lrmmBandPass */
int nTmp = 0;
int nMax = 0;
int nOPD = 0;
int bolIndex = 0;
int index = 0;
int indexIn = 0;
int indexOut = 0;
int badPixel = 0;
int k0 = 0;
int indexZPD = 0;
int done = 0; /* Track completion of extracting multiple scans */
int outDataCount = 0; /* The number of output data files being written */
double lenLeft,
lenRight,
minLenLeft,
minLenRight,
minLen,
minZPD,
maxZPD,
midZPD = 0.0; /* Mirror position half side measures */
int midZPDPos = 0; /* Middle ZPD position in mirror position array */
double EPSILON = 0.0;
char fileName[SMF_PATH_MAX+1];
char scanNumStr[5+1]; /* String form of scan number of the input file */
int scanNum = 0; /* Scan number of the input file */
int conNum = 0; /* Concatenation number of the input file (left shifted scanNum) */
int scanDir = 0; /* Scan direction: 1 -> back to front (positive), -1 -> front to back (negative) */
JCMTState *allState = NULL; /* Temporary buffer for reduced header allState array data */
/* Get Input, Output groups */
kpg1Rgndf("IN", 0, 1, "", &gIn, &nFiles, status);
kpg1Wgndf("OUT", gOut, nFiles, nFiles, "More output files expected!", &gOut, &nOutFiles, status);
/* Read in ADAM parameters */
parGet0d("BANDPASS", &lrmmBandPass, status); /* Low res mm band +/- offset from centre */
/* Treat as Low Resolution scan? */
if(lrmmBandPass > 0) {
LR = 1;
}
/* Eliminate the first record in the output group, since it will be replaced later */
gTmp = grpCopy(gOut, 1, 1, 1, status);
grpDelet(&gOut, status);
gOut = gTmp;
/* BEGIN NDF */
ndfBegin();
/* Loop through each input file */
for(fIndex = 1; fIndex <= nFiles; fIndex++) {
/* Open Observation file */
smf_open_file(gIn, fIndex, "READ", 0, &inData, status);
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep(FUNC_NAME, "Unable to open the source file!", status);
goto CLEANUP;
}
smf_fits_getS(inData->hdr, "OBJECT", object, sizeof(object), status);
smf_fits_getS(inData->hdr, "SUBARRAY", subarray, sizeof(subarray), status);
smf_fits_getS(inData->hdr, "OBSID", obsID, sizeof(obsID), status);
smf_fits_getS(inData->hdr, "FTS_MODE", scanMode, sizeof(scanMode), status);
smf_fits_getD(inData->hdr, "SCANVEL", &scanVel, status);
smf_fits_getD(inData->hdr, "STEPTIME", &stepTime, status);
/* Nyquist frequency */
fNyquist = 10.0 / (8.0 * scanVel * stepTime);
dz = 1.0 / (2.0 * fNyquist);
EPSILON = scanVel * stepTime / 2;
/* Extract the scan number from the input file to be incremented in the output files */
one_strlcpy(scanNumStr, &(inData->file->name[strlen(inData->file->name) - 8]),
astMIN(SMF_PATH_MAX + 1, 5), status);
if (*status == ONE__TRUNC) {
errRep(FUNC_NAME, "Error extracting scanNumStr!", status);
errAnnul(status);
}
/* Create a temporary base file name from input file name */
one_strlcpy(fileName, inData->file->name,
astMIN(SMF_PATH_MAX + 1, strlen(inData->file->name) - 7), status);
if (*status == ONE__TRUNC) {
errRep(FUNC_NAME, "Error extracting base fileName!", status);
errAnnul(status);
}
scanNum = (int) one_strtod(scanNumStr, status);
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Error extracting scanNum!", status);
errAnnul(status);
}
/* Left shift scanNum to conNum as a prefix to make output scan number unique */
if(scanNum < 100) {
conNum = scanNum * 100;
} else if(scanNum < 1000) {
conNum = scanNum * 10;
}
/*printf("%s: Processing file: %s, having basename: %s and scanNumStr: %s, scanNum: %04d\n",
TASK_NAME, inData->file->name, fileName, scanNumStr, scanNum);*/
/* Data cube dimensions */
nWidth = inData->dims[0];
nHeight = inData->dims[1];
nFrames = inData->dims[2];
nPixels = nWidth * nHeight;
/* Mirror positions in mm */
nTmp = nFrames;
MIRPOS = astCalloc(nFrames, sizeof(*MIRPOS));
fts2_getmirrorpositions(inData, MIRPOS, &nTmp, status); // (mm)
if(*status != SAI__OK) {
*status = SAI__ERROR;
errRep( FUNC_NAME, "Unable to get the mirror positions!", status);
goto CLEANUP;
}
nStart = -1;
nStop = -1;
nStartNext = 0;
hrStart = -1;
hrStop = -1;
lrStart = -1;
lrStop = -1;
outDataCount = 0;
done = 0;
do {
/* Find the next range of single scan mirror positions for which to extract corresponding NDF data */
for(n=nStartNext; n<nFrames-1; n++){
if(hrStart < 0 && fabs(MIRPOS[n+1] - MIRPOS[n]) >= EPSILON) {
nStart = n;
hrStart = n;
/*printf("%s: Split nStart=%d\n", TASK_NAME, nStart);*/
}
if(hrStart >= 0 && hrStop < 0 && (fabs(MIRPOS[n+1] - MIRPOS[n]) < EPSILON || n+1 == nFrames-1)) {
hrStop = n+1;
hrFramesOutPrev = hrFramesOut;
hrFramesOut = abs(hrStop - hrStart) + 1;
outDataCount++;
nStop = hrStop;
nFramesOutPrev = hrFramesOutPrev;
nFramesOut = hrFramesOut;
/*printf("%s: Split: %d of %d frames found at hrStart=%d, hrStop=%d\n",
TASK_NAME, outDataCount, hrFramesOut, hrStart, hrStop);*/
break;
}
}
/* Determine scan direction */
if(MIRPOS[hrStart] < MIRPOS[hrStop]) {
scanDir = 1; /* Positive */
} else {
scanDir = -1; /* Negative */
}
/* Limit to specified mirror position range */
if(LR) {
/* Calculate how many frames correspond to the given +/- mm of LR bandpass */
lrBandPassFrames = lrmmBandPass / dz;
/* Find the centre of the current scan */
lrCentre = floor((abs(hrStop-hrStart)+1)/2);
/* Set low res start and stop values at corresponding frame offsets from centre */
lrStart = lrCentre - lrBandPassFrames;
lrStop = lrCentre + lrBandPassFrames;
lrFramesOutPrev = lrFramesOut;
lrFramesOut = abs(lrStop - lrStart) + 1;
nStart = lrStart;
nStop = lrStop;
nFramesOutPrev = lrFramesOutPrev;
nFramesOut = lrFramesOut;
/*printf("%s: LR Split: %d of %d frames found at lrStart=%d, lrStop=%d\n",
TASK_NAME, outDataCount, lrFramesOut, lrStart, lrStop);*/
}
/* Check for end of data condition */
if(hrStop < hrStart || hrStop >= nFrames-1) {
hrStop = nFrames-1;
done = 1;
}
/* Output scan if there is a start and stop position found,
and for the last scan if it's the only one
and if it's not too short (compared to the previous one) */
/*printf("%s: nStart=%d, nStop=%d, nFramesOutPrev=%d, nFramesOut=%d\n", TASK_NAME, nStart, nStop, nFramesOutPrev, nFramesOut);*/
if(nStart >=0 && nStop > 0 &&
(nFramesOutPrev == 0 ||
(nFramesOutPrev > 0 && nFramesOut > 0 && (double)hrFramesOut/(double)hrFramesOutPrev >= 0.5))) {
/* Copy single scan NDF data from input to output */
outData = smf_deepcopy_smfData(inData, 0, SMF__NOCREATE_DATA | SMF__NOCREATE_FTS, 0, 0, status);
outData->dtype = SMF__DOUBLE;
outData->ndims = 3;
outData->dims[0] = nWidth;
outData->dims[1] = nHeight;
outData->dims[2] = nFramesOut;
outData_pntr = (double*) astMalloc((nPixels * nFramesOut) * sizeof(*outData_pntr));
outData->pntr[0] = outData_pntr;
outData->hdr->nframes = nFramesOut;
for(i=0; i<nWidth; i++) {
for(j=0; j<nHeight; j++) {
bolIndex = i + j * nWidth;
for(k=nStart; k<=nStop; k++) {
indexIn = bolIndex + k * nPixels;
indexOut = bolIndex + (k-nStart) * nPixels;
*((double*)(outData->pntr[0]) + indexOut) = *((double*)(inData->pntr[0]) + indexIn);
}
}
}
/* Update the FITS headers */
outData->fts = smf_create_smfFts(status);
/* Update FITS component */
smf_fits_updateD(outData->hdr, "FNYQUIST", fNyquist, "Nyquist frequency (cm^-1)", status);
smf_fits_updateI(outData->hdr, "MIRSTART", 1, "Frame index in which the mirror starts moving", status);
smf_fits_updateI(outData->hdr, "MIRSTOP", nFramesOut, "Frame index in which the mirror stops moving", status);
smf_fits_updateI(outData->hdr, "SCANDIR", scanDir, "Scan direction", status);
smf_fits_updateD(outData->hdr, "OPDMIN", 0.0, "Minimum OPD", status);
smf_fits_updateD(outData->hdr, "OPDSTEP", 0.0, "OPD step size", status);
/* Update the JCMTSTATE header */
/* Reallocate outData header array memory to reduced size */
allState = (JCMTState*) astRealloc(outData->hdr->allState, nFramesOut * sizeof(*(outData->hdr->allState)));
if(*status == SAI__OK && allState) {
outData->hdr->allState = allState;
} else {
errRepf(TASK_NAME, "Error reallocating allState JCMTState header", status);
goto CLEANUP;
}
for(k=nStart; k<=nStop; k++) {
/* Copy over JCMTstate */
/*printf("%s: memcpy allState: %d to: %p from: %p size: %d\n",TASK_NAME, k,
(void *) &(outData->hdr->allState[k-nStart]), (void *) &(inData->hdr->allState[k]), sizeof(*(outData->hdr->allState)) );*/
memcpy( (void *) &(outData->hdr->allState[k-nStart]), (void *) &(inData->hdr->allState[k]), sizeof(*(outData->hdr->allState)) );
/*printf("%s: Scan: %d index: %d rts_num: %d\n", TASK_NAME, outDataCount, k-nStart, outData->hdr->allState[k-nStart].rts_num);*/
/*printf("%s: Scan: %d index: %d fts_pos: %f\n", TASK_NAME, outDataCount, k-nStart, outData->hdr->allState[k-nStart].fts_pos);*/
}
/* Write output */
/* Append unique suffix to fileName */
/* This must be modified by the concatenation file scan number to improve uniqueness */
n = one_snprintf(outData->file->name, SMF_PATH_MAX, "%s%04d_scn.sdf", status, fileName, conNum+outDataCount);
/*printf("%s: Writing outData->file->name: %s\n", TASK_NAME, outData->file->name);*/
if(n < 0 || n >= SMF_PATH_MAX) {
errRepf(TASK_NAME, "Error creating outData->file->name", status);
goto CLEANUP;
}
/* Update the list of output _scn file names */
grpPut1(gOut, outData->file->name, 0, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error saving outData file name", status);
goto CLEANUP;
}
smf_write_smfData(outData, NULL, outData->file->name, gOut, fIndex, 0, MSG__VERB, 0, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error writing outData file", status);
goto CLEANUP;
}
smf_close_file(&outData, status);
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error closing outData file", status);
goto CLEANUP;
}
if(*status != SAI__OK) {
errRepf(TASK_NAME, "Error closing outData file", status);
goto CLEANUP;
}
}/* else {
if(!(nStart >=0 && nStop)) printf("%s: Output scan condition failed: nStart(%d) >= nStop(%d) is FALSE\n",TASK_NAME, nStart, nStop);
if(!(nFramesOutPrev == 0 ||
(nFramesOutPrev > 0 && nFramesOut > 0 && (double)nFramesOut/(double)nFramesOutPrev >= 0.5))) printf("%s: Output scan condition failed: nFramesOutPrev(%d) == 0 || (nFramesOutPrev(%d) > 0 && nFramesOut(%d) > 0 && nFramesOut/nFramesOutPrev (%f) >= 0.5) is FALSE\n", TASK_NAME, nFramesOutPrev, nFramesOutPrev, nFramesOut, (double)nFramesOut/(double)nFramesOutPrev);
}*/
/* Prepare for next iteration */
nStartNext = hrStop + 1;
hrStart = -1;
hrStop = -1;
} while (!done);
/* Deallocate memory used by arrays */
if(MIRPOS) { MIRPOS = astFree(MIRPOS); }
/* Close the file */
smf_close_file(&inData, status);
}
CLEANUP:
/* Deallocate memory used by arrays */
if(inData) { smf_close_file(&inData, status); }
if(outData) { smf_close_file(&outData, status); }
/* END NDF */
ndfEnd(status);
/* Write out the list of output NDF names, annulling the error if a null
parameter value is supplied. */
if( *status == SAI__OK && gOut ) {
grpList( "OUTFILES", 0, 0, NULL, gOut, status );
if( *status == PAR__NULL ) {
errRep(FUNC_NAME, "Error writing OUTFILES!", status);
errAnnul( status );
}
}
/* Delete groups */
if(gIn) { grpDelet(&gIn, status); }
if(gOut) { grpDelet(&gOut, status); }
}
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);
}
}
void smf_find_science(const Grp * ingrp, Grp **outgrp, int reverttodark,
Grp **darkgrp, Grp **flatgrp, int reducedark,
int calcflat, smf_dtype darktype, smfArray ** darks,
smfArray **fflats, AstKeyMap ** heateffmap,
double * meanstep, int * status ) {
smfSortInfo *alldarks; /* array of sort structs for darks */
smfSortInfo *allfflats; /* array of fast flat info */
Grp * dgrp = NULL; /* Internal dark group */
double duration_darks = 0.0; /* total duration of all darks */
double duration_sci = 0.0; /* Duration of all science observations */
size_t dkcount = 0; /* Dark counter */
size_t ffcount = 0; /* Fast flat counter */
Grp * fgrp = NULL; /* Fast flat group */
size_t i; /* loop counter */
smfData *infile = NULL; /* input file */
size_t insize; /* number of input files */
size_t nsteps_dark = 0; /* Total number of steps for darks */
size_t nsteps_sci = 0; /* Total number of steps for science */
AstKeyMap * heatermap = NULL; /* Heater efficiency map */
AstKeyMap * obsmap = NULL; /* Info from all observations */
AstKeyMap * objmap = NULL; /* All the object names used */
AstKeyMap * scimap = NULL; /* All non-flat obs indexed by unique key */
Grp *ogrp = NULL; /* local copy of output group */
size_t sccount = 0; /* Number of accepted science files */
struct timeval tv1; /* Timer */
struct timeval tv2; /* Timer */
if (meanstep) *meanstep = VAL__BADD;
if (outgrp) *outgrp = NULL;
if (darkgrp) *darkgrp = NULL;
if (darks) *darks = NULL;
if (fflats) *fflats = NULL;
if (heateffmap) *heateffmap = NULL;
if (*status != SAI__OK) return;
/* Sanity check to make sure we return some information */
if ( outgrp == NULL && darkgrp == NULL && darks == NULL && fflats == NULL) {
*status = SAI__ERROR;
errRep( " ", FUNC_NAME ": Must have some non-NULL arguments"
" (possible programming error)", status);
return;
}
/* Start a timer to see how long this takes */
smf_timerinit( &tv1, &tv2, status );
/* Create new group for output files */
ogrp = smf_grp_new( ingrp, "Science", status );
/* and a new group for darks */
dgrp = smf_grp_new( ingrp, "DarkFiles", status );
/* and for fast flats */
fgrp = smf_grp_new( ingrp, "FastFlats", status );
/* and also create a keymap for the observation description */
obsmap = astKeyMap( "KeyError=1" );
/* and an object map */
objmap = astKeyMap( "KeyError=1" );
/* This keymap contains the sequence counters for each related
subarray/obsidss/heater/shutter combination and is used to decide
if a bad flat is relevant */
scimap = astKeyMap( "KeyError=1,KeyCase=0" );
/* This keymap is used to contain relevant heater efficiency data */
heatermap = astKeyMap( "KeyError=1,KeyCase=0" );
/* Work out how many input files we have and allocate sufficient sorting
space */
insize = grpGrpsz( ingrp, status );
alldarks = astCalloc( insize, sizeof(*alldarks) );
allfflats = astCalloc( insize, sizeof(*allfflats) );
/* check each file in turn */
for (i = 1; i <= insize; i++) {
int seqcount = 0;
char keystr[100]; /* Key for scimap entry */
/* open the file but just to get the header */
smf_open_file( ingrp, i, "READ", SMF__NOCREATE_DATA, &infile, status );
if (*status != SAI__OK) break;
/* Fill in the keymap with observation details */
smf_obsmap_fill( infile, obsmap, objmap, status );
/* Find the heater efficiency map if required */
if (*status == SAI__OK && heateffmap) {
char arrayidstr[32];
smf_fits_getS( infile->hdr, "ARRAYID", arrayidstr, sizeof(arrayidstr),
status );
if (!astMapHasKey( heatermap, arrayidstr ) ) {
smfData * heateff = NULL;
dim_t nbolos = 0;
smf_flat_params( infile, "RESIST", NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, &heateff, status );
smf_get_dims( heateff, NULL, NULL, &nbolos, NULL, NULL, NULL, NULL,
status );
if (heateff) astMapPut0P( heatermap, arrayidstr, heateff, NULL );
}
}
/* Get the sequence counter for the file. We do not worry about
duplicate sequence counters (at the moment) */
smf_find_seqcount( infile->hdr, &seqcount, status );
/* The key identifying this subarray/obsidss/heater/shutter combo */
smf__calc_flatobskey( infile->hdr, keystr, sizeof(keystr), status );
if (smf_isdark( infile, status )) {
/* Store the sorting information */
dkcount = smf__addto_sortinfo( infile, alldarks, i, dkcount, "Dark", status );
smf__addto_durations( infile, &duration_darks, &nsteps_dark, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
} else {
/* compare sequence type with observation type and drop it (for now)
if they differ */
if ( infile->hdr->obstype == infile->hdr->seqtype ) {
/* Sanity check the header for corruption. Compare RTS_NUM with SEQSTART
and SEQEND. The first RTS_NUM must either be SEQSTART or else between
SEQSTART and SEQEND (if someone has giving us a section) */
int seqstart = 0;
int seqend = 0;
int firstnum = 0;
JCMTState *tmpState = NULL;
smf_getfitsi( infile->hdr, "SEQSTART", &seqstart, status );
smf_getfitsi( infile->hdr, "SEQEND", &seqend, status );
tmpState = infile->hdr->allState;
if( tmpState ) {
firstnum = (tmpState[0]).rts_num;
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
if ( firstnum >= seqstart && firstnum <= seqend ) {
/* store the file in the output group */
ndgCpsup( ingrp, i, ogrp, status );
msgOutif(MSG__DEBUG, " ", "Non-dark file: ^F",status);
smf__addto_durations( infile, &duration_sci, &nsteps_sci, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
sccount++;
} else {
msgOutif( MSG__QUIET, "",
"File ^F has a corrupt FITS header. Ignoring it.",
status );
}
} else {
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
/* store the file in the output group */
ndgCpsup( ingrp, i, ogrp, status );
msgOutif( MSG__DEBUG, " ",
"File ^F lacks JCMTState: assuming it is non-dark",status);
smf__addto_durations( infile, &duration_sci, &nsteps_sci, status );
astMapPutElemI( scimap, keystr, -1, seqcount );
sccount++;
}
} else if (infile->hdr->seqtype == SMF__TYP_FASTFLAT ) {
ffcount = smf__addto_sortinfo( infile, allfflats, i, ffcount, "Fast flat", status );
} else {
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>");
msgOutif(MSG__DEBUG, " ", "Sequence type mismatch with observation type: ^F",status);
}
}
/* close the file */
smf_close_file( &infile, status );
}
/* Store output group in return variable or else free it */
if (outgrp) {
*outgrp = ogrp;
} else {
grpDelet( &ogrp, status );
}
/* process flatfields if necessary */
if (ffcount > 0 && fflats ) {
smfArray * array = NULL;
/* sort flats into order */
qsort( allfflats, ffcount, sizeof(*allfflats), smf_sort_bydouble);
if (fflats) array = smf_create_smfArray( status );
/* now open the flats and store them if requested */
if (*status == SAI__OK && array && ffcount) {
size_t start_ffcount = ffcount;
AstKeyMap * flatmap = NULL;
if (calcflat) {
/* Use AgeUp so that we get the keys out in the sorted order
that allfflats used */
flatmap = astKeyMap( "KeyCase=0,KeyError=1,SortBy=AgeDown" );
}
/* Read each flatfield. Calculate a responsivity image and a flatfield
solution. Store these in a keymap along with related information
which is itself stored in a keymap indexed by a string made of
OBSIDSS, reference heater value, shutter and subarray.
*/
for (i = 0; i < start_ffcount; i++ ) {
size_t ori_index = (allfflats[i]).index;
smfData * outfile = NULL;
char keystr[100];
AstKeyMap * infomap = astKeyMap( "KeyError=1" );
int oplen = 0;
char thisfile[MSG__SZMSG];
int seqcount = 0;
/* read filename from group */
infile = NULL;
smf_open_file( ingrp, ori_index, "READ", 0, &infile, status );
if ( *status != SAI__OK ) {
/* This should not happen because we have already opened
the file. If it does happen we abort with error. */
if (infile) smf_close_file( &infile, status );
break;
}
/* Calculate the key for this observation */
smf__calc_flatobskey( infile->hdr, keystr, sizeof(keystr), status );
/* Get the file name for error messages */
smf_smfFile_msg( infile->file, "F", 1, "<unknown file>" );
msgLoad( "", "^F", thisfile, sizeof(thisfile), &oplen, status );
/* And the sequence counter to link against science observations */
smf_find_seqcount( infile->hdr, &seqcount, status );
/* Prefill infomap */
astMapPut0C( infomap, "FILENAME", thisfile, "");
astMapPut0I( infomap, "SEQCOUNT", seqcount, "");
/* Collapse it */
if (*status == SAI__OK) {
smf_flat_fastflat( infile, &outfile, status );
if (*status == SMF__BADFLAT) {
errFlush( status );
if (calcflat) {
/* Need to generate an outfile like smf_flat_fastflat
and one heater setting will force smf_flat_calcflat to fail */
smf_flat_malloc( 1, infile, NULL, &outfile, status );
} else {
if (outfile) smf_close_file( &outfile, status );
if (infile) smf_close_file( &infile, status );
infomap = astAnnul( infomap );
ffcount--;
continue;
}
}
}
if (outfile && *status == SAI__OK) {
smf_close_file( &infile, status );
infile = outfile;
if (calcflat) {
size_t ngood = 0;
smfData * curresp = NULL;
int utdate;
if (*status == SAI__OK) {
ngood = smf_flat_calcflat( MSG__VERB, NULL, "RESIST",
"FLATMETH", "FLATORDER", NULL, "RESPMASK",
"FLATSNR", NULL, infile, &curresp, status );
if (*status != SAI__OK) {
/* if we failed to calculate a flatfield we continue but force the
flatfield to be completely bad. This will force the science data associated
with the flatfield to be correctly blanked. We do not annul though
if we have a SUBPAR error telling us that we have failed to define
our parameters properly. */
if (*status != SUBPAR__NOPAR) errAnnul(status);
/* parameters of flatfield */
ngood = 0;
/* Generate a blank flatfield and blank responsivity image */
smf_flat_badflat( infile, &curresp, status );
}
/* Retrieve the UT date so we can decide whether to compare
flatfields */
smf_getfitsi( infile->hdr, "UTDATE", &utdate, status );
/* Store the responsivity data for later on and the processed
flatfield until we have vetted it */
astMapPut0P( infomap, "CALCFLAT", infile, "" );
astMapPut0P( infomap, "RESP", curresp, "" );
astMapPut0I( infomap, "UTDATE", utdate, "" );
astMapPut0I( infomap, "ISGOOD", 1, "" );
astMapPut0I( infomap, "NGOOD", ngood, "" );
astMapPut0I( infomap, "GRPINDEX", ori_index, "" );
astMapPut0I( infomap, "SMFTYP", infile->hdr->obstype, "" );
astMapPutElemA( flatmap, keystr, -1, infomap );
}
} else { /* if (calcflat) */
/* Store the collapsed flatfield - the processed flat is not stored here yet */
smf_addto_smfArray( array, infile, status );
/* Copy the group info */
ndgCpsup( ingrp, ori_index, fgrp, status );
}
} /* if (outfile) */
/* Annul the keymap (will be fine if it is has been stored in another keymap) */
infomap = astAnnul( infomap );
} /* End loop over flatfields */
/* Now we have to loop over the related flatfields to disable
bolometers that are not good and also decide whether we
need to set status to bad. */
if (*status == SAI__OK && calcflat ) {
size_t nkeys = astMapSize( flatmap );
for (i = 0; i < nkeys; i++ ) {
const char *key = astMapKey( flatmap, i );
int nf = 0;
AstKeyMap ** kmaps = NULL;
int nelem = astMapLength( flatmap, key );
kmaps = astMalloc( sizeof(*kmaps) * nelem );
astMapGet1A( flatmap, key, nelem, &nelem, kmaps );
for ( nf = 0; nf < nelem && *status == SAI__OK; nf++ ) {
AstKeyMap * infomap = kmaps[nf];
int isgood = 0;
astMapGet0I( infomap, "ISGOOD", &isgood );
if (isgood) {
/* The flatfield worked */
size_t ngood = 0;
int itemp;
int utdate = 0;
int ratioFlats = 0;
/* Get the UT date - we do not compare flatfields after
the time we enabled heater tracking at each sequence. */
astMapGet0I( infomap, "UTDATE", &utdate );
/* Get the number of good bolometers at this point */
astMapGet0I( infomap, "NGOOD", &itemp );
ngood = itemp;
/* Decide if we want to do the ratio test. We default to
not doing it between 20110901 and 20120827 which is
the period when we did mini-heater tracks before each
flat. ! indicates that we choose based on date. */
if (*status == SAI__OK) {
parGet0l( "FLATUSENEXT", &ratioFlats, status );
if ( *status == PAR__NULL ) {
errAnnul( status );
if (utdate >= 20110901 || utdate <= 20120827 ) {
ratioFlats = 0;
} else {
ratioFlats = 1;
}
}
}
/* Can we compare with the next flatfield? */
if (ngood < SMF__MINSTATSAMP || !ratioFlats ) {
/* no point doing all the ratio checking for this */
} else if ( nelem - nf >= 2 ) {
AstKeyMap * nextmap = kmaps[nf+1];
const char *nextfname = NULL;
const char *fname = NULL;
smfData * curresp = NULL;
smfData * nextresp = NULL;
smfData * curflat = NULL;
void *tmpvar = NULL;
size_t bol = 0;
smfData * ratio = NULL;
double *in1 = NULL;
double *in2 = NULL;
double mean = VAL__BADD;
size_t nbolo;
double *out = NULL;
double sigma = VAL__BADD;
float clips[] = { 5.0, 5.0 }; /* 5.0 sigma iterative clip */
size_t ngoodz = 0;
astMapGet0C( nextmap, "FILENAME", &nextfname );
astMapGet0C( infomap, "FILENAME", &fname );
/* Retrieve the responsivity images from the keymap */
astMapGet0P( infomap, "RESP", &tmpvar );
curresp = tmpvar;
astMapGet0P( nextmap, "RESP", &tmpvar );
nextresp = tmpvar;
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
curflat = tmpvar;
nbolo = (curresp->dims)[0] * (curresp->dims)[1];
/* get some memory for the ratio if we have not already.
We could get some memory once assuming each flat has the
same number of bolometers... */
ratio = smf_deepcopy_smfData( curresp, 0, 0, 0, 0, status );
if( *status == SAI__OK ) {
/* divide: smf_divide_smfData ? */
in1 = (curresp->pntr)[0];
in2 = (nextresp->pntr)[0];
out = (ratio->pntr)[0];
for (bol=0; bol<nbolo;bol++) {
if ( in1[bol] != VAL__BADD && in1[bol] != 0.0 &&
in2[bol] != VAL__BADD && in2[bol] != 0.0 ) {
out[bol] = in1[bol] / in2[bol];
} else {
out[bol] = VAL__BADD;
}
}
}
/* find some statistics */
smf_clipped_stats1D( out, 2, clips, 1, nbolo, NULL, 0, 0, &mean,
&sigma, NULL, 0, &ngoodz, status );
if (*status == SMF__INSMP) {
errAnnul(status);
msgOutiff( MSG__QUIET, "",
"Flatfield ramp ratio of %s with %s had too few bolometers (%zu < %d).",
status, fname, nextfname, ngoodz, SMF__MINSTATSAMP );
ngood = ngoodz; /* Must be lower or equal to original ngood */
} else if (*status == SAI__OK && mean != VAL__BADD && sigma != VAL__BADD && curflat->da) {
/* Now flag the flatfield as bad for bolometers that have changed
more than n%. We expect the variation to be 1+/-a small bit */
const double pmrange = 0.10;
double thrlo = 1.0 - pmrange;
double thrhi = 1.0 + pmrange;
size_t nmasked = 0;
double *flatcal = curflat->da->flatcal;
msgOutiff( MSG__DEBUG, "", "Flatfield fast ramp ratio mean = %g +/- %g (%zu bolometers)",
status, mean, sigma, ngood);
/* we can just set the first slice of the flatcal to bad. That should
be enough to disable the entire bolometer. We have just read these
data so they should be in ICD order. */
for (bol=0; bol<nbolo;bol++) {
if ( out[bol] != VAL__BADD &&
(out[bol] < thrlo || out[bol] > thrhi ) ) {
flatcal[bol] = VAL__BADD;
nmasked++;
} else if ( in1[bol] != VAL__BADD && in2[bol] == VAL__BADD ) {
/* A bolometer is bad next time but good now so we must set it bad now */
flatcal[bol] = VAL__BADD;
nmasked++;
}
}
if ( nmasked > 0 ) {
msgOutiff( MSG__NORM, "", "Masked %zu bolometers in %s from unstable flatfield",
status, nmasked, fname );
/* update ngood to take into account the masking */
ngood -= nmasked;
}
}
smf_close_file( &ratio, status );
} /* End of flatfield responsivity comparison */
/* if we only have a few bolometers left we now consider this
a bad flat unless it is actually an engineering measurement
where expect some configurations to give zero bolometers */
if (ngood < SMF__MINSTATSAMP) {
const char *fname = NULL;
void * tmpvar = NULL;
int smftyp = 0;
smfData * curflat = NULL;
astMapGet0I( infomap, "SMFTYP", &smftyp );
astMapGet0C( infomap, "FILENAME", &fname );
if (smftyp != SMF__TYP_NEP) {
msgOutiff( MSG__QUIET, "",
"Flatfield %s has %zu good bolometer%s.%s",
status, fname, ngood, (ngood == 1 ? "" : "s"),
( ngood == 0 ? "" : " Keeping none.") );
isgood = 0;
/* Make sure that everything is blanked. */
if (ngood > 0) {
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
curflat = tmpvar;
if (curflat && curflat->da) {
size_t bol;
size_t nbolo = (curflat->dims)[0] * (curflat->dims)[1];
double *flatcal = curflat->da->flatcal;
for (bol=0; bol<nbolo; bol++) {
/* Just need to set the first element to bad */
flatcal[bol] = VAL__BADD;
}
}
}
} else {
msgOutiff( MSG__NORM, "",
"Flatfield ramp file %s has %zu good bolometer%s. Eng mode.",
status, fname, ngood, (ngood == 1 ? "" : "s") );
}
}
/* We do not need the responsivity image again */
{
void *tmpvar = NULL;
smfData * resp = NULL;
astMapGet0P( infomap, "RESP", &tmpvar );
resp = tmpvar;
if (resp) smf_close_file( &resp, status );
astMapRemove( infomap, "RESP" );
}
} /* End of isgood comparison */
/* We are storing flats even if they failed. Let the downstream
software worry about it */
{
int ori_index;
smfData * flatfile = NULL;
void *tmpvar = NULL;
/* Store in the output group */
astMapGet0I( infomap, "GRPINDEX", &ori_index );
ndgCpsup( ingrp, ori_index, fgrp, status );
/* And store in the smfArray */
astMapGet0P( infomap, "CALCFLAT", &tmpvar );
astMapRemove( infomap, "CALCFLAT" );
flatfile = tmpvar;
smf_addto_smfArray( array, flatfile, status );
}
/* Free the object as we go */
kmaps[nf] = astAnnul( kmaps[nf] );
} /* End of loop over this obsidss/subarray/heater */
kmaps = astFree( kmaps );
}
}
if (array->ndat) {
if (fflats) *fflats = array;
} else {
smf_close_related(&array, status );
if (fflats) *fflats = NULL;
}
}
}
/* no need to do any more if neither darks nor darkgrp are defined or we might
be wanting to revert to darks. */
if (dkcount > 0 && (darks || darkgrp || reverttodark ) ) {
smfArray * array = NULL;
/* sort darks into order */
qsort( alldarks, dkcount, sizeof(*alldarks), smf_sort_bydouble);
if (darks) array = smf_create_smfArray( status );
/* now open the darks and store them if requested */
if (*status == SAI__OK) {
for (i = 0; i < dkcount; i++ ) {
size_t ori_index = (alldarks[i]).index;
/* Store the entry in the output group */
ndgCpsup( ingrp, ori_index, dgrp, status );
if (darks) {
/* read the value from the new group */
smf_open_file( dgrp, i+1, "READ", 0, &infile, status );
/* do we have to process these darks? */
if (reducedark) {
smfData *outfile = NULL;
smf_reduce_dark( infile, darktype, &outfile, status );
if (outfile) {
smf_close_file( &infile, status );
infile = outfile;
}
}
smf_addto_smfArray( array, infile, status );
}
}
if (darks) *darks = array;
}
}
/* free memory */
alldarks = astFree( alldarks );
allfflats = astFree( allfflats );
if( reverttodark && outgrp && (grpGrpsz(*outgrp,status)==0) &&
(grpGrpsz(dgrp,status)>0) ) {
/* If outgrp requested but no science observations were found, and
dark observations were found, return darks in outgrp and set
flatgrp and darkgrp to NULL. This is to handle cases where we
want to process data taken in the dark like normal science
data. To activate this behaviour set reverttodark */
msgOutiff( MSG__NORM, "", "Treating the dark%s as science data",
status, ( dkcount > 1 ? "s" : "" ) );
*outgrp = dgrp;
if( darkgrp ){
*darkgrp = NULL;
}
if( flatgrp ) {
*flatgrp = NULL;
}
grpDelet( &ogrp, status);
grpDelet( &fgrp, status);
if (meanstep && nsteps_dark > 0) *meanstep = duration_darks / nsteps_dark;
/* Have to clear the darks smfArray as well */
if (darks) smf_close_related( darks, status );
} else {
/* Store the output groups in the return variable or free it */
if (darkgrp) {
*darkgrp = dgrp;
} else {
grpDelet( &dgrp, status);
}
if (flatgrp) {
*flatgrp = fgrp;
} else {
grpDelet( &fgrp, status);
}
if (meanstep && nsteps_sci > 0) *meanstep = duration_sci / nsteps_sci;
}
msgSeti( "ND", sccount );
msgSeti( "DK", dkcount );
msgSeti( "FF", ffcount );
msgSeti( "TOT", insize );
if ( insize == 1 ) {
if (dkcount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was a dark",
status);
} else if (ffcount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was a fast flatfield",
status);
} else if (sccount == 1) {
msgOutif( MSG__VERB, " ", "Single input file was accepted (observation type same as sequence type)",
status);
} else {
msgOutif( MSG__VERB, " ", "Single input file was not accepted.",
status);
}
} else {
if (dkcount == 1) {
msgSetc( "DKTXT", "was a dark");
} else {
msgSetc( "DKTXT", "were darks");
}
if (ffcount == 1) {
msgSetc( "FFTXT", "was a fast flat");
} else {
msgSetc( "FFTXT", "were fast flats");
}
if (sccount == 1) {
msgSetc( "NDTXT", "was science");
} else {
msgSetc( "NDTXT", "were science");
}
/* This might be a useful message */
msgOutif( MSG__NORM, " ", "Out of ^TOT input files, ^DK ^DKTXT, ^FF ^FFTXT "
"and ^ND ^NDTXT", status );
}
if (meanstep && *meanstep != VAL__BADD) {
msgOutiff( MSG__VERB, "", "Mean step time for input files = %g sec",
status, *meanstep );
}
/* Store the heater efficiency map */
if (*status != SAI__OK) heatermap = smf_free_effmap( heatermap, status );
if (heateffmap) *heateffmap = heatermap;
/* Now report the details of the observation */
smf_obsmap_report( MSG__NORM, obsmap, objmap, status );
obsmap = astAnnul( obsmap );
objmap = astAnnul( objmap );
scimap = astAnnul( scimap );
msgOutiff( SMF__TIMER_MSG, "",
"Took %.3f s to find science observations",
status, smf_timerupdate( &tv1, &tv2, status ) );
return;
}
/* Main entry */
void smurf_fixsteps( int *status ) {
/* Local Variables */
AstKeyMap *keymap; /* Default config parameter values */
AstKeyMap *sub_instruments; /* Info about sub-instruments */
FILE *fd = NULL; /* File descriptor */
Grp *igrp = NULL; /* Input group of files */
Grp *ogrp = NULL; /* Output group of files */
dim_t dcfitbox; /* DCFITBOX config parameter */
dim_t dcsmooth; /* DCSMOOTH config parameter */
dim_t nx; /* Length of first pixel axis */
double dcthresh; /* DCTHRESH config parameter */
double sizetol; /* Tolerance allowed on step height */
int changed; /* Have any step fixes changed? */
int dclimcorr; /* DCLIMCORR config parameter */
int dcmaxsteps; /* DCMAXSTEPS config parameter */
int first; /* Index of first change to report */
int itemp; /* Intermediate value */
int meanshift; /* Use a mean shift filter? */
int nnew; /* Number of new step fixes */
int nold; /* Number of old step fixes */
size_t nrej; /* Number of rejected bolometers */
size_t outsize; /* Total number of NDF names in the output group */
size_t size; /* Number of files in input group */
smfData *data = NULL; /* Output smfData */
smfData *indata = NULL; /* Input smfData */
smfStepFix *newsteps = NULL; /* New step fix descriptions */
smfStepFix *oldsteps = NULL; /* Old step fix descriptions */
ThrWorkForce *wf = NULL; /* Pointer to a pool of worker threads */
/* Check inherited status */
if (*status != SAI__OK) return;
/* begin an NDF context. */
ndfBegin();
/* Get the name of the input NDF. */
kpg1Rgndf( "IN", 1, 1, "", &igrp, &size, status );
/* Get output file(s) */
kpg1Wgndf( "OUT", igrp, size, 0, "More output files required...",
&ogrp, &outsize, status );
/* Open the input data file, read-only. */
smf_open_file( igrp, 1, "Read", 0, &indata, status );
/* Since we will be modifying the data values, we need a deep copy. */
data = smf_deepcopy_smfData( indata, 0, 0, 0, 0, status );
/* Place cleaning parameters into a keymap and set defaults. Note that we
use the map-maker defaults file here so that we populate the locked
keymap with all the parameters that people may come across to allow
them to load their map-maker config directly this application. */
sub_instruments = smf_subinst_keymap( SMF__SUBINST_NONE, data, NULL, 0,
status );
keymap = kpg1Config( "CONFIG", "$SMURF_DIR/smurf_makemap.def",
sub_instruments, status );
sub_instruments = astAnnul( sub_instruments );
/* Set the default for each of the step fixing config parameters. */
astMapGet0I( keymap, "DCSMOOTH", &itemp );
parDef0i( "DCSMOOTH", itemp, status );
astMapGet0I( keymap, "DCFITBOX", &itemp );
parDef0i( "DCFITBOX", itemp, status );
astMapGet0I( keymap, "DCMAXSTEPS", &itemp );
parDef0i( "DCMAXSTEPS", itemp, status );
astMapGet0I( keymap, "DCLIMCORR", &itemp );
parDef0i( "DCLIMCORR", itemp, status );
astMapGet0D( keymap, "DCTHRESH", &dcthresh );
parDef0d( "DCTHRESH", dcthresh, status );
/* Get values for the config params */
parGet0i( "DCSMOOTH", &itemp, status );
dcsmooth = itemp;
parGet0i( "DCFITBOX", &itemp, status );
dcfitbox = itemp;
parGet0i( "DCMAXSTEPS", &itemp, status );
dcmaxsteps = itemp;
parGet0i( "DCLIMCORR", &itemp, status );
dclimcorr = itemp;
parGet0d( "DCTHRESH", &dcthresh, status );
parGet0l( "MEANSHIFT", &meanshift, status );
/* Find the number of cores/processors available and create a pool of
threads of the same size. */
wf = thrGetWorkforce( thrGetNThread( SMF__THREADS, status ), status );
/* Fix the steps. */
smf_fix_steps( wf, data, dcthresh, dcsmooth, dcfitbox, dcmaxsteps,
dclimcorr, meanshift, &nrej, &newsteps, &nnew, status );
/* Display a summary of what was done by the step fixer. */
msgBlank( status );
if( nrej == 0 ) {
msgOut( "", "No bolometers were rejected", status );
} else if( nrej == 1 ) {
msgOut( "", "One bolometer was rejected", status );
} else {
msgSeti( "NREJ", nrej );
msgOut( "", "^NREJ bolometers were rejected", status );
}
parPut0i( "NREJECTED", nrej, status );
if( nnew == 0 ) {
msgOut( "", "No steps were fixed", status );
} else if( nnew == 1 ) {
msgOut( "", "One step was fixed", status );
} else {
msgSeti( "NNEW", nnew );
msgOut( "", "^NNEW steps were fixed", status );
}
parPut0i( "NFIXED", nnew, status );
/* If required, write out to a text file details of the steps that were
fixed. */
fd = smf_open_textfile( "NEWSTEPS", "w", "<none>", status );
if( fd ) {
smf1_write_steps( fd, indata, nnew, newsteps, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr, nrej, status );
fclose( fd );
}
/* If required, create the output NDF. */
if( outsize > 0 && indata && indata->file ) {
smf_write_smfData( data, NULL, NULL, ogrp, 1,
indata->file->ndfid, MSG__VERB, 0, status );
}
/* Save the length of the first pixel axis. */
nx = data ? data->dims[ 0 ] : 0;
/* Close the NDFs. */
smf_close_file( &data, status );
smf_close_file( &indata, status );
/* Attempt to open a file containing descriptions of steps fixed by a
previous invocation of this program. */
fd = smf_open_textfile( "OLDSTEPS", "r", "<none>", status );
if( fd ) {
/* Get SIZETOL - the minimum significant fractional error in step sizes. */
parGet0d( "SIZETOL", &sizetol, status );
/* Read the contents of the file, issuing a warning if the global
properties read from the file (e.g. parameters used, no. of steps
found, etc) differ from those of the current invocation. */
msgBlank( status );
oldsteps = smf1_read_steps( fd, dcthresh, dcsmooth,
dcfitbox, dcmaxsteps, dclimcorr,
nrej, nnew, &nold, status );
/* Get the index of the first change to report. */
parGet0i( "FIRST", &first, status );
/* Compare the new step fixes with the old step fixes, issuing a warning
for the first step fix that has changed. */
changed = smf1_check_steps( "CONTINUE", first, nx, sizetol,
nold, nnew, oldsteps, newsteps, status );
/* Store a flag indicating if any sstep fixes have chnaged. */
parPut0l( "CHANGED", changed, status );
/* Tell the user if nothing has changed. */
if( ! changed ) {
msgOut( "", "There are no significant differences "
"between old and new step fixes.", status );
}
msgBlank( status );
/* Close the old steps file, and free the memory holding the old step
descriptions. */
fclose( fd );
oldsteps = astFree( oldsteps );
}
/* Free resources. */
newsteps = astFree( newsteps );
grpDelet( &igrp, status );
grpDelet( &ogrp, status );
/* End the NDF context. */
ndfEnd( status );
/* If anything went wrong issue a context message. */
if( *status != SAI__OK ) msgOutif( MSG__VERB, " ", "FIXSTEPS failed.",
status );
}
void smf_mapbounds_approx( Grp *igrp, size_t index, char *system,
int *lbnd_out, int *ubnd_out, AstFrameSet **outframeset,
int *moving, int *status ) {
/* Local variables */
smfData *data = NULL; /* pointer to SCUBA2 data struct */
int dxpix; /* Map X offset in pixels */
int dypix; /* Map Y offset in pixels */
smfFile *file = NULL; /* SCUBA2 data file information */
AstFitsChan *fitschan = NULL;/* Fits channels to construct WCS header */
AstFrameSet *fs = NULL; /* A general purpose FrameSet pointer */
smfHead *hdr = NULL; /* Pointer to data header this time slice */
double hghtbox; /* Map height in arcsec */
int hghtpix; /* RA-Dec map height in pixels */
int i; /* loop counter */
dim_t k; /* Loop counter */
double maphght = 0.0; /* Map height in radians */
double mappa = 0.0; /* Map position angle in radians */
double mapwdth = 0.0; /* Map width in radians */
double mapx; /* Map X offset in radians */
double mapy; /* Map Y offset in radians */
double par[7]; /* Projection parameters */
double pixsize = 0.0; /* Requested pixel size */
double shift[ 2 ]; /* Shifts from PIXEL to GRID coords */
AstMapping *sky2map = NULL; /* Mapping celestial->map coordinates */
AstSkyFrame *skyframe = NULL;/* Output SkyFrame */
AstFrame *skyin = NULL; /* Sky Frame in input FrameSet */
double skyref[ 2 ]; /* Values for output SkyFrame SkyRef attribute */
AstFrameSet *swcsin = NULL; /* FrameSet describing input WCS */
int temp; /* Temporary variable */
double wdthbox; /* Map width in arcsec */
int wdthpix; /* RA-Dec map width in pixels */
double x_array_corners[4]; /* X-Indices for corner bolos in array */
double y_array_corners[4]; /* Y-Indices for corner pixels in array */
/* Main routine */
if (*status != SAI__OK) return;
/* Begin an AST context to ensure that all AST objects are annuled
before returning to caller */
astBegin;
/* Initialize output frameset pointer to NULL */
*outframeset = NULL;
for( i = 0; i < 7; i++ ) par[ i ] = AST__BAD;
/* Read data from the given input file in the group - note index
should be 1 as we use the first file in the Grp to define the map
bounds */
smf_open_file( igrp, index, "READ", SMF__NOCREATE_DATA, &data, status );
/* Simply abort if it is not a scan */
if (*status == SAI__OK && data->hdr->obsmode != SMF__OBS_SCAN) {
*status = SAI__ERROR;
errRep(" ", "Can not call smf_mapbounds_approx with non-scan observation"
" (possible programming error)", status);
goto CLEANUP;
}
/* Retrieve file name for use feedback */
file = data->file;
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
if( *status == SAI__OK ) {
msgOutif(MSG__VERB, " ",
"SMF_MAPBOUNDS_APPROX: Processing ^FILE",
status);
} else {
errRep( "smf_mapbounds_approx", "Couldn't open input file, ^FILE", status );
}
/* Check that the data dimensions are 3 (for time ordered data) */
if( *status == SAI__OK ) {
if( data->ndims != 3 ) {
smf_smfFile_msg( file, "FILE", 1, "<unknown>" );
msgSeti("THEDIMS", data->ndims);
*status = SAI__ERROR;
errRep("smf_mapbounds_approx",
"^FILE data has ^THEDIMS dimensions, should be 3.",
status);
}
}
/* Construct the WCS for the first time slice in this file */
smf_tslice_ast( data, 1, 1, NO_FTS, status);
/* Retrieve header for later constructing output WCS */
if( *status == SAI__OK) {
hdr = data->hdr;
swcsin = hdr->wcs;
/* Calculate default pixel size */
pixsize = smf_calc_telres( hdr->fitshdr, status );
/* Get the user defined pixel size - we trust that smf_get_projpar will
also read PIXSIZE and get the same answer. We pre-fill par[] to allow
PIXSIZE=! to accept the dynamic default in both places.*/
parGdr0d( "PIXSIZE", pixsize, 0, 60, 1, &pixsize, status );
par[4] = pixsize*AST__DD2R/3600.0;
par[5] = par[4];
/* Retrieve input SkyFrame */
skyin = astGetFrame( swcsin, AST__CURRENT );
/* Retrieve map height and width from header - will be undef for
non-scan so set up defaults first. */
mapwdth = 0.0;
maphght = 0.0;
smf_getfitsd( hdr, "MAP_WDTH", &mapwdth, status );
smf_getfitsd( hdr, "MAP_HGHT", &maphght, status );
/* Make an approximation if map height and width are not set -
note that this should ONLY apply for non-scan mode data */
if ( !mapwdth || !maphght ) {
if (*status == SAI__OK) {
*status = SAI__ERROR;
errRep(" ", "MAP_WDTH and MAP_HGHT must be > 0", status);
goto CLEANUP;
}
}
mapx = 0.0; /* Used if the FITS keyword values are undefed */
mapy = 0.0;
smf_getfitsd( hdr, "MAP_X", &mapx, status );
smf_getfitsd( hdr, "MAP_Y", &mapy, status );
/* Convert map Position Angle to radians */
mappa = 0.0;
smf_fits_getD( hdr, "MAP_PA", &mappa, status );
mappa *= AST__DD2R;
/* Calculate size of output map in pixels */
/* Note: this works for the simulator... */
wdthbox = mapwdth*fabs(cos(mappa)) + maphght*fabs(sin(mappa));
hghtbox = maphght*fabs(cos(mappa)) + mapwdth*fabs(sin(mappa));
wdthpix = (int) ( wdthbox / pixsize);
hghtpix = (int) ( wdthbox / pixsize);
dxpix = (int) (mapx / pixsize);
dypix = (int) (mapy / pixsize);
/* Get the offsets for each corner of the array */
temp = (wdthpix - 1) / 2;
x_array_corners[0] = dxpix - temp;
x_array_corners[1] = dxpix - temp;
x_array_corners[2] = dxpix + temp;
x_array_corners[3] = dxpix + temp;
temp = (hghtpix - 1) / 2;
y_array_corners[0] = dypix - temp;
y_array_corners[1] = dypix + temp;
y_array_corners[2] = dypix - temp;
y_array_corners[3] = dypix + temp;
lbnd_out[0] = x_array_corners[0];
ubnd_out[0] = x_array_corners[0];
lbnd_out[1] = y_array_corners[0];
ubnd_out[1] = y_array_corners[0];
/* Update min/max */
for( k=0; k<4; k++ ) {
if( x_array_corners[k] < lbnd_out[0] ) lbnd_out[0] = x_array_corners[k];
if( y_array_corners[k] < lbnd_out[1] ) lbnd_out[1] = y_array_corners[k];
if( x_array_corners[k] > ubnd_out[0] ) ubnd_out[0] = x_array_corners[k];
if( y_array_corners[k] > ubnd_out[1] ) ubnd_out[1] = y_array_corners[k];
}
} else {
goto CLEANUP;
}
/* Now create the output FrameSet. */
smf_calc_skyframe( skyin, system, hdr, 0, &skyframe, skyref, moving,
status );
/* Get the orientation of the map vertical within the output celestial
coordinate system. This is derived form the MAP_PA FITS header, which
gives the orientation of the map vertical within the tracking system. */
mappa = smf_calc_mappa( hdr, system, skyin, status );
/* Calculate the projection parameters. We do not enable autogrid determination
for SCUBA-2 so we do not need to obtain all the data before calculating
projection parameters. */
smf_get_projpar( skyframe, skyref, *moving, 0, 0, NULL, 0,
mappa, par, NULL, NULL, status );
/* Now populate a FitsChan with FITS-WCS headers describing the
required tan plane projection. The longitude and latitude axis
types are set to either (RA,Dec) or (AZ,EL) to get the correct
handedness. */
fitschan = astFitsChan ( NULL, NULL, " " );
smf_makefitschan( astGetC( skyframe, "System"), &(par[0]),
&(par[2]), &(par[4]), par[6], fitschan, status );
astClear( fitschan, "Card" );
fs = astRead( fitschan );
/* Extract the output PIXEL->SKY Mapping - note this is will be
inverted later to create the sk2map mapping */
sky2map = astGetMapping( fs, AST__BASE, AST__CURRENT );
/* Create the output FrameSet */
*outframeset = astFrameSet( astFrame(2, "Domain=GRID"), " " );
/* Now add the SkyFrame to it */
astAddFrame( *outframeset, AST__BASE, sky2map, skyframe );
/* Apply a ShiftMap to the output FrameSet to re-align the GRID
coordinates */
shift[0] = -lbnd_out[0];
shift[1] = -lbnd_out[1];
astRemapFrame( *outframeset, AST__BASE, astShiftMap( 2, shift, " " ) );
astExport( *outframeset );
/* Report the pixel bounds of the cube. */
if( *status == SAI__OK ) {
msgOutif( MSG__NORM, " ", " ", status );
msgSeti( "XL", lbnd_out[ 0 ] );
msgSeti( "YL", lbnd_out[ 1 ] );
msgSeti( "XU", ubnd_out[ 0 ] );
msgSeti( "YU", ubnd_out[ 1 ] );
msgOutif( MSG__NORM, " ", " Output map pixel bounds: ( ^XL:^XU, ^YL:^YU )",
status );
}
/* Change the pixel bounds to be consistent with the new CRPIX */
ubnd_out[0] -= lbnd_out[0]-1;
lbnd_out[0] = 1;
ubnd_out[1] -= lbnd_out[1]-1;
lbnd_out[1] = 1;
/* Clean Up */
CLEANUP:
if (*status != SAI__OK) {
errRep(FUNC_NAME, "Unable to determine map bounds", status);
}
if( data != NULL )
smf_close_file( &data, status);
astEnd;
}
void smf_write_bolomap( ThrWorkForce *wf, smfArray *res, smfArray *lut,
smfArray *qua, smfDIMMData *dat, dim_t msize,
const Grp *bolrootgrp, int varmapmethod,
const int *lbnd_out, const int *ubnd_out,
AstFrameSet *outfset, int *status ) {
int addtomap=0; /* Set if adding to existing map */
size_t bstride; /* Bolometer stride */
double *curmap=NULL; /* Pointer to current map being rebinned */
double *curvar=NULL; /* Pointer to variance associate with curmap */
dim_t dsize; /* Size of data arrays in containers */
size_t idx=0; /* index within subgroup */
size_t k; /* loop counter */
int *lut_data=NULL; /* Pointer to DATA component of lut */
char name[GRP__SZNAM+1]; /* Buffer for storing names */
dim_t nbolo; /* Number of bolometers */
size_t nbolomaps = 0; /* Number of bolomaps written */
char *pname=NULL; /* Poiner to name */
smf_qual_t *qua_data=NULL; /* Pointer to DATA component of qua */
double *res_data=NULL; /* Pointer to DATA component of res */
if( *status != SAI__OK ) return;
if( !res || !lut || !qua || !dat || !bolrootgrp ||
!lbnd_out || !ubnd_out || !outfset ) {
*status = SAI__ERROR;
errRep( "", FUNC_NAME ": NULL inputs supplied", status );
return;
}
/* Loop over subgroup index (subarray) */
for( idx=0; idx<res->ndat; idx++ ) {
smf_qual_t *bolomask = NULL;
double *bmapweight = NULL;
double *bmapweightsq = NULL;
int *bhitsmap = NULL;
/* Pointers to everything we need */
res_data = res->sdata[idx]->pntr[0];
lut_data = lut->sdata[idx]->pntr[0];
qua_data = qua->sdata[idx]->pntr[0];
smf_get_dims( res->sdata[idx], NULL, NULL, &nbolo, NULL,
&dsize, &bstride, NULL, status );
/* Make a copy of the quality at first time slice as a good
bolo mask, and then set quality to SMF__Q_BADB. Later we
will unset BADB for one bolo at a time to make individual
maps. */
bolomask = astMalloc( nbolo*sizeof(*bolomask) );
bmapweight = astMalloc( msize*sizeof(*bmapweight) );
bmapweightsq = astMalloc( msize*sizeof(*bmapweightsq) );
bhitsmap = astMalloc( msize*sizeof(*bhitsmap) );
if( *status == SAI__OK ) {
for( k=0; k<nbolo; k++ ) {
bolomask[k] = qua_data[k*bstride];
qua_data[k*bstride] = SMF__Q_BADB;
}
/* Identify good bolos in the copied mask and produce a map */
for( k=0; (k<nbolo)&&(*status==SAI__OK); k++ ) {
if( !(bolomask[k]&SMF__Q_BADB) ) {
Grp *mgrp=NULL; /* Temporary group to hold map names */
smfData *mapdata=NULL;/* smfData for new map */
char tmpname[GRP__SZNAM+1]; /* temp name buffer */
char thisbol[20]; /* name particular to this bolometer */
size_t col, row;
char subarray[10];
nbolomaps++;
/* Set the quality back to good for this single bolometer */
qua_data[k*bstride] = bolomask[k];
/* Create a name for the new map, take into account the
chunk number and subarray. Only required if we are using a single
output container. */
pname = tmpname;
grpGet( bolrootgrp, 1, 1, &pname, sizeof(tmpname), status );
one_strlcpy( name, tmpname, sizeof(name), status );
one_strlcat( name, ".", sizeof(name), status );
/* Subarray, column and row. HDS does not care about case but we
convert to upper case anyhow. */
smf_find_subarray( res->sdata[idx]->hdr, subarray, sizeof(subarray),
NULL, status );
if (*status == SAI__OK) {
size_t len = strlen(subarray);
size_t n = 0;
for (n=0; n<len; n++) {
subarray[n] = toupper(subarray[n]);
}
}
col = (k % res->sdata[idx]->dims[1])+1;
row = (k / res->sdata[idx]->dims[1])+1;
sprintf( thisbol, "%3sC%02zuR%02zu",
subarray,
col, /* x-coord */
row ); /* y-coord */
one_strlcat( name, thisbol, sizeof(name), status );
mgrp = grpNew( "bolomap", status );
grpPut1( mgrp, name, 0, status );
msgOutf( "", "*** Writing single bolo map %s", status,
name );
/* Try to open an existing extention first. Create a new map
array, and then later we'll add it to the existing
one. If it isn't there, create it. */
smf_open_file( mgrp, 1, "UPDATE", 0, &mapdata, status );
if( *status == SAI__OK ) {
/* Allocate memory for the new rebinned data */
curmap = astCalloc( msize, sizeof(*curmap) );
curvar = astCalloc( msize, sizeof(*curvar) );
addtomap = 1;
} else if( *status == DAT__NAMIN ) {
/* Create a new extension */
errAnnul( status );
smf_open_newfile ( mgrp, 1, SMF__DOUBLE, 2, lbnd_out,
ubnd_out, SMF__MAP_VAR, &mapdata, status);
/* Rebin directly into the newly mapped space */
if( *status == SAI__OK ) {
curmap = mapdata->pntr[0];
curvar = mapdata->pntr[1];
addtomap = 0;
}
}
/* Rebin the data for this single bolometer. Don't care
about variance weighting because all samples from
same detector are about the same. */
smf_rebinmap1( wf, res->sdata[idx],
dat->noi ? dat->noi[0]->sdata[idx] : NULL,
lut_data, 0, 0, 0, NULL, 0,
SMF__Q_GOOD, varmapmethod,
AST__REBININIT | AST__REBINEND,
curmap, bmapweight, bmapweightsq, bhitsmap,
curvar, msize, NULL, status );
/* If required, add this new map to the existing one */
if( addtomap ) {
size_t i;
double *oldmap=NULL;
double *oldvar=NULL;
double weight;
if( *status == SAI__OK ) {
oldmap = mapdata->pntr[0];
oldvar = mapdata->pntr[1];
for( i=0; i<msize; i++ ) {
if( oldmap[i]==VAL__BADD ) {
/* No data in this pixel in the old map, just copy */
oldmap[i] = curmap[i];
oldvar[i] = curvar[i];
} else if( curmap[i]!=VAL__BADD &&
oldvar[i]!=VAL__BADD && oldvar[i]!=0 &&
curvar[i]!=VAL__BADD && curvar[i]!=0 ) {
/* Both old and new values available */
weight = 1/oldvar[i] + 1/curvar[i];
oldmap[i] = (oldmap[i]/oldvar[i] + curmap[i]/curvar[i]) /
weight;
oldvar[i] = 1/weight;
}
}
}
/* Free up temporary arrays */
curmap = astFree( curmap );
curvar = astFree( curvar );
}
/* Write out COLNUM and ROWNUM to FITS header */
if( *status == SAI__OK ) {
AstFitsChan *fitschan=NULL;
fitschan = astFitsChan ( NULL, NULL, " " );
atlPtfti( fitschan, "COLNUM", col, "bolometer column", status);
atlPtfti( fitschan, "ROWNUM", row, "bolometer row", status );
atlPtfts( fitschan, "SUBARRAY", subarray, "Subarray identifier",
status );
kpgPtfts( mapdata->file->ndfid, fitschan, status );
if( fitschan ) fitschan = astAnnul( fitschan );
/* Set the bolo to bad quality again */
qua_data[k*bstride] = SMF__Q_BADB;
/* Write WCS */
smf_set_moving(outfset,NULL,status);
ndfPtwcs( outfset, mapdata->file->ndfid, status );
}
/* Clean up */
if( mgrp ) grpDelet( &mgrp, status );
if( mapdata ) smf_close_file( &mapdata, status );
}
}
/* Set quality back to its original state */
for( k=0; k<nbolo; k++ ) {
qua_data[k*bstride] = bolomask[k];
}
}
/* Free up memory */
bolomask = astFree( bolomask );
bmapweight = astFree( bmapweight );
bmapweightsq = astFree( bmapweightsq );
bhitsmap = astFree( bhitsmap );
}
msgOutf( "", "*** Wrote %zu bolo maps", status, nbolomaps );
}
int *smf_jsatiles_data( Grp *igrp, size_t size, int *ntile, int *status ){
/* Local Variables */
AstFrame *frm = NULL;
AstFrameSet *fs;
JCMTState *state;
const char *trsys;
const char *trsys_last;
dim_t *hits = NULL;
dim_t *ph;
dim_t iframe;
double *gx = NULL;
double *gy = NULL;
double *p1;
double *p2;
double *px;
double *py;
double *trac1 = NULL;
double *trac2 = NULL;
double fov;
double point1[ 2 ];
double point2[ 2 ];
double search;
int *tiles = NULL;
int dim[ 2 ];
int i;
int ix;
int iy;
int lbnd[ 2 ];
int ubnd[ 2 ];
size_t ifile;
smfData *data = NULL;
smfHead *hdr = NULL;
smfJSATiling skytiling;
smf_inst_t inst = SMF__INST_NONE;
smf_inst_t instrument;
smf_subinst_t subinst;
/* Initialise */
*ntile = 0;
/* Check inherited status */
if( *status != SAI__OK ) return tiles;
/* Start an AST context so that all AST objects created in this function
are annulled automatically. */
astBegin;
/* Loop round all the input NDFs. */
trsys_last = "";
for( ifile = 1; ifile <= size && *status == SAI__OK; ifile++ ) {
/* Obtain information about the current input NDF. */
smf_open_file( igrp, ifile, "READ", SMF__NOCREATE_DATA, &data,
status );
/* Get a pointer to the header. */
hdr = data->hdr;
/* Get the instrument. */
if( hdr->instrument == INST__SCUBA2 ) {
subinst = smf_calc_subinst( hdr, status );
if( subinst == SMF__SUBINST_850 ) {
inst = SMF__INST_SCUBA_2_850;
} else {
inst = SMF__INST_SCUBA_2_450;
}
} else if( hdr->instrument == INST__ACSIS ) {
inst = SMF__INST_HARP;
} else if( *status == SAI__OK ) {
*status = SAI__ERROR;
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
errRep( "", "No tiles are yet defined for the instrument that "
"created ^FILE.", status );
}
/* If this is the first file, it defines the instrument in use. */
if( ifile == 1 ) {
instrument = inst;
/* Get the parameters that define the layout of sky tiles for the
instrument. */
smf_jsatiling( instrument, &skytiling, status );
/* Create a FrameSet describing the whole sky in which each pixel
corresponds to a single tile. The current Frame is ICRS (RA,Dec) and
the base Frame is grid coords in which each grid pixel corresponds to
a single tile. */
smf_jsatile( 0, &skytiling, 0, NULL, &fs, NULL, lbnd, ubnd, status );
/* Allocate an image with one pixel for each tile, and fill it with
zeros. */
dim[ 0 ] = ubnd[ 0 ] - lbnd[ 0 ] + 1;
dim[ 1 ] = ubnd[ 1 ] - lbnd[ 1 ] + 1;
hits = astCalloc( dim[0]*dim[1], sizeof( *hits ) );
/* Get the radius of the field of view in radians. */
fov = 0.5*(skytiling.fov*AST__DD2R)/3600.0;
/* If this is not the first file, report an error if the instrument has
changed... */
} else if( instrument != inst && *status == SAI__OK ) {
smf_smfFile_msg( data->file, "FILE", 1, "<unknown>" );
errRep( "", "The file ^FILE was created by a different instrument "
"to the previous files.", status );
}
/* Re-map the current Frame of the hits map WCS FrameSet to be the tracking
system used by the current file (if it has changed). */
trsys = sc2ast_convert_system( (hdr->allState)[0].tcs_tr_sys,
status );
if( *status == SAI__OK && strcmp( trsys, trsys_last ) ) {
astSetC( fs, "System", trsys );
trsys_last = trsys;
frm = astGetFrame( fs, AST__CURRENT );
}
/* Get the radius of the search circle. */
search = fov + sqrt( hdr->instap[ 0 ]*hdr->instap[ 0 ] +
hdr->instap[ 1 ]*hdr->instap[ 1 ] );
/* Ensure our work arrays are big enough to hold the current file. */
trac1 = astGrow( trac1, 4*hdr->nframes, sizeof( *trac1 ) );
trac2 = astGrow( trac2, 4*hdr->nframes, sizeof( *trac2 ) );
gx = astGrow( gx, 4*hdr->nframes, sizeof( *gx ) );
gy = astGrow( gy, 4*hdr->nframes, sizeof( *gy ) );
/* Check pointers can be used safely. */
if( *status == SAI__OK ) {
/* Loop round all time slices, getting the tracking coords at the corners
of a box that enclose the field of view. */
p1 = trac1;
p2 = trac2;
state = hdr->allState;
for( iframe = 0; iframe < hdr->nframes; iframe++,state++ ) {
point1[ 0 ] = state->tcs_tr_ac1;
point1[ 1 ] = state->tcs_tr_ac2;
for( i = 0; i < 4; i++ ) {
astOffset2( frm, point1, i*AST__DPIBY2, search, point2 );
*(p1++) = point2[ 0 ];
*(p2++) = point2[ 1 ];
}
}
/* Convert them to grid coords in the hits map. */
astTran2( fs, 4*hdr->nframes, trac1, trac2, 0, gx, gy );
/* Loop round them all again. Update the hits map to indicate how many
points fall in each tile. */
px = gx;
py = gy;
for( iframe = 0; iframe < 4*hdr->nframes; iframe++,px++,py++ ) {
ix = (int)( *px + 0.5 ) - 1;
iy = (int)( *py + 0.5 ) - 1;
hits[ ix + iy*dim[ 0 ] ]++;
}
}
/* Close the current input data file. */
smf_close_file( &data, status);
data = NULL;
}
/* Form a list of all the tiles that receive any data. */
ph = hits;
for( iy = 0; iy < dim[ 1 ]; iy++ ) {
for( ix = 0; ix < dim[ 0 ]; ix++,ph++ ) {
if( *ph > 0 ) {
tiles = astGrow( tiles, ++(*ntile), sizeof( *tiles ) );
if( *status == SAI__OK ) {
tiles[ *ntile - 1 ] = smf_jsatilexy2i( ix, iy, &skytiling,
status );
}
}
}
}
/* Free resources. */
hits = astFree( hits );
trac1 = astFree( trac1 );
trac2 = astFree( trac2 );
gx = astFree( gx );
gy = astFree( gy );
if( *status != SAI__OK ) {
tiles = astFree( tiles );
*ntile = 0;
}
astEnd;
return tiles;
}
void smf_labelunit( Grp *igrp, int size, smfData *odata, int *status ){
/* Local Variables */
char label1[ SMF__CHARLABEL ];/* Label from first NDF */
char unit1[ SMF__CHARLABEL ]; /* Unit from first NDF */
int ifile; /* Index of current input file */
smfData *data = NULL; /* Pointer to data struct for current input file */
/* Check inherited status */
if( *status != SAI__OK ) return;
/* Loop round all the input NDFs. */
for( ifile = 1; ifile <= size && *status == SAI__OK; ifile++ ) {
char * unit = NULL;
char * label = NULL;
/* Obtain information about the current input NDF. */
smf_open_file( NULL, igrp, ifile, "READ", 0, &data, status );
if (*status == SAI__OK) {
unit = data->hdr->units;
label = data->hdr->dlabel;
/* If this is the first input NDF, copy the Label and Unit string to the
output NDF, and save them for later use. */
if( ifile == 1 ) {
if( strlen( label ) ) {
ndfCput( label, odata->file->ndfid, "Label", status );
}
if( strlen( unit ) ) {
ndfCput( unit, odata->file->ndfid, "Unit", status );
}
one_strlcpy( label1, label, sizeof(label1), status );
one_strlcpy( unit1, unit, sizeof(unit1), status );
/* Otherwise, compare the Label and Unit strings for this input NDF with
those from the first input NDF. If any difference is found issue a
warning. */
} else if( *status == SAI__OK && strcmp( label, label1 ) ) {
msgSeti( "I", ifile );
msgSetc( "L1", label1 );
msgSetc( "L", label );
smf_smfFile_msg( data->file, "N", 1, "<unknown file>" );
msgOutif( MSG__NORM, " ", " WARNING: Input ^I (^N) has Label "
"'^L' but the first input had Label '^L1'.", status );
} else if( *status == SAI__OK && strcmp( unit, unit1 ) ) {
msgSeti( "I", ifile );
msgSetc( "U1", unit1 );
msgSetc( "U", unit );
smf_smfFile_msg( data->file, "N", 1, "<unknown file>" );
msgOutif( MSG__NORM, " ", " WARNING: Input ^I (^N) has Unit "
"'^U' but the first input had Unit '^U1'.", status );
}
}
/* Close the current input data file. */
smf_close_file( NULL, &data, status );
data = NULL;
}
}