tpctac.h

Go to the documentation of this file.

 
#ifndef _TPCTAC_H_
#define _TPCTAC_H_
/*****************************************************************************/
 
/*****************************************************************************/
#include "tpcclibConfig.h"
/*****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
/*****************************************************************************/
//#include "tpcextensions.h"
#include "tpccsv.h"
#include "tpcift.h"
#include "tpcisotope.h"
/*****************************************************************************/
 
/*****************************************************************************/
typedef enum {
  TAC_FORMAT_UNKNOWN,     
  TAC_FORMAT_SIMPLE,      
  TAC_FORMAT_DFT,         
  TAC_FORMAT_IFT,         
  TAC_FORMAT_NCI,         
  TAC_FORMAT_PMOD,        
  TAC_FORMAT_CSV_INT,     
  TAC_FORMAT_CSV_UK,      
  TAC_FORMAT_TSV_INT,     
  TAC_FORMAT_TSV_UK,      
  TAC_FORMAT_CPT,         
  TAC_FORMAT_IDWC,        
  TAC_FORMAT_IF,          
  TAC_FORMAT_XML,         
  TAC_FORMAT_HTML,        
  TAC_FORMAT_SIF,         
  TAC_FORMAT_XELERIS,     
  TAC_FORMAT_INVEON,      
  TAC_FORMAT_AMIDE,       
  TAC_FORMAT_CARIMAS_TXT, 
  TAC_FORMAT_QVIEW,       
  TAC_FORMAT_MAT,         
  TAC_FORMAT_4DM,         
  TAC_FORMAT_HRRT_HC,     
  TAC_FORMAT_HRPLUS_HC,   
  TAC_FORMAT_ABSS_SCANDITRONICS, 
  TAC_FORMAT_ABSS_GEMS,   
  TAC_FORMAT_ABSS_ALLOGG_OLD, 
  TAC_FORMAT_ABSS_ALLOGG, 
  TAC_FORMAT_BINARY,      
  TAC_FORMAT_LAST
} tacformat;
/*****************************************************************************/
 
/*****************************************************************************/
typedef struct TACC {
  tactype   type;  
  double    size;
  unit      sunit;
  double   *y;
  char      sw;
  char      sw2;
  char      name[MAX_TACNAME_LEN+1];
} TACC;
/*****************************************************************************/
typedef struct TAC {
  int           sampleNr;
  int           tacNr;
  tacformat     format;
  int           isframe;
  double       *x;
  double       *x1;
  double       *x2;
  int           cunit;
  int           tunit;
  double       *w;
  weights       weighting;
  TACC         *c;
  int           _tacNr;
  int           _sampleNr;
  double       *_data;
  IFT           h;
} TAC;
/*****************************************************************************/
 
/*****************************************************************************/
typedef struct MTAC {
  TAC *tac;
  int nr;
  int _nr;
} MTAC;
/*****************************************************************************/
 
/*****************************************************************************/
/* tac */
extern void tacInit(TAC *tac);
extern void taccInit(TACC *tacc);
extern void tacFree(TAC *tac);
extern void tacFreeExceptHeader(TAC *tac);
extern void taccFree(TACC *tacc);
extern int tacAllocate(TAC *tac, int sampleNr, int tacNr);
extern int tacAllocateMore(TAC *tac, int tacNr);
extern int tacCopyTacc(TACC *d1, TACC *d2, int sampleNr);
extern int tacCopyTaccdata(TACC *d1, TACC *d2, int sampleNr);
extern int tacCopyTacchdr(TACC *d1, TACC *d2);
extern int tacCopyHdr(TAC *tac1, TAC *tac2);
extern int tacIsSize(TAC *d);
extern int tacDuplicate(TAC *tac1, TAC *tac2);
extern int tacExtract(TAC *d1, TAC *d2, const int i);
extern int tacAllocateMoreSamples(TAC *tac, int addNr);
/*****************************************************************************/
 
/*****************************************************************************/
/* mtac */
extern void mtacInit(MTAC *mtac);
extern void mtacFree(MTAC *mtac);
extern int mtacAllocate(MTAC *mtac, int nr);
extern int mtacAllocateMore(MTAC *mtac, int nr);
extern int mtacAddTAC(MTAC *mtac, TAC *tac);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacio */
extern char *tacFormattxt(tacformat c);
extern int tacFormatIdentify(const char *s);
extern char *tacDefaultExtension(tacformat c);
extern int tacFormatDetermine(const char *fname, TPCSTATUS *status);
extern int tacFormatWriteSupported(tacformat format);
extern int tacWrite(TAC *tac, FILE *fp, tacformat format, int extra, TPCSTATUS *status);
extern int tacRead(TAC *d, const char *fname, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacift */
extern int tacGetHeaderStudynr(IFT *h, char *s, TPCSTATUS *status);
extern int tacSetHeaderStudynr(IFT *h, const char *s);
extern int tacGetHeaderUnit(TAC *tac, TPCSTATUS *status);
extern int tacSetHeaderUnit(IFT *h, int u);
extern int tacGetHeaderTimeunit(TAC *tac, TPCSTATUS *status);
extern int tacSetHeaderTimeunit(IFT *h, int u);
extern int tacGetHeaderIsotope(IFT *h, char *s, TPCSTATUS *status);
extern int tacSetHeaderIsotope(IFT *h, const char *s);
extern int tacGetHeaderScanstarttime(IFT *h, char *s, TPCSTATUS *status);
extern int tacSetHeaderScanstarttime(IFT *h, const char *s);
extern int tacGetHeaderInjectiontime(IFT *h, char *s, TPCSTATUS *status);
extern int tacSetHeaderInjectiontime(IFT *h, const char *s);
extern decaycorrection tacGetHeaderDecayCorrection(IFT *h);
int tacSetHeaderDecayCorrection(IFT *h, decaycorrection dc);
/*****************************************************************************/
 
/*****************************************************************************/
/* simpleio */
extern int tacWriteSimple(TAC *tac, FILE *fp, int extra, TPCSTATUS *status);
extern int tacReadSimple(TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* dftio */
extern int tacNameSplit(
  const char *rname, char *name1, char *name2, char *name3, unsigned int max_name_len
);
extern int tacWriteDFT(TAC *tac, FILE *fp, int extra, TPCSTATUS *status);
extern int tacReadDFT(TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* sifio */
extern int tacWriteSIF(TAC *tac, FILE *fp, int extra, TPCSTATUS *status);
extern int tacReadSIF(TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* pmodio */
extern int tacWritePMOD(TAC *tac, FILE *fp, int extra, TPCSTATUS *status);
extern int tacReadPMOD(TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* qviewio */
extern int tacReadQView(TAC *tac, CSV *csv, const int grouponly, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* 4dmio */
extern int tacRead4DM(TAC *tac, CSV *csv, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* matio */
extern int tacReadMat(TAC *tac, CSV *csv, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* taccsv */
extern int tacWriteCSV(TAC *tac, FILE *fp, int extra, tacformat format, TPCSTATUS *status);
extern int tacReadCSV(TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status);
extern int tacReadInveonCSV(TAC *tac, CSV *csv, TPCSTATUS *status);
extern int tacReadCarimasTxt(TAC *tac, CSV *csv, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* hcio */
extern int tacReadHRRTHC(TAC *tac, CSV *csv, TPCSTATUS *status);
extern int tacReadHRPLUSHC(TAC *tac, CSV *csv, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacnan */
extern int tacXNaNs(TAC *tac);
extern int tacYNaNs(TAC *tac, const int i);
extern int tacNaNs(TAC *tac);
extern int tacNotNaNs(TAC *tac, const int i);
extern int tacFixNaNs(TAC *tac);
extern int tacNthSample(TAC *tac, const int sn, const int i);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacselect */
extern int tacSelectTACs(TAC *d, const char *region_name, int reset, TPCSTATUS *status);
extern int tacSelectedTACs(TAC *d);
extern int tacFirstSelected(TAC *d);
extern int tacSelectBestReference(TAC *d);
//int tacNameMatch(const char *tacname, const char *test_str, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacorder */
extern int tacVerifyTimeOrder(TAC *d, TPCSTATUS *status);
extern int tacSortByTime(TAC *d, TPCSTATUS *status);
extern int tacSortByConc(TAC *d, const int i, TPCSTATUS *status);
extern int tacSortByName(TAC *d, TPCSTATUS *status);
extern int tacSortByAUC(TAC *d, TPCSTATUS *status);
extern int tacMoveTACC(TAC *d, int from, int to);
extern int tacSwapTACCs(TAC *d, int i1, int i2);
extern int tacDeleteTACC(TAC *d, int i);
extern int tacMultipleSamples(TAC *d1, const int fixMode, TAC *d2, const int verbose);
/*****************************************************************************/
 
/*****************************************************************************/
/* taccomp */
extern int tacCompareUnit(TAC *d1, TAC *d2, TPCSTATUS *status);
extern int tacCompareNames(TAC *d1, TAC *d2, const int i, TPCSTATUS *status);
extern int tacCompareConc(
  TAC *d1, TAC *d2, const int i, const double test_abs, const double test_rel,
  TPCSTATUS *status
);
extern int tacCompareTimes(
  TAC *d1, TAC *d2, const double test_abs, const double test_rel,
  TPCSTATUS *status
);
extern int tacCompareWeights(
  TAC *d1, TAC *d2, const double test_abs, const double test_rel,
  TPCSTATUS *status
);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacunits */
extern int tacXUnitConvert(TAC *d, const int u, TPCSTATUS *status);
extern int tacYUnitConvert(TAC *d, const int u, TPCSTATUS *status);
extern int tacYUnitMass2Volume(TAC *tac, const double density, TPCSTATUS *status);
extern int tacYUnitVolume2Mass(TAC *tac, const double density, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacname */
extern int tacIndividualNames(TAC *tac);
extern void tacEnsureNames(TAC *tac);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacx */
extern int tacXCopy(TAC *tac1, TAC *tac2, int i1, int i2);
extern int tacCorrectFrameOverlap(TAC *d, TPCSTATUS *status);
extern int tacXRange(TAC *d, double *xmin, double *xmax);
extern int tacSampleXRange(TAC *d, double *xmin, double *xmax);
extern int tacMinX(TAC *d);
extern int tacIsX(TAC *d);
extern int tacXMatch(TAC *d1, TAC *d2, const int verbose);
extern int tacAddZeroSample(TAC *d, TPCSTATUS *status);
extern int tacDeleteSample(TAC *d, int i);
extern int tacDeleteMissingSamples(TAC *d);
extern int tacExtractRange(TAC *d1, TAC *d2, double startT, double endT);
extern int tacExtractSamples(TAC *d1, TAC *d2, int si, int ei);
extern int tacCheckX1X2X(TAC *d);
extern int tacSetX(TAC *d, TPCSTATUS *status);
extern int tacGetSampleInterval(TAC *d, double ilimit, double *minfdur, double *maxfdur);
extern int tacToBars(TAC *tac1, TAC *tac2);
extern int tacFramesToSteps(TAC *inp, TAC *out, TPCSTATUS *status);
extern int tacIsXContiguous(TAC *d);
extern int tacSetXContiguous(TAC *d);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacy */
extern int tacYRange(
  TAC *d, int i, double *ymin, double *ymax,
  int *smin, int *smax, int *imin, int *imax
);
extern int tacYRangeInXRange(
  TAC *d, int i, const double xmin, const double xmax, 
  double *ymin, double *ymax, int *smin, int *smax, int *imin, int *imax
);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacw */
extern int tacIsWeighted(TAC *tac);
extern int tacWCopy(TAC *tac1, TAC *tac2, int i1, int i2);
extern int tacWMove(TAC *tac, int ow, TPCSTATUS *status);
extern int tacWByFreq(TAC *tac, isotope isot, TPCSTATUS *status);
extern unsigned int tacWSampleNr(TAC *tac);
extern int tacWeightNorm(TAC *tac, TPCSTATUS *status);
extern int tacWeightModerate(
  TAC *tac, const double minprop, const int doZeroes, const int doNaNs, TPCSTATUS *status
);
extern int sifWeight(TAC *sif, isotope isot, TPCSTATUS *status);
extern int tacSetWeights(TAC *tac, weights weightMethod, int weightNr, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacdc */
extern int tacGetIsotope(TAC *tac);
extern void tacSetIsotope(TAC *tac, int isotope);
extern int tacDecayCorrection(TAC *tac, int isotope, int mode, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacabss */
extern int tacReadAllogg(TAC *tac, IFT *hdr, TPCSTATUS *status);
extern int tacReadOldAllogg(TAC *tac, IFT *hdr, TPCSTATUS *status);
extern int tacReadScanditronics(TAC *tac, IFT *hdr, TPCSTATUS *status);
extern int tacReadGEMS(TAC *tac, IFT *hdr, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
/* tacxmlio */
extern int tacWriteXML(TAC *tac, FILE *fp, TPCSTATUS *status);
/*****************************************************************************/
 
/*****************************************************************************/
#endif /* TPCTAC */