tacift.c

Go to the documentation of this file.

 
/*****************************************************************************/
#include "tpcclibConfig.h"
/*****************************************************************************/
#include "tpcift.h"
#include "tpcisotope.h"
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <string.h>
/*****************************************************************************/
#include "tpctac.h"
/*****************************************************************************/
 
/*****************************************************************************/
int tacGetHeaderStudynr(
  IFT *h,
  char *s,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(s!=NULL) *s='\0';
  if(h==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) printf("%s()\n", __func__);
 
  /* Find the item index */
  int i;
  i=iftFindKey(h, "studynr", 0);
  if(i<0) i=iftFindKey(h, "study_number", 0);
  if(i<0) i=iftFindKey(h, "study number", 0);
  if(i<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
    return TPCERROR_NO_KEY;
  }
  /* Check that item has content */
  size_t len;
  if(h->item[i].value==NULL) len=0;
  else len=strlen(h->item[i].value);
  if(len<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_VALUE);
    return TPCERROR_NO_VALUE;
  }
  if(len>MAX_STUDYNR_LEN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  /* All fine, then copy studynr */
  if(s!=NULL) strlcpy(s, h->item[i].value, MAX_STUDYNR_LEN);
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderStudynr(
  IFT *h,
  const char *s
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous studynr(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "studynr", start);
    if(i<0) i=iftFindKey(h, "study_number", start);
    if(i<0) i=iftFindKey(h, "study number", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* If new studynr is empty, then just return */
  if(s==NULL || *s=='\0') return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return (iftPut(h, "studynr", s, (char)1, NULL));
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderUnit(
  IFT *h,
  int u
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous unit(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "unit", start);
    if(i<0) i=iftFindKey(h, "calibration_unit", start);
    if(i<0) i=iftFindKey(h, "activity_units", start);
    if(i<0) i=iftFindKey(h, "activity units", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* If new unit is unknown, then just return */
  if(u<=UNIT_UNKNOWN || u>=UNIT_LAST) return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return (iftPut(h, "unit", unitName(u), (char)1, NULL));
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacGetHeaderUnit(
  TAC *tac,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>0) printf("%s()\n", __func__);
  tac->cunit=UNIT_UNKNOWN;
 
  /* Find the item index */
  int i;
  i=iftFindKey(&tac->h, "unit", 0);
  if(i<0) i=iftFindKey(&tac->h, "calibration_unit", 0);
  if(i<0) i=iftFindKey(&tac->h, "activity_units", 0);
  if(i<0) i=iftFindKey(&tac->h, "activity units", 0);
  if(i<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
    return TPCERROR_NO_KEY;
  }
  /* Check that item has content */
  size_t len;
  if(tac->h.item[i].value==NULL) len=0;
  else len=strlen(tac->h.item[i].value);
  if(len<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_VALUE);
    return TPCERROR_NO_VALUE;
  }
  
  /* Identify unit string */
  tac->cunit=unitIdentify(tac->h.item[i].value);
 
  /* Delete unit strings from header */
  tacSetHeaderUnit(&tac->h, UNIT_UNKNOWN);
 
  /* If unit was unknown, then return error */
  if(tac->cunit==UNIT_UNKNOWN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  /* Otherwise ok */  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderTimeunit(
  IFT *h,
  int u
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous time unit(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "timeunit", start);
    if(i<0) i=iftFindKey(h, "time_unit", start);
    if(i<0) i=iftFindKey(h, "time unit", start);
    if(i<0) i=iftFindKey(h, "time units", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* If new unit is unknown, then just return */
  if(u<=UNIT_UNKNOWN || u>=UNIT_LAST) return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return (iftPut(h, "timeunit", unitName(u), (char)1, NULL));
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacGetHeaderTimeunit(
  TAC *tac,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>0) printf("%s()\n", __func__);
  tac->tunit=UNIT_UNKNOWN;
 
  /* Find the item index */
  int i;
  i=iftFindKey(&tac->h, "timeunit", 0);
  if(i<0) i=iftFindKey(&tac->h, "time_unit", 0);
  if(i<0) i=iftFindKey(&tac->h, "time unit", 0);
  if(i<0) i=iftFindKey(&tac->h, "time units", 0);
  if(i<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
    return TPCERROR_NO_KEY;
  }
  /* Check that item has content */
  size_t len;
  if(tac->h.item[i].value==NULL) len=0;
  else len=strlen(tac->h.item[i].value);
  if(len<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_VALUE);
    return TPCERROR_NO_VALUE;
  }
  
  /* Identify unit string */
  tac->tunit=unitIdentify(tac->h.item[i].value);
 
  /* Delete unit strings from header */
  tacSetHeaderTimeunit(&tac->h, UNIT_UNKNOWN);
 
  /* If unit was unknown, then return error */
  if(tac->tunit==UNIT_UNKNOWN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  /* Otherwise ok */  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacGetHeaderIsotope(
  IFT *h,
  char *s,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(s!=NULL) *s='\0';
  if(h==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) printf("%s()\n", __func__);
 
  /* Find the item index */
  int i;
  i=iftFindKey(h, "isotope", 0);
  if(i<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
    return TPCERROR_NO_KEY;
  }
  /* Check that item has content */
  size_t len;
  if(h->item[i].value==NULL) len=0;
  else len=strlen(h->item[i].value);
  if(len<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_VALUE);
    return TPCERROR_NO_VALUE;
  }
  if(len>MAX_ISOTOPE_LEN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  /* All fine, then copy isotope */
  if(s!=NULL) strlcpy(s, h->item[i].value, MAX_ISOTOPE_LEN);
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderIsotope(
  IFT *h,
  const char *s
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous isotope(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "isotope", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* If new isotope is empty, then just return */
  if(s==NULL || *s=='\0') return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return (iftPut(h, "isotope", s, (char)1, NULL));
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacGetHeaderScanstarttime(
  IFT *h,
  char *s,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(s!=NULL) *s='\0';
  if(h==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) printf("%s()\n", __func__);
 
  /* Find the item index */
  int i;
  i=iftFindKey(h, "scan_start_time", 0);
  if(i<0) i=iftFindKey(h, "scan start time", 0);
  if(i<0) i=iftFindKey(h, "scan_start", 0);
  if(i<0) i=iftFindKey(h, "scan start", 0);
  if(i<0) i=iftFindKey(h, "scantime", 0);
  if(i<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
    return TPCERROR_NO_KEY;
  }
  /* Check that item has content */
  size_t len;
  if(h->item[i].value==NULL) len=0;
  else len=strlen(h->item[i].value);
  if(len<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_VALUE);
    return TPCERROR_NO_VALUE;
  }
  if(len>19) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  /* All fine, then copy it */
  if(s!=NULL) strcpy(s, h->item[i].value);
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderScanstarttime(
  IFT *h,
  const char *s
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous scan start time(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "scan_start_time", start);
    if(i<0) i=iftFindKey(h, "scan start time", start);
    if(i<0) i=iftFindKey(h, "scan_start", start);
    if(i<0) i=iftFindKey(h, "scan start", start);
    if(i<0) i=iftFindKey(h, "scantime", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* If new scan start time is empty, then just return */
  if(s==NULL || *s=='\0') return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return (iftPut(h, "scan_start_time", s, (char)1, NULL));
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacGetHeaderInjectiontime(
  IFT *h,
  char *s,
  TPCSTATUS *status
) {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(s!=NULL) *s='\0';
  if(h==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) printf("%s()\n", __func__);
 
  /* Find the item index */
  int i;
  i=iftFindKey(h, "injection_time", 0);
  if(i<0) i=iftFindKey(h, "injection time", 0);
  if(i<0) i=iftFindKey(h, "injectiontime", 0);
  if(i<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_KEY);
    return TPCERROR_NO_KEY;
  }
  /* Check that item has content */
  size_t len;
  if(h->item[i].value==NULL) len=0;
  else len=strlen(h->item[i].value);
  if(len<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_VALUE);
    return TPCERROR_NO_VALUE;
  }
  if(len>19) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  /* All fine, then copy it */
  if(s!=NULL) strcpy(s, h->item[i].value);
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderInjectiontime(
  IFT *h,
  const char *s
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous scan start time(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "injection_time", start);
    if(i<0) i=iftFindKey(h, "injection time", start);
    if(i<0) i=iftFindKey(h, "injectiontime", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* If new scan start time is empty, then just return */
  if(s==NULL || *s=='\0') return(TPCERROR_OK);
  
  /* Otherwise create new key and value */
  return (iftPut(h, "injection_time", s, (char)1, NULL));
}
/*****************************************************************************/
 
/*****************************************************************************/
decaycorrection tacGetHeaderDecayCorrection(
  IFT *h
) {
  if(h==NULL) return(DECAY_UNKNOWN);
 
  /* Find the item index */
  int i;
  i=iftFindKey(h, "decay_correction", 0);
  if(i<0) i=iftFindKey(h, "decay correction", 0);
  if(i<0) return(DECAY_UNKNOWN);
 
  /* Check the contents */
  if(h->item[i].value==NULL || strlen(h->item[i].value)<1) 
    return(DECAY_UNKNOWN);
  if(strncasecmp(h->item[i].value, "YES", 1)==0) return(DECAY_CORRECTED);
  if(strncasecmp(h->item[i].value, "NO", 1)==0) return(DECAY_NOTCORRECTED);
  if(strcasecmp(h->item[i].value, "ON")==0) return(DECAY_CORRECTED);
  if(strcasecmp(h->item[i].value, "OFF")==0) return(DECAY_NOTCORRECTED);
  return(DECAY_UNKNOWN);
}
/*****************************************************************************/
 
/*****************************************************************************/
int tacSetHeaderDecayCorrection(
  IFT *h,
  decaycorrection dc 
) {
  if(h==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous status */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(h, "decay_correction", start);
    if(i<0) i=iftFindKey(h, "decay correction", start);
    if(i<0) break;
    iftDelete(h, i); if(i>start) start=i;
  }
 
  /* Create new key and value */
  if(dc==DECAY_CORRECTED)
    return (iftPut(h, "decay_correction", "yes", (char)1, NULL));
  else if(dc==DECAY_NOTCORRECTED)
    return (iftPut(h, "decay_correction", "no", (char)1, NULL));
 
  /* If unknown, then just return */
  return(TPCERROR_OK);  
}
/*****************************************************************************/
 
/*****************************************************************************/