int smf_validate_smfData( const smfData * data, int hashdr, int hasfile,
                          int *status ) {

  if (*status != SAI__OK) return 0;

  if ( data == NULL ) {
    *status = SAI__ERROR;
    errRep( FUNC_NAME,
            "Supplied smfData is a NULL pointer. Possible programming error.",
            status);
    return 0;
  }

  if ( hasfile && data->file == NULL ) {
    *status = SAI__ERROR;
    errRep( FUNC_NAME,
            "No file associated with supplied smfData. "
            "Possible programming error.", status );
    return 0;
  }

  if (hashdr) return smf_validate_smfHead( data->hdr, 0, 0, status );

  return 1;

}

void smf_check_flat ( const smfData *data, int *status ) {

  smfDA *da;
  smf_dtype dtype;

  if ( *status != SAI__OK ) return;
  if ( !data ) {
    *status = SAI__ERROR;
    errRep("", "Error checking if data are flatfielded. smfData is null."
           " (possible programming error)", status );
    return;
  }

  /* Retrieve the smfDa struct */
  da = data->da;
  dtype = data->dtype;

  /* Data need flatfielding if da is defined */
  if ( da == NULL || dtype == SMF__DOUBLE) {
    /* No raw data struct => data flatfielded */
    *status = SMF__FLATN;
    errRep(FUNC_NAME, "Data are already flatfielded", status);
  }

}

void fts2_getmirrorpositions(smfData* data, double* positions, int* size, int* status)
{
  if(*status != SAI__OK) { return; }

  char ftsMode[SZFITSTR];
  size_t count      = 0;    /* Size */
  HDSLoc* hdsLoc    = NULL; /* Pointer to HDS location */
  HDSLoc* hdsLocPos = NULL; /* Pointer to mirror positions */

  smf_fits_getS(data->hdr, "FTS_MODE", ftsMode, sizeof(ftsMode), status);
  if(strncmp(ftsMode, "FSCAN", 5) == 0 ) {
    hdsLoc = smf_get_xloc(data, "JCMTSTATE", "EXT", "READ", 0, 0, status);
    datFind(hdsLoc, "FTS_POS", &hdsLocPos, status);
    datSize(hdsLocPos, &count, status);
    datGetVD(hdsLocPos, count, positions, &count, status);
    *size = (int) count;
  } else if(strncmp(ftsMode, "STEPINT", 7) == 0 ) {
    *status = SAI__ERROR;
    errRep(FUNC_NAME, "STEPINT mode is NOT supported!", status);
  } else {
    *status = SAI__ERROR;
    errRep(FUNC_NAME, "Unknown Scan Mode is found!", status);
  }

  if(hdsLoc) { datAnnul(&hdsLoc, status); }
  if(hdsLocPos) { datAnnul(&hdsLocPos, status); }
}

void smf_find_dateobs( const smfHead* hdr, double *dateobs, double *dateend,
                       int *status) {

  /* initialise error condition before checking status */
  if (dateobs) *dateobs = VAL__BADD;
  if (dateend) *dateend = VAL__BADD;

  if (*status != SAI__OK) return;

  if (dateobs == NULL && dateend == NULL) {
    *status = SAI__ERROR;
    errRep(" ", FUNC_NAME " called with both dateobs and dateend NULL"
           " (possible programming error)", status);
    return;
  }

  if (!smf_validate_smfHead(hdr, 0, 0, status)) return;

  if (!hdr->allState && !hdr->fitshdr) {
    *status = SAI__ERROR;
    errRep( " ","Can not find date of observation without FITS header "
            "or JCMTSTATE extension", status );
    return;
  }

  if (dateobs) *dateobs = smf__find_utc( hdr, 1, status );
  if (dateend) *dateend = smf__find_utc( hdr, 0, status );
  return;
}

double smf_map_getpixsize( const smfData *data, int *status ) {

  double at[3]={0,0,0};         /* Grid coords. where we check the scale */
  int naxes;                    /* Number of axes */
  double pixsize=VAL__BADD;     /* The pixel size */
  double pixscl[3];

  if( *status != SAI__OK ) return pixsize;

  if( !data ) {
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME ": NULL smfData supplied", status );
    return pixsize;
  }

  if( !data->hdr || !data->hdr->wcs ) {
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME ": no header, or missing WCS", status );
    return pixsize;
  }

  /* Check number of axes in the frameset. It will usually be 3 because
     we have a frequency axis of length 1 for normal SMURF maps */
  naxes = astGetI( data->hdr->wcs, "naxes" );
  if( (naxes < 2) || (naxes > 3) ) {
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME
            ": Frameset does not appear to corresond to a 2-d map", status );
    return pixsize;
  }

  /* Take the average of the x- and y-pixel spacings in radians at the
     centre of the map, and then convert to arcsec */

  at[0] = -(data->lbnd[0]-1);
  at[1] = -(data->lbnd[1]-1);

  kpgPixsc( data->hdr->wcs, at, pixscl, NULL, NULL, 0, status );
  if( *status == SAI__OK ) {
    pixsize = (pixscl[0] + pixscl[1])/2.;
    pixsize *= DR2AS;

    msgOutiff( MSG__DEBUG, "", FUNC_NAME
               ": determined pixel size from WCS at map coordinates (%g,%g) "
               "to be %g arcsec", status, at[0], at[1], pixsize );
  } else {
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME ": could not determine pixel size from WCS", status );
  }


  return pixsize;
}

size_t smf_dtype_sz( const smf_dtype dtype, int *status ) {

  size_t retval = 0;

  if (*status != SAI__OK) return retval;

  /* now switch on data type */
  switch( dtype ) {
  case SMF__INTEGER:
    retval = sizeof(int);
    break;
  case SMF__FLOAT:
    retval = sizeof(float);
    break;
  case SMF__DOUBLE:
    retval = sizeof(double);
    break;
  case SMF__USHORT:
    retval = sizeof(unsigned short);
    break;
  case SMF__UBYTE:
    retval = sizeof(unsigned char);
    break;
  default:
    retval = 0;
    *status = SMF__BDTYP;
    msgSeti( "TC", dtype );
    errRep(FUNC_NAME, "Unable to determine size of datatype. Data typecode was ^TC", status );
  }

  return retval;
}

void * smf_map_or_malloc (size_t nelem, smf_dtype type, int zero, int indf,
                          const char * comp, int *status ) {

  void *pntr[3];     /* ndfMap pointers */
  int nout = 0;      /* number of elements mapped */

  if (*status != SAI__OK) return NULL;

  /* just malloc if we do not have a file */
  if ( indf == NDF__NOID) {
     if( zero ) {
       return astCalloc( nelem, smf_dtype_sz(type, status) );
     } else {
       return astMalloc( nelem*smf_dtype_sz(type, status) );
     }
  }

  ndfMap( indf, comp, smf_dtype_str(type, status),
          (zero ? "WRITE/ZERO" : "WRITE"), pntr, &nout, status);

  if (nelem != (size_t)nout && *status == SAI__OK) {
    ndfUnmap( indf, comp, status );
    *status = SAI__ERROR;
    msgSetc( "COMP", comp );
    msgSeti( "ORI", nelem );
    msgSeti( "NOUT", nout );
    errRep(" ", "Mapping ^COMP in NDF but size differs from that listed in smfData attributes (^ORI != ^NOUT)", status);
    pntr[0] = NULL;
  }
  return pntr[0];
}

smfDA *
smf_create_smfDA( int * status ) {

  smfDA * da = NULL;   /* File components */

  if (*status != SAI__OK) return NULL;

  da = astMalloc( 1*sizeof(*da) );

  if (*status != SAI__OK) {
    errRep(FUNC_NAME,"Unable to allocate memory for smfDA structure",
	   status );
    return NULL;
  }

  /* Initialise smfDA */
  da->flatcal = NULL;
  da->flatpar = NULL;
  da->dksquid = NULL;
  da->flatmeth = SMF__FLATMETH_NULL;
  da->nflat = 0;
  da->refres = VAL__BADD;
  da->heatval = NULL;
  da->nheat = 0;

  return da;
}

smf_calcmodelptr smf_model_getptr( smf_modeltype type, int *status) {

  /* Local Variables */
  smf_calcmodelptr retval = NULL;

  /* Main routine */
  if (*status != SAI__OK) return NULL;

  switch( type ) {

  case SMF__COM:
    retval = (smf_calcmodelptr) &smf_calcmodel_com;
    break;

  case SMF__EXT:
    retval = (smf_calcmodelptr) &smf_calcmodel_ext;
    break;

  case SMF__NOI:
    retval = (smf_calcmodelptr) &smf_calcmodel_noi;
    break;

  case SMF__DKS:
    retval = (smf_calcmodelptr) &smf_calcmodel_dks;
    break;

  case SMF__GAI:
    retval = (smf_calcmodelptr) &smf_calcmodel_gai;
    break;

  case SMF__FLT:
    retval = (smf_calcmodelptr) &smf_calcmodel_flt;
    break;

  case SMF__PLN:
    retval = (smf_calcmodelptr) &smf_calcmodel_pln;
    break;

  case SMF__SMO:
    retval = (smf_calcmodelptr) &smf_calcmodel_smo;
    break;

  case SMF__TWO:
    retval = (smf_calcmodelptr) &smf_calcmodel_two;
    break;

  case SMF__TMP:
    retval = (smf_calcmodelptr) &smf_calcmodel_tmp;
    break;

  default:
    msgSetc( "NM", smf_model_getname(type, status) );
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME
            ": Invalid smf_modeltype given (^NM), or no function available.",
	   status);
  }

  return retval;
}

void smf_dream_getgrid( const AstKeyMap *keymap, double *gridstep, int *ngrid,
                        int gridminmax[4], int gridpts[DREAM__MXGRID][2],
                        int *status) {

  /* Local variables */
  int k;                     /* Loop counter */
  int tmp;                   /* General purpose temporary variable */
  int xgrid;                 /* X position in reconstruction grid */
  int ygrid;                 /* Y position in reconstruction grid */

  /* Check status */
  if (*status != SAI__OK) return;

  /* Retrieve relevant settings from config file */
  if( !astMapGet0D( keymap, "GRIDSTEP", gridstep ) ) {
    *gridstep = 6.28; /* Define default value */
  }

  /* Get the grid extent, prefill it just in case */
  gridminmax[XMIN] = 0;
  gridminmax[XMAX] = 1;
  gridminmax[YMIN] = 0;
  gridminmax[YMAX] = 1;
  if( !astMapGet1I( keymap, "GRIDMINMAX", 4, &tmp, gridminmax ) ) {
    *status = SAI__ERROR;
    errRep(FUNC_NAME, "GRIDXMIN unspecified", status);
  }

  if ( *status == SAI__OK ) {
    /* Check gridxmax > gridxmin etc: swap them round by default? */
    if ( gridminmax[XMIN] > gridminmax[XMAX] ) {
      msgOutif(MSG__VERB," ", "Xmin > Xmax: swapping them round", status );
      tmp = gridminmax[XMIN];
      gridminmax[XMIN] = gridminmax[XMAX];
      gridminmax[XMAX] = tmp;
    }
    if ( gridminmax[YMIN] > gridminmax[YMAX] ) {
      msgOutif(MSG__VERB," ", "Ymin > Ymax: swapping them round", status );
      tmp = gridminmax[YMIN];
      gridminmax[YMIN] = gridminmax[YMAX];
      gridminmax[YMAX] = tmp;
    }

    /* Create gridpts array from min/max extent */
    *ngrid = ((gridminmax[XMAX] - gridminmax[XMIN] + 1) *
	      (gridminmax[YMAX] - gridminmax[YMIN] + 1));
    k = 0;
    for ( ygrid=gridminmax[YMIN]; ygrid<=gridminmax[YMAX]; ygrid++ ) {
      for ( xgrid=gridminmax[XMIN]; xgrid<=gridminmax[XMAX]; xgrid++ ) {
        gridpts[k][0] = xgrid;
        gridpts[k][1] = ygrid;
        k++;
      }
    }

  }

}

void adamtest ( int * status ) {

  if (*status != SAI__OK) return;

  msgOut("MSG1", "This text should not appear for msgOut", status );
  msgSeti("TEST", 5);
  msgOut(" ", "     Testing ^^ %% % $ $$ %ET - $TESTOBJ ^TEST",status);
  msgOut( " ", "  Testing $ %ET Again %%ET ^^$", status );
  msgOut(" ", "$$DOLLAR ^^CARET %%PERCENT at start of string", status);

  /* Make up a bad status */
  *status = MSG__SYNER;
  errRep( " ", "This is the error message ^STATUS embedded",
          status );

  errRep( "MSG1", "This text should not appear", status );

  errRep( " ", "Should be expanded: %ET as 'EXPOSURE_TIME'", status);

  errRep( " ", "Object $TESTOBJ %s %XX should be somewhere", status );

  errRep( " ", "Multiple %ET and ^STATUS and %TESTOBJ and %BLAH", status );

  errRep( " ", "Double up %% escape $$ characters", status );

  msgSetc( "X1", STRING );
  msgSetc( "X2", STRING);
  msgSetc( "X3", STRING);
  msgSetc( "X4", STRING);
  msgSetc( "X5", STRING);
  msgSetc( "X6", STRING);
  errRep( " ","Overflow: ^X1:^X2:^X3:^X4:^X5:^X6", status );

}

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;
}

double smf_raw2current( smfHead *hdr, int *status ) {

  /* Local Variables */
  double raw2current=VAL__BADD; /* Conversion factor */
  double dateobs=VAL__BADD;     /* UTC MJD at observation start */
  double dateconst=VAL__BADD;   /* UTC MJD when constant changes */
  AstTimeFrame *tf = NULL;      /* time frame for date conversion */

  /* Main routine */
  if( *status != SAI__OK ) return VAL__BADD;

  /* Get the MJD for start of the observation */
  smf_find_dateobs( hdr, &dateobs, NULL, status );

  /* Convert ISO dates for when the values changed to MJDs for comparison */
  tf = astTimeFrame( " " );
  astSet( tf, "TimeScale=UTC" );
  astSet( tf, "TimeOrigin=%s", "2011-06-04T00:00:00" );
  dateconst = astGetD( tf, "TimeOrigin" );

  if( (*status==SAI__OK) && (dateobs!=VAL__BADD) && (dateconst!=VAL__BADD) ) {
    if( dateobs < dateconst) {

      /* Prior to 2011-06-04 we use the following value. According to
         Dan 1.52e-13 was the measured factor for mce mode 1
         (unfiltered output) on some old prototype array. The 3.3
         multiplier corrected the conversion for mce mode 2 (filtered
         output). Note that SIMULT is defined in smurf_par.h */

      raw2current = SIMULT * 3.3 * 1.52e-13;
    } else {

      /* Later the MCE low-pass filter was modified to accomodate a
         faster sample rate. With the new firmware on s8a the measured
         factor for mce mode 1 (unfiltered output) is 1.56e-13 and to
         correct for mce mode 2 (filtered output) requires a 1/1.15
         multiplier. */

      raw2current = SIMULT * 1.56e-13 / 1.15;
    }
  }

  if( (*status==SAI__OK) && (raw2current==VAL__BADD) ) {
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME ": was unable to determine conversion factor",
            status );
  }

  msgOutiff( MSG__DEBUG, "", FUNC_NAME ": calculated a value of %lf", status,
             raw2current );

  /* Clean up */
  tf = astAnnul( tf );

  return raw2current;
}

void    error(int num, char *msg1, char *msg2)
{
    int status;

    status = SAI__ERROR;
    msgSetc( "TOK1", msg1 );
    msgSetc( "TOK2", msg2 );
    errRep( " ", "^TOK1 ^TOK2", &status );

    longjmp( env, num );
}

void smf_addmap1( double *map1, double *mapweight1, int *hitsmap1,
                  double *mapvar1, smf_qual_t *mapqual1, double *map2,
                  double *mapweight2, int *hitsmap2, double *mapvar2,
                  smf_qual_t *mapqual2, dim_t msize, int *status ) {

  /* Local Variables */
  dim_t i;                   /* Loop counter */

  /* Main routine */
  if (*status != SAI__OK) return;

  /* Check for NULL inputs */
  if( (map1==NULL) || (mapweight1==NULL) || (hitsmap1==NULL) ||
      (mapvar1==NULL) || (map2==NULL) || (mapweight2==NULL) ||
      (hitsmap2==NULL) || (mapvar2==NULL) ) {
      *status = SAI__ERROR;
      errRep(FUNC_NAME, "Addmap failed due to NULL inputs.", status);
      return;
  }

  /* Loop over every pixel and store the weighted values in arrays associated
     with map1 */

  for( i=0; i<msize; i++ ) {
    if( (map1[i] == VAL__BADD) || (mapvar1[i] == VAL__BADD) ) {
      /* If bad pixel in map1 just copy map2 regardless */
      map1[i] = map2[i];
      mapweight1[i] = mapweight2[i];
      hitsmap1[i] = hitsmap2[i];
      mapvar1[i] = mapvar2[i];
      mapqual1[i] = mapqual2[i];
    } else if( (map2[i] != VAL__BADD) && (mapvar2[i] != VAL__BADD) ) {
      /* Add together if both maps have good pixels */
      if( (mapvar1[i]<=0) || (mapvar2[i]<=0) ) {
	*status = SAI__ERROR;
	errRepf("", FUNC_NAME ": invalid variance(s) <=0 detected (%g and %g)", status,
                mapvar1[i], mapvar2[i]);
	return;
      } else {
        double w = 1./mapvar1[i] + 1./mapvar2[i];

        map1[i] = (map1[i]/mapvar1[i] + map2[i]/mapvar2[i])/w;
        mapweight1[i] += mapweight2[i];
        hitsmap1[i] += hitsmap2[i];
        mapqual1[i] &= mapqual2[i];
	mapvar1[i] = 1. / w;
      }
    }
  }

}

double smf_difftime( struct timeval *tv1, struct timeval *tv2, int *status) {

  if (*status != SAI__OK) return 0;

  if( !tv1 || !tv2 ) {
    *status = SAI__ERROR;
    errRep( "", FUNC_NAME ": NULL pointers to timeval structs supplied.",
            status );
    return 0;
  }

  return (double)(tv2->tv_sec-tv1->tv_sec) +
    (1.0E-6*(double)(tv2->tv_usec-tv1->tv_usec));
}

smfDream *smf_create_smfDream( int * status ) {

  /* Need to make sure that any memory we malloc will be freed on error
     so make sure we NULL all pointers first. */
  smfDream *dream = NULL;      /* smfDream struct to fill */
  size_t i;                    /* Loop counter */

  if (*status != SAI__OK) return NULL;

  /* Create an empty smfDream  */
  dream = astMalloc( 1*sizeof(smfDream) );
  if (*status != SAI__OK) {
    /* Add our own message to the stack */
    errRep(FUNC_NAME, "Unable to allocate memory for smfDream structure",
	   status);
    goto CLEANUP;
  }

  /* Integers */
  dream->nvert = 0;
  dream->ngrid = 0;
  dream->ncycles = 0;
  dream->nsampcycle = 0;
  for ( i = 0; i < DREAM__MXVERT; i++ ) {
    (dream->jigvert)[i][0] = 0;
    (dream->jigvert)[i][1] = 0;
  }
  for ( i = 0; i < DREAM__MXGRID; i++ ) {
    (dream->gridpts)[i][0] = 0;
    (dream->gridpts)[i][1] = 0;
  }

  /* Pointers to the grid weights and inverse matrix */
  dream->gridwts = NULL;
  dream->invmatx = NULL;

  /* Doubles */
  dream->jigscal = 0.0;
  dream->gridstep = 0.0;
  for ( i = 0; i < DREAM__MXSAM; i++ ) {
    (dream->jigpath)[i][0] = 0.0;
    (dream->jigpath)[i][1] = 0.0;
  }

  return dream;

 CLEANUP:
  dream = astFree( dream );
  return NULL;
}

static void smf__calc_flatobskey( smfHead *hdr, char * keystr, size_t keylen,
                                  int *status ) {

  int curheat = 0;
  int detbias = 0;
  char subarray[10];
  double shutter = 0.0;
  size_t nwrite = 0;
  int utdate = 0;

  if (*status != SAI__OK) return;
  if (!hdr) return;

  /* get reference heater value, bias, shutter and subarray string */
  /* PIXHEAT and DETBIAS are not written by the simulator so we default
     those to 0 */
  smf_getfitsi( hdr, "PIXHEAT", &curheat, status );
  if (*status == SMF__NOKWRD) errAnnul(status);

  /* As of September 1st we heater track after doing the flat ramp.
     This means that the heater value will have changed slightly between
     ramp and science. */
  smf_getfitsi( hdr, "UTDATE", &utdate, status );
  if (utdate >= 20110901 &&
      (hdr->obstype == SMF__TYP_SCIENCE || hdr->obstype == SMF__TYP_POINTING)) {
    curheat = 0;
  }

  smf_getfitsi( hdr, "DETBIAS", &detbias, status );
  if (*status == SMF__NOKWRD) errAnnul(status);

  smf_getfitsd( hdr, "SHUTTER", &shutter, status );
  smf_find_subarray( hdr, subarray, sizeof(subarray), NULL,
                     status );
  if (*status != SAI__OK) return;

  nwrite = snprintf(keystr, keylen, "%s_%s_%.1f_%d_%d",
                    hdr->obsidss, subarray, shutter, detbias, curheat );

  if (nwrite >= keylen) {
    /* The string was truncated */
    *status = SMF__STRUN;
    errRep("", "String truncation forming flatfield key (Possible programming error)",
           status );
  }

}

static smf_obstype smf__parse_obstype ( char obs_type[], int *status ) {
  smf_obstype type = SMF__TYP_NULL;

  if (*status != SAI__OK) return type;

  if (strcasecmp( obs_type, "SCIENCE" ) == 0) {
    type = SMF__TYP_SCIENCE;
  } else if (strcasecmp( obs_type, "POINTING" ) == 0) {
    type = SMF__TYP_POINTING;
  } else if (strcasecmp( obs_type, "FOCUS" ) == 0) {
    type = SMF__TYP_FOCUS;
  } else if (strcasecmp( obs_type, "SKYDIP" ) == 0) {
    type = SMF__TYP_SKYDIP;
  } else if (strcasecmp( obs_type, "FLATFIELD" ) == 0) {
    type = SMF__TYP_FLATFIELD;
  } else if (strcasecmp( obs_type, "FASTFLAT" ) == 0) {
    type = SMF__TYP_FASTFLAT;
  } else if (strcasecmp( obs_type, "NOISE" ) == 0) {
    type = SMF__TYP_NOISE;
  } else if (strcasecmp( obs_type, "HEATRAMP" ) == 0) {
    type = SMF__TYP_HEATRAMP;
  } else if (strcasecmp( obs_type, "BIASRAMP" ) == 0) {
    type = SMF__TYP_BIASRAMP;
  } else if (strcasecmp( obs_type, "BIASSAW" ) == 0) {
    type = SMF__TYP_BIASSAW;
  } else if (strcasecmp( obs_type, "NEP" ) == 0) {
    type = SMF__TYP_NEP;
  } else if (strcasecmp( obs_type, "RAMP" ) == 0) {
    type = SMF__TYP_RAMP;
  } else if (strcasecmp( obs_type, "IV_CURVES_M" ) == 0) {
    type = SMF__TYP_IV_CURVES_M;
  } else if (strcasecmp( obs_type, "IV_CURVES_H" ) == 0) {
    type = SMF__TYP_IV_CURVES_H;
  } else if (strcasecmp( obs_type, "OPEN_LOOP_G" ) == 0) {
    type = SMF__TYP_OPEN_LOOP_G;
  } else if (strcasecmp( obs_type, "SETUP" ) == 0) {
    type = SMF__TYP_SETUP;
  } else {
    if (*status == SAI__OK) {
      *status = SAI__ERROR;
      msgSetc( "TYP", obs_type );
      errRep( " ", "Unrecognized observation type '^TYP'", status );
    }
  }
  return type;
}

void gsdac_get0b ( const gsd *gsd,
                   const char *name, char *value, int *status ) {

  /* Local variables */
  char array;                  /* array flag (should always be false) */
  int itemno;                  /* item number of the GSD header */
  char type;                   /* data type of the item (should always be B) */
  char unit[11];               /* unit of the GSD header */

  /* Check inherited status */
  if ( *status != SAI__OK ) return;

  /* Get the item number. */
  CALLGSD( gsdFind ( gsd->fileDsc, gsd->itemDsc, name, &itemno,
		     unit, &type, &array ),
           status,
           msgSetc ( "NAME", name ); errRep ( "gsdac_get0b", "gsdFind : Could not find element ^NAME in file", status ); );