tpctac.h File Reference

Header file for library libtpctac. More...

#include "tpcclibConfig.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "tpccsv.h"
#include "tpcift.h"
#include "tpcisotope.h"

Go to the source code of this file.

Data Structures
struct	TACC
struct	TAC
struct	MTAC

Enumerations
enum	tacformat {   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 }

Functions
void	tacInit (TAC *tac)
void	taccInit (TACC *tacc)
void	tacFree (TAC *tac)
void	tacFreeExceptHeader (TAC *tac)
void	taccFree (TACC *tacc)
int	tacAllocate (TAC *tac, int sampleNr, int tacNr)
int	tacAllocateMore (TAC *tac, int tacNr)
int	tacCopyTacc (TACC *d1, TACC *d2, int sampleNr)
int	tacCopyTaccdata (TACC *d1, TACC *d2, int sampleNr)
int	tacCopyTacchdr (TACC *d1, TACC *d2)
int	tacCopyHdr (TAC *tac1, TAC *tac2)
	Copy TAC header data from tac1 to tac2.
int	tacIsSize (TAC *d)
int	tacDuplicate (TAC *tac1, TAC *tac2)
	Make a duplicate of TAC structure.
int	tacExtract (TAC *d1, TAC *d2, const int i)
	Extract the specified TAC from existing TAC structure into a new TAC.
int	tacAllocateMoreSamples (TAC *tac, int addNr)
	Allocate memory for more samples in TAC data.
void	mtacInit (MTAC *mtac)
void	mtacFree (MTAC *mtac)
int	mtacAllocate (MTAC *mtac, int nr)
int	mtacAllocateMore (MTAC *mtac, int nr)
int	mtacAddTAC (MTAC *mtac, TAC *tac)
char *	tacFormattxt (tacformat c)
int	tacFormatIdentify (const char *s)
char *	tacDefaultExtension (tacformat c)
int	tacFormatDetermine (const char *fname, TPCSTATUS *status)
int	tacFormatWriteSupported (tacformat format)
int	tacWrite (TAC *tac, FILE *fp, tacformat format, int extra, TPCSTATUS *status)
int	tacRead (TAC *d, const char *fname, TPCSTATUS *status)
int	tacGetHeaderStudynr (IFT *h, char *s, TPCSTATUS *status)
int	tacSetHeaderStudynr (IFT *h, const char *s)
int	tacGetHeaderUnit (TAC *tac, TPCSTATUS *status)
int	tacSetHeaderUnit (IFT *h, int u)
int	tacGetHeaderTimeunit (TAC *tac, TPCSTATUS *status)
int	tacSetHeaderTimeunit (IFT *h, int u)
int	tacGetHeaderIsotope (IFT *h, char *s, TPCSTATUS *status)
int	tacSetHeaderIsotope (IFT *h, const char *s)
int	tacGetHeaderScanstarttime (IFT *h, char *s, TPCSTATUS *status)
int	tacSetHeaderScanstarttime (IFT *h, const char *s)
int	tacGetHeaderInjectiontime (IFT *h, char *s, TPCSTATUS *status)
int	tacSetHeaderInjectiontime (IFT *h, const char *s)
decaycorrection	tacGetHeaderDecayCorrection (IFT *h)
int	tacSetHeaderDecayCorrection (IFT *h, decaycorrection dc)
int	tacWriteSimple (TAC *tac, FILE *fp, int extra, TPCSTATUS *status)
int	tacReadSimple (TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status)
int	tacNameSplit (const char *rname, char *name1, char *name2, char *name3, unsigned int max_name_len)
int	tacWriteDFT (TAC *tac, FILE *fp, int extra, TPCSTATUS *status)
int	tacReadDFT (TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status)
int	tacWriteSIF (TAC *tac, FILE *fp, int extra, TPCSTATUS *status)
int	tacReadSIF (TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status)
int	tacWritePMOD (TAC *tac, FILE *fp, int extra, TPCSTATUS *status)
int	tacReadPMOD (TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status)
int	tacReadQView (TAC *tac, CSV *csv, const int grouponly, TPCSTATUS *status)
int	tacRead4DM (TAC *tac, CSV *csv, TPCSTATUS *status)
int	tacReadMat (TAC *tac, CSV *csv, TPCSTATUS *status)
int	tacWriteCSV (TAC *tac, FILE *fp, int extra, tacformat format, TPCSTATUS *status)
int	tacReadCSV (TAC *tac, CSV *csv, IFT *hdr, TPCSTATUS *status)
int	tacReadInveonCSV (TAC *tac, CSV *csv, TPCSTATUS *status)
int	tacReadCarimasTxt (TAC *tac, CSV *csv, TPCSTATUS *status)
int	tacReadHRRTHC (TAC *tac, CSV *csv, TPCSTATUS *status)
int	tacReadHRPLUSHC (TAC *tac, CSV *csv, TPCSTATUS *status)
int	tacXNaNs (TAC *tac)
int	tacYNaNs (TAC *tac, const int i)
int	tacNaNs (TAC *tac)
int	tacNotNaNs (TAC *tac, const int i)
int	tacFixNaNs (TAC *tac)
int	tacNthSample (TAC *tac, const int sn, const int i)
int	tacSelectTACs (TAC *d, const char *region_name, int reset, TPCSTATUS *status)
int	tacSelectedTACs (TAC *d)
int	tacFirstSelected (TAC *d)
int	tacSelectBestReference (TAC *d)
int	tacVerifyTimeOrder (TAC *d, TPCSTATUS *status)
int	tacSortByTime (TAC *d, TPCSTATUS *status)
int	tacSortByConc (TAC *d, const int i, TPCSTATUS *status)
int	tacSortByName (TAC *d, TPCSTATUS *status)
int	tacSortByAUC (TAC *d, TPCSTATUS *status)
int	tacMoveTACC (TAC *d, int from, int to)
int	tacSwapTACCs (TAC *d, int i1, int i2)
int	tacDeleteTACC (TAC *d, int i)
int	tacMultipleSamples (TAC *d1, const int fixMode, TAC *d2, const int verbose)
	Check TAC data for multiple samples with the same sample time. Optionally replace the multiple samples with their mean.
int	tacCompareUnit (TAC *d1, TAC *d2, TPCSTATUS *status)
int	tacCompareNames (TAC *d1, TAC *d2, const int i, TPCSTATUS *status)
int	tacCompareConc (TAC *d1, TAC *d2, const int i, const double test_abs, const double test_rel, TPCSTATUS *status)
int	tacCompareTimes (TAC *d1, TAC *d2, const double test_abs, const double test_rel, TPCSTATUS *status)
int	tacCompareWeights (TAC *d1, TAC *d2, const double test_abs, const double test_rel, TPCSTATUS *status)
int	tacXUnitConvert (TAC *d, const int u, TPCSTATUS *status)
int	tacYUnitConvert (TAC *d, const int u, TPCSTATUS *status)
int	tacYUnitMass2Volume (TAC *tac, const double density, TPCSTATUS *status)
int	tacYUnitVolume2Mass (TAC *tac, const double density, TPCSTATUS *status)
int	tacIndividualNames (TAC *tac)
void	tacEnsureNames (TAC *tac)
int	tacXCopy (TAC *tac1, TAC *tac2, int i1, int i2)
int	tacCorrectFrameOverlap (TAC *d, TPCSTATUS *status)
	Correct PET frame start and end times if frames are slightly overlapping or have small gaps in between.
int	tacXRange (TAC *d, double *xmin, double *xmax)
	Get the range of x values (times) in TAC structure.
int	tacSampleXRange (TAC *d, double *xmin, double *xmax)
	Get the range of x values (times) in TAC structure.
int	tacMinX (TAC *d)
	Get the minimum x value in TAC structure.
int	tacIsX (TAC *d)
	Verify if TAC structure contains reasonable x values (times).
int	tacXMatch (TAC *d1, TAC *d2, const int verbose)
	Check whether sample (frame) times are the same (or very close to) in two TAC structures.
int	tacAddZeroSample (TAC *d, TPCSTATUS *status)
	Add an initial sample to TAC(s) with zero time and concentration.
int	tacDeleteSample (TAC *d, int i)
	Delete a certain sample (time frame) from TAC structure.
int	tacDeleteMissingSamples (TAC *d)
	Delete those samples (time frames) from TAC structure, which contain only missing y values, and/or x is NaN.
int	tacExtractRange (TAC *d1, TAC *d2, double startT, double endT)
	Extract the specified time (x) range from TAC structure.
int	tacExtractSamples (TAC *d1, TAC *d2, int si, int ei)
	Extract the specified sample range from TAC structure.
int	tacCheckX1X2X (TAC *d)
	Check that sample (time frame) x, x1, and x2 values are reasonably set when compared to each other in TAC structure.
int	tacSetX (TAC *d, TPCSTATUS *status)
	Set TAC x values based on x1 and x2 values, or guess x1 and x2 values based on x values.
int	tacGetSampleInterval (TAC *d, double ilimit, double *minfdur, double *maxfdur)
	Get the shortest and longest sampling intervals or frame lengths in TAC structure.
int	tacToBars (TAC *tac1, TAC *tac2)
	Transform TAC data with frame start and end times into suitable form for plotting with frames as bars.
int	tacFramesToSteps (TAC *inp, TAC *out, TPCSTATUS *status)
	Transform TAC with frames into TAC with frames represented with stepwise changing dot-to-dot data.
int	tacIsXContiguous (TAC *d)
	Check that PET TAC frame times are contiguous, without even tiny overlap or gaps in between.
int	tacSetXContiguous (TAC *d)
	Set PET TAC frame times contiguous, without even tiny overlap or gaps in between.
int	tacYRange (TAC *d, int i, double *ymin, double *ymax, int *smin, int *smax, int *imin, int *imax)
	Get the range of y values (concentrations) in TAC struct.
int	tacYRangeInXRange (TAC *d, int i, const double xmin, const double xmax, double *ymin, double *ymax, int *smin, int *smax, int *imin, int *imax)
	Get the range of y values (concentrations) in TAC struct, including only samples with x (times) inside given range.
int	tacIsWeighted (TAC *tac)
int	tacWCopy (TAC *tac1, TAC *tac2, int i1, int i2)
int	tacWMove (TAC *tac, int ow, TPCSTATUS *status)
int	tacWByFreq (TAC *tac, isotope isot, TPCSTATUS *status)
unsigned int	tacWSampleNr (TAC *tac)
int	tacWeightNorm (TAC *tac, TPCSTATUS *status)
int	tacWeightModerate (TAC *tac, const double minprop, const int doZeroes, const int doNaNs, TPCSTATUS *status)
int	sifWeight (TAC *sif, isotope isot, TPCSTATUS *status)
int	tacSetWeights (TAC *tac, weights weightMethod, int weightNr, TPCSTATUS *status)
int	tacGetIsotope (TAC *tac)
void	tacSetIsotope (TAC *tac, int isotope)
int	tacDecayCorrection (TAC *tac, int isotope, int mode, TPCSTATUS *status)
int	tacReadAllogg (TAC *tac, IFT *hdr, TPCSTATUS *status)
int	tacReadOldAllogg (TAC *tac, IFT *hdr, TPCSTATUS *status)
int	tacReadScanditronics (TAC *tac, IFT *hdr, TPCSTATUS *status)
int	tacReadGEMS (TAC *tac, IFT *hdr, TPCSTATUS *status)
int	tacWriteXML (TAC *tac, FILE *fp, TPCSTATUS *status)

Detailed Description

Header file for library libtpctac.

Time-activity curve (TAC) processing and file i/o.

Author

Vesa Oikonen

Copyright

(c) Turku PET Centre

Definition in file tpctac.h.

Enumeration Type Documentation

tacformat

enum tacformat

TAC file format codes; see tac_format

Enumerator
TAC_FORMAT_UNKNOWN	Unknown format.
TAC_FORMAT_SIMPLE	x and y's with space delimiters
TAC_FORMAT_DFT	Data format of Turku PET Centre.
TAC_FORMAT_IFT	Interfile-type data (supported for writing)
TAC_FORMAT_NCI	Old Turku PET Centre format.
TAC_FORMAT_PMOD	PMOD TAC format.
TAC_FORMAT_CSV_INT	International CSV.
TAC_FORMAT_CSV_UK	UK CSV.
TAC_FORMAT_TSV_INT	International TSV (comma as decimal separator)
TAC_FORMAT_TSV_UK	UK TSV (point as decimal separator)
TAC_FORMAT_CPT	CPT format.
TAC_FORMAT_IDWC	Hammersmith tissue file format.
TAC_FORMAT_IF	Hammersmith input file format.
TAC_FORMAT_XML	XML format (supported for writing)
TAC_FORMAT_HTML	HTML table format (supported for writing)
TAC_FORMAT_SIF	Scan information file.
TAC_FORMAT_XELERIS	Xeleris format (reading supported)
TAC_FORMAT_INVEON	Inveon format (reading supported)
TAC_FORMAT_AMIDE	Amide format (reading supported)
TAC_FORMAT_CARIMAS_TXT	Carimas txt format (reading supported)
TAC_FORMAT_QVIEW	QView CSV TAC format (reading supported)
TAC_FORMAT_MAT	Matlab matrix TAC format (reading supported)
TAC_FORMAT_4DM	4DM TAC format (reading supported)
TAC_FORMAT_HRRT_HC	HRRT head curve format (reading supported)
TAC_FORMAT_HRPLUS_HC	HR+ head curve format (reading supported)
TAC_FORMAT_ABSS_SCANDITRONICS	Scanditronics ABSS data; reading supported.
TAC_FORMAT_ABSS_GEMS	GEMS ABSS data; reading supported.
TAC_FORMAT_ABSS_ALLOGG_OLD	ALLOGG ABSS data (old format); reading supported.
TAC_FORMAT_ABSS_ALLOGG	ALLOGG ABSS data; reading supported.
TAC_FORMAT_BINARY	Binary format (currently not supported)

Definition at line 27 of file tpctac.h.

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

Function Documentation

mtacAddTAC()

int mtacAddTAC ( MTAC * mtac, TAC * tac )

extern

Copy given TAC structure into MTAC list.

See also

mtacInit, mtacFree, mtacAllocate, MTAC, TAC

Returns

Returns TPCERROR status.

Parameters

mtac	Pointer to initiated MTAC structure; any old contents are preserved.
tac	Pointer to TAC structure to add.

Definition at line 121 of file mtac.c.

  {
  if(mtac==NULL || tac==NULL) return TPCERROR_FAIL;
  /* Make room for the TAC */
  int ret=mtacAllocateMore(mtac, 1); if(ret!=TPCERROR_OK) return(ret);
  /* Copy TAC into the end of the list */
  ret=tacDuplicate(tac, &mtac->tac[mtac->nr]); if(ret!=TPCERROR_OK) return(ret);
  mtac->nr++;
  return TPCERROR_OK;
}

mtacAllocate()

int mtacAllocate ( MTAC * mtac, int nr )

extern

Allocate memory for TACs in MTAC data structure.

See also

mtacInit, mtacFree, mtacAddTAC

Returns

Returns TPCERROR status.

Parameters

mtac	Pointer to initiated MTAC structure; any old contents are deleted. Number of TACs is kept at zero, but TACs in the list are initiated.
nr	Nr of TACs to allocate

Definition at line 56 of file mtac.c.

  {
  if(mtac==NULL) return TPCERROR_FAIL;
  /* Delete any previous contents */
  mtacFree(mtac);
  /* If no memory is requested, then just return */
  if(nr<1) return TPCERROR_OK;
  /* Allocate the list of TACs */
  mtac->tac=(TAC*)malloc(nr*sizeof(TAC));
  if(mtac->tac==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<nr; i++) tacInit(&mtac->tac[i]);
  mtac->_nr=nr;
  return TPCERROR_OK;
}

Referenced by mtacAllocateMore().

mtacAllocateMore()

int mtacAllocateMore ( MTAC * mtac, int nr )

extern

Allocate memory for more TACs in MTAC structure. Previous contents are not changed.

See also

mtacAllocate, mtacInit, mtacFree, mtacAddTAC, MTAC, TAC

Returns

Returns TPCERROR status.

Parameters

mtac	Pointer to initiated and previously allocated MTAC structure; any old contents are preserved, including nr of TACs.
nr	Nr of additional TAC structures to allocate; if structure contains unused space for requested TACs already, then nothing is done.

Definition at line 83 of file mtac.c.

  {
  if(mtac==NULL) return TPCERROR_FAIL;
 
  /* If not allocated before, then use mtacAllocate */
  if(mtac->_nr==0) return(mtacAllocate(mtac, nr));
 
  /* Check if there is enough space already */
  int newNr, addNr;
  newNr=mtac->nr + nr;
  addNr=newNr - mtac->_nr;
  if(addNr<=0) return TPCERROR_OK;
  
  /* Reallocate memory for TACC data */
  TAC *tacPtr;
  tacPtr=realloc(mtac->tac, sizeof(TAC)*newNr);
  if(tacPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
  mtac->tac=tacPtr;
 
  /* Update the nr of allocated TACs and initiate new TACs */ 
  for(int i=mtac->_nr; i<newNr; i++) tacInit(&mtac->tac[i]);
  mtac->_nr=newNr;
 
  return TPCERROR_OK;
}

Referenced by mtacAddTAC().

mtacFree()

void mtacFree ( MTAC * mtac )

extern

Free memory allocated for MTAC data. All contents are destroyed.

Precondition

Before first use initialize the MTAC struct with mtacInit().

See also

mtacInit, tacFree

Parameters

mtac	Pointer to MTAC.

Definition at line 38 of file mtac.c.

  {
  if(mtac==NULL) return;
  /* Free allocated TACs. */ 
  for(int i=0; i<mtac->_nr; i++) tacFree(&mtac->tac[i]); 
  free(mtac->tac);
  // then set everything to zero or NULL again
  mtacInit(mtac);
}

Referenced by mtacAllocate().

mtacInit()

void mtacInit ( MTAC * mtac )

extern

Initiate the MTAC structure before any use.

See also

mtacFree, MTAC, TAC

Parameters

mtac	Pointer to MTAC.

Definition at line 23 of file mtac.c.

  {
  if(mtac==NULL) return;
  mtac->nr=mtac->_nr=0;
  mtac->tac=NULL;
}

Referenced by mtacFree().

sifWeight()

int sifWeight ( TAC * sif, isotope isot, TPCSTATUS * status )

extern

Calculate weights for frames in SIF data based on true counts.

Weights are calculated from formula weight=(frame duration)^2 / (trues in a frame) which is applicable to non-decay corrected data. If weights are to be applied to decay-corrected data, provide function with isotope to use formula weight=(frame duration)^2 / (decay corrected trues in a frame) instead.

Reference: Mazoyer BM, Huesman RH, Budinger TF, Knittel BL. Dynamic PET data analysis. J Comput Assist Tomogr 1986; 10:645-653.

Formula is not applicable to initial frames where trues can be zero or even less, but weights for frames with no trues should still be high for fitting purposes; therefore, in those cases, weight is set to the maximum weight that was calculated from the data.

Weights are normalized to have an average of 1.0 for frames that have weight above zero.

See also

tacWCopy, tacWByFreq, tacWSampleNr, tacReadSIF, tacWeightModerate, tacWeightNorm, tacDecayCorrection, tacIsWeighted, tacSetWeights

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

sif	Pointer to SIF data, stored in TAC structure. Weights are added to the structure. Data must have at least two columns (TACs), which are assumed to represent prompts and randoms, to calculate trues as prompts - randoms. Counts in SIF are assumed to be not corrected for physical decay. Frame times are assumed to be in seconds.
isot	Isotope code, in case the weights are calculated for decay corrected data. Enter ISOTOPE_UNKNOWN if calculating weights for non-corrected data. SIF should contain isotope, too, but that is not used in this function.
status	Pointer to status data; enter NULL if not needed

Definition at line 363 of file tacw.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(%s)\n", __func__, isotopeName(isot));
  if(sif==NULL || sif->tacNr<1 || sif->sampleNr<1) {
    if(sif!=NULL && verbose>2) {
      printf("  sif.tacNr := %d\n  sif.sampleNr := %d\n", sif->tacNr, sif->sampleNr);
    }
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  sif->weighting=WEIGHTING_OFF;
  if(sif->tacNr<2 || !sif->isframe) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  /* Check times */
  double xmin, xmax;
  if(tacXRange(sif, &xmin, &xmax) || !(xmax>xmin)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_XRANGE);
    return TPCERROR_INVALID_XRANGE;
  }
 
  /* Calculate trues */
  double trues[sif->sampleNr];
  for(int i=0; i<sif->sampleNr; i++) trues[i]=sif->c[0].y[i]-sif->c[1].y[i];
  if(verbose>2) {
    printf("\nTrues:\n");
    for(int i=0; i<sif->sampleNr; i++) printf("\t%g\n", trues[i]);
    fflush(stdout);
  }
  /* Correct for decay, if requested */
  if(isot!=ISOTOPE_UNKNOWN) {
    for(int i=0; i<sif->sampleNr; i++)
      trues[i]*=decayCorrectionFactorFromIsotope(isot, sif->x1[i]/60., (sif->x2[i]-sif->x1[i])/60.);
    if(verbose>2) {
      printf("\nTrues after decay correction:\n");
      for(int i=0; i<sif->sampleNr; i++) printf("\t%g\n", trues[i]);
      fflush(stdout);
    }
  }
  /* Calculate weights */
  double wMax=0.0;
  for(int i=0; i<sif->sampleNr; i++) {
    double fdur=sif->x2[i]-sif->x1[i]; if(fdur<0.0) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_X);
      return TPCERROR_INVALID_X;
    }
    if(trues[i]>0.0) {
      sif->w[i]=fdur*fdur/trues[i];
      if(sif->w[i]>wMax) wMax=sif->w[i];
    } else {
      sif->w[i]=nan("");
    }
  }
  if(!(wMax>0.0)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  if(verbose>1) {printf("\twMax := %g\n", wMax); fflush(stdout);}
  /* Set maximum weight to frames which had no true counts */
  for(int i=0; i<sif->sampleNr; i++) if(!(trues[i]>0.0) && isnan(sif->w[i])) sif->w[i]=wMax;
  if(verbose>2) {
    printf("\nWeights before normalization:\n");
    for(int i=0; i<sif->sampleNr; i++) printf("\t%g\n", sif->w[i]);
    fflush(stdout);
  }
 
  /* Normalize weights */
  sif->weighting=WEIGHTING_ON_COUNTS;
  if(tacWeightNorm(sif, status)!=TPCERROR_OK) return(status->error);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacSetWeights().

tacAddZeroSample()

int tacAddZeroSample ( TAC * d, TPCSTATUS * status )

extern

Add an initial sample to TAC(s) with zero time and concentration.

If the sample time of the first sample is zero (or smaller) already, then nothing is done. Sort by sample time before calling this.

See also

tacSortByTime, tacAllocateMoreSamples, tacIsX, tacCheckX1X2X, tacMinX, tacInterpolateToEqualLengthFrames

Author

Vesa Oikonen

Returns

Returns TPCERROR status (0 if ok).

Parameters

d	Pointer to the TAC structure.
status	Pointer to status data; enter NULL if not needed.

Definition at line 366 of file tacx.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(d==NULL || d->_sampleNr<1 || d->_tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
 
  /* Check if we already have the zero sample */
  if(d->sampleNr>0) {
    if((d->isframe && d->x1[0]<=0.0) || (!d->isframe && d->x[0]<=0.0)) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
      return TPCERROR_OK;
    }
  }
  
  /* If we have no samples at all, but space for samples, then just make one */
  if(d->sampleNr==0 && d->_sampleNr>0) {
    d->x[0]=d->x1[0]=d->x2[0]=0.0; d->sampleNr=1;
    for(int j=0; j<d->tacNr; j++) d->c[j].y[0]=0.0;
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
  
  /* Add space for one more sample */
  int ret;
  ret=tacAllocateMoreSamples(d, 1);
  if(ret!=TPCERROR_OK) {statusSet(status, __func__, __FILE__, __LINE__, ret); return ret;}
  
  /* Move all data to make room for the zero sample */
  for(int fi=d->sampleNr; fi>0; fi--) {
    d->x[fi]=d->x[fi-1]; d->x1[fi]=d->x1[fi-1]; d->x2[fi]=d->x2[fi-1];
    for(int ri=0; ri<d->tacNr; ri++) d->c[ri].y[fi]=d->c[ri].y[fi-1];
    d->w[fi]=d->w[fi-1];
  } // previous sample
  d->sampleNr++;
  /* ... and then add the zero sample */
  for(int ri=0; ri<d->tacNr; ri++) d->c[ri].y[0]=0.0;
  if(!d->isframe) {
    d->x[0]=d->x1[0]=d->x2[0]=0.0;
  } else {
    d->x1[0]=0.0; d->x2[0]=d->x1[1]; d->x[0]=0.5*(d->x1[0]+d->x2[0]);
  }
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

Referenced by tacInput2sim().

tacAllocate()

int tacAllocate ( TAC * tac, int sampleNr, int tacNr )

extern

Allocate memory for TAC data (and set data pointers inside the structure). Any previous contents are deleted. Contents are set to NaN.

See also

tacAllocateMore, tacDuplicate, tacInit, tacFree

Returns

Returns TPCERROR status.

Parameters

tac	Pointer to initiated TAC structure data; any old contents are deleted. tacNr and sampleNr inside the structure are set to or kept at zero.
sampleNr	Nr of samples to allocate.
tacNr	Nr of concentration arrays (regional TACs) to allocate.

Definition at line 130 of file tac.c.

  {
  if(tac==NULL) return TPCERROR_FAIL;
  /* Delete any previous contents */
  tacFree(tac);
  /* If no memory is requested, then just return */
  if(sampleNr<1 && tacNr<1) return TPCERROR_OK;
  if(sampleNr<1 || tacNr<1) return TPCERROR_FAIL;
 
  /* Allocate memory for TACC data */
  tac->c=(TACC*)malloc(tacNr*sizeof(TACC));
  if(tac->c==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<tacNr; i++) taccInit(&tac->c[i]);
  tac->_tacNr=tacNr;
 
  /* Allocate memory for all double arrays */
  int n; n=sampleNr*(4+tacNr);
  tac->_data=(double*)calloc(n, sizeof(double));
  if(tac->_data==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<n; i++) tac->_data[i]=nan("");
  tac->_sampleNr=sampleNr;
 
  /* Set pointers for curve data */
  double *d=tac->_data;
  tac->x=d; d+=sampleNr;
  tac->x1=d; d+=sampleNr;
  tac->x2=d; d+=sampleNr;
  tac->w=d; d+=sampleNr;
  for(int i=0; i<tacNr; i++) {tac->c[i].y=d; d+=sampleNr;}
 
  return TPCERROR_OK;
}

Referenced by bfm1TCM(), bfmSRTM(), imgToSIF(), mfCreateTAC(), tacAllocateMoreSamples(), tacAllocateWithPAR(), tacDelayFit(), tacDuplicate(), tacExtract(), tacExtractRange(), tacExtractSamples(), tacInterpolate(), tacInterpolateToEqualLengthFrames(), tacMultipleSamples(), tacRead4DM(), tacReadAllogg(), tacReadCarimasTxt(), tacReadCSV(), tacReadDFT(), tacReadGEMS(), tacReadHRPLUSHC(), tacReadHRRTHC(), tacReadInveonCSV(), tacReadMat(), tacReadOldAllogg(), tacReadPMOD(), tacReadQView(), tacReadScanditronics(), tacReadSIF(), tacReadSimple(), and tacSetWeights().

tacAllocateMore()

int tacAllocateMore ( TAC * tac, int tacNr )

extern

Allocate memory for more TACs in TAC data (and set data pointers inside the structure).

Previous contents are not changed. New contents are set to NaN.

See also

tacAllocate, tacAllocateMoreSamples, tacCopyTacc

Returns

Returns TPCERROR status.

Parameters

tac	Pointer to initiated and previously allocated TAC structure data; any old contents are preserved, including tacNr.
tacNr	Nr of additional concentration arrays (regional TACs) to allocate; if structure contains unused space for requested TACs already, then nothing is done.

Definition at line 178 of file tac.c.

  {
  if(tac==NULL) return TPCERROR_FAIL;
  if(tac->_sampleNr<1) return TPCERROR_FAIL;
  /* Check if there is enough space already */
  int newNr, addNr;
  newNr=tac->tacNr+tacNr;
  addNr=newNr-tac->_tacNr;
  //printf("newNr := %d\naddNr := %d\n", newNr, addNr);
  if(addNr<=0) return TPCERROR_OK;
 
  /* Reallocate memory for TACC data */
  TACC *taccPtr;
  taccPtr=realloc(tac->c, sizeof(TACC)*newNr);
  if(taccPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
  tac->c=taccPtr;
  /* Reallocate memory for double arrays */
  double *dPtr;
  dPtr=realloc(tac->_data, sizeof(double)*(4+newNr)*tac->_sampleNr);
  if(dPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
  tac->_data=dPtr;
  /* If both ok, then update the nr of allocated TACs and initiate new TTACs */ 
  for(int i=tac->_tacNr; i<newNr; i++) taccInit(&tac->c[i]);
  tac->_tacNr=newNr;
  
  /* Reset pointers for curve data */
  double *d=tac->_data;
  tac->x=d; d+=tac->_sampleNr;
  tac->x1=d; d+=tac->_sampleNr;
  tac->x2=d; d+=tac->_sampleNr;
  tac->w=d; d+=tac->_sampleNr;
  for(int i=0; i<tac->_tacNr; i++) {tac->c[i].y=d; d+=tac->_sampleNr;}
 
  /* Set new y values to NaN */
  for(int i=tac->_tacNr-addNr; i<tac->_tacNr; i++)
    for(int j=0; j<tac->_sampleNr; j++) tac->c[i].y[j]=nan("");
 
  return TPCERROR_OK;
}

Referenced by imgToSIF(), tacInterpolateInto(), tacReadReference(), and tacSetX().

tacAllocateMoreSamples()

int tacAllocateMoreSamples ( TAC * tac, int addNr )

extern

Allocate memory for more samples in TAC data.

Previous contents are not changed. _sampleNr is increased by nr_to_add, but sampleNr is not changed, and the contents of the new last frame(s) are empty (NaN).

See also

tacAllocateMore, tacAddZeroSample, tacDuplicate

Returns

Returns TPCERROR status (0 when successful).

Parameters

tac	Pointer to initiated and previously allocated TAC structure data; any old contents are preserved, including tacNr and sampleNr.
addNr	Nr of samples to add; if TAC structure contains unused space for requested samples already, then nothing is done.

Definition at line 435 of file tac.c.

  {
  if(addNr<1) return TPCERROR_OK;
  if(tac==NULL) return TPCERROR_FAIL;
  if(tac->_sampleNr<1 || tac->_tacNr<1) return TPCERROR_FAIL;
  
  /* Check if there is enough space already */
  int newNr;
  newNr=tac->sampleNr+addNr;
  addNr=newNr-tac->_sampleNr;
  if(addNr<=0) return TPCERROR_OK;
 
  /* Make a temporary copy of the original data */
  int ret;
  TAC temp; tacInit(&temp);
  ret=tacDuplicate(tac, &temp); if(ret!=TPCERROR_OK) return(ret);
  
  /* Delete and reallocate the original TAC */
  tacFree(tac);
  ret=tacAllocate(tac, newNr, temp.tacNr);
  if(ret!=TPCERROR_OK) {tacFree(&temp); return(ret);}
  tac->sampleNr=temp.sampleNr;
  tac->tacNr=temp.tacNr;
 
  /* Copy the contents */
  ret=tacCopyHdr(&temp, tac);
  if(ret!=TPCERROR_OK) {tacFree(&temp); return(ret);}
  for(int i=0, ret=0; i<temp.tacNr && ret==0; i++)
    ret=tacCopyTacc(&temp.c[i], &tac->c[i], temp.sampleNr);
  if(ret!=0) {tacFree(&temp); return TPCERROR_FAIL;}
  ret=tacXCopy(&temp, tac, 0, temp.sampleNr-1);
  if(ret!=0) {tacFree(&temp); return TPCERROR_FAIL;}
 
  tacFree(&temp); 
  return TPCERROR_OK;
}

Referenced by imgToSIF(), tacAddZeroSample(), tacFramesToSteps(), tacInput2sim(), tacSetXContiguous(), and tacToBars().

taccFree()

void taccFree ( TACC * tacc )

extern

Free memory allocated for TACC data. All contents are destroyed.

Precondition

Before first use initialize the TACC structure with taccInit().

See also

tacFree, taccInit, tacInit, tacAllocate

Author

Vesa Oikonen

Parameters

tacc	Pointer to TACC

Definition at line 68 of file tac.c.

  {
  // TACC does not actually contain mallocated or callocated memory,
  // therefore we can just clear the values
  taccInit(tacc);
}

Referenced by tacFree(), and tacFreeExceptHeader().

tacCheckX1X2X()

int tacCheckX1X2X ( TAC * d )

extern

Check that sample (time frame) x, x1, and x2 values are reasonably set when compared to each other in TAC structure.

See also

tacSortByTime, tacIsX, tacAddZeroSample, tacXCopy, tacSetX, tacXNaNs, tacGetSampleInterval, tacIsXContiguous

Author

Vesa Oikonen

Returns

Returns 1 if reasonable, 0 if not.

Parameters

d	Pointer to the TAC structure. TAC samples must be sorted. TAC isframe setting has no effect here.

Definition at line 621 of file tacx.c.

  {
  if(d==NULL || d->sampleNr<1) return(0);
  int i, n;
  double x1, x2, x, dx;
 
  for(i=n=0; i<d->sampleNr; i++) {
    x1=d->x1[i]; x2=d->x2[i]; dx=x2-x1; x=0.5*(x1+x2);
    /* if not similar, or both missing (NaN), that is considered as non-match */
    if(!doubleMatch(x, d->x[i], 0.15*dx)) {n++; break;}
    /* check that there is not much overlap with previous sample */
    if(i>0 && (x1+0.15*dx)<d->x2[i-1]) {n++; break;}
    /* check that there is not much gap on both sides */
    if(i>0 && i<d->sampleNr-1) {
      if(x1-0.15*dx>d->x2[i-1] && x2+0.15*dx<d->x1[i+1]) {n++; break;}
    }
  }
  if(n>0) return(0); else return(1);
}

Referenced by tacSetX().

taccInit()

void taccInit ( TACC * tacc )

extern

Initiate the TACC structure before any use.

See also

tacInit, taccFreeExceptHeader, tacInit

Author

Vesa Oikonen

Parameters

tacc	Pointer to TACC

Definition at line 48 of file tac.c.

  {
  if(tacc==NULL) return;
  tacc->type=TACTYPE_UNKNOWN;
  tacc->size=0.0;
  tacc->sunit=UNIT_UNKNOWN;
  tacc->y=NULL;
  tacc->sw=tacc->sw2=0;
  tacc->name[0]='\0';
}

Referenced by tacAllocate(), tacAllocateMore(), and taccFree().

tacCompareConc()

int tacCompareConc ( TAC * d1, TAC * d2, const int i, const double test_abs, const double test_rel, TPCSTATUS * status )

extern

Check whether TAC concentrations (y values) are the same in two TAC data. Note that units are ignored here.

If either absolute or relative difference is below the limit, the test is reported as passed.

See also

tacCompareUnit, tacCompareTimes.

Returns

0 in case of match, and >0 if no match or error.

Author

Vesa Oikonen

Parameters

d1	Pointer to TAC structure.
d2	Pointer to TAC structure.
i	TAC index [0..tacNr-1] to compare; enter <0 to verify all TACs.
test_abs	Limit for accepted absolute difference; obligatory.
test_rel	Optional limit for accepted relative difference |2*(x1-x2)/(x1+x2)| ; set to negative value to not test this; in case of zero mean, this test is assumed to fail, but test for absolute difference may still pass.
status	Pointer to status data; enter NULL if not needed.

Definition at line 122 of file taccomp.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>1) printf("%s()\n", __func__);
 
  /* Check that required data exists */
  if(d1==NULL || d2==NULL || d1->tacNr<1 || d2->tacNr<1
     || d1->sampleNr<1 || d2->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
  /* If index is specified, then verify that that TAC is available */
  if(i>=0 && (i>=d1->tacNr || i>=d2->tacNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 1;
  }
 
  /* If index is not specified, then tacNr must match */
  if(i<0 && (d1->tacNr!=d2->tacNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different TAC nr.\n");
    return(2);
  }
 
  /* Sample nr must match */
  if(d1->sampleNr!=d2->sampleNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different sample nr.\n");
    return(3);
  }
  
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  for(int ri=0; ri<d1->tacNr; ri++) if(i<0 || i==ri) {
    for(int fi=0; fi<d1->sampleNr; fi++) {
      if(doubleMatch(d1->c[ri].y[fi], d2->c[ri].y[fi], test_abs)==1)
        continue;
      if(test_rel>0.0 &&
         doubleMatchRel(d1->c[ri].y[fi], d2->c[ri].y[fi], test_rel)==1)
        continue;
      if(verbose>0) {
        double s;
        s=fabs(d1->c[ri].y[fi]-d2->c[ri].y[fi]);
        printf("tac1.c[%d].y[%d] := %g\n", ri, fi, d1->c[ri].y[fi]);
        printf("tac2.c[%d].y[%d] := %g\n", ri, fi, d2->c[ri].y[fi]);
        printf("|diff| := %g\n", s);
        printf("diff_limit := %g\n", test_abs);
        if(test_rel>0.0) printf("rel_diff_limit := %g\n", test_rel);
      }
      return(10);
    }
  }
  return(0);
}

tacCompareNames()

int tacCompareNames ( TAC * d1, TAC * d2, const int i, TPCSTATUS * status )

extern

Check whether TAC names are the same in two TAC data.

Comparison is very strict and even case-sensitive, thus TAC names may need to be preprocessed if this is used for other purpose than SW testing.

Returns

0 in case of match, 1 if no match or error.

Author

Vesa Oikonen

See also

tacSortByName, tacCompareUnit

Parameters

d1	Pointer to TAC structure.
d2	Pointer to TAC structure.
i	TAC index [0..tacNr-1] to compare; enter <0 to verify all TACs.
status	Pointer to status data; enter NULL if not needed.

Definition at line 67 of file taccomp.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>1) printf("%s()\n", __func__);
 
  /* Check that required data exists */
  if(d1==NULL || d2==NULL || d1->tacNr<1 || d2->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
  /* If index is specified, then verify that that TAC is available */
  if(i>=0 && (i>=d1->tacNr || i>=d2->tacNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 1;
  }
 
  /* If index is not specified, then tacNr must match */
  if(i<0 && (d1->tacNr!=d2->tacNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different TAC nr.\n");
    return(1);
  }
 
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  for(int ri=0; ri<d1->tacNr; ri++) if(i<0 || i==ri) {
    if(strcmp(d1->c[ri].name, d2->c[ri].name)!=0) {
      if(verbose>0) {
        printf("tac1.c[%d].name := '%s'\n", ri, d1->c[ri].name);
        printf("tac2.c[%d].name := '%s'\n", ri, d2->c[ri].name);
      }
      return(1);
    }
  }
  return(0);
}

tacCompareTimes()

int tacCompareTimes ( TAC * d1, TAC * d2, const double test_abs, const double test_rel, TPCSTATUS * status )

extern

Check whether TAC sample times (x values) are the same in two TAC data. Note that units are ignored here.

If either absolute or relative difference is below the limit, the test is reported as passed.

See also

tacCompareUnit, tacCompareConc, tacSortByTime, tacVerifyTimeOrder.

Returns

0 in case of match, and >0 if no match or error.

Author

Vesa Oikonen

Parameters

d1	Pointer to TAC structure.
d2	Pointer to TAC structure.
test_abs	Limit for accepted absolute difference.
test_rel	Optional limit for accepted relative difference |2*(x1-x2)/(x1+x2)| ; set to negative value to not test this; in case of zero mean, this test is assumed to fail, but test for absolute difference may still pass.
status	Pointer to status data; enter NULL if not needed.

Definition at line 201 of file taccomp.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>1) printf("%s()\n", __func__);
 
  /* Check that required data exists */
  if(d1==NULL || d2==NULL || d1->sampleNr<1 || d2->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
 
  /* X type must match */
  if(d1->isframe!=d2->isframe) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different sampling type.\n"); 
    return(2);
  }
  
  /* Sample nr must match */
  if(d1->sampleNr!=d2->sampleNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different sample nr.\n");
    return(3);
  }
  
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  for(int fi=0; fi<d1->sampleNr; fi++) {
    if(d1->isframe==0) {
      if(doubleMatch(d1->x[fi], d2->x[fi], test_abs)==1)
        continue;
      if(test_rel>0.0 && doubleMatchRel(d1->x[fi], d2->x[fi], test_rel)==1)
        continue;
      if(verbose>0) {
        double s;
        s=fabs(d1->x[fi]-d2->x[fi]);
        printf("tac1.x[%d] := %g\n", fi, d1->x[fi]);
        printf("tac2.x[%d] := %g\n", fi, d2->x[fi]);
        printf("|diff| := %g\n", s);
        printf("diff_limit := %g\n", test_abs);
        if(test_rel>0.0) printf("rel_diff_limit := %g\n", test_rel);
      }
      return(10);
    } else {
      if(doubleMatch(d1->x1[fi], d2->x1[fi], test_abs)==1 &&
         doubleMatch(d1->x2[fi], d2->x2[fi], test_abs)==1)
        continue;
      if(test_rel>0.0 &&
         doubleMatchRel(d1->x1[fi], d2->x1[fi], test_rel)==1 &&
         doubleMatchRel(d1->x2[fi], d2->x2[fi], test_rel)==1)
        continue;
      if(verbose>0) {
        printf("tac1.x1[%d] := %g\n", fi, d1->x1[fi]);
        printf("tac2.x1[%d] := %g\n", fi, d2->x1[fi]);
        printf("|diff| := %g\n", fabs(d1->x1[fi]-d2->x1[fi]));
        printf("tac1.x2[%d] := %g\n", fi, d1->x2[fi]);
        printf("tac2.x2[%d] := %g\n", fi, d2->x2[fi]);
        printf("|diff| := %g\n", fabs(d1->x2[fi]-d2->x2[fi]));
        printf("diff_limit := %g\n", test_abs);
        if(test_rel>0.0) printf("rel_diff_limit := %g\n", test_rel);
      }
      return(11);
    }
  }
  return(0);
}

tacCompareUnit()

int tacCompareUnit ( TAC * d1, TAC * d2, TPCSTATUS * status )

extern

Check whether time and concentration units are the same in two TAC data.

Returns

0 in case of match, 1 if y (concentration) unit is not matching, 2 if x (time) unit is not matching, and 3 if neither is matching.

See also

tacCompareConc, tacCompareTimes

Author

Vesa Oikonen

Parameters

d1	Pointer to TAC structure.
d2	Pointer to TAC structure.
status	Pointer to status data; enter NULL if not needed

Definition at line 27 of file taccomp.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>1) printf("%s()\n", __func__);
 
  /* Check that required data exists */
  if(d1==NULL || d2==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 3;
  }
 
  int ret=0;
  if(d1->cunit!=d2->cunit) ret+=1;
  if(d1->tunit!=d2->tunit) ret+=2;
  if(ret>0 && verbose>0) {
    printf("tac1.cunit := %s\n", unitName(d1->cunit));
    printf("tac2.cunit := %s\n", unitName(d2->cunit));
    printf("tac1.tunit := %s\n", unitName(d1->tunit));
    printf("tac2.tunit := %s\n", unitName(d2->tunit));
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(ret);
}

tacCompareWeights()

int tacCompareWeights ( TAC * d1, TAC * d2, const double test_abs, const double test_rel, TPCSTATUS * status )

extern

Check whether TAC weights are the same in two TAC data.

If either absolute or relative difference is below the limit, the test is reported as passed.

See also

tacCompareTimes, tacCompareConc, tacCompareNames.

Returns

0 in case of match, and >0 if no match or error.

Author

Vesa Oikonen

Parameters

d1	Pointer to TAC structure.
d2	Pointer to TAC structure.
test_abs	Limit for accepted absolute difference.
test_rel	Optional limit for accepted relative difference |2*(w1-w2)/(w1+w2)| ; set to negative value to not test this; in case of zero mean, this test is assumed to fail, but test for absolute difference may still pass.
status	Pointer to status data; enter NULL if not needed.

Definition at line 289 of file taccomp.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>1) printf("%s()\n", __func__);
 
  /* Check that required data exists */
  if(d1==NULL || d2==NULL || d1->sampleNr<1 || d2->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
 
  /* Weight setting must match */
  if(d1->weighting!=d2->weighting) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different weighting setting.\n"); 
    return(2);
  }
  
  /* If no weights, then no checking either */
  if(d1->weighting==WEIGHTING_OFF && d2->weighting==WEIGHTING_OFF) return(0);
  if(d1->weighting==WEIGHTING_UNKNOWN && d2->weighting==WEIGHTING_UNKNOWN) return(0);
  
  /* Sample nr must match */
  if(d1->sampleNr!=d2->sampleNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different sample nr.\n");
    return(3);
  }
  
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  for(int fi=0; fi<d1->sampleNr; fi++) {
    if(doubleMatch(d1->w[fi], d2->w[fi], test_abs)==1) continue;
    if(test_rel>0.0 && doubleMatchRel(d1->w[fi], d2->w[fi], test_rel)==1) continue;
    if(verbose>0) {
      double s;
      s=fabs(d1->w[fi]-d2->w[fi]);
      printf("tac1.w[%d] := %g\n", fi, d1->w[fi]);
      printf("tac2.w[%d] := %g\n", fi, d2->w[fi]);
      printf("|diff| := %g\n", s);
      printf("diff_limit := %g\n", test_abs);
      if(test_rel>0.0) printf("rel_diff_limit := %g\n", test_rel);
    }
    return(10);
  }
  return(0);
}

tacCopyHdr()

int tacCopyHdr ( TAC * tac1, TAC * tac2 )

extern

Copy TAC header data from tac1 to tac2.

Information regarding data size or weighting is not copied. IFT contents are copied if available. Previous IFT contents are deleted.

See also

tacCopyTacchdr, tacIsWeighted, tacWCopy

Returns

Returns TPCERROR status.

Parameters

tac1	Pointer to source TAC structure.
tac2	Pointer to target TAC structure.

Definition at line 310 of file tac.c.

  {
  /* Check that required data exists */
  if(tac1==NULL || tac2==NULL) return TPCERROR_FAIL;
  /* Copy TAC header fields */
  tac2->format=tac1->format;
  tac2->isframe=tac1->isframe;
  tac2->cunit=tac1->cunit;
  tac2->tunit=tac1->tunit;
  //tac2->weighting=tac1->weighting;
  /* Copy IFT */
  iftFree(&tac2->h); iftDuplicate(&tac1->h, &tac2->h);
  return TPCERROR_OK;
}

Referenced by tacAllocateMoreSamples(), tacDuplicate(), tacExtract(), tacExtractRange(), tacExtractSamples(), tacInterpolate(), tacInterpolateToEqualLengthFrames(), and tacMultipleSamples().

tacCopyTacc()

int tacCopyTacc ( TACC * d1, TACC * d2, int sampleNr )

extern

Copy TACC contents (y data and its header) from tacc1 to tacc2.

These may be inside different TAC structures, therefore sampleNr is needed.

See also

tacCopyTacchdr, tacCopyTaccdata, tacXCopy, tacWCopy, tacDuplicate, tacCopyHdr, tacAllocateMore, tacDeleteTACC, tacSwapTACCs

Returns

Returns TPCERROR status.

Parameters

d1	Pointer to source TACC structure.
d2	Pointer to target TACC structure.
sampleNr	Sample (frame) number.

Definition at line 233 of file tac.c.

  {
  int ret;
  
  /* Check that required data exists */
  if(d1==NULL || d2==NULL) return TPCERROR_FAIL;
  /* Copy TACC header */
  ret=tacCopyTacchdr(d1, d2); if(ret!=TPCERROR_OK) return ret;
  /* Copy TACC data */
  ret=tacCopyTaccdata(d1, d2, sampleNr); if(ret!=TPCERROR_OK) return ret;
  return TPCERROR_OK;
}

Referenced by tacAllocateMoreSamples(), tacDuplicate(), tacExtract(), and tacReadReference().

tacCopyTaccdata()

int tacCopyTaccdata ( TACC * d1, TACC * d2, int sampleNr )

extern

Copy TACC y data from tacc1 to tacc2.

These may be inside different TAC structures, therefore sampleNr is needed.

See also

tacCopyTacchdr, tacXCopy, tacWCopy

Returns

Returns TPCERROR status.

Parameters

d1	Pointer to source TACC structure.
d2	Pointer to target TACC structure.
sampleNr	Sample (frame) nr.

Definition at line 260 of file tac.c.

  {
  /* Check that required data exists */
  if(d1==NULL || d2==NULL) return TPCERROR_FAIL;
  if(sampleNr<1) return TPCERROR_OK;
  /* Copy data array contents */
  for(int i=0; i<sampleNr; i++) d2->y[i]=d1->y[i];
  return TPCERROR_OK;
}

Referenced by tacCopyTacc().

tacCopyTacchdr()

int tacCopyTacchdr ( TACC * d1, TACC * d2 )

extern

Copy TACC header data from tacc1 to tacc2.

See also

tacCopyHdr, tacCopyTaccdata, tacCopyTacc

Returns

Returns TPCERROR status.

Parameters

d1	Pointer to source TACVOI structure.
d2	Pointer to target TACVOI structure.

Definition at line 282 of file tac.c.

  {
  /* Check that required data exists */
  if(d1==NULL || d2==NULL) return TPCERROR_FAIL;
  /* Copy TACC header fields */
  d2->type=d1->type;
  d2->size=d1->size;
  d2->sunit=d1->sunit;
  d2->sw=d1->sw;
  d2->sw2=d1->sw2;
  strcpy(d2->name, d1->name);
  return TPCERROR_OK;
}

Referenced by tacCopyTacc(), tacExtractRange(), tacExtractSamples(), tacInterpolate(), tacInterpolateInto(), tacInterpolateToEqualLengthFrames(), and tacMultipleSamples().

tacCorrectFrameOverlap()

int tacCorrectFrameOverlap ( TAC * d, TPCSTATUS * status )

extern

Correct PET frame start and end times if frames are slightly overlapping or have small gaps in between.

Large gap is not corrected and it does not lead to an error. If TAC file does not contain frame start and end times, but just mid time point, then this function does nothing but check that samples are in correct order. Data must be sorted for increasing sample time before calling this function, otherwise an error is returned.

See also

tacIsX, tacXRange, tacVerifyTimeOrder, tacSortByTime, tacXCopy, tacMultipleSamples, tacFramesToSteps

Returns

If overlap is considerable (>20%), or another error is encountered, function returns a non-zero enum tpcerror value. Otherwise 0 (TPCERROR_OK) is returned.

Author

Vesa Oikonen

Test

Add tests.

Parameters

d	Pointer to TAC data which is sorted by increasing sample time.
status	Pointer to status data; enter NULL if not needed.

Definition at line 65 of file tacx.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(d==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  /* If no frame start and end times, then just check the order */
  if(d->isframe==0) {
    if(tacVerifyTimeOrder(d, status)) {
      if(verbose>0) fprintf(stderr, "Error: sample times are not in order.\n");
      return(status->error);
    }
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
  /* Check each frame */  
  double overlap, flen1, flen2, overlap_limit=0.0;
  for(int fi=0; fi<d->sampleNr-1; fi++) {
    overlap=d->x2[fi]-d->x1[fi+1];
    if(overlap==0.0) continue; // no gap or overlap
    /* Calculate the frame length of current frame and the next frame */
    flen1=d->x2[fi]-d->x1[fi]; flen2=d->x2[fi+1]-d->x1[fi+1];
    if(flen1<0.0 || flen2<0.0) return(1);
    /* Set the limit */
    if(flen1<flen2) overlap_limit=0.2*flen1; else overlap_limit=0.2*flen2;
    /* Check if gap or overlap is too large to be fixed automatically */
    if(overlap<-overlap_limit) continue; // gap is too large, then do nothing
    if(overlap>overlap_limit) { // overlap is too large: error
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OVERLAPPING_DATA);
      return(TPCERROR_OVERLAPPING_DATA);
    }
    /* Correct the small gap/overlap by making frame durations more similar */
    if(overlap>0.0) { // overlap
      if(flen1>flen2) d->x2[fi]=d->x1[fi+1]; else d->x1[fi+1]=d->x2[fi];
    } else { // gap
      if(flen1>flen2) d->x1[fi+1]=d->x2[fi]; else d->x2[fi]=d->x1[fi+1];
    }
  }
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

Referenced by tacReadModelingData().

tacDecayCorrection()

int tacDecayCorrection ( TAC * tac, int isotope, int mode, TPCSTATUS * status )

extern

Correct TAC data for physical decay, or remove the decay correction. Sample weights, if available, are modified, too.

See also

tacGetHeaderDecayCorrection, tacGetIsotope, tacGetHeaderIsotope, decayCorrectionFactorFromIsotope, tacDelay

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC structure; status of decay correction in TAC is not verified, but set in this function. TAC must contain valid sample time unit.
isotope	Isotope code.
mode	0=Remove decay correction; 1=Correct for decay.
status	Pointer to status data; enter NULL if not needed.

Definition at line 59 of file tacdc.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* check that data exists */
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  /* check time unit */
  if(!unitIsTime(tac->tunit)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNKNOWN_UNIT);
    return TPCERROR_UNKNOWN_UNIT;
  }
  /* check isotope and get halflife */
  double f, lambda, halflife=isotopeHalflife(isotope); // halflife in min
  if(isotope==ISOTOPE_UNKNOWN || isnan(halflife)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNKNOWN_ISOTOPE);
    return TPCERROR_UNKNOWN_ISOTOPE;
  }  
  /* convert halflife to the same unit that the TAC data has */
  f=unitConversionFactor(UNIT_MIN, tac->tunit);
  if(!isnan(f)) halflife*=f;
  /* calculate the lambda */
  lambda=lambdaFromHalflife(halflife);
  if(mode==0) lambda=-lambda;
  if(verbose>2) {
    printf("halflife := %g\n", halflife);
    printf("lambda := %g\n", lambda);
  }
 
 
  /*
   *  Decay correction / removal
   */
  if(verbose>2) {
    if(mode!=0) printf("decay correction\n"); else printf("removing decay correction\n");
    fflush(stdout);
  }
  for(int i=0; i<tac->sampleNr; i++) {
    /* Calculate decay correction factor */
    if(tac->isframe) {
      if(isnan(tac->x1[i]) || isnan(tac->x2[i])) continue;
      f=decayCorrectionFactorFromLambda(lambda, tac->x1[i], tac->x2[i]-tac->x1[i]);
    } else {
      if(isnan(tac->x[i])) continue;
      f=decayCorrectionFactorFromLambda(lambda, tac->x[i], 0.0);
    }
    if(verbose>6) printf("  %10.4f  ->  %e\n", tac->x[i], f);
    /* Correct all TACs */
    for(int j=0; j<tac->tacNr; j++) tac->c[j].y[i]*=f;
    /* Opposite correction for weights, if available */
    if(tac->weighting==WEIGHTING_ON_GENERAL || tac->weighting==WEIGHTING_ON_COUNTS ||
       tac->weighting==WEIGHTING_ON_FD)
      tac->w[i]/=f;
  }
  if(tacIsWeighted(tac)) tacWeightNorm(tac, NULL);
  if(mode==0) tacSetHeaderDecayCorrection(&tac->h, DECAY_NOTCORRECTED);
  else tacSetHeaderDecayCorrection(&tac->h, DECAY_CORRECTED);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
} 

Referenced by tacSetWeights().

tacDefaultExtension()

char * tacDefaultExtension ( tacformat c )

extern

Return pointer to default TAC filename extension, including the dot, based on the TAC format code.

Returns

pointer to the filename extension string.

See also

tpcformat, tacFormattxt, tacFormatWriteSupported

Author

Vesa Oikonen

Parameters

c	TAC format code.

Definition at line 144 of file tacio.c.

  {
  if(c<TAC_FORMAT_UNKNOWN || c>=TAC_FORMAT_LAST) return NULL;
  return (char*)tac_fn_ext[c];
}

tacDeleteMissingSamples()

int tacDeleteMissingSamples ( TAC * d )

extern

Delete those samples (time frames) from TAC structure, which contain only missing y values, and/or x is NaN.

See also

tacDeleteSample, tacExtractRange, tacIsX, tacXNaNs, tacFixNaNs, tacIsXContiguous

Returns

Returns TPCERROR status (0 if ok).

Parameters

d	Pointer to the TAC structure.

Definition at line 450 of file tacx.c.

  {
  if(d==NULL) return TPCERROR_FAIL;
  int fi, ri, n, delthat=0;
  fi=d->sampleNr-1;
  while(fi>=0) {
    delthat=0;
    /* check the x value(s) for this sample */
    if(d->isframe) {
      if(!isfinite(d->x1[fi]) || !isfinite(d->x2[fi])) delthat=1;
    } else {
      if(!isfinite(d->x[fi])) delthat=1;
    }
    /* check the y value(s) for this sample */
    for(ri=n=0; ri<d->tacNr; ri++) if(isfinite(d->c[ri].y[fi])) n++;
    if(n==0) delthat=1;
    if(delthat!=0) {
      /* delete sample */
      tacDeleteSample(d, fi);
    }
    /* go to previous sample */
    fi--;
  }
  return TPCERROR_OK;
}

Referenced by tacMultipleSamples().

tacDeleteSample()

int tacDeleteSample ( TAC * d, int i )

extern

Delete a certain sample (time frame) from TAC structure.

See also

tacAllocateMoreSamples, tacExtractRange, tacDeleteMissingSamples, tacMultipleSamples

Author

Vesa Oikonen

Returns

Returns TPCERROR status (0 if ok).

Parameters

d	Pointer to the TAC structure.
i	Index of the sample to delete, [0..sampleNr-1].

Definition at line 426 of file tacx.c.

  {
  if(d==NULL || i<0 || i>=d->sampleNr) return TPCERROR_FAIL;
  int fi, ri;
  for(fi=i+1; fi<d->sampleNr; fi++) {
    d->x[fi-1]=d->x[fi]; d->x1[fi-1]=d->x1[fi]; d->x2[fi-1]=d->x2[fi];
    for(ri=0; ri<d->tacNr; ri++) d->c[ri].y[fi-1]=d->c[ri].y[fi];
    d->w[fi-1]=d->w[fi];
  }
  d->sampleNr--;
  return TPCERROR_OK;
}

Referenced by tacDeleteMissingSamples(), and tacMultipleSamples().

tacDeleteTACC()

int tacDeleteTACC ( TAC * d, int i )

extern

Delete specified TACC inside TAC structure, moving the positions of other TACCs accordingly.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSwapTACCs, tacMoveTACC

Parameters

d	Pointer to TAC data. Main header is not changed, but tacNr is decreased.
i	TACC index [0..tacNr-1].

Definition at line 310 of file tacorder.c.

  {
  /* Check that region exists */
  if(d==NULL || i<0 || i>=d->tacNr) return(TPCERROR_FAIL);
  /* If the last TACC is to be deleted, then just decrease the tacNr */
  if(i==d->tacNr-1) {d->tacNr--; return(TPCERROR_OK);}
  /* Otherwise move it to the last position, and then decrease tacNr */
  if(tacMoveTACC(d, i, d->tacNr-1)!=TPCERROR_OK) return(TPCERROR_FAIL);
  d->tacNr--;
  return(TPCERROR_OK);
}

Referenced by tacReadReference(), and tacWMove().

tacDuplicate()

int tacDuplicate ( TAC * tac1, TAC * tac2 )

extern

Make a duplicate of TAC structure.

In the duplicate, space is allocated only for the tacNr and sampleNr specified in the original TAC.

See also

tacExtract, tacAllocate, tacCopyHdr, tacCopyTacc, tacXCopy, tacDeleteTACC

Returns

Returns TPCERROR status (0 when successful).

Parameters

tac1	Pointer to the source TAC.
tac2	Pointer to the target TAC; must be initiated; any old contents are deleted.

Definition at line 356 of file tac.c.

  {
  if(tac1==NULL || tac2==NULL) return TPCERROR_FAIL;
  if(tac1->sampleNr<1 || tac1->tacNr<1) return TPCERROR_FAIL;
 
  /* Empty the duplicate */
  tacFree(tac2);
 
  int ret;
 
  /* Allocate memory for tac2 */
  ret=tacAllocate(tac2, tac1->sampleNr, tac1->tacNr);
  if(ret!=TPCERROR_OK) return(ret);
  tac2->sampleNr=tac1->sampleNr;
  tac2->tacNr=tac1->tacNr;
 
  /* Copy the contents */
  ret=tacCopyHdr(tac1, tac2);
  if(ret!=TPCERROR_OK) return(ret);
  for(int i=0, ret=0; i<tac1->tacNr && ret==0; i++)
    ret=tacCopyTacc(&tac1->c[i], &tac2->c[i], tac1->sampleNr);
  if(ret!=0) return TPCERROR_FAIL;
  ret=tacXCopy(tac1, tac2, 0, tac1->sampleNr-1);
  if(ret!=0) return TPCERROR_FAIL;
  ret=tacWCopy(tac1, tac2, 0, tac1->sampleNr-1);
  if(ret!=0) return TPCERROR_FAIL;
  
  return TPCERROR_OK;
}

Referenced by mtacAddTAC(), tacAllocateMoreSamples(), tacDelayFit(), tacExtractRange(), tacExtractSamples(), tacFramesToSteps(), tacInput2sim(), tacIntegrate(), tacIntegrateFE(), tacMultipleSamples(), tacReadReference(), tacSetX(), tacSetXContiguous(), and tacToBars().

tacEnsureNames()

void tacEnsureNames ( TAC * tac )

extern

Ensure that TAC structure contains a name for each TAC. If not available, then TAC index+1 is written as name.

See also

tacIndividualNames, tacSelectTACs, tacSelectBestReference, roinameMatch

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC structure.

Definition at line 50 of file tacname.c.

  {
  if(tac==NULL || tac->tacNr<1) return;
  int ri, u, n;
  u=tac->tacNr; n=1; while((u/=10)>=1) n++;
  if(n>MAX_TACNAME_LEN) n=MAX_TACNAME_LEN;
  for(ri=0; ri<tac->tacNr; ri++) {
    if(!roinameExists(tac->c[ri].name))
      sprintf(tac->c[ri].name, "%0*d", n, 1+ri);
  }
  return;
}

Referenced by tacWriteCSV(), tacWriteDFT(), tacWritePMOD(), tacWriteSheetIntoXML(), and tacWriteXML().

tacExtract()

int tacExtract ( TAC * d1, TAC * d2, const int i )

extern

Extract the specified TAC from existing TAC structure into a new TAC.

See also

tacDuplicate, tacDeleteTACC, tacCopyTacc, tacExtractSamples

Returns

Returns TPCERROR status (0 if ok).

Parameters

d1	Pointer to the source TAC structure. Not modified.
d2	Pointer to the target TAC structure; any previous contents are deleted.

See also

tacInit, tacFree

Parameters

i	Index of the TAC to extract [0..tacNr-1].

Definition at line 396 of file tac.c.

  {
  if(d1==NULL || d2==NULL) return TPCERROR_FAIL;
  if(d1->sampleNr<1 || d1->tacNr<1) return TPCERROR_NO_DATA;
  if(i<0 || i>=d1->tacNr) return TPCERROR_INVALID_VALUE;
 
  /* Remove any old contents in target structure */
  tacFree(d2);
 
  /* Allocate space for the new TAC */
  int ret=tacAllocate(d2, d1->sampleNr, 1); if(ret!=TPCERROR_OK) return(ret);
  d2->sampleNr=d1->sampleNr;
  d2->tacNr=1;
 
  /* Copy contents */
  ret=tacCopyHdr(d1, d2); if(ret!=TPCERROR_OK) {tacFree(d2); return(ret);}
  ret=tacXCopy(d1, d2, 0, d1->sampleNr-1); if(ret!=TPCERROR_OK) {tacFree(d2); return(ret);}
  ret=tacCopyTacc(d1->c+i, d2->c, d1->sampleNr); if(ret!=TPCERROR_OK) {tacFree(d2); return(ret);}
  ret=tacWCopy(d1, d2, 0, d1->sampleNr-1); if(ret!=TPCERROR_OK) {tacFree(d2); return(ret);}
 
  return(TPCERROR_OK);
}

tacExtractRange()

int tacExtractRange ( TAC * d1, TAC * d2, double startT, double endT )

extern

Extract the specified time (x) range from TAC structure.

See also

tacDeleteSample, tacDeleteMissingSamples, tacExtractSamples, tacCheckX1X2X, tacGetSampleInterval

Author

Vesa Oikonen

Returns

Returns TPCERROR status (0 if ok).

Parameters

d1	Pointer to the source TAC structure. Data must be sorted by ascending x.
d2	Pointer to the target TAC structure; any previous contents are deleted. The source TAC pointer can be given for in-place extraction.

See also

tacInit, tacFree

Parameters

startT	Start time of data that is preserved (in same units as in TAC)
endT	End time of data that is preserved (in same units as in TAC)

Definition at line 486 of file tacx.c.

  {
  if(d1==NULL || d2==NULL) return TPCERROR_FAIL;
  if(d1->sampleNr<1) return TPCERROR_NO_DATA;
  if(endT<startT) return TPCERROR_INVALID_VALUE;
 
  /* Duplicate source TAC, in case target points to the same data */
  TAC tac; tacInit(&tac); if(tacDuplicate(d1, &tac)!=TPCERROR_OK) return TPCERROR_FAIL;
 
  /* Remove any old contents in target structure */
  tacFree(d2);
 
  /* Get the range of TAC frame middle times */
  double beg, end;
  if(tac.isframe) {
    beg=0.5*(tac.x1[0]+tac.x2[0]); 
    end=0.5*(tac.x1[tac.sampleNr-1]+tac.x2[tac.sampleNr-1]); 
  } else {
    beg=tac.x[0]; end=tac.x[tac.sampleNr-1];
  }
  
  /* Check whether required range is outside the TAC range */
  if(startT>=end || endT<beg) {tacFree(&tac); return TPCERROR_NO_DATA;}
 
  /* If the whole TAC is inside required range, then just copy it */
  if(startT<=beg && endT>=end) {
    int ret=tacDuplicate(&tac, d2);
    tacFree(&tac); return(ret);
  }
  
  /* Count how many samples are inside the required range */
  /* And get the first and last sample indices */
  int i, n=0, i1=-1, i2=-1;
  double x;
  for(i=0; i<tac.sampleNr; i++) {
    if(tac.isframe) x=0.5*(tac.x1[i]+tac.x2[i]); else x=tac.x[i];
    if(x<startT) continue;
    if(x>endT) break;
    i2=i; if(i1<0) i1=i;
    n++;
  }
  if(n==0 || i1<0 || i2<i1) {tacFree(&tac); return TPCERROR_NO_DATA;}
  
  /* Allocate memory for the data to be extracted */
  int ret;
  ret=tacAllocate(d2, n, tac.tacNr); if(ret!=TPCERROR_OK) {tacFree(&tac); return(ret);}
  d2->sampleNr=n;
  d2->tacNr=tac.tacNr;
 
  /* Copy the contents */
  ret=tacCopyHdr(&tac, d2); if(ret!=TPCERROR_OK) {tacFree(&tac); return(ret);}
  for(int j=0, ret=0; j<tac.tacNr && ret==0; j++)
    ret=tacCopyTacchdr(&tac.c[j], &d2->c[j]);
  if(ret!=TPCERROR_OK) {tacFree(&tac); return(ret);}
  d2->isframe=tac.isframe;
  d2->weighting=tac.weighting;
  for(i=i1, n=0; i<=i2 && n<d2->sampleNr; i++, n++) {
    d2->x[n]=tac.x[i]; d2->x1[n]=tac.x1[i]; d2->x2[n]=tac.x2[i];
    d2->w[n]=tac.w[i];
    for(int j=0; j<tac.tacNr; j++) d2->c[j].y[n]=tac.c[j].y[i];
  }
  tacFree(&tac);
  return TPCERROR_OK;
}

tacExtractSamples()

int tacExtractSamples ( TAC * d1, TAC * d2, int si, int ei )

extern

Extract the specified sample range from TAC structure.

See also

tacExtractRange, tacDeleteSample, tacDeleteMissingSamples, tacInit, tacFree

Author

Vesa Oikonen

Returns

Returns TPCERROR status (0 if ok).

Parameters

d1	Pointer to the source TAC structure. Data must be sorted by ascending x.
d2	Pointer to the target TAC structure; any previous contents are deleted.
si	Index of first sample to extract.
ei	Index of last sample to extract.

Definition at line 568 of file tacx.c.

  {
  if(d1==NULL || d2==NULL) return TPCERROR_FAIL;
  if(d1->sampleNr<1) return TPCERROR_NO_DATA;
  if(si<0 || ei<si || si>d1->sampleNr-1) return TPCERROR_INVALID_VALUE;
  if(ei>d1->sampleNr-1) ei=d1->sampleNr-1;
 
  /* Remove any old contents in target struct */
  tacFree(d2);
 
  /* If the whole TAC is inside required range, then just copy it */
  if(si==0 && ei==d1->sampleNr-1) return(tacDuplicate(d1, d2));
  
  /* Count how many samples are inside the required range */
  int n=1+ei-si; if(n==0) return TPCERROR_NO_DATA;
  
  /* Allocate memory for the data to be extracted */
  int ret=tacAllocate(d2, n, d1->tacNr); if(ret!=TPCERROR_OK) return(ret);
  d2->sampleNr=n;
  d2->tacNr=d1->tacNr;
 
  /* Copy the contents */
  ret=tacCopyHdr(d1, d2); if(ret!=TPCERROR_OK) return(ret);
  for(int j=0, ret=0; j<d1->tacNr && ret==0; j++) ret=tacCopyTacchdr(&d1->c[j], &d2->c[j]);
  if(ret!=TPCERROR_OK) return(ret);
  d2->isframe=d1->isframe;
  d2->weighting=d1->weighting;
  for(int i=si, n=0; i<=ei && n<d2->sampleNr; i++, n++) {
    d2->x[n]=d1->x[i]; d2->x1[n]=d1->x1[i]; d2->x2[n]=d1->x2[i];
    d2->w[n]=d1->w[i];
    for(int j=0; j<d1->tacNr; j++) d2->c[j].y[n]=d1->c[j].y[i];
  }
 
  return TPCERROR_OK;
}

tacFirstSelected()

int tacFirstSelected ( TAC * d )

extern

Get the index of first selected TAC (sw!=0) in TAC structure.

Returns

the index of first selected TACs, or <0 if not found.

See also

tacSelectedTACs, tacSelectTACs, tacSelectBestReference

Parameters

d	Pointer to TAC data.

Definition at line 122 of file tacselect.c.

  {
  if(d==NULL || d->tacNr<1) return(-1);
  for(int i=0; i<d->tacNr; i++) if(d->c[i].sw!=0) return(i);
  return(-1);
}

tacFixNaNs()

int tacFixNaNs ( TAC * tac )

extern

Fix missing y values in TAC structure by interpolation. X values cannot be fixed. Extrapolation of the last missing values is not possible, but beginning can be estimated assuming first point (0,0).

See also

tacXNaNs, tacYNaNs, tacNotNaNs, tacDeleteMissingSamples

Returns

Returns 0 if missing values could be filled with reasonable values.

Parameters

tac	Pointer to TAC structure.

Definition at line 121 of file tacnan.c.

  {
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1) return(1);
  if(tacXNaNs(tac)>0) return(2);
 
  int ri, fi, fj;
  double x1, x2, y1, y2, x, y;
  /* If NaNs with negative sample times, then set value to zero */
  for(fi=0; fi<tac->sampleNr; fi++) {
    if(tac->isframe) x=0.5*(tac->x1[fi]+tac->x2[fi]); else x=tac->x[fi];
    if(x>0.0) continue; 
    for(ri=0; ri<tac->tacNr; ri++) 
      if(!isfinite(tac->c[ri].y[fi])) tac->c[ri].y[fi]=0.0;
  }
  /* Go through the data, finding previous and next good value */
  for(ri=0; ri<tac->tacNr; ri++) if(tacYNaNs(tac, ri)>0) {
    x1=x2=y1=y2=nan("");
    for(fi=0; fi<tac->sampleNr; fi++) {
      if(tac->isframe) x=0.5*(tac->x1[fi]+tac->x2[fi]); else x=tac->x[fi];
      /* Save previous good point */
      if(isfinite(tac->c[ri].y[fi])) {y1=tac->c[ri].y[fi]; x1=x; continue;}
      /* We have missing value if we are here */
      /* Search for the next good point after this NaN */
      x2=y2=nan("");
      for(fj=fi+1; fj<tac->sampleNr; fj++) {
        if(!isfinite(tac->c[ri].y[fj])) continue;
        if(tac->isframe) x2=0.5*(tac->x1[fj]+tac->x2[fj]); else x2=tac->x[fj];
        y2=tac->c[ri].y[fj];
        break;
      }
      /* If no good points after current point, then that is bad */
      if(!isfinite(x2)) return(3);
      /* If the point before is not available, then use (0,0) */
      if(!isfinite(x1)) x1=y1=0.0;
      /* Now, interpolate value for current point */
      if(x2==x1) y=0.5*(y1+y2); else y=y2-(x2-x)*(y2-y1)/(x2-x1);
      tac->c[ri].y[fi]=y;
    } // next sample
  } // next TAC
  
  return(0);
}

tacFormatDetermine()

int tacFormatDetermine ( const char * fname, TPCSTATUS * status )

extern

Determine the format of TAC file.

Note

Not all formats are identified, and identification does not mean that reading the format would be supported.

Returns

the format number, or TAC_FORMAT_UNKNOWN if not identified or in case of an error.

Author

Vesa Oikonen

See also

tacDefaultExtension, tacFormatIdentify, tacFormatWriteSupported

Parameters

fname	Pointer to the file name; this string is not modified.
status	Pointer to status data; enter NULL if not needed

Definition at line 161 of file tacio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
 
  if(fname==NULL || strlen(fname)<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TAC_FORMAT_UNKNOWN;
  }
  if(verbose>1) {printf("%s(%s)\n", __func__, fname); fflush(stdout);}
  int format=TAC_FORMAT_UNKNOWN;
 
  /* Open file; note that 'b' is required for fgetpos() and fsetpos() to work correctly */
  FILE *fp;
  fp=fopen(fname, "rb");
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_OPEN);
    return format;
  }
 
  /* Binary data? */
  int ret;
  size_t fsize=asciiFileSize(fp, &ret);
  if(verbose>3) {printf("  fsize := %zu\n", fsize); fflush(stdout);}
  if(fsize<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    fclose(fp); return format;
  }
  if(ret==1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    fclose(fp); return TAC_FORMAT_BINARY;
  }
 
  /* Read file to a string */
  char *data;
  data=asciiFileRead(fp, NULL, fsize+1); rewind(fp);
  if(data==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    fclose(fp); return format;
  }
  /* Check if one of Inveon formats */
  if(strncasecmp(data, "#Subject ID,Subject Weight,Subject Sex,Unique Series ID,Series Date,Series Description", 20)==0 ||
     strncasecmp(data, "#Subject ID;Subject Weight;Subject Sex;Unique Series ID;Series Date;Series Description", 20)==0) {
    format=TAC_FORMAT_INVEON;
  }
 
  /* Read the first non-comment line */
  int i=0, j;
  char *cptr, *line=NULL;
  cptr=data;
  while((line=strTokenDup(cptr, "\n\r", &j))!=NULL) {
    if(!asciiCommentLine(line, NULL) && strlen(line)>1) break;
    free(line); cptr+=j; i++;
  }
  free(data);
  if(line==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    fclose(fp); return format;
  }
 
  /* Check for identification strings */
  if(verbose>1) {printf("  checking for magic number\n"); fflush(stdout);}
  if(strncasecmp(line, "DFT", 3)==0) {
    format=TAC_FORMAT_DFT;
  } else if(strncasecmp(line, "cpt", 3)==0) {
    format=TAC_FORMAT_NCI;
  } else if(strcmp(line, "directory,file name,num,slice,mean,sd,cov,max,min,pixel,total,group")==0) {
    format=TAC_FORMAT_QVIEW;
  } else if(strncmp(line, "PatientName,", 12)==0) {
    format=TAC_FORMAT_4DM;
  } else if(strstr(line, " - Time")!=NULL && strstr(line, "(upper bound)")!=NULL &&
            strstr(line, "(lower bound)")!=NULL && strstr(line, "(standard deviation)")!=NULL) {
    format=TAC_FORMAT_INVEON;
  }
  free(line);
  if(format!=TAC_FORMAT_UNKNOWN) {
    if(verbose>0) {printf("  identified as %s file\n", tacFormattxt(format)); fflush(stdout);}
    fclose(fp); return format;
  }
 
  /* Identify certain file name extensions */
  if(verbose>1) {printf("  checking file name extension\n"); fflush(stdout);}
  cptr=strrchr(fname, '.'); if(cptr!=NULL) cptr++;
  if(verbose>1 && cptr!=NULL) printf("  extension := %s\n", cptr);
  if(strcasecmp(cptr, "IDWC")==0 || strcasecmp(cptr, "IDW")==0) {
    format=TAC_FORMAT_IDWC;
  } else if(strcasecmp(cptr, "IF")==0) {
    format=TAC_FORMAT_IF;
  } else if(strcasecmp(cptr, "XML")==0) {
    format=TAC_FORMAT_XML;
  } else if(strcasecmp(cptr, "SIF")==0) {
    format=TAC_FORMAT_SIF;
  } else if(strcasecmp(cptr, "LIS")==0) {
    format=TAC_FORMAT_ABSS_SCANDITRONICS;
  } else if(strcasecmp(cptr, "ALG")==0) {
    format=TAC_FORMAT_ABSS_ALLOGG_OLD;
  } 
  if(format!=TAC_FORMAT_UNKNOWN) {
    if(verbose>0) {printf("  identified as %s file\n", tacFormattxt(format)); fflush(stdout);}
    fclose(fp); return format;
  }
 
#if(0)
  /* Try to read as CSV (or TSV) file */
  int ret;
  FILE *fp;
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_OPEN);
    return TPCERROR_CANNOT_OPEN;
  }
  CSV csv; csvInit(&csv);
  ret=csvRead(&csv, fp, status);
  
#endif
 
 
  fclose(fp);
  if(verbose>0) {printf("  format not identified\n"); fflush(stdout);}
  return format; 
}

tacFormatIdentify()

int tacFormatIdentify ( const char * s )

extern

Identify the string representation of the TAC file format.

Returns

enum tacformat, or 0 (enum TAC_FORMAT_UNKNOWN) if not identified.

Author

Vesa Oikonen

See also

tpcformat, tacFormattxt, tacDefaultExtension

Parameters

s	TAC format as a string.

Definition at line 113 of file tacio.c.

  {
  if(s==NULL || strlen(s)<1) return TAC_FORMAT_UNKNOWN;
  /* Try if string can be found directly in the table */
  for(int i=0; i<TAC_FORMAT_LAST; i++) {
    if(strcasecmp(tac_format[i], s)==0) return i;
  }
  /* Format string is not following TPC standard, lets try something else */
  if(     strcasecmp(s, "dat")==0)              return TAC_FORMAT_TSV_UK;
  else if(strcasecmp(s, "txt")==0)              return TAC_FORMAT_TSV_UK;
  else if(strcasecmp(s, "tac")==0)              return TAC_FORMAT_PMOD;
  else if(strcasecmp(s, "bld")==0)              return TAC_FORMAT_PMOD;
  else if(strcasecmp(s, "htm")==0)              return TAC_FORMAT_HTML;
  else if(strcasecmp(s, "csv")==0)              return TAC_FORMAT_CSV_UK;
  else if(strcasecmp(s, "tsv")==0)              return TAC_FORMAT_TSV_UK;
  else if(strcasecmp(s, "lis")==0)              return TAC_FORMAT_ABSS_SCANDITRONICS;
  else if(strcasecmp(s, "alg")==0)              return TAC_FORMAT_ABSS_ALLOGG_OLD;
 
  return TAC_FORMAT_UNKNOWN;
}

tacFormattxt()

char * tacFormattxt ( tacformat c )

extern

Return pointer to TAC file format description with the format code.

Returns

pointer to the TAC file format string.

See also

tpcformat, tacFormatIdentify, tacDefaultExtension

Author

Vesa Oikonen

Parameters

c	TAC format code.

Definition at line 98 of file tacio.c.

  {
  if(c<TAC_FORMAT_UNKNOWN || c>=TAC_FORMAT_LAST) return NULL;
  return (char*)tac_format[c];
}

Referenced by tacFormatDetermine(), tacRead(), and tacWrite().

tacFormatWriteSupported()

int tacFormatWriteSupported ( tacformat format )

extern

Check whether writing of specified TAC format is supported.

Returns

1 if supported, 0 if not.

See also

tacWrite, tacFormatDetermine, tacRead

Parameters

format

File format code, for example TAC->format.

Definition at line 291 of file tacio.c.

  {
  int ret=0;
  switch(format) {
    case TAC_FORMAT_SIMPLE:
      ret=1;
      break;
    case TAC_FORMAT_DFT:
      ret=1;
      break;
    case TAC_FORMAT_PMOD:
      ret=1;
      break;
    case TAC_FORMAT_CSV_INT:
    case TAC_FORMAT_CSV_UK:
    case TAC_FORMAT_TSV_INT:
    case TAC_FORMAT_TSV_UK:
      ret=1;
      break;
    case TAC_FORMAT_SIF:
      ret=1;
      break;
    case TAC_FORMAT_XML:
      ret=1;
      break;
    default:
      ret=0;
  }
  return(ret);
}

tacFramesToSteps()

int tacFramesToSteps ( TAC * inp, TAC * out, TPCSTATUS * status )

extern

Transform TAC with frames into TAC with frames represented with stepwise changing dot-to-dot data.

See also

tacInterpolate, tacToBars, tacAUC, tacDelay, tacInterpolateToEqualLengthFrames, liInterpolate

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

inp	Pointer to source TAC structure.

Precondition

Data must be sorted by increasing x. There must be no gaps or overlap between frames.

See also

tacSortByTime, tacSetXContiguous

Parameters

out	Pointer to the initiated target TAC structure; any previous contents are deleted.
status	Pointer to status data; enter NULL if not needed.

Definition at line 942 of file tacx.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(inp==NULL || out==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  /* Check the function input */
  if(inp->sampleNr<1 || inp->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Check that input does not have any missing values */
  if(tacNaNs(inp)>0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_MISSING_DATA);
    return TPCERROR_MISSING_DATA;
  }
 
  /* Check that there are no gaps or overlap between frames */
  {
    //printf("  checking that there are no gaps or overlap\n"); fflush(stdout);
    int ret=tacIsXContiguous(inp);
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    if(ret!=TPCERROR_OK) return(ret);
  }
 
  /* First, duplicate the TAC data */
  //printf("  copying data\n"); fflush(stdout);
  if(tacDuplicate(inp, out)!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
 
  /* If frame start and end times are NOT present, then consider that work is done */
  if(inp->isframe==0) return(TPCERROR_OK);
 
  /* Add room for more frames */
  //printf("  allocating memory for output\n"); fflush(stdout);
  if(tacAllocateMoreSamples(out, 2+2*out->sampleNr)!=0) {
    tacFree(out);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OUT_OF_MEMORY);
    return TPCERROR_OUT_OF_MEMORY;
  }
 
  /* Make separate 'samples' for each frame start and end time */
  out->isframe=0;
  out->sampleNr=0;
  /* Add zero sample at zero time if data starts later */
  if(inp->x1[0]>0.01*(inp->x2[0]-inp->x1[0])) {
    if(verbose>10) printf("  add zero sample\n");
    out->x[0]=0.0;
    for(int ri=0; ri<out->tacNr; ri++) out->c[ri].y[0]=0.0;
    out->sampleNr++;
  }
  /* Add zero sample at the start of the first frame */
  if(verbose>10) printf("  add first frame zero sample\n");
  out->x[out->sampleNr]=inp->x1[0];
  for(int ri=0; ri<out->tacNr; ri++) out->c[ri].y[out->sampleNr]=0.0;
  out->sampleNr++;
 
  /* Add frame start and end times */
  for(int fi=0; fi<inp->sampleNr; fi++) {
    if(verbose>10) printf("  frame %d: %g - %g\n", 1+fi, inp->x1[fi], inp->x2[fi]);
    /* add start sample, if any of y values differs from previous one */
    out->x[out->sampleNr]=out->x[out->sampleNr-1];
//    if(fi==0) out->x[out->sampleNr]=inp->x1[fi];
//    else out->x[out->sampleNr]=out->x[out->sampleNr-1];
    int dn=0;
    for(int ri=0; ri<out->tacNr; ri++) {
      out->c[ri].y[out->sampleNr]=inp->c[ri].y[fi];
      if(out->c[ri].y[out->sampleNr]!=out->c[ri].y[out->sampleNr-1]) dn++;
    }
    if(dn>0) out->sampleNr++;
    /* add end sample */
    out->x[out->sampleNr]=inp->x2[fi];
    for(int ri=0; ri<out->tacNr; ri++)
      out->c[ri].y[out->sampleNr]=inp->c[ri].y[fi];
    out->sampleNr++;
  }
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacAUC(), and tacDelay().

tacFree()

void tacFree ( TAC * tac )

extern

Free memory allocated for TAC data. All contents are destroyed, including any header data.

Precondition

Before first use initialize the TAC structure with tacInit().

See also

tacFreeExceptHeader, tacInit, tacAllocate, tacDuplicate, tacDeleteTACC

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC

Definition at line 106 of file tac.c.

  {
  if(tac==NULL) return;
  free(tac->_data);
  // Free allocated TACC contents; actually not necessary, but lets do it
  // for consistency */ 
  for(int i=0; i<tac->_tacNr; i++) taccFree(&tac->c[i]); 
  // Free the TACC list
  free(tac->c);
  // Free the header data
  iftFree(&tac->h);
  // then set everything to zero or NULL again
  tacInit(tac);
}

Referenced by bfm1TCM(), bfmSRTM(), freeDelayFitData(), imgReadNifti(), imgWriteNifti(), mfCreateTAC(), mtacFree(), tacAllocate(), tacAllocateMoreSamples(), tacAUC(), tacDelay(), tacDuplicate(), tacExtract(), tacExtractRange(), tacExtractSamples(), tacFramesToSteps(), tacInput2sim(), tacIntegrate(), tacIntegrateFE(), tacInterpolate(), tacInterpolateToEqualLengthFrames(), tacMultipleSamples(), tacRead(), tacRead4DM(), tacReadAllogg(), tacReadCarimasTxt(), tacReadCSV(), tacReadDFT(), tacReadGEMS(), tacReadHRPLUSHC(), tacReadHRRTHC(), tacReadInveonCSV(), tacReadMat(), tacReadModelingData(), tacReadModelingInput(), tacReadOldAllogg(), tacReadPMOD(), tacReadQView(), tacReadReference(), tacReadScanditronics(), tacReadSIF(), tacReadSimple(), tacSetWeights(), tacSetX(), tacSetXContiguous(), and tacToBars().

tacFreeExceptHeader()

void tacFreeExceptHeader ( TAC * tac )

extern

Free memory allocated for TAC data. All contents are destroyed, except the header data in IFT structure.

Precondition

Before first use initialize the TAC structure with tacInit().

See also

tacFree, tacInit, tacAllocate, tacDuplicate

Parameters

tac	Pointer to TAC

Definition at line 84 of file tac.c.

  {
  if(tac==NULL) return;
  free(tac->_data);
  // Free allocated TACC contents; actually not necessary, but lets do it
  // for consistency */ 
  for(int i=0; i<tac->_tacNr; i++) taccFree(&tac->c[i]); 
  // Free the TACC list
  free(tac->c);
  // then set everything to zero or NULL again
  tacInit(tac);
}

tacGetHeaderDecayCorrection()

decaycorrection tacGetHeaderDecayCorrection ( IFT * h )

extern

Get the status of decay correction from TAC struct header.

Returns

enum DECAY_UNKNOWN, DECAY_NOTCORRECTED, or DECAY_CORRECTED.

Author

Vesa Oikonen

See also

tacSetHeaderDecayCorrection, tacGetHeaderIsotope, tacDecayCorrection

Parameters

h	Pointer to TAC header structure.

Definition at line 548 of file tacift.c.

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

tacGetHeaderInjectiontime()

int tacGetHeaderInjectiontime ( IFT * h, char * s, TPCSTATUS * status )

extern

Get injection time from TAC structure header.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSetHeaderInjectiontime, tacSetHeaderScanstarttime, tacDecayCorrection, tacGetHeaderIsotope

Parameters

h	Pointer to TAC header structure.
s	Pointer to preallocated string of length 19+1 (at least); enter NULL if you only want to test if header contains injection time.
status	Pointer to status data; enter NULL if not needed.

Definition at line 462 of file tacift.c.

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

tacGetHeaderIsotope()

int tacGetHeaderIsotope ( IFT * h, char * s, TPCSTATUS * status )

extern

Get isotope from TAC struct header.

See also

tacGetIsotope, tacDecayCorrection, isotopeIdentify, tacGetHeaderDecayCorrection

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

h	Pointer to TAC header structure.
s	Pointer to preallocated string of length MAX_ISOTOPE_LEN+1 (at least); enter NULL if you only want to test if header contains isotope code.
status	Pointer to status data; enter NULL if not needed.

Definition at line 290 of file tacift.c.

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

Referenced by abssWrite(), tacGetIsotope(), tacReadSIF(), and tacWriteSIF().

tacGetHeaderScanstarttime()

int tacGetHeaderScanstarttime ( IFT * h, char * s, TPCSTATUS * status )

extern

Get scan start time from TAC structure header.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSetHeaderScanstarttime, tacGetHeaderInjectiontime, tacDecayCorrection, tacGetHeaderIsotope

Parameters

h	Pointer to TAC header structure.
s	Pointer to preallocated string of length 19+1 (at least); enter NULL if you only want to test if header contains scan start time.
status	Pointer to status data; enter NULL if not needed.

Definition at line 372 of file tacift.c.

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

Referenced by abssWrite(), imgFromSIF(), tacReadSIF(), and tacWriteSIF().

tacGetHeaderStudynr()

int tacGetHeaderStudynr ( IFT * h, char * s, TPCSTATUS * status )

extern

Get study number from TAC struct header.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSetHeaderStudynr, parIsStudyNr

Parameters

h	Pointer to TAC header struct
s	Pointer to preallocated string of length MAX_STUDYNR_LEN+1 (at least); enter NULL if you only want to test whether header contains studynr
status	Pointer to status data; enter NULL if not needed

Definition at line 26 of file tacift.c.

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

Referenced by abssWrite(), imgFromSIF(), tacRead(), tacReadSIF(), tacWriteCSV(), tacWriteDFT(), and tacWriteSIF().

tacGetHeaderTimeunit()

int tacGetHeaderTimeunit ( TAC * tac, TPCSTATUS * status )

extern

Get time (x) unit from TAC struct header and write to main TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC struct
status	Pointer to status data; enter NULL if not needed

Definition at line 234 of file tacift.c.

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

Referenced by tacReadCSV(), tacReadDFT(), tacReadPMOD(), and tacReadSimple().

tacGetHeaderUnit()

int tacGetHeaderUnit ( TAC * tac, TPCSTATUS * status )

extern

Get concentration (y) unit from TAC struct header and write to main TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC struct
status	Pointer to status data; enter NULL if not needed

Definition at line 145 of file tacift.c.

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

Referenced by tacReadCSV(), tacReadDFT(), tacReadPMOD(), and tacReadSimple().

tacGetIsotope()

int tacGetIsotope ( TAC * tac )

extern

Read isotope code from TAC header.

See also

tacGetHeaderIsotope, tacSetIsotope, isotopeIdentify, tacDecayCorrection

Author

Vesa Oikonen

Returns

Returns isotope code, or ISOTOPE_UNKNOWN, if not found.

Parameters

tac	Pointer to source TAC structure.

Definition at line 25 of file tacdc.c.

  {
  if(tac==NULL) return(ISOTOPE_UNKNOWN);
  char buf[MAX_ISOTOPE_LEN+1];
  if(tacGetHeaderIsotope(&tac->h, buf, NULL)!=TPCERROR_OK) return(ISOTOPE_UNKNOWN);
  return(isotopeIdentify(buf));
}

Referenced by imgFromSIF(), tacReadModelingData(), tacReadReference(), and tacSetWeights().

tacGetSampleInterval()

int tacGetSampleInterval ( TAC * d, double ilimit, double * minfdur, double * maxfdur )

extern

Get the shortest and longest sampling intervals or frame lengths in TAC structure.

Data is not modified. Data must be sorted by increasing x.

See also

tacXRange, tacIsX, tacCheckX1X2X, tacInterpolateToEqualLengthFrames

Author

Vesa Oikonen

Returns

Returns <>0 in case of failure.

Parameters

d	Pointer to TAC structure.
ilimit	Interval limit: smaller sampling intervals of frame lengths are not accepted; use this to prevent 0 interval in case of step functions or zero length frames; enter NaN if not applied.
minfdur	Pointer to variable for minimum interval (NULL if not needed).
maxfdur	Pointer to variable for maximum interval (NULL if not needed).

Definition at line 832 of file tacx.c.

  {
  if(minfdur!=NULL) *minfdur=nan("");
  if(maxfdur!=NULL) *maxfdur=nan("");
  /* Check the data */
  if(d==NULL || d->sampleNr<1) return(1);
  double mi=nan(""), ma=nan("");
  if(d->isframe) {
    for(int i=0; i<d->sampleNr; i++) {
      double f=d->x2[i]-d->x1[i];
      if(!isnan(ilimit) && !(f>=ilimit)) continue;
      if(isnan(mi) || f<mi) mi=f;
      if(isnan(ma) || f>ma) ma=f;
    }
  } else {
    for(int i=1; i<d->sampleNr; i++) {
      double f=d->x[i]-d->x[i-1];
      if(!isnan(ilimit) && !(f>=ilimit)) continue;
      if(isnan(mi) || f<mi) mi=f;
      if(isnan(ma) || f>ma) ma=f;
    }
    if(isnan(mi) || isnan(ma)) { // as the last resort use the time of first sample
      double f=d->x[0]; 
      if(f>0.0 && !isnan(ilimit) && f>=ilimit) {
        if(isnan(mi)) mi=f;
        if(isnan(ma)) ma=f;
      }
    }
  }
  if(minfdur!=NULL) *minfdur=mi;
  if(maxfdur!=NULL) *maxfdur=ma;
  
  if(minfdur!=NULL && isnan(mi)) return(2);
  if(maxfdur!=NULL && isnan(ma)) return(2);
 
  return(0);
}

Referenced by tacInterpolateToEqualLengthFrames().

tacIndividualNames()

int tacIndividualNames ( TAC * tac )

extern

Verifies that TAC structure contains a name for each TAC, and no other TAC has the same name.

Returns

1 if individual names exist, 0 if not.

Author

Vesa Oikonen

See also

tacSelectTACs, tacSelectBestReference, roinameMatch, tacEnsureNames

Parameters

tac	Pointer to TAC structure.

Definition at line 24 of file tacname.c.

  {
  if(tac==NULL || tac->tacNr<1) return(0);
  int ri, rj;
  /* First check that names do exist */
  for(ri=0; ri<tac->tacNr; ri++) {
    if(!roinameExists(tac->c[ri].name)) return(0);
  }
  /* If just one TAC, then its name is individual */
  if(tac->tacNr==1) return(1);
  /* Otherwise compare each of the names */
  for(ri=0; ri<tac->tacNr-1; ri++)
    for(rj=ri+1; rj<tac->tacNr; rj++)
      if(strcasecmp(tac->c[ri].name, tac->c[rj].name)==0) return(0);
  return(1);
}

tacInit()

void tacInit ( TAC * tac )

extern

Initiate the TAC structure before any use.

See also

tacFree, tacFreeExceptHeader, tacAllocate, tacDuplicate

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC

Definition at line 24 of file tac.c.

  {
  if(tac==NULL) return;
  tac->sampleNr=tac->_sampleNr=0;
  tac->tacNr=tac->_tacNr=0;
  tac->format=TAC_FORMAT_UNKNOWN;
  tac->isframe=0;
  tac->x=tac->x1=tac->x2=NULL;
  tac->cunit=tac->tunit=UNIT_UNKNOWN;
  tac->w=NULL;
  tac->weighting=WEIGHTING_UNKNOWN;
  tac->c=NULL;
  tac->_data=NULL;
  iftInit(&tac->h);
}

Referenced by bfm1TCM(), imgReadNifti(), imgWriteNifti(), initDelayFitData(), mtacAllocate(), mtacAllocateMore(), tacAllocateMoreSamples(), tacAUC(), tacDelay(), tacExtractRange(), tacFree(), tacFreeExceptHeader(), tacInput2sim(), tacMultipleSamples(), tacReadModelingData(), tacReadModelingInput(), tacReadReference(), tacSetWeights(), tacSetX(), and tacSetXContiguous().

tacIsSize()

int tacIsSize ( TAC * d )

extern

Check if any of TAC sets has VOI size (volume).

Returns

1 if size(s) exist, and 0 if not (or in case of an error).

See also

tacIsWeighted, tacIsX

Parameters

d	Pointer to TAC structure.

Definition at line 335 of file tac.c.

  {
  if(d==NULL || d->tacNr<1) return(0);
  for(int ri=0; ri<d->tacNr; ri++) {
    if(isnan(d->c[ri].size)) continue;
    if(d->c[ri].size<=0.0) continue;
    return(1);
  }
  return(0);
}

Referenced by tacWriteCSV().

tacIsWeighted()

int tacIsWeighted ( TAC * tac )

extern

Check if TAC contains weights as indicated by the 'weighting' field.

See also

tacSetWeights, tacWMove, sifWeight, tacWByFreq, imgHasWeights, tacIsX, tacIsSize

Returns

Returns 1 if weighted, and 0 if not or in case of an error.

Parameters

tac	Pointer to TAC structure.

Definition at line 24 of file tacw.c.

  {
  if(tac==NULL) return(0);
  if(tac->weighting==WEIGHTING_UNKNOWN || tac->weighting==WEIGHTING_OFF) return(0);
  if(tac->weighting<WEIGHTING_LAST) return(1);
  return(0);
}

Referenced by parAllocateWithTAC(), tacDecayCorrection(), tacSampleXRange(), tacSetWeights(), tacWeightModerate(), tacWeightNorm(), tacWMove(), tacWriteCSV(), tacWriteDFT(), tacWritePMOD(), tacWriteSheetIntoXML(), and tacWriteXML().

tacIsX()

int tacIsX ( TAC * d )

extern

Verify if TAC structure contains reasonable x values (times).

Data is not modified. Data does not need to be sorted. Data can contain NaNs, as long as some x values are available. Note that x values are considered not to exist even when there is only one sample with x=0.

See also

tacXRange, tacSetX, tacXCopy, tacCheckX1X2X, tacXNaNs, tacFixNaNs, tacMultipleSamples, tacVerifyTimeOrder, tacIsWeighted, tacIsXContiguous

Author

Vesa Oikonen

Returns

Returns 1 if x values are present, 0 if not (all zeroes or missing).

Parameters

d	Pointer to TAC structure; not modified.

Definition at line 226 of file tacx.c.

  {
  if(d==NULL || d->sampleNr<1) return(0);
  double a, b;
  if(tacXRange(d, &a, &b)) return(0);
  if(fabs(a)<1.0E-30 && fabs(b)<1.0E-30) return(0);
  if(fabs(a)<1.0E-30 && fabs(a-b)<1.0E-30) return(0);
  return(1);
}

Referenced by tacInterpolateToEqualLengthFrames(), tacMultipleSamples(), tacReadReference(), tacSetWeights(), and tacSetX().

tacIsXContiguous()

int tacIsXContiguous ( TAC * d )

extern

Check that PET TAC frame times are contiguous, without even tiny overlap or gaps in between.

See also

tacSetXContiguous, tacIsX, tacXRange, tacVerifyTimeOrder, tacSortByTime, tacXCopy, tacMultipleSamples

Returns

If no overlap or gaps, TPCERROR_OK (0) is returned.

Author

Vesa Oikonen

Parameters

d	Pointer to TAC data which is sorted by increasing sample time.

Definition at line 1130 of file tacx.c.

  {
  if(d==NULL) return TPCERROR_FAIL;
  if(tacXNaNs(d)>0) return(TPCERROR_INVALID_X);
 
  /* If no frame start and end times, then just check the order */
  if(d->isframe==0) {
    if(tacVerifyTimeOrder(d, NULL)) return(TPCERROR_INVALID_XRANGE);
    return TPCERROR_OK;
  }
 
  /* Check each frame */
  for(int fi=0; fi<d->sampleNr-1; fi++) {
    double e=d->x2[fi]-d->x1[fi+1];
    if(e<0.0) return(TPCERROR_LARGE_GAP);
    if(e>0.0) return(TPCERROR_OVERLAPPING_DATA);
  }
 
  return(TPCERROR_OK);
}

Referenced by tacFramesToSteps(), and tacSetXContiguous().

tacMinX()

int tacMinX ( TAC * d )

extern

Get the minimum x value in TAC structure.

Data does not need to be sorted, and it can contain missing x and y values (NaNs).

See also

tacSampleXRange, tacIsX, tacAddZeroSample

Returns

Returns the index of sample with min x, or -1 in case of an error.

Parameters

d	Pointer to the TAC structure; not modified.

Definition at line 201 of file tacx.c.

  {
  if(d==NULL || !(d->sampleNr>0)) return(-1);
  int imin=-1; double xmin=nan("");
  for(int i=0; i<d->sampleNr; i++) {
    double t1; if(d->isframe) t1=0.5*(d->x1[i]+d->x2[i]); else t1=d->x[i];
    if(!isfinite(t1)) continue;
    if(!isfinite(xmin) || imin<0 || t1<xmin) {xmin=t1; imin=i; continue;}
  }
  return(imin);
}

Referenced by tacMultipleSamples().

tacMoveTACC()

int tacMoveTACC ( TAC * d, int from, int to )

extern

Move TACC from one position to another inside TAC structure, moving the positions of other TACCs accordingly.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSwapTACCs, tacDeleteTACC, tacCopyTacc

Parameters

d	Pointer to TAC data. Main header and tacNr are not changed.
from	TACC index [0.._tacNr-1]
to	TACC index [0.._tacNr-1]

Definition at line 250 of file tacorder.c.

  {
  int i;
  TACC tacc;
  size_t taccSize;
 
  if(d==NULL || from<0 || to<0) return(TPCERROR_FAIL);
  if(from>=d->_tacNr || to>=d->_tacNr) return(TPCERROR_FAIL);
  if(from==to) return(TPCERROR_OK); // nothing to do
  taccSize=sizeof(TACC);
  memcpy(&tacc, d->c+from, taccSize);
  if(from>to) for(i=from; i>to; i--)
    memcpy(d->c+i, d->c+(i-1), taccSize);
  else for(i=from; i<to; i++)
    memcpy(d->c+i, d->c+(i+1), taccSize);
  memcpy(d->c+i, &tacc, taccSize);
  return(TPCERROR_OK);
}

Referenced by tacDeleteTACC().

tacMultipleSamples()

int tacMultipleSamples ( TAC * d1, const int fixMode, TAC * d2, const int verbose )

extern

Check TAC data for multiple samples with the same sample time. Optionally replace the multiple samples with their mean.

Data does no need to be sorted before calling this. Output is not necessarily sorted either.

See also

tacCorrectFrameOverlap, tacCompareTimes, tacSortByTime, tacIsX, tacDeleteSample

Returns

If fixMode is zero, then returns 1 if multiple samples are found, and 0 if not. If fixMode is 1, then returns 0 if successful, and otherwise >0.

Parameters

d1	Pointer to the input TAC structure; optionally modified.
fixMode	Just inspect for multiple samples (0), or replace those with mean (1).
d2	Pointer to the output TAC structure; enter NULL if just inspecting. To replace the contents of input TAC, enter the same pointer here.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 336 of file tacorder.c.

  {
  if(verbose>0) {printf("\n%s(%d)\n", __func__, fixMode); fflush(stdout);}
 
  /* Check data */
  if(fixMode!=0 && (d1==NULL || d2==NULL || d1->sampleNr<1)) return(2);
  if(d1==NULL || d1->sampleNr<2 || !tacIsX(d1)) return(0);
 
  /* Set limit for similarity of sample times; the same sample times can have been saved in 
     files with variable precision. */
  const double simlim=1.0E-03; if(verbose>1) printf("  limit := %g\n", simlim);
 
  /* Check if there are any multiple samples */
  int isMultiple=0;
  for(int i=0; i<d1->sampleNr-1 && !isMultiple; i++) {
    double t1; if(d1->isframe) t1=0.5*(d1->x1[i]+d1->x2[i]); else t1=d1->x[i];
    for(int j=i+1; j<d1->sampleNr; j++) {
      double t2; if(d1->isframe) t2=0.5*(d1->x1[j]+d1->x2[j]); else t2=d1->x[j];
      double dt=fabs(t2-t1); 
      if(verbose>4) printf("  |%g - %g| = %g\n", t1, t2, dt);
      if(dt<simlim) {isMultiple=1; break;}
    }
  }
  if(verbose>1) {printf("  isMultiple := %d\n", isMultiple); fflush(stdout);}
  if(fixMode==0) return(isMultiple); // done, if fixing not asked for
 
  /* If there were no multiples, copy the input to output and quit */
  if(!isMultiple) {
    TAC itac; tacInit(&itac); 
    if(tacDuplicate(d1, &itac)!=TPCERROR_OK) return(3);
    if(tacDuplicate(&itac, d2)!=TPCERROR_OK) {tacFree(&itac); return(3);}
    tacFree(&itac); return(0);
  }
 
  /* Ok there are multiples that need to be fixed. */
  /* We'll start by making a copy of the input data, and removing any existing data in 
     the output; copy is needed, because output structure can be the same as input */
  TAC itac; tacInit(&itac); if(tacDuplicate(d1, &itac)!=TPCERROR_OK) return(4);
  tacFree(d2);
  /* Delete missing samples from the input */
  tacDeleteMissingSamples(&itac); if(verbose>2) printf("  itac.sampleNr := %d\n", itac.sampleNr);
  /* Allocate memory for the output data */
  if(tacAllocate(d2, itac.sampleNr, itac.tacNr)!=TPCERROR_OK) {tacFree(&itac); return(5);}
  if(tacCopyHdr(&itac, d2)!=TPCERROR_OK) {tacFree(&itac); return(6);}
  for(int r=0; r<itac.tacNr; r++)
    if(tacCopyTacchdr(&itac.c[r], &d2->c[r])!=TPCERROR_OK) {tacFree(&itac); return(7);}
  d2->weighting=WEIGHTING_OFF;
  d2->tacNr=itac.tacNr;
 
  /* Go through the input data */
  while(itac.sampleNr>0) {
    /* Find the smallest sample time */
    int i=tacMinX(&itac); if(i<0) break;
    if(verbose>3) printf("  smallest x[%d]=%g\n", i, itac.x[i]);
    /* Copy values to the first free output sample */
    for(int r=0; r<itac.tacNr; r++) d2->c[r].y[d2->sampleNr]=0.0;
    int rn[itac.tacNr]; for(int r=0; r<itac.tacNr; r++) rn[r]=0;
    for(int r=0; r<itac.tacNr; r++)
      if(isfinite(itac.c[r].y[i])) {
        d2->c[r].y[d2->sampleNr]=itac.c[r].y[i];
        rn[r]++;
      }
    d2->x[d2->sampleNr]=itac.x[i]; d2->x1[d2->sampleNr]=itac.x1[i]; d2->x2[d2->sampleNr]=itac.x2[i];
    double t1; if(itac.isframe) t1=0.5*(itac.x1[i]+itac.x2[i]); else t1=itac.x[i];
    /* Delete the sample from input */
    tacDeleteSample(&itac, i);
    /* Search the input for matching sample times */
    while(itac.sampleNr>0) {
      /* Find the smallest sample time left */
      int i=tacMinX(&itac); if(i<0) break;
      if(verbose>3) printf("    smallest x[%d]=%g\n", i, itac.x[i]);
      double t2; if(itac.isframe) t2=0.5*(itac.x1[i]+itac.x2[i]); else t2=itac.x[i];
      double dt=fabs(t2-t1); if(verbose>4) printf("  |%g - %g| = %g\n", t1, t2, dt);
      if(!(dt<simlim)) break; // if this is not close enough, then none will be
      /* Add values to the first free output sample */
      for(int r=0; r<itac.tacNr; r++)
        if(isfinite(itac.c[r].y[i])) {
          d2->c[r].y[d2->sampleNr]+=itac.c[r].y[i];
          rn[r]++;
        }
      /* Delete also this sample from input */
      tacDeleteSample(&itac, i);
    }
    /* Divide values by the summed number of samples */
    for(int r=0; r<itac.tacNr; r++) d2->c[r].y[d2->sampleNr]/=(double)rn[r];
    /* Move to next output sample */
    d2->sampleNr++;
  }
  tacFree(&itac);
 
  /* Check that we got something left */
  if(d2->sampleNr<1) return(10);
 
  return(0);
}

tacNameSplit()

int tacNameSplit ( const char * rname, char * name1, char * name2, char * name3, unsigned int max_name_len )

extern

Split TAC name into 1-3 subparts of given max length.

Returns

Returns the number of subparts; note that number is 3 if third subpart is found even if 1st and/or 2nd subparts were not found.

See also

roinameSubpart

Parameters

rname	TAC name to split
name1	Pointer to 1st subname (usually anatomical region); NULL if not needed
name2	Pointer to 2nd subname (usually hemisphere); NULL if not needed
name3	Pointer to 3rd subname (usually image plane); NULL if not needed
max_name_len	Max length of subnames, excluding terminal null

Definition at line 26 of file dftio.c.

  {
  /* Initiate subnames */
  if(name1!=NULL) strcpy(name1, "");
  if(name2!=NULL) strcpy(name2, "");
  if(name3!=NULL) strcpy(name3, "");
 
  /* Check input */
  if(max_name_len<1) return 0;
  if(rname==NULL || *rname=='\0') return 0;
 
  /* Work with a copy of TAC name */
  char *temp=strdup(rname);
 
  /* Remove any quotes and trailing and initial spaces */
  if(strClean(temp)) {free(temp); return 0;}
  //printf("temp='%s'\n", temp);
 
  /* Allocate memory for local subnames */
  int fullLen=(int)strlen(rname);
  char sname[3][fullLen+1];
 
  /* Determine the subpart delimiters so that subpart number would be optimal */
  char space[32];
  strcpy(space, " \t"); 
  int n=strTokenNr(temp, space);
  if(n<3) {strcat(space, "_"); n=strTokenNr(temp, space);}
  if(n<3) {strcat(space, "-"); n=strTokenNr(temp, space);}
  //printf("n=%d space='%s'\n", n, space);
 
  /* get subparts */
  char *cptr=temp; int i;
  n=0; i=0;
  while(n<3 && *cptr!='\0') {
    //printf("  cptr='%s' n=%d i=%d\n", cptr, n, i);
    /* If delimiter */
    if(strspn(cptr, space)>0) {
      /* then end this subpart */
      sname[n][i]='\0';
      /* and prepare for the next */ 
      n++; i=0;
      cptr++; continue;
    }
    sname[n][i]=*cptr;
    cptr++; i++;
  } 
  if(n<3) {sname[n][i]='\0'; n++;}
  for( ; n<3 ;n++) strcpy(sname[n], "");
 
  for(i=0; i<3; i++) {
    /* If name was '.' then replace it with empty string */
    if(strcmp(sname[i], ".")==0) strcpy(sname[i], "");
    //printf("         -> '%s'\n", sname[i]);
  }
 
  /* If subname2 is empty and subname1 is too long, then divide it */
  if(sname[1][0]=='\0' && strlen(sname[0])>max_name_len)
    strlcpy(sname[1], &sname[0][max_name_len], fullLen+1);
  /* If subname3 is empty and subname2 is too long, then divide it */
  if(sname[2][0]=='\0' && strlen(sname[1])>max_name_len)
    strlcpy(sname[2], &sname[1][max_name_len], fullLen+1);
 
  /* Fill the output strings */
  char *nptr;
  for(i=n=0; i<3; i++) {
    //printf("         -> '%s'\n", sname[i]);
    if(i==0) nptr=name1; else if(i==1) nptr=name2; else nptr=name3;
    if(strlen(sname[i])>0) n=i+1;
    if(nptr==NULL) continue;
    strlcpy(nptr, sname[i], max_name_len+1);
  }
 
  free(temp);
  return n;
}

Referenced by tacWriteDFT().

tacNaNs()

int tacNaNs ( TAC * tac )

extern

Check TAC structure for missing sample times and values.

See also

tacXNaNs, tacYNaNs, tacNotNaNs, tacFixNaNs

Returns

Returns the number of missing values that were found.

Parameters

tac	Pointer to TAC structure.

Definition at line 71 of file tacnan.c.

  {
  return(tacXNaNs(tac)+tacYNaNs(tac, -1));
}

Referenced by tacFramesToSteps(), tacInterpolate(), tacInterpolateInto(), tacReadModelingData(), and tacReadModelingInput().

tacNotNaNs()

int tacNotNaNs ( TAC * tac, const int i )

extern

Check TAC structure for missing sample times and values.

See also

tacNaNs, tacXNaNs, tacYNaNs, tacFixNaNs

Returns

Returns the number of samples which do not contain missing x or y values.

Parameters

tac	Pointer to TAC structure.
i	Index of TAC to test; <0 to test all TACs.

Definition at line 84 of file tacnan.c.

  {
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1 || i>=tac->tacNr) return(0);
  
  int ri, fi, nan_nr=0;
  for(fi=0; fi<tac->sampleNr; fi++) {
    /* First, check x value(s) */
    if(tac->isframe) {
      if(!isfinite(tac->x1[fi])) {nan_nr++; continue;}
      if(!isfinite(tac->x2[fi])) {nan_nr++; continue;}
    } else {
      if(!isfinite(tac->x[fi])) {nan_nr++; continue;}
    }
    /* If ok, then check y value(s) */
    if(i>=0) {
      if(!isfinite(tac->c[i].y[fi])) nan_nr++; 
      continue;
    }
    for(ri=0; ri<tac->tacNr; ri++)
      if(!isfinite(tac->c[ri].y[fi])) {nan_nr++; break;}
  } // next sample
  return(tac->sampleNr-nan_nr);
}

tacNthSample()

int tacNthSample ( TAC * tac, const int sn, const int i )

extern

Search the Nth sample (1..n) in TAC structure which does not contain missing x or y values. Use tacNotNaNs to get the number of existing samples in TAC.

See also

tacNotNaNs, tacFixNaNs

Returns

Returns the sample index, or <1 if not available.

Parameters

tac	Pointer to TAC structure.
sn	Number (1..n) of sample to search for; 1 to search for the first one, tacNotNaNs(&tac, -1) to search for the last one.
i	Index of TAC to test; <0 to test all TACs

Definition at line 173 of file tacnan.c.

  {
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1 || i>=tac->tacNr) return(-1);
  if(sn<1 || sn>tac->sampleNr) return(-1);
  
  int ri, fi, n=0;
  for(fi=0; fi<tac->sampleNr; fi++) {
    /* First, check x value(s) */
    if(tac->isframe) {
      if(!isfinite(tac->x1[fi]) || !isfinite(tac->x2[fi])) continue;
    } else {
      if(!isfinite(tac->x[fi])) continue;
    }
    /* If ok, then check y value(s) */
    if(i>=0) {
      if(!isfinite(tac->c[i].y[fi])) continue;
    } else {
      for(ri=0; ri<tac->tacNr; ri++) if(!isfinite(tac->c[ri].y[fi])) break;
      if(ri!=tac->tacNr) continue;
    }
    n++;
    if(n==sn) return(fi);
  } // next sample, if necessary
  return(-1);
}

tacRead()

int tacRead ( TAC * d, const char * fname, TPCSTATUS * status )

extern

Read TAC file contents into TAC data structure.

This function reads simple data format (time + data columns), DFT format, PMOD format, Hammersmith formats (IDWC and IF), and some CSV formats.

Author

Vesa Oikonen

Returns

code tpcerror, TPCERROR_OK (0) when successful.

See also

tacInit, tacWrite, tacFormatDetermine, csvRead, iftRead

Parameters

d	Pointer to initiated TAC struct where TAC data will be written; any old content is deleted.
fname	Pointer to the filename; this string is not modified.
status	Pointer to status data; enter NULL if not needed.

Definition at line 413 of file tacio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(fname==NULL || strlen(fname)<1 || d==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>1) printf("%s(%s)\n", __func__, fname);
  int format=TAC_FORMAT_UNKNOWN;
 
  /* Delete any previous data */
  tacFree(d);
 
  /* Open the file */
  FILE *fp;
  fp=fopen(fname, "r");
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_OPEN);
    return TPCERROR_CANNOT_OPEN;
  }
  
  /* Verify that file does not contain binary data */
  {
    int n, binpart;
    n=asciiFileSize(fp, &binpart);
    if(verbose>4) printf("file_size := %d\n", n);
    if(n<2 || binpart!=0) {
      if(verbose>0) {
        printf("file_size := %d\n", n);
        printf("binpart := %d\n", binpart);
        fflush(stdout);
      }
      fclose(fp);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
  }
 
  /* Try to read the file as CSV file */
  int ret;
  CSV csv; csvInit(&csv);
  rewind(fp);
  ret=csvRead(&csv, fp, status);
  fclose(fp);
  if(ret!=TPCERROR_OK) {csvFree(&csv); return ret;}
  if(verbose>20) {
    printf("\n --- CSV contents ---\n");
    csvWrite(&csv, 0, stdout, status);
    fflush(stdout);
  }
 
  /* Try to identify file format from a magic number in the start */
  if(verbose>1) printf("checking for magic number\n");
  if(strncasecmp(csv.c[0].content, "DFT", 3)==0) {
    format=TAC_FORMAT_DFT;
  } else if(strncasecmp(csv.c[0].content, "cpt", 3)==0) {
    format=TAC_FORMAT_NCI;
  } else if(csv.nr>8 && strcasecmp(csv.c[0].content, "time")==0 &&
            strcasecmp(csv.c[1].content, "prompt")==0 &&
            strcasecmp(csv.c[2].content, "delayed")==0 &&
            strcasecmp(csv.c[3].content, "p_rate")==0) {
    format=TAC_FORMAT_HRPLUS_HC;
  } else if(strncasecmp(csv.c[0].content, "Time", 4)==0) {
    format=TAC_FORMAT_PMOD;
  } else if(strncasecmp(csv.c[0].content, "Start", 5)==0) {
    format=TAC_FORMAT_PMOD;
  } else if(strncasecmp(csv.c[0].content, "<?xml version", 6)==0) {
    format=TAC_FORMAT_XML;
  } else if(csv.nr>12 && strcasecmp(csv.c[0].content, "directory")==0 &&
            strcasecmp(csv.c[1].content, "file name")==0 &&
            strcasecmp(csv.c[2].content, "num")==0 &&
            strcasecmp(csv.c[3].content, "slice")==0 &&
            strcasecmp(csv.c[4].content, "mean")==0 &&
            strcasecmp(csv.c[5].content, "sd")==0 &&
            strcasecmp(csv.c[6].content, "cov")==0 &&
            strcasecmp(csv.c[7].content, "max")==0 &&
            strcasecmp(csv.c[8].content, "min")==0 &&
            strcasecmp(csv.c[9].content, "pixel")==0 &&
            strcasecmp(csv.c[10].content, "total")==0 &&
            strcasecmp(csv.c[11].content, "group")==0) {
    format=TAC_FORMAT_QVIEW;
  } else if(csv.nr>10 && strcasecmp(csv.c[0].content, "PatientName")==0 &&
            strcasecmp(csv.c[2].content, "Patient MRN")==0 ) {
    format=TAC_FORMAT_4DM;
  } else if(csv.nr>5 && strstr(csv.c[0].content, " - Time")!=NULL &&
            strstr(csv.c[2].content, "(upper bound)")!=NULL &&
            strstr(csv.c[3].content, "(lower bound)")!=NULL &&
            strstr(csv.c[4].content, "(standard deviation)")!=NULL) {
    format=TAC_FORMAT_INVEON;
  } else if(strcasecmp(csv.c[0].content, "TAC")==0) {
    if(csv.separator=='\t') format=TAC_FORMAT_TSV_UK;
    else if(csv.separator==',') format=TAC_FORMAT_CSV_INT;
    else format=TAC_FORMAT_CSV_UK;
    // CSV subformat may not be strictly correct yet
  } else if(csv.nr>4 && strcasecmp(csv.c[0].content, "Singles")==0 &&
            strcasecmp(csv.c[1].content, "Randoms")==0 &&
            strcasecmp(csv.c[2].content, "Prompts")==0 &&
            strncasecmp(csv.c[3].content, "Time(ms)", 4)==0) {
    format=TAC_FORMAT_HRRT_HC;
  } else if(csvCell(&csv, 1, 0) && strcasecmp(csvCell(&csv, 1, 0), "Num Voxels")==0 ) 
  {
    format=TAC_FORMAT_CARIMAS_TXT;
  }
 
  /* If not identified, then try certain file name extensions. */
  /* Extension is not always reliable, therefore magic nr is tried first */
  if(format==TAC_FORMAT_UNKNOWN) {
    if(verbose>1) printf("checking file name extension\n");
    char *cptr, *extension;
    cptr=filenameGetExtension(fname);
    if(cptr!=NULL && strlen(cptr)>1) extension=strdup(cptr+1); 
    else extension=strdup("");
    if(verbose>1) printf("extension := '%s'\n", extension);
    cptr=extension;
    if(strcasecmp(cptr, "IDWC")==0 || strcasecmp(cptr, "IDW")==0) {
      format=TAC_FORMAT_IDWC;
    } else if(strcasecmp(cptr, "IF")==0) {
      format=TAC_FORMAT_IF;
    } else if(strcasecmp(cptr, "XML")==0) {
      format=TAC_FORMAT_XML;
    } else if(strcasecmp(cptr, "HTML")==0 || strcasecmp(cptr, "HTM")==0) {
      format=TAC_FORMAT_HTML;
    } else if(strcasecmp(cptr, "SIF")==0) {
      format=TAC_FORMAT_SIF;
    } else if(strcasecmp(cptr, "HC")==0) {
      format=TAC_FORMAT_HRRT_HC;
    } else if(strcasecmp(cptr, "R")==0) {
      format=TAC_FORMAT_HRPLUS_HC;
    } 
    free(extension);
  }
 
  /* If still unknown, read all data as IFT */
  IFT hdr; iftInit(&hdr);
  if(format==TAC_FORMAT_UNKNOWN) {
    if(verbose>2) {printf("reading all data in IFT structure\n"); fflush(stdout);}
    fp=fopen(fname, "r");
    if(fp!=NULL) {iftRead(&hdr, fp, 0, 1, status); fclose(fp);}
  }
  if(format==TAC_FORMAT_UNKNOWN) {
    /* Try Allogg ABSS */
    if(iftSearchValue(&hdr, "//Heading", 0)>=0 &&
       iftSearchValue(&hdr, "//Data", 0)>=0 &&
       iftFindPair(&hdr, "System ID", "ABSS09282", 0)>=0)
    { 
      format=TAC_FORMAT_ABSS_ALLOGG;
    /* Try Scanditronics and GEMS ABSS */
    } else if(iftSearchValue(&hdr, "AUX", 0)>=0 && iftSearchValue(&hdr, "1st detector pair", 0)>=0) {
      if(iftSearchValue(&hdr, "Scanditronics", 0)>=0)
        format=TAC_FORMAT_ABSS_SCANDITRONICS;
      else
        format=TAC_FORMAT_ABSS_GEMS;
    } else if(iftFindKey(&hdr, "Discriminators", 0)>=0) { // Try old Allogg
      format=TAC_FORMAT_ABSS_ALLOGG_OLD;
    /* Try another Inveon format */
    } else if(iftSearchValue(&hdr, "Subject Weight", 0)>=0 && iftSearchValue(&hdr, "Subject Sex", 0)>=0) {
      format=TAC_FORMAT_INVEON;
    }
  }
 
  /* Try to identify as Mat file */
  if(format==TAC_FORMAT_UNKNOWN && csvIsRegular(&csv) && csv.row_nr>1 && csv.col_nr>1) {
    if(verbose>2) printf("\nRegular CSV, therefore trying Mat file format\n");
    /* Starting from second row, each first cell should be inside '' */
    int ok=1; char *c; int len;
    for(int r=1; r<csv.row_nr; r++) {
      c=csvCell(&csv, r, 0); if(c==NULL) {ok=0; break;}
      len=strlen(c); if(len<2) {ok=0; break;} // should be at least ''
      if(c[0]!='\'' || c[len-1]!='\'') {ok=0; break;}
    }
    if(ok) format=TAC_FORMAT_MAT;
  }
 
  /* more formats should be identified here */
  if(format==TAC_FORMAT_UNKNOWN) {
    if(verbose>10) {
      printf("\n FORMAT NOT IDENTIFIED \n");
      printf("\n --- CSV contents ---\n");
      csvWrite(&csv, 0, stdout, status);
      fflush(stdout);
    }
  }
 
  /* If not identified, then try to read as simple data */
  if(format==TAC_FORMAT_UNKNOWN) format=TAC_FORMAT_SIMPLE;
 
  if(verbose>1) {printf("  file format: %s\n", tacFormattxt(format)); fflush(stdout);}
 
 
  /* Read the supported formats */
  /* Certain formats may contain additional header information in comment
     lines; read comment headers to be added into TAC struct for further 
     processing; ABSS formats use the previously read whole IFT data.
     Header may not exist, therefore do not worry about errors here.
   */
  switch(format) {
    case TAC_FORMAT_SIMPLE:
      iftFree(&hdr);
      fp=fopen(fname, "r");
      if(fp!=NULL) {iftRead(&hdr, fp, 0, 2, status); fclose(fp);}
      ret=tacReadSimple(d, &csv, &hdr, status);
      break;
    case TAC_FORMAT_DFT:
      iftFree(&hdr);
      fp=fopen(fname, "r");
      if(fp!=NULL) {iftRead(&hdr, fp, 0, 2, status); fclose(fp);}
      ret=tacReadDFT(d, &csv, &hdr, status);
      break;
    case TAC_FORMAT_PMOD:
      iftFree(&hdr);
      fp=fopen(fname, "r");
      if(fp!=NULL) {iftRead(&hdr, fp, 0, 2, status); fclose(fp);}
      ret=tacReadPMOD(d, &csv, &hdr, status);
      break;
    case TAC_FORMAT_QVIEW:
      ret=tacReadQView(d, &csv, 0, status);
      break;
    case TAC_FORMAT_MAT:
      ret=tacReadMat(d, &csv, status);
      break;
    case TAC_FORMAT_4DM:
      ret=tacRead4DM(d, &csv, status);
      break;
    case TAC_FORMAT_CSV_UK:
    case TAC_FORMAT_TSV_UK:
    case TAC_FORMAT_CSV_INT:
    case TAC_FORMAT_TSV_INT:
      iftFree(&hdr);
      fp=fopen(fname, "r");
      if(fp!=NULL) {iftRead(&hdr, fp, 0, 2, status); fclose(fp);}
      ret=tacReadCSV(d, &csv, &hdr, status);
      break;
    case TAC_FORMAT_CARIMAS_TXT:
      ret=tacReadCarimasTxt(d, &csv, status);
      break;
    case TAC_FORMAT_INVEON:
      ret=tacReadInveonCSV(d, &csv, status);
      break;
    case TAC_FORMAT_SIF:
      iftFree(&hdr);
      fp=fopen(fname, "r");
      if(fp!=NULL) {iftRead(&hdr, fp, 0, 2, status); fclose(fp);}
      ret=tacReadSIF(d, &csv, &hdr, status);
      break;
    case TAC_FORMAT_HRRT_HC:
      ret=tacReadHRRTHC(d, &csv, status);
      break;
    case TAC_FORMAT_HRPLUS_HC:
      ret=tacReadHRPLUSHC(d, &csv, status);
      break;
    case TAC_FORMAT_ABSS_ALLOGG:
      //iftFree(&hdr);
      //fp=fopen(fname, "r");
      //if(fp!=NULL) {iftRead(&hdr, fp, 0, 1, status); fclose(fp);}
      ret=tacReadAllogg(d, &hdr, status);
      break;
    case TAC_FORMAT_ABSS_ALLOGG_OLD:
      ret=tacReadOldAllogg(d, &hdr, status);
      break;
    case TAC_FORMAT_ABSS_SCANDITRONICS:
      ret=tacReadScanditronics(d, &hdr, status);
      break;
    case TAC_FORMAT_ABSS_GEMS:
      ret=tacReadGEMS(d, &hdr, status);
      break;
    default:
    /* The rest of formats are not supported */
    if(verbose>0) printf("identified as %s file\n", tacFormattxt(format));
    ret=TPCERROR_UNSUPPORTED;
    statusSet(status, __func__, __FILE__, __LINE__, ret);
  }
  csvFree(&csv); iftFree(&hdr);
  if(ret!=TPCERROR_OK) {tacFree(d); return(ret);}
  
  /* Set study number, if not yet set, based on file name */
  if(verbose>1) printf("checking studynr\n");
  if(tacGetHeaderStudynr(&d->h, NULL, status)!=TPCERROR_OK) {
    if(verbose>2) printf("studynr not found in %s\n", fname);
    char studynr[MAX_STUDYNR_LEN+1];
    /* Only valid studynr is accepted */
    ret=studynrFromFilename(fname, studynr, 1);
    if(ret==0) { 
      if(verbose>2) printf("studynr based on filename: %s\n", studynr);
      ret=tacSetHeaderStudynr(&d->h, studynr);
    } else if(verbose>1)
      fprintf(stderr, "Error: cannot get valid studynr from filename.\n");
  }
 
  /* Set y unit, if not yet set, based on file name */
  if(verbose>1) printf("checking concentration units\n");
  if(d->cunit==UNIT_UNKNOWN) {
    d->cunit=unitIdentifyFilename(fname);
    if(d->cunit!=UNIT_UNKNOWN && verbose>1) {
      printf("concentration units based on filename := %s\n", unitName(d->cunit)); fflush(stdout);
    }
  }
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by imgReadNifti(), imgWriteNifti(), tacReadModelingData(), tacReadModelingInput(), and tacReadReference().

tacRead4DM()

int tacRead4DM ( TAC * tac, CSV * csv, TPCSTATUS * status )

extern

Read 4DM CSV format from CSV structure into TAC structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacRead, tacWrite, tacInit

Parameters

tac	Pointer to TAC structure, contents of which are to be written.
csv	Pointer to CSV from which data is read.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file 4dmio.c.

  {
  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__); fflush(stdout);}
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<4 || csv->col_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  int ret=0;
 
  /* Check from the first column that data indeed is 4DM data */
  if(strcasecmp(csv->c[0].content, "PatientName")!=0 || 
     strcasecmp(csv->c[2].content, "Patient MRN")!=0)
  {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Find the frame number from specific field */
  int frameNr=0;
  {
    int i=csvFindField(csv, "Number of Frames", 4);
    if(i<0 || i>=csv->nr-1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
    i++;
    strClean(csv->c[i].content);
    frameNr=atoi(csv->c[i].content);
    if(verbose>1) printf("frameNr := %d\n", frameNr);
    if(frameNr<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
      return TPCERROR_NO_DATA;
    }
  }
 
  /* Estimate the number of ROIs */
  int maxTacNr=0;
  {
    int i=4;
    do {
      i=csvSearchField(csv, "TAC ROI ", ++i);
      if(i<0) break;
      if(csv->c[i].col==0) maxTacNr++;
    } while(i<csv->nr);
    if(verbose>1) printf("maxTacNr := %d\n", maxTacNr);
    if(maxTacNr<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
      return TPCERROR_NO_DATA;
    }
  }
 
  /* Allocate memory for TAC data */
  ret=tacAllocate(tac, frameNr, maxTacNr);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return(ret);
  tac->isframe=1;
  tac->sampleNr=frameNr;
 
  /* Copy frame start times from CSV into TAC structure */
  {
    int i=csvSearchField(csv, "Frame Start Times", 4);
    char tmp[64];
    strncpyCleanSpaces(tmp, csv->c[i].content+17, 30); strCleanPars(tmp); 
    tac->tunit=unitIdentify(tmp);
    if(verbose>2) printf("tunit := %s\n", unitName(tac->tunit));
    int row=csv->c[i].row;
    int fails=0;
    for(int fi=0; fi<tac->sampleNr; fi++) {
      i++;
      if(csv->c[i].row!=row) {fails++; break;}
      strClean(csv->c[i].content);
      tac->x1[fi]=atofVerified(csv->c[i].content);
    }
    if(fails>0) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
  }
 
  /* Get frame durations from CSV to write frame end times into TAC structure */
  {
    int i=csvSearchField(csv, "Frame Durations", 4);
    int row=csv->c[i].row;
    int fails=0;
    for(int fi=0; fi<tac->sampleNr; fi++) {
      i++;
      if(csv->c[i].row!=row) {fails++; break;}
      strClean(csv->c[i].content);
      tac->x2[fi]=tac->x1[fi]+atofVerified(csv->c[i].content);
      tac->x[fi]=0.5*(tac->x1[fi]+tac->x2[fi]);
    }
    if(fails>0) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
  }
 
  /* Copy ROI data from CSV into TAC structure */
  tac->tacNr=0;
  {
    int i=4;
    while((i=csvSearchField(csv, "TAC ROI ", i))>0) {
      int row=csv->c[i].row;
      strlcpy(tac->c[tac->tacNr].name, csv->c[i].content+8, MAX_TACNAME_LEN+1);
      int fails=0, goods=0;
      for(int fi=0; fi<tac->sampleNr; fi++) {
        i++;
        if(csv->c[i].row!=row) {fails++; break;}
        strClean(csv->c[i].content);
        tac->c[tac->tacNr].y[fi]=atofVerified(csv->c[i].content);
        if(isnormal(tac->c[tac->tacNr].y[fi])) goods++; // zero is not accepted here on purpose 
      }
      if(fails==0 && goods>0) tac->tacNr++;
    }
    if(tac->tacNr<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
      return TPCERROR_NO_DATA;
    }
  }
 
  /* Get concentration units */
  {
    int i=csvSearchField(csv, "TAC FA Blood LV ", 4);
    if(i>=0) {
      char tmp[64];
      strncpyCleanSpaces(tmp, csv->c[i].content+16, 64); strCleanPars(tmp); 
      tac->cunit=unitIdentify(tmp);
      if(verbose>2) printf("cunit := %s\n", unitName(tac->cunit));
    }
  }
 
  /* Get isotope */
  {
    int isotope=ISOTOPE_UNKNOWN;
    int i=csvFindField(csv, "Radionuclide Name", 4);
    if(i>=0 && i<csv->nr-1 && csv->c[i].row==csv->c[i+1].row) {
      char *buf=strTokenDup(csv->c[++i].content, " ", NULL);
      isotope=isotopeIdentify(buf);
      free(buf);
    }
    if(isotope!=ISOTOPE_UNKNOWN) tacSetIsotope(tac, isotope);
    if(verbose>2) printf("isotope := %s\n", isotopeName(isotope));
  }
 
  if(tac->sampleNr<1 || tac->tacNr<1) {
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  tac->format=TAC_FORMAT_4DM;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

tacReadAllogg()

int tacReadAllogg ( TAC * tac, IFT * hdr, TPCSTATUS * status )

extern

Read Allogg #2 ABSS data from IFT struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacInit, tacRead, tacReadOldAllogg

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
hdr	Pointer to IFT to read data from.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file tacabss.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(hdr==NULL || hdr->keyNr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
 
  /* Check whether IFT even can contain Allogg data */
  int ii;
  /* Find the line '//Heading' */
  ii=iftSearchValue(hdr, "//Heading", 0);
  if(ii<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Find the line '//Data' */
  ii=iftSearchValue(hdr, "//Data", 0);
  if(ii<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Sample data should start after this index (right after title) */
  if(verbose>3) {
    printf("found '%s' at ii=%d\n", hdr->item[ii].value, ii);
    fflush(stdout);
  }
  /* Allocate memory for TAC data */
  int ret;
  ret=tacAllocate(tac, hdr->keyNr-ii, 8);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return(ret);
  tac->tacNr=8;
  /* Set basic header information */
  tac->format=TAC_FORMAT_ABSS_ALLOGG;
  tac->isframe=1; // Allogg data always contains frame start and end times
  tac->tunit=UNIT_SEC;
  tac->cunit=UNIT_COUNTS;
  /* Set TAC names into TAC struct */
  strcpy(tac->c[0].name, "Singles");
  strcpy(tac->c[1].name, "Coincidents");
  strcpy(tac->c[2].name, "Singles-count-rate");
  strcpy(tac->c[3].name, "Coincidents-count-rate");
  strcpy(tac->c[4].name, "Singles-count-rate-DTC");
  strcpy(tac->c[5].name, "Coincidents-count-rate-DTC");
  strcpy(tac->c[6].name, "Singles-DTC-decay");
  strcpy(tac->c[7].name, "Coincidents-DTC-decay");
 
  /* Find the first line starting with valid date and time */
  struct tm start_time;
  ii++;
  for(; ii<hdr->keyNr; ii++) {
    if(strDateTimeRead(hdr->item[ii].value, &start_time)==0) break;
  }
  if(ii==hdr->keyNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_MISSING_DATA);
    return(TPCERROR_MISSING_DATA);
  }
  /* Save the start time of the first sample to be saved later in TAC header */
  char scan_start_time[32];
  if(strftime(scan_start_time, 20, "%Y-%m-%d %H:%M:%S", &start_time)==0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  /* Go through the lines, extracting sample data, and deleting data lines
     from the header; stop storing sample data after first invalid line */
  if(verbose>2) {printf("  reading data lines...\n"); fflush(stdout);}
  int i=0, n, stopped=0;
  while(ii<hdr->keyNr && i<tac->_sampleNr) {
    if(stopped) {iftDelete(hdr, ii); continue;}
    if(hdr->item[ii].value[0]=='#') {ii++; continue;}
    if(hdr->item[ii].value==NULL) {iftDelete(hdr, ii); continue;}
    if(strnlen(hdr->item[ii].key, 3)>0) {
      iftDelete(hdr, ii); stopped=1; continue;
    }
    if(strDateTimeRead(hdr->item[ii].value, &start_time)!=0) {
      iftDelete(hdr, ii); stopped=1; continue;
    }
    //printf("reading sample '%s'\n", hdr->item[ii].value+20); fflush(stdout);
    n=sscanf(hdr->item[ii].value+20, "%lf %lf %lf %lf %lf %lf %lf %lf %lf\n", 
         &tac->x1[i],
         &tac->c[0].y[i], &tac->c[1].y[i], &tac->c[2].y[i], &tac->c[3].y[i], 
         &tac->c[4].y[i], &tac->c[5].y[i], &tac->c[6].y[i], &tac->c[7].y[i]
        ); 
    if(n==9) i++; else stopped=1;
    iftDelete(hdr, ii);
  }
  tac->sampleNr=i;
  if(verbose>2) printf("  %d data line(s) read.\n", i);
  if(i<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(TPCERROR_NO_DATA);
  }
 
  /* Calculate frame end and mid times */
  for(i=0; i<tac->sampleNr-1; i++) {
    tac->x2[i]=tac->x1[i+1];
    tac->x[i]=0.5*(tac->x1[i]+tac->x2[i]);
  }
  /* last sample */
  if(tac->sampleNr>1) {
    tac->x2[i]=tac->x1[i]+(tac->x2[i-1]-tac->x1[i-1]);
  } else {
    tac->x2[i]=tac->x1[i]+1.0;
  }
  tac->x[i]=0.5*(tac->x1[i]+tac->x2[i]);
 
  /* Delete more lines from the header */
  ii=iftSearchValue(hdr, "//Heading", 0); if(ii>=0) iftDelete(hdr, ii);
  ii=iftSearchValue(hdr, "//Data", 0); if(ii>=0) iftDelete(hdr, ii);
  ii=iftSearchValue(hdr, "Absolute time", 0); if(ii>=0) iftDelete(hdr, ii);
  /* Set all header lines to comments */
  for(ii=0; ii<hdr->keyNr; ii++) hdr->item[ii].comment=1;
  /* Copy the header contents to TAC (deletes previous contents) */
  (void)iftDuplicate(hdr, &tac->h);
  tac->h.type=3;
  /* Copy study number to the TAC header */
  ii=iftFindKey(hdr, "Run number", 0); 
  if(ii>=0 && strnlen(hdr->item[ii].value, 5)>0)
   (void)tacSetHeaderStudynr(&tac->h, hdr->item[ii].value);
  /* Copy the start time of the first sample to the TAC header */
  (void)tacSetHeaderScanstarttime(&tac->h, scan_start_time);
 
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadCarimasTxt()

int tacReadCarimasTxt ( TAC * tac, CSV * csv, TPCSTATUS * status )

extern

Read Carimas TXT TAC format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacReadCSV, tacRead

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read; if it contains only one column, then it is assumed to represent the first y column and x column is not filled.
status	Pointer to status data; enter NULL if not needed.

Definition at line 631 of file taccsv.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(tac==NULL) {
    if(verbose>0) printf("tac := NULL\n");
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
 
  tacFree(tac);
 
  if(verbose>2) {
    printf("csv.row_nr := %d\n", csv->row_nr);
    printf("csv.col_nr := %d\n", csv->col_nr);
  }
  if(csv==NULL || csv->row_nr<6 || csv->col_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  /* Check that data indeed is CSV TAC data */
  if(strcasecmp(csvCell(csv, 1, 0), "Num Voxels")!=0 ||
     strncasecmp(csvCell(csv, 2, 0), "Volume (mm^3)", 6)!=0 ||
     strncasecmp(csvCell(csv, 3, 0), "Times(s)", 5)!=0 )
  {
    if(verbose>0) {
      printf("cell[%d][%d] := '%s'\n", 1, 0, csvCell(csv, 1, 0));
      printf("cell[%d][%d] := '%s'\n", 2, 0, csvCell(csv, 2, 0));
      printf("cell[%d][%d] := '%s'\n", 3, 0, csvCell(csv, 3, 0));
    }
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  char *cptr;
  int ret, fi, ri, oknr;
 
  /* Allocate memory for TAC data */
  ret=tacAllocate(tac, csv->row_nr-4, csv->col_nr-1);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=csv->col_nr-1; tac->sampleNr=csv->row_nr-4;
  tac->isframe=1;
  // initiate the format, may be changed later if necessary
  tac->format=TAC_FORMAT_CARIMAS_TXT;
 
  /* Get time unit from the 4th nonempty title line, inside parens */
  tac->tunit=UNIT_UNKNOWN;
  cptr=csvCell(csv, 3, 0);
  if(cptr!=NULL && strncasecmp(cptr, "Times(s)", 5)==0) {
    char *tmp=strdup(cptr+5);
    strCleanPars(tmp); tac->tunit=unitIdentify(tmp);
    free(tmp);
  }
 
  /* Get concentration unit the first title line, inside parens */
  tac->cunit=UNIT_UNKNOWN;
  cptr=csvCell(csv, 0, 1);
  if(cptr!=NULL && strchr(cptr, '(')!=0) {
    char *tmp=strdup(strchr(cptr, '('));
    strCleanPars(tmp); tac->cunit=unitIdentify(tmp);
    free(tmp);
  }
 
  /* Read TAC names from the first title line */
  if(verbose>4) printf("reading VOI names\n");
  ret=oknr=0;
  for(ri=0; ri<tac->tacNr; ri++) {
    cptr=csvCell(csv, 0, ri+1); if(!cptr) {ret++; break;}
    if(strlen(cptr)==0) break;
    strlcpy(tac->c[ri].name, cptr, MAX_TACNAME_LEN+1);
    cptr=strchr(tac->c[ri].name, '('); if(cptr) *cptr='\0';
    if(strcmp(tac->c[ri].name, ".")==0) strcpy(tac->c[ri].name, "");
    oknr++;
  }
  if(ret || oknr<1) {
    if(verbose>0) printf("could not read TAC names.\n");
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Set tacNr, in case that txt file had empty fields */
  tac->tacNr=oknr;
  if(verbose>2) printf("  tacNr=%d\n", tac->tacNr);
 
  /* Get VOI volumes from the 3rd line */
  if(verbose>4) printf("reading VOI volumes\n");
  ret=oknr=0;
  for(ri=0; ri<tac->tacNr; ri++) {
    cptr=csvCell(csv, 2, ri+1); if(!cptr) {ret++; break;}
    if(atofCheck(cptr, &tac->c[ri].size)!=0) tac->c[ri].size=nan("");
    oknr++;
  }
  if(ret || oknr<1) {
    if(verbose>0) printf("could not read TAC volumes.\n");
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Copy x and y data from CSV into TAC struct */
  if(verbose>4) printf("reading x and y values\n");
  ret=oknr=0;
  for(fi=0; fi<tac->sampleNr; fi++) {
    /* Frame times */
    cptr=csvCell(csv, fi+4, 0); if(!cptr) {ret++; break;}
    if(sscanf(cptr, "%lf - %lf", &tac->x1[fi], &tac->x2[fi])!=2) {ret++; break;}
    /* Concentrations */
    for(ri=0; ri<tac->tacNr; ri++) {
      cptr=csvCell(csv, fi+4, ri+1); if(!cptr) {ret++; break;}
      ret=atofCheck(cptr, &tac->c[ri].y[fi]); if(ret) break;
    }
    oknr++;
  }
  if(ret || oknr<1) {
    if(verbose>0) printf("could not read data.\n");
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(verbose>2) printf("  sampleNr=%d\n", tac->sampleNr);
 
  /* Set middle sample times */
  if(tac->isframe)
    for(fi=0; fi<tac->sampleNr; fi++)
      tac->x[fi]=0.5*(tac->x1[fi]+tac->x2[fi]);
 
  /* Move column containing weights to its correct place in the struct */
  ret=tacWMove(tac, 1, status);
  if(ret!=TPCERROR_OK && ret!=TPCERROR_NO_WEIGHTS) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return(ret);
  }
  if(tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadCSV()

int tacReadCSV ( TAC * tac, CSV * csv, IFT * hdr, TPCSTATUS * status )

extern

Read CSV TAC format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWriteCSV, tacRead, tacReadCarimasTxt

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read; if it contains only one column, then it is assumed to represent the first y column and x column is not filled.
hdr	Pointer to possible header data, which, if available, if processed and copied to TAC too; enter NULL if not available.
status	Pointer to status data; enter NULL if not needed.

Definition at line 212 of file taccsv.c.

  {
  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__);
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<2 || csv->col_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  /* Check from the first field that data indeed is CSV TAC data */
  if(strcasecmp(csv->c[0].content, "TAC")!=0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Get time type from the title line */
  int i, isframe=-1;
  for(i=2; i<csv->nr; i++) if(csv->c[i].row==1 && csv->c[i].col==0) break;
  if(strncasecmp(csv->c[i].content, "time", 4)==0) isframe=0;
  else if(strncasecmp(csv->c[i].content, "start", 5)==0 &&
          strncasecmp(csv->c[i+1].content, "end", 3)==0) isframe=1;
  if(isframe<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Allocate memory for TAC data */
  int n, ret;
  n=csv->col_nr-1; if(isframe==1) n--;
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  ret=tacAllocate(tac, csv->row_nr-2, n);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=n; tac->sampleNr=csv->row_nr-2;
  tac->isframe=isframe;
  // initiate the format, may be changed later if necessary
  if(csv->separator=='\t') tac->format=TAC_FORMAT_TSV_UK;
  else if(csv->separator==',') tac->format=TAC_FORMAT_CSV_INT;
  else tac->format=TAC_FORMAT_CSV_UK;
 
  /* Copy header to TAC struct */
  iftDuplicate(hdr, &tac->h);
 
  /* Read study id from the second field */
  tacSetHeaderStudynr(&tac->h, csv->c[1].content);
  
  /* Get time unit from the first title field, inside parens */
  char *cptr;
  for(i=2; i<csv->nr; i++) if(csv->c[i].row==1 && csv->c[i].col==0) break;
  cptr=strchr(csv->c[i].content, '[');
  if(cptr==NULL) {
    tac->tunit=UNIT_UNKNOWN;
  } else {
    char *tmp=strdup(cptr+1);
    cptr=strrchr(tmp, ']'); if(cptr!=NULL) *cptr='\0';
    tac->tunit=unitIdentify(tmp);
    free(tmp);
  }
 
  /* Get concentration unit from 2nd or 3rd field, inside parens */
  i++; if(isframe) i++;
  cptr=strchr(csv->c[i].content, '[');
  if(cptr==NULL) {
    tac->cunit=UNIT_UNKNOWN;
  } else {
    char *tmp=strdup(cptr+1);
    cptr=strrchr(tmp, ']'); if(cptr!=NULL) *cptr='\0';
    tac->cunit=unitIdentify(tmp);
    free(tmp);
  }
 
  /* Read TAC names from the title line */
  n=0;
  for(; i<csv->nr; i++) {
    if(csv->c[i].row!=1 || n>=tac->tacNr) break;
    /* Copy TAC name, removing unit if necessary */
    if(strchr(csv->c[i].content, '[')) {
      char *tmp=strdup(csv->c[i].content);
      cptr=strchr(tmp, '['); *cptr='\0';
      strlcpy(tac->c[n].name, tmp, MAX_TACNAME_LEN+1);
      free(tmp);
    } else {
      strlcpy(tac->c[n].name, csv->c[i].content, MAX_TACNAME_LEN+1);
    }
    if(strcmp(tac->c[n].name, ".")==0) strcpy(tac->c[n].name, "");
    n++;
  }
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  tac->tacNr=n;
  if(verbose>2) printf("  tacNr=%d\n", tac->tacNr);
 
  /* Copy x and y data from CSV into TAC struct */
  int fi=0, ri=0, oknr=0, maxfi=0;
  ret=0;
  double v;
  for(i=2; i<csv->nr; i++) if(csv->c[i].row==2) break;
  for(; i<csv->nr; i++) {
    if(verbose>10)
      printf("i=%d\trow=%d\tcol=%d\t'%s'\n", i, csv->c[i].row, csv->c[i].col, csv->c[i].content);
    if(csv->c[i].col==0 && strcasecmp(csv->c[i].content, "volume")==0)
      break; // stop if VOI volume line is encountered
    fi=csv->c[i].row-2; if(fi<0 || fi>=tac->sampleNr) {ret++; continue;}
    if(fi>maxfi) maxfi=fi;
    if(csv->c[i].col<0) {ret++; continue;}
    ri=csv->c[i].col-1; if(tac->isframe) ri--; 
    if(ri>=tac->tacNr) {ret++; continue;}
    v=atofVerified(csv->c[i].content); if(!isnan(v)) oknr++;
    if(verbose>10) printf("   -> fi=%d\tri=%d\t=\t%g\n", fi, ri, v);
    if(ri<0) {
      if(tac->isframe) {
        if(ri==-2) tac->x1[fi]=v; else if(ri==-1) tac->x2[fi]=v;
      } else tac->x[fi]=v;
    } else tac->c[ri].y[fi]=v;
    /* check whether we have decimal comma or dot */
    if(tac->format==TAC_FORMAT_CSV_UK || tac->format==TAC_FORMAT_TSV_UK) {
      if(strHaveDecimalComma(csv->c[i].content)) {
        if(tac->format==TAC_FORMAT_TSV_UK) tac->format=TAC_FORMAT_TSV_INT;
        else tac->format=TAC_FORMAT_CSV_INT;
      } 
    }
  }
  tac->sampleNr=maxfi+1;
  if(verbose>2) printf("  sampleNr=%d\n", tac->sampleNr);
  if(verbose>0 && ret>0) printf("%d error(s) in reading CSV file format.\n", ret);
  if(oknr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Set middle sample times when necessary */
  if(tac->isframe)
    for(fi=0; fi<tac->sampleNr; fi++)
      tac->x[fi]=0.5*(tac->x1[fi]+tac->x2[fi]);
 
  /* Get VOI volumes from the following line */
  if(i<csv->nr && strcasecmp(csv->c[i].content, "volume")==0) {
    if(tac->isframe) i++;
    for(ri=0; ri<tac->tacNr; ri++) {
      if(csv->c[i+ri].row!=csv->c[i].row) break;
      tac->c[ri].size=atofVerified(csv->c[i+ri].content);
    }
  }
 
  /* If units are not known, try to read units from header */
  if(tac->cunit==UNIT_UNKNOWN) tacGetHeaderUnit(tac, NULL);
  else tacSetHeaderUnit(&tac->h, UNIT_UNKNOWN);
  if(tac->tunit==UNIT_UNKNOWN) tacGetHeaderTimeunit(tac, NULL);
  else tacSetHeaderTimeunit(&tac->h, UNIT_UNKNOWN);
 
  /* Move column containing weights to its correct place in the struct */
  ret=tacWMove(tac, 1, status);
  if(ret!=TPCERROR_OK && ret!=TPCERROR_NO_WEIGHTS) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return(ret);
  }
  if(tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadDFT()

int tacReadDFT ( TAC * tac, CSV * csv, IFT * hdr, TPCSTATUS * status )

extern

Read DFT format from CSV structure into TAC structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWriteDFT, tacWrite

Parameters

tac	Pointer to TAC structure, into which are to be written; any previous contents are deleted.
csv	Pointer to CSV from which data is read; it must contain at least one or two x columns and one y column.
hdr	Pointer to possible header data, which, if available, is copied to TAC as a processed version; enter NULL if not available
status	Pointer to status data; enter NULL if not needed

Definition at line 300 of file dftio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(csv==NULL || csv->row_nr<5 || csv->col_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) printf("%s()\n", __func__);
 
  /* Verify the magic number first */
  if(strncasecmp(csv->c[0].content, "DFT", 3)!=0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  int ret, i, j, m, n, isframe=0, is2cunit=0, is2tunit=0, tunit;
  char *cptr;
 
  /* Get some important information from title lines first */
  for(i=0; i<csv->nr; i++) if(csv->c[i].col==0 && csv->c[i].row==3) break;
  if(i==csv->nr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Do we have one or two x columns */
  // note that time unit may or may not be included in this field, depending
  // on field separator
  if(strncasecmp(csv->c[i].content, "Times", 5)==0) isframe=1;
  else if(strncasecmp(csv->c[i].content, "Time", 4)==0) isframe=0;
  else if(strncasecmp(csv->c[i].content, "Distances", 9)==0) isframe=1;
  else if(strncasecmp(csv->c[i].content, "Distance", 8)==0) isframe=0;
  else {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(verbose>2) printf("  isframe=%d\n", isframe);
  /* Get time unit from first or second field, inside parens */
  cptr=strchr(csv->c[i].content, '(');
  if(cptr==NULL) cptr=strchr(csv->c[i].content, '[');
  if(cptr==NULL) {cptr=strchr(csv->c[i+1].content, '('); is2tunit=1;}
  if(cptr==NULL) {cptr=strchr(csv->c[i+1].content, '['); is2tunit=1;}
  if(cptr==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  } else {
    char *tmp=strdup(cptr); strCleanPars(tmp); tunit=unitIdentify(tmp);
    free(tmp);
  }
 
  /* Allocate memory for TAC data */
  m=csv->row_nr-4;
  n=csv->col_nr-1; if(isframe) n--;
  if(n<1 || m<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  ret=tacAllocate(tac, m, n);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=n; tac->sampleNr=m; // these may be refined later
  tac->isframe=isframe;
  tac->tunit=tunit;
 
  /* Copy header to TAC struct */
  iftDuplicate(hdr, &tac->h);
 
  /* Read first title line, jumping over magic number */
  n=0;
  for(i=1; i<csv->nr; i++) {
    if(csv->c[i].row!=0 || n>=tac->tacNr) break;
    /* Copy TAC name */
    strlcpy(tac->c[n].name, csv->c[i].content, MAX_TACNAME_LEN+1);
    if(strcmp(tac->c[n].name, ".")==0) strcpy(tac->c[n].name, "");
    n++;
  }
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  tac->tacNr=n;
  if(verbose>2)
    printf("  tacNr=%d\n  sampleNr=%d\n", tac->tacNr, tac->sampleNr);
 
  /* Get study number */
  for(i=0; i<csv->nr; i++) if(csv->c[i].row==1 && csv->c[i].col==0) {
    if(strlen(csv->c[i].content)>0 && strcmp(csv->c[i].content, ".")!=0)
      tacSetHeaderStudynr(&tac->h, csv->c[i].content);
    break;
  }
  
  /* Get concentration unit from the first item on line 3 */
  for(i=0; i<csv->nr; i++) if(csv->c[i].row==2 && csv->c[i].col==0) break;
  tac->cunit=unitIdentify(csv->c[i].content);
  /* Carimas may (erroneously) write conc unit in two columns, with actual 
     unit in 2nd column inside parenthesis */
  if(strInPars(csv->c[i+1].content)
     && csvRowLength(csv, 2)==csvRowLength(csv, 1)+1)
  {
    if(verbose>2) printf("  concentration unit spans two columns\n");
    is2cunit=1;
    if(tac->cunit==UNIT_UNKNOWN) {
      char *tmp=strdup(csv->c[i+1].content);
      strCleanPars(tmp); tac->cunit=unitIdentify(tmp);
      free(tmp);
    }
  }
 
  
  /* Catenate additional TAC names if available on lines 2 and 3 */
  for(int ri=0; ri<tac->tacNr; ri++) {
    for(i=0; i<csv->nr; i++) if(csv->c[i].row==1 && csv->c[i].col==ri+1) break;
    for(j=i; j<csv->nr; j++) if(csv->c[j].row==2 && csv->c[j].col==ri+1) break;
    if(i==csv->nr || j==csv->nr) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
    if(is2cunit) j++; // add one in case cunit spans two columns
    m=strlen(csv->c[i].content); if(strcmp(csv->c[i].content, ".")==0) m=0;
    n=strlen(csv->c[j].content); if(strcmp(csv->c[j].content, ".")==0) n=0;
    if((m+n)>0 && (strlen(tac->c[ri].name)<MAX_TACNAME_LEN-1))
      strcat(tac->c[ri].name, "_");
    if(m>0 && (m+strlen(tac->c[ri].name)<MAX_TACNAME_LEN))
      strcat(tac->c[ri].name, csv->c[i].content);
    if(n>0 && (strlen(tac->c[ri].name)<MAX_TACNAME_LEN-1))
      strcat(tac->c[ri].name, "_");
    if(n>0 && (n+strlen(tac->c[ri].name)<MAX_TACNAME_LEN))
      strcat(tac->c[ri].name, csv->c[j].content);
  }
 
  /* Read sizes from 4th line */
  n=csvRowLength(csv, 3);
  for(i=0; i<csv->nr; i++) if(csv->c[i].row==3) {
    m=csv->c[i].col-1; if(is2tunit) m--; 
    if(m>=0 && m<tac->tacNr) tac->c[m].size=atofVerified(csv->c[i].content);
  }
#if(0)
  for(i=0, m=-1, n=0; i<csv->nr; i++) if(csv->c[i].row==3) {n++; if(m<0) m=i;}
  if(n==tac->tacNr+1) m+=1;
  else if(n==tac->tacNr+2) m+=2;
  else {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  for(int ri=0; ri<tac->tacNr; ri++)
    tac->c[ri].size=atofVerified(csv->c[m++].content);
#endif
 
  /* Copy x and y data from CSV into TAC struct */
  int fi=0, ri=0, oknr=0;
  ret=0;
  double v;
  for(i=0; i<csv->nr; i++) if(csv->c[i].row==4) break;
  for(; i<csv->nr; i++) {
    if(verbose>10)
      printf("i=%d\trow=%d\tcol=%d\n", i, csv->c[i].row, csv->c[i].col);
    fi=csv->c[i].row-4; if(fi<0 || fi>=tac->sampleNr) {ret++; continue;}
    if(csv->c[i].col<0) {ret++; continue;}
    ri=csv->c[i].col-1; 
    if(tac->isframe) ri--; 
    if(ri>=tac->tacNr) {ret++; continue;}
    v=atofVerified(csv->c[i].content); if(!isnan(v)) oknr++;
    if(verbose>10) printf("   -> fi=%d\tri=%d\t=\t%g\n", fi, ri, v);
    if(ri<0) {
      if(tac->isframe) {
        if(ri==-2) tac->x1[fi]=v; else if(ri==-1) tac->x2[fi]=v;
      } else tac->x[fi]=v;
    } else tac->c[ri].y[fi]=v;
  }
  if(verbose>0 && ret>0)
    printf("%d error(s) in reading DFT file format.\n", ret);
  if(oknr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Set middle sample times when necessary */
  if(tac->isframe)
    for(fi=0; fi<tac->sampleNr; fi++)
      tac->x[fi]=0.5*(tac->x1[fi]+tac->x2[fi]);
 
  /* If units are not known, try to read units from header */
  if(tac->cunit==UNIT_UNKNOWN) tacGetHeaderUnit(tac, NULL);
  else tacSetHeaderUnit(&tac->h, UNIT_UNKNOWN);
  if(tac->tunit==UNIT_UNKNOWN) tacGetHeaderTimeunit(tac, NULL);
  else tacSetHeaderTimeunit(&tac->h, UNIT_UNKNOWN);
 
  /* Move column containing weights to its correct place in the struct */
  ret=tacWMove(tac, 1, status);
  if(ret!=TPCERROR_OK && ret!=TPCERROR_NO_WEIGHTS) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return(ret);
  }
  if(tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  tac->format=TAC_FORMAT_DFT;
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadGEMS()

int tacReadGEMS ( TAC * tac, IFT * hdr, TPCSTATUS * status )

extern

Read GEMS ABSS data from IFT struct into TAC struct.

Two date-time strings will be written in header, scan_start_time containing the time of the first sample, and sampler_start_time containing the time given in ABSS file header.

GEMS ABSS format is almost identical to Scanditronics, but the headers and times are processed differently, hence separate functions. If function finds that provided data is actually from Scanditronics, it calls tacReadScanditronics.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacInit, tacRead, tacReadScanditronics, tacReadAllogg

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
hdr	Pointer to IFT to read data from.
status	Pointer to status data; enter NULL if not needed.

Definition at line 516 of file tacabss.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(hdr==NULL || hdr->keyNr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
 
  /* Check whether IFT contains GEMS (or Scanditronics) data */
  int format;
  if(iftSearchValue(hdr, "AUX", 0)<0 || 
     iftSearchValue(hdr, "1st detector pair", 0)<0)
  {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(iftSearchValue(hdr, "Scanditronics", 0)>=0) {
    if(verbose>0) printf("data is GEMS but Scanditronics format\n");
    return(tacReadScanditronics(tac, hdr, status));
  } else {
    format=TAC_FORMAT_ABSS_GEMS;
  }
 
  /* Find the measurement start date, possibly with time;
     at least the date must be there for calibration. */
  struct tm start_time;
  int ii, n;
  for(ii=0; ii<hdr->keyNr; ii++) {
    if(strnlen(hdr->item[ii].key, 3)>0) continue;
    n=strnlen(hdr->item[ii].value, 22);
    if(n<10 || n>19) continue;
    //printf("ii=%d '%s' '%s'\n", ii, hdr->item[ii].key, hdr->item[ii].value);
    if(strDateTimeRead(hdr->item[ii].value, &start_time)!=0) {
      /* Date and time not found, try only date */
      if(strDateRead(hdr->item[ii].value, &start_time)!=0) continue; 
    }
    break;
  }
  if(ii==hdr->keyNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  //printf("found '%s' at ii=%d\n", hdr->item[ii].value, ii);
 
  /* Sample data should start after this index */
  /* Allocate memory for TAC data */
  int ret;
  ret=tacAllocate(tac, hdr->keyNr-ii, 7);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return(ret);
  tac->tacNr=7;
  /* Set basic header information */
  tac->format=format;
  tac->isframe=1; // Data always contains frame start and end times
  tac->tunit=UNIT_SEC;
  tac->cunit=UNIT_COUNTS;
  /* Set TAC names into TAC struct */
  strcpy(tac->c[0].name, "Detector1-Coinc");
  strcpy(tac->c[1].name, "Detector1-Singl1");
  strcpy(tac->c[2].name, "Detector1-Singl2");
  strcpy(tac->c[3].name, "Detector2-Coinc");
  strcpy(tac->c[4].name, "Detector2-Singl1");
  strcpy(tac->c[5].name, "Detector2-Singl2");
  strcpy(tac->c[6].name, "AUX-counts");
 
  /* Go through the lines, extracting sample data, and deleting data lines
     from the header */
  if(verbose>2) printf("  reading data lines...\n");
  ii++;
  int i=0, stopped=0;
  double time_of_day, first_tod=0.0, time_since_start, meas_interval;
  while(ii<hdr->keyNr && i<tac->_sampleNr) {
    if(stopped) {iftDelete(hdr, ii); continue;}
    if(strnlen(hdr->item[ii].key, 3)>0 || hdr->item[ii].value==NULL) {
      iftDelete(hdr, ii); continue;}
    if(hdr->item[ii].value[0]=='#') {iftDelete(hdr, ii); continue;}
    //printf("ii=%d '%s'\n", ii, hdr->item[ii].value);
    n=sscanf(hdr->item[ii].value, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n", 
         &time_of_day, &time_since_start, &meas_interval, 
         &tac->c[0].y[i], &tac->c[1].y[i], &tac->c[2].y[i], &tac->c[3].y[i],
         &tac->c[4].y[i], &tac->c[5].y[i], &tac->c[6].y[i]);
    //printf("  n=%d\n", n);
    if(n!=10) {
      /* first line may contain the protocol; keep it as comment */
      if(i==0) {ii++; continue;}
      /* Later occurrence is considered as an error */
      stopped=1; iftDelete(hdr, ii); continue;
    } 
    if(time_of_day==0.0 && meas_interval==0.0) {
      stopped=1; iftDelete(hdr, ii); continue;}
    if(i==0) first_tod=time_of_day;
    tac->x1[i]=time_since_start;
    tac->x2[i]=time_since_start+meas_interval;
    i++;
    iftDelete(hdr, ii);
  }
  tac->sampleNr=i;
  if(verbose>2) printf("  %d data line(s) read.\n", i);
  if(i<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(TPCERROR_NO_DATA);
  }
  if(verbose>4) printf("  first_tod := %.1lf\n", first_tod);
  
  /* Calculate frame mid times */
  for(i=0; i<tac->sampleNr; i++) tac->x[i]=0.5*(tac->x1[i]+tac->x2[i]);
 
  /* Read scan start time from the first sample, which is used also as 
     sampler start time, if only date was given in the header */
  char scan_start_time[32], sampler_start_time[32];
  time_t tim=(time_t)first_tod;
  struct tm tmtim;
  if(gmtime_r(&tim, &tmtim)==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  /* Check whether also date is here; 
     if yes, this is actually Scanditronics data */
  if(tmtim.tm_year>71 || tmtim.tm_mday>1) {
    if(verbose>0) printf("data is not GEMS but Scanditronics format\n");
    if(verbose>1 && 
       strftime(scan_start_time, 32, "%Y-%m-%d %H:%M:%S", &tmtim)!=0) {
      printf("first_sample_time := %s\n", scan_start_time);
    }
    tacFree(tac);
    return(tacReadScanditronics(tac, hdr, status));
  }
  if(start_time.tm_hour==0 && start_time.tm_min==0 && start_time.tm_sec==0) {
    start_time.tm_hour=tmtim.tm_hour;
    start_time.tm_min=tmtim.tm_min;
    start_time.tm_sec=tmtim.tm_sec;
    n=strftime(sampler_start_time, 32, "%Y-%m-%d %H:%M:%S", &start_time);
    if(n==0) strcpy(sampler_start_time, "");
    strcpy(scan_start_time, sampler_start_time);
  } else {
    n=strftime(sampler_start_time, 32, "%Y-%m-%d %H:%M:%S", &start_time);
    if(n==0) strcpy(sampler_start_time, "");
    start_time.tm_hour=tmtim.tm_hour;
    start_time.tm_min=tmtim.tm_min;
    start_time.tm_sec=tmtim.tm_sec;
    n=strftime(scan_start_time, 32, "%Y-%m-%d %H:%M:%S", &start_time);
    if(n==0) strcpy(scan_start_time, "");
  }
  if(!scan_start_time[0]) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
 
 
  /* Set all header lines to comments */
  for(ii=0; ii<hdr->keyNr; ii++) hdr->item[ii].comment=1;
  /* Copy the header contents to TAC (deletes previous contents) */
  (void)iftDuplicate(hdr, &tac->h);
  tac->h.type=3;
  /* Set the scan start time in the TAC header */
  (void)tacSetHeaderScanstarttime(&tac->h, scan_start_time);
  /* Set the sampler start time in the TAC header */
  if(sampler_start_time[0])
    (void)iftPut(&tac->h, "sampler_start_time", sampler_start_time, 1, NULL);
  /* Copy study number to the TAC header */
  ii=iftFindKey(hdr, "Patient", 0); 
  if(ii>=0 && strnlen(hdr->item[ii].value, 5)>0)
   (void)tacSetHeaderStudynr(&tac->h, hdr->item[ii].value);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead(), and tacReadScanditronics().

tacReadHRPLUSHC()

int tacReadHRPLUSHC ( TAC * tac, CSV * csv, TPCSTATUS * status )

extern

Read HR+ head curve (.r) format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read; if it contains only one column, then it is assumed to represent the first y column and x column is not filled.
status	Pointer to status data; enter NULL if not needed

Definition at line 114 of file hcio.c.

  {
  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__);
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<2 || csv->col_nr<8) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  /* Check from the title fields that data indeed is HRRT HC data */
  int ret=0;
  if(strcasecmp(csv->c[0].content, "time")!=0) ret++;
  if(strcasecmp(csv->c[1].content, "prompt")!=0) ret++;
  if(strcasecmp(csv->c[2].content, "delayed")!=0) ret++;
  if(strcasecmp(csv->c[3].content, "p_rate")!=0) ret++;
  if(strcasecmp(csv->c[4].content, "d_rate")!=0) ret++;
  if(strcasecmp(csv->c[5].content, "dtime")!=0) ret++;
  if(strcasecmp(csv->c[6].content, "frame")!=0) ret++;
  if(strcasecmp(csv->c[7].content, "singles")!=0) ret++;
  if(ret>0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Allocate memory for TAC data */
  ret=tacAllocate(tac, csv->row_nr-1, 7);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=7; tac->sampleNr=csv->row_nr-1;
  if(verbose>2) printf("  sampleNr=%d\n", tac->sampleNr);
 
  /* Set time type */
  tac->isframe=0;
  /* Set time unit */
  tac->tunit=UNIT_MSEC;
  /* Set concentration unit */
  tac->cunit=UNIT_KCPS;
 
  /* Set TAC names */
  strcpy(tac->c[0].name, "prompt");
  strcpy(tac->c[1].name, "delayed");
  strcpy(tac->c[2].name, "p_rate");
  strcpy(tac->c[3].name, "d_rate");
  strcpy(tac->c[4].name, "dtime");
  strcpy(tac->c[5].name, "frame");
  strcpy(tac->c[6].name, "singles");
 
  /* Copy x and y data from CSV into TAC struct */
  double v; int oknr=0;
  for(int i=8; i<csv->nr; i++) {
    if(csv->c[i].row<1 || csv->c[i].row>tac->sampleNr || csv->c[i].col>7) 
      continue;
    v=atofVerified(csv->c[i].content); if(!isnan(v)) oknr++;
    if(csv->c[i].col==0) tac->x[csv->c[i].row-1]=v;
    else tac->c[csv->c[i].col-1].y[csv->c[i].row-1]=v;
  }
  if(oknr<8) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Set file format */
  tac->format=TAC_FORMAT_HRPLUS_HC;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadHRRTHC()

int tacReadHRRTHC ( TAC * tac, CSV * csv, TPCSTATUS * status )

extern

Read HRRT head curve (.hc) format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read; if it contains only one column, then it is assumed to represent the first y column and x column is not filled.
status	Pointer to status data; enter NULL if not needed

Definition at line 25 of file hcio.c.

  {
  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__);
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<2 || csv->col_nr<4) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  /* Check from the title fields that data indeed is HRRT HC data */
  int ret=0;
  if(strcasecmp(csv->c[0].content, "Singles")!=0) ret++;
  if(strcasecmp(csv->c[1].content, "Randoms")!=0) ret++;
  if(strcasecmp(csv->c[2].content, "Prompts")!=0) ret++;
  if(strncasecmp(csv->c[3].content, "Time(ms)", 4)!=0) ret++;
  if(ret>0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Allocate memory for TAC data */
  ret=tacAllocate(tac, csv->row_nr-1, 3);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=3; tac->sampleNr=csv->row_nr-1;
  if(verbose>2) printf("  sampleNr=%d\n", tac->sampleNr);
 
  /* Set time type */
  tac->isframe=0;
  /* Get time unit from the last title field, inside parens */
  char *cptr=strchr(csv->c[3].content, '(');
  if(cptr==NULL) {
    tac->tunit=UNIT_UNKNOWN;
  } else {
    char *tmp=strdup(cptr+1);
    cptr=strrchr(tmp, ')'); if(cptr!=NULL) *cptr='\0';
    tac->tunit=unitIdentify(tmp);
    free(tmp);
  }
  /* Set concentration unit */
  tac->cunit=UNIT_KCPS;
 
  /* Set TAC names */
  strcpy(tac->c[0].name, "Singles");
  strcpy(tac->c[1].name, "Randoms");
  strcpy(tac->c[2].name, "Prompts");
 
  /* Copy x and y data from CSV into TAC struct */
  double v; int oknr=0;
  for(int i=4; i<csv->nr; i++) {
    if(csv->c[i].row<1 || csv->c[i].row>tac->sampleNr || csv->c[i].col>3) 
      continue;
    v=atofVerified(csv->c[i].content); if(!isnan(v)) oknr++;
    if(csv->c[i].col==3) tac->x[csv->c[i].row-1]=v;
    else tac->c[csv->c[i].col].y[csv->c[i].row-1]=v;
  }
  if(oknr<4) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Set file format */
  tac->format=TAC_FORMAT_HRRT_HC;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadInveonCSV()

int tacReadInveonCSV ( TAC * tac, CSV * csv, TPCSTATUS * status )

extern

Read Inveon TAC format from CSV struct into TAC struct.

Note that there are several Inveon TAC formats, and not all are supported.

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to Inveon CSV from which data is read.
status	Pointer to status data; enter NULL if not needed

Definition at line 405 of file taccsv.c.

  {
  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__);
 
  int ret;
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<2 || csv->col_nr<5) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  /* Check from the first row that data indeed is CSV TAC data */
  if(strstr(csv->c[0].content, " - Time")==NULL || 
     strstr(csv->c[2].content, "(upper bound)")==NULL || 
     strstr(csv->c[3].content, "(lower bound)")==NULL ||
     strstr(csv->c[4].content, "(standard deviation)")==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
 
  /* Allocate memory for TAC data */
  ret=tacAllocate(tac, csv->row_nr-1, csv->col_nr/5);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=csv->col_nr/5; tac->sampleNr=csv->row_nr-1;
  tac->format=TAC_FORMAT_INVEON;
 
  /* This format has only frame middle time */
  tac->isframe=0;
 
  /* Read TAC names and units */
  char *cptr, buf[1024];
  ret=0;
  for(int ri=0; ri<tac->tacNr; ri++) {
    int ci=5*ri;
    strlcpy(buf, csv->c[ci].content, 1024);
    cptr=strcasestr(buf, " - Time"); if(cptr==NULL) {ret++; break;}
    *cptr=(char)0; strlcpy(tac->c[ri].name, buf, MAX_TACNAME_LEN);
    if(ri==0) { // Time unit only from the first column
      cptr=strcasestr(csv->c[ci].content, "Time (");
      if(cptr!=NULL) {
        strlcpy(buf, cptr+6, 1024);
        cptr=strchr(buf, ')'); if(cptr!=NULL) *cptr=(char)0;
        tac->tunit=unitIdentify(buf);
      }
    }
    if(ri==0) { // Concentration unit only from the first TAC
      ci++;
      cptr=strcasestr(csv->c[ci].content, " - ");
      if(cptr!=NULL) {
        strlcpy(buf, cptr+3, 1024);
        cptr=strchr(buf, ','); if(cptr!=NULL) *cptr=(char)0;
        tac->cunit=unitIdentify(buf);
      }
    }
  }
 
  /* Read one line at a time */
  for(int si=0; si<tac->sampleNr; si++) {
    ret=atofCheck(csvCell(csv, 1+si, 0), &tac->x[si]); if(ret) break;
    for(int ri=0; ri<tac->tacNr; ri++) {
      ret=atofCheck(csvCell(csv, 1+si, 1+5*ri), &tac->c[ri].y[si]); if(ret) break;
    }
  }
 
 
  if(tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  tac->format=TAC_FORMAT_PMOD;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadMat()

int tacReadMat ( TAC * tac, CSV * csv, TPCSTATUS * status )

extern

Read Mat format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read.
status	Pointer to status data; enter NULL if not needed

Definition at line 25 of file matio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(csv==NULL || csv->row_nr<1 || csv->col_nr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) printf("%s()\n", __func__);
 
  int ret, n;
 
  /* Check that CSV is of regular size */
  if(!csvIsRegular(csv)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Column and row numbers must be at least 2 */
  if(csv->col_nr<2 || csv->row_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Allocate memory for TAC data */
  ret=tacAllocate(tac, csv->col_nr-1, csv->row_nr-1);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=csv->row_nr-1; tac->sampleNr=csv->col_nr-1;
  tac->isframe=1;
 
  /* First cell may contain study number */
  char *cptr=csvCell(csv, 0, 0);
  if(cptr!=NULL && cptr[0] && strnlen(cptr, 20)<20)
    tacSetHeaderStudynr(&tac->h, cptr);
 
  /* Get sample times from the first line */
  for(int j=0; j<tac->sampleNr; j++) {
    cptr=csvCell(csv, 0, j+1); if(cptr==NULL) {ret++; break;}
    n=strlen(cptr); if(n<3) {ret++; break;}
    char *cptr2=strchr(cptr+1, '-'); if(cptr2!=NULL) {*cptr2=(char)0; cptr2++;}
    tac->x1[j]=atofVerified(cptr);
    tac->x2[j]=atofVerified(cptr2);
    if(isnan(tac->x1[j]) || isnan(tac->x2[j])) {ret++; break;}
    tac->x[j]=0.5*(tac->x1[j]+tac->x2[j]);
  }
  if(ret) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
 
  /* Get region names from the first column */
  ret=0;
  for(int i=0; i<tac->tacNr; i++) {
    cptr=csvCell(csv, i+1, 0); if(cptr==NULL) {ret++; break;}
    n=strlen(cptr); if(n>2 && cptr[n-1]=='\'') {cptr[n-1]=(char)0; n--;}
    if(n>1 && cptr[0]=='\'') {cptr++; n--;}
    if(n>0) strlcpy(tac->c[i].name, cptr, MAX_TACNAME_LEN); 
  }
  if(ret) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Get concentrations */
  n=0; ret=0;
  for(int i=0; i<tac->tacNr && ret==0; i++) {
    for(int j=0; j<tac->sampleNr; j++) {
      cptr=csvCell(csv, i+1, j+1); if(cptr==NULL) {ret++; break;}
      tac->c[i].y[j]=atofVerified(cptr); if(!isnan(tac->c[i].y[j])) n++;
    }
  }
  if(ret) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
 
  tac->format=TAC_FORMAT_MAT;
  tac->weighting=WEIGHTING_OFF;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadOldAllogg()

int tacReadOldAllogg ( TAC * tac, IFT * hdr, TPCSTATUS * status )

extern

Read Allogg #1 ABSS data from IFT struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacInit, tacRead, tacReadAllogg

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
hdr	Pointer to IFT to read data from.
status	Pointer to status data; enter NULL if not needed.

Definition at line 173 of file tacabss.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(hdr==NULL || hdr->keyNr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
 
  /* Check whether IFT even can contain Allogg 1 data */
  int ii;
  /* Find a specific key */
  ii=iftFindKey(hdr, "Discriminators", 0);
  if(ii<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Find the measurement start date and time, and store for later use */
  char scan_start_time[32];
  int n, year, month, day, hour, min, sec;
  char buf[128];
  for(ii=0; ii<hdr->keyNr; ii++) {
    if(strnlen(hdr->item[ii].key, 3)>0 || hdr->item[ii].value==NULL) continue;
    if(strDateTimeValid(hdr->item[ii].value, scan_start_time)==0) {
      n=sscanf(scan_start_time, "%d-%d-%d %d:%d:%d", 
               &year, &month, &day, &hour, &min, &sec);
    } else {
      n=strnlen(hdr->item[ii].value, 15);
      if(n<8 || n>10) continue;
      //printf("ii=%d '%s' '%s'\n", ii, hdr->item[ii].key, hdr->item[ii].value);
      n=sscanf(hdr->item[ii].value, "%d-%d-%d", &year, &month, &day);
    }
    if(n==3 || n==6) break;
  }
  if(ii==hdr->keyNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  //printf("found '%s' at ii=%d\n", hdr->item[ii].value, ii);
 
  /* Find the measurement start time HHMMSS */
  for(ii=0; ii<hdr->keyNr; ii++) {
    if(strnlen(hdr->item[ii].key, 3)>0 || hdr->item[ii].value==NULL) continue;
    //printf("ii=%d '%s' '%s'\n", ii, hdr->item[ii].key, hdr->item[ii].value);
    if(strnlen(hdr->item[ii].value, 10)==6) break;
  }
  if(ii==hdr->keyNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  //printf("found '%s' at ii=%d\n", hdr->item[ii].value, ii);
  strlcpy(buf, hdr->item[ii].value, 128);   buf[2]=(char)0; hour=atoi(buf);
  strlcpy(buf, hdr->item[ii].value+2, 128); buf[2]=(char)0; min=atoi(buf);
  strlcpy(buf, hdr->item[ii].value+4, 128); buf[2]=(char)0; sec=atoi(buf);
    
  /* Make date and time string and set abss->startTime */
  sprintf(scan_start_time, "%04d-%02d-%02d %02d:%02d:%02d", 
          year, month, day, hour, min, sec);
  if(verbose>11) printf("  scan_start_time := %s\n", buf);
 
  /* Sample data should start after this index */
  /* Allocate memory for TAC data */
  int ret;
  ret=tacAllocate(tac, hdr->keyNr-ii, 2);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return(ret);
  tac->tacNr=2;
  /* Set basic header information */
  tac->format=TAC_FORMAT_ABSS_ALLOGG_OLD;
  tac->isframe=1; // Allogg data always contains frame start and end times
  tac->tunit=UNIT_SEC;
  tac->cunit=UNIT_COUNTS;
  /* Set TAC names into TAC struct */
  strcpy(tac->c[0].name, "Singles");
  strcpy(tac->c[1].name, "Coincidents");
 
  /* Go through the lines, extracting sample data, and deleting data lines
     from the header */
  if(verbose>2) printf("  reading data lines...\n");
  ii++;
  int i=0;
  while(ii<hdr->keyNr && i<tac->_sampleNr) {
    if(strnlen(hdr->item[ii].key, 3)>0 || hdr->item[ii].value==NULL) {
      iftDelete(hdr, ii); continue;}
    if(hdr->item[ii].value[0]=='#') {iftDelete(hdr, ii); continue;}
    n=sscanf(hdr->item[ii].value, "%lf %lf %lf", 
         &tac->x2[i], &tac->c[0].y[i], &tac->c[1].y[i]);
    if(n==3) i++;
    iftDelete(hdr, ii);
  }
  tac->sampleNr=i;
  if(verbose>2) printf("  %d data line(s) read.\n", i);
  if(i<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(TPCERROR_NO_DATA);
  }
  
  /* Calculate frame start and mid times */
  for(i=1; i<tac->sampleNr; i++) {
    tac->x1[i]=tac->x2[i-1];
    tac->x[i]=0.5*(tac->x1[i]+tac->x2[i]);
  }
  /* first sample */
  i=0;
  if(tac->sampleNr>1) {
    tac->x1[i]=tac->x2[i]-(tac->x2[i+1]-tac->x1[i+1]);
  } else {
    tac->x1[i]=0.0;
  }
  tac->x[i]=0.5*(tac->x1[i]+tac->x2[i]);
 
  /* Set all header lines to comments */
  for(ii=0; ii<hdr->keyNr; ii++) hdr->item[ii].comment=1;
  /* Copy the header contents to TAC (deletes previous contents) */
  (void)iftDuplicate(hdr, &tac->h);
  tac->h.type=3;
  /* Copy the start time to the TAC header */
  (void)tacSetHeaderScanstarttime(&tac->h, scan_start_time);
 
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadPMOD()

int tacReadPMOD ( TAC * tac, CSV * csv, IFT * hdr, TPCSTATUS * status )

extern

Read PMOD format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWritePMOD, tacRead

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read; if it contains only one column, then it is assumed to represent the first y column and x column is not filled.
hdr	Pointer to possible header data, which, if available, is processed and copied to TAC too; enter NULL if not available.
status	Pointer to status data; enter NULL if not needed.

Definition at line 146 of file pmodio.c.

  {
  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__);
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<2 || csv->col_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  /* Check from the first field that data indeed is PMOD data */
  int isframe=-1;
  if(strncasecmp(csv->c[0].content, "Time", 4)==0) isframe=0;
  else if(strncasecmp(csv->c[0].content, "Start", 5)==0 &&
          strncasecmp(csv->c[1].content, "End", 3)==0) isframe=1;
  if(isframe<0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Allocate memory for TAC data */
  int n, ret;
  n=csv->col_nr-1; if(isframe==1) n--;
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  ret=tacAllocate(tac, csv->row_nr-1, n);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=n; tac->sampleNr=csv->row_nr-1;
  tac->isframe=isframe;
 
  /* Copy header to TAC structure */
  iftDuplicate(hdr, &tac->h);
 
  /* Get time unit from first field, inside parens */
  char *cptr;
  cptr=strchr(csv->c[0].content, '[');
  if(cptr==NULL) { // Standard way of specifying units not found
    cptr=strchr(csv->c[0].content, '('); // Non-standard way to specify units
    if(cptr==NULL) { // Not even non-standard way used
      tac->tunit=UNIT_UNKNOWN;
    }
  }
  if(cptr!=NULL) {
    char *tmp=strdup(cptr+1);
    cptr=strrchr(tmp, ']');  if(cptr==NULL) cptr=strrchr(tmp, ')');
    if(cptr!=NULL) *cptr='\0';
    tac->tunit=unitIdentify(tmp);
    free(tmp);
  }
 
  /* Get concentration unit from 2nd field, inside parens */
  cptr=strchr(csv->c[1].content, '[');
  if(cptr==NULL) {
    tac->cunit=UNIT_UNKNOWN;
  } else {
    char *tmp=strdup(cptr+1);
    cptr=strrchr(tmp, ']'); if(cptr!=NULL) *cptr='\0';
    tac->cunit=unitIdentify(tmp);
    free(tmp);
  }
  
  /* Read TAC names from the title line */
  int i;
  n=0; if(isframe==0) i=1; else i=2;
  for(; i<csv->nr; i++) {
    if(csv->c[i].row!=0 || n>=tac->tacNr) break;
    /* Copy TAC name, removing unit if necessary */
    if(strchr(csv->c[i].content, '[')) {
      char *tmp=strdup(csv->c[i].content);
      cptr=strchr(tmp, '['); *cptr='\0';
      strlcpy(tac->c[n].name, tmp, MAX_TACNAME_LEN+1);
      free(tmp);
    } else {
      strlcpy(tac->c[n].name, csv->c[i].content, MAX_TACNAME_LEN+1);
    }
    if(strcmp(tac->c[n].name, ".")==0) strcpy(tac->c[n].name, "");
    n++;
  }
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  tac->tacNr=n;
  if(verbose>2) printf("  tacNr=%d\n  sampleNr=%d\n", tac->tacNr, tac->sampleNr);
 
  /* Copy x and y data from CSV into TAC structure */
  int fi=0, ri=0, oknr=0;
  ret=0;
  double v;
  for(i=0; i<csv->nr; i++) if(csv->c[i].row==1) break;
  for(; i<csv->nr; i++) {
    if(verbose>10) printf("i=%d\trow=%d\tcol=%d\n", i, csv->c[i].row, csv->c[i].col);
    fi=csv->c[i].row-1; if(fi<0 || fi>=tac->sampleNr) {ret++; continue;}
    if(csv->c[i].col<0) {ret++; continue;}
    ri=csv->c[i].col-1; if(tac->isframe) ri--; 
    if(ri>=tac->tacNr) {ret++; continue;}
    v=atofVerified(csv->c[i].content); if(isfinite(v)) oknr++;
    if(verbose>10) printf("   -> fi=%d\tri=%d\t=\t%g\n", fi, ri, v);
    if(ri<0) {
      if(tac->isframe) {
        if(ri==-2) tac->x1[fi]=v; else if(ri==-1) tac->x2[fi]=v;
      } else tac->x[fi]=v;
    } else tac->c[ri].y[fi]=v;
  }
  if(verbose>0 && ret>0) printf("%d error(s) in reading PMOD file format.\n", ret);
  if(oknr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Set middle sample times when necessary */
  if(tac->isframe)
    for(fi=0; fi<tac->sampleNr; fi++)
      tac->x[fi]=0.5*(tac->x1[fi]+tac->x2[fi]);
 
  /* Delete any empty columns (no name, no values) from the end */
  int ci=tac->tacNr-1;
  while(ci>0) {
    if(strlen(tac->c[ci].name)>0) break;
    int i;
    for(i=0; i<tac->sampleNr; i++) if(isfinite(tac->c[ci].y[i])) break;
    if(i<tac->sampleNr) break;
    tac->tacNr--; ci--;
  }
 
  /* If units are not known, try to read units from header */
  if(tac->cunit==UNIT_UNKNOWN) tacGetHeaderUnit(tac, NULL);
  else tacSetHeaderUnit(&tac->h, UNIT_UNKNOWN);
  if(tac->tunit==UNIT_UNKNOWN) tacGetHeaderTimeunit(tac, NULL);
  else tacSetHeaderTimeunit(&tac->h, UNIT_UNKNOWN);
 
  /* Move column containing weights to its correct place in the structure */
  if(tac->tacNr>1) { // except if file contains only one TAC
    ret=tacWMove(tac, 1, status);
    if(ret!=TPCERROR_OK && ret!=TPCERROR_NO_WEIGHTS) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      return(ret);
    }
  }
  if(tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  tac->format=TAC_FORMAT_PMOD;
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadQView()

int tacReadQView ( TAC * tac, CSV * csv, const int grouponly, TPCSTATUS * status )

extern

Read QView format from CSV struct into TAC struct.

Note that QView TAC format does not contain frame times.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacRead, tacWrite, tacInit

Parameters

tac	Pointer to TAC structure, contents of which are to be written.
csv	Pointer to CSV from which data is read.
grouponly	Read TACs of all ROIs (0), or only group means (1).
status	Pointer to status data; enter NULL if not needed.

Definition at line 27 of file qviewio.c.

  {
  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__); fflush(stdout);}
 
  tacFree(tac);
 
  if(csv==NULL || csv->row_nr<2 || csv->col_nr<12) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  int ret=0;
 
  /* Check from the first line (title) that data indeed is QView data */
  if(strcasecmp(csv->c[0].content, "directory")!=0 || 
     strcasecmp(csv->c[11].content, "group")!=0)
  {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Find the highest frame number from parens in 'num' field */
  int maxFrameNr=0;
  {
    int fn;
    char *cptr, *cptr2;
    for(int ri=1; ri<csv->row_nr; ri++) {
      cptr=csvCell(csv, ri, 2); if(cptr==NULL) continue;
      if(verbose>50) printf("  '%s'\n", cptr);
      cptr2=strchr(cptr, '('); if(cptr2==NULL) continue;
      fn=atoi(cptr2+1); if(fn>maxFrameNr) maxFrameNr=fn;
    }
  }
  if(verbose>1) printf("maxFrameNr := %d\n", maxFrameNr);
  if(maxFrameNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Estimate the number of TACs */
  int maxTacNr=(csv->row_nr-1)/maxFrameNr; // row_nr includes the title line
  if(verbose>1) printf("maxTacNr := %d\n", maxTacNr);
  if(maxFrameNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Allocate memory for TAC data; and to be on the safe side, for one extra TAC */
  ret=tacAllocate(tac, maxFrameNr, maxTacNr);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return(ret);
  tac->isframe=0;
 
  /* Copy data from CSV into TAC structure */
  ret=0;
  for(int i=1; i<csv->row_nr; i++) {
    /* Read the cells of this CSV line */
    char *cnum, *cslice, *cmean, *cpixel, *cgroup;
    cnum=csvCell(csv, i, 2); if(cnum==NULL) continue;
    cslice=csvCell(csv, i, 3); if(cslice==NULL) continue;
    cmean=csvCell(csv, i, 4); if(cmean==NULL) continue;
    cpixel=csvCell(csv, i, 9); if(cpixel==NULL) continue;
    cgroup=csvCell(csv, i, 11); if(cgroup==NULL) continue;
    /* Get slice number; if missing, then this is group ROI */
    int slice;
    ret=atoiCheck(cslice, &slice);
    if(ret!=0) {slice=-1; ret=0;}
    /* If only group ROIs were requested, and this is not group */
    if(slice>0 && grouponly!=0) continue;
    /* Depending on previous, get frame number and group name, or frame and ROI number */
    char *cptr=strchr(cnum, '('); if(cptr==NULL) continue;
    int fn=atoi(cptr+1); if(fn<1 || fn>maxFrameNr) {ret=1; break;}
    char tacname[MAX_TACNAME_LEN+1];
    if(slice<1) { // this is group
      /* Check group name, and use it as TAC name */
      if(strnlen(cgroup, 2)<1) {ret=2; break;}
      strlcpy(tacname, cgroup, MAX_TACNAME_LEN);
    } else { // this is one roi at one image slice
      /* Get ROI number */
      int roinr=atoi(cnum); if(roinr<1) {ret=3; break;}
      /* If group name exists, the use that and ROI number and slice number to construct TAC name */
      if(strnlen(cgroup, 2)>0 && strnlen(cgroup, 2)<12) {
        sprintf(tacname, "%s_roi%d__pl%d", cgroup, roinr, slice);
      } else {
        /* Otherwise use ROI number and slice number to construct TAC name */
        sprintf(tacname, "roi%d__pl%d", roinr, slice);
      }
    }
    /* Get the number of pixels */
    int pxlnr;
    ret=atoiCheck(cpixel, &pxlnr); if(ret) {pxlnr=0; ret=0;}
    /* Get the ROI concentration */
    double conc=atofVerified(cmean);
    if(verbose>20) printf("tacname='%s' pxlnr=%d fn=%d conc=%g\n", tacname, pxlnr, fn, conc);
    /* Determine the TAC index for this; first check if this TAC already is added */
    int ri;
    for(ri=0; ri<tac->tacNr; ri++) {
      if(strcmp(tac->c[ri].name, tacname)==0 && doubleMatch(tac->c[ri].size, (double)pxlnr, 0.1))
        break;
      /* if TAC is not yet added, then ri will be set to the first free index */
    }
    /* check that ri is not too big */
    if(ri>=maxTacNr) {ret=4; break;}
    /* Put value in place */
    tac->c[ri].y[fn-1]=conc;
    /* If this was first encounter of this TAC, then set other info, and increase tacNr */
    if(ri>=tac->tacNr) {
      strcpy(tac->c[ri].name, tacname);
      tac->c[ri].size=(double)pxlnr;
      tac->tacNr++;
    }
    /* Increase also sampleNr when necessary */
    if(fn>tac->sampleNr) tac->sampleNr=fn;
  }
  if(ret) {
    if(verbose>1) printf("  error %d\n", ret);
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  if(tac->sampleNr<1 || tac->tacNr<1) {
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  for(int i=0; i<tac->sampleNr; i++) tac->x[i]=tac->x1[i]=tac->x2[i]=0.0;
 
  tac->format=TAC_FORMAT_QVIEW;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadScanditronics()

int tacReadScanditronics ( TAC * tac, IFT * hdr, TPCSTATUS * status )

extern

Read Scanditronics ABSS data from IFT struct into TAC struct.

Two date-time strings will be written in header, scan_start_time containing the time of the first sample, and sampler_start_time containing the time given in ABSS file header.

Scanditronics ABSS format is almost identical to GEMS, but the headers and times are processed differently, hence separate functions. If function finds that provided data is actually from GEMS, it calls tacReadGEMS.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacInit, tacRead, tacReadGEMS, tacReadAllogg

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
hdr	Pointer to IFT to read data from.
status	Pointer to status data; enter NULL if not needed.

Definition at line 326 of file tacabss.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(hdr==NULL || hdr->keyNr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
 
  /* Check whether IFT contains Scanditronics (or GEMS) data */
  int format;
  if(iftSearchValue(hdr, "AUX", 0)<0 || 
     iftSearchValue(hdr, "1st detector pair", 0)<0)
  {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  format=TAC_FORMAT_ABSS_SCANDITRONICS;
 
  /* Find the measurement start date, possibly with time; Scanditronics
     header is not required to contain the date and time, because those are
     stored as the first column in the sample data. */
  struct tm start_time; start_time.tm_mday=0;
  int ii, n;
  for(ii=0; ii<hdr->keyNr; ii++) {
    if(strnlen(hdr->item[ii].key, 3)>0) continue;
    n=strnlen(hdr->item[ii].value, 22);
    if(n<10 || n>19) continue;
    //printf("ii=%d '%s' '%s'\n", ii, hdr->item[ii].key, hdr->item[ii].value);
    if(strDateTimeRead(hdr->item[ii].value, &start_time)!=0) {
      /* Date and time not found, try only date */
      if(strDateRead(hdr->item[ii].value, &start_time)!=0) continue; 
    }
    break;
  }
  if(verbose>1) {
    if(ii==hdr->keyNr) printf("  header does not contain date and time.\n");
    else printf("found '%s' at ii=%d\n", hdr->item[ii].value, ii);
  }
 
  /* Sample data should start after this index */
  /* Allocate memory for TAC data */
  int ret;
  ret=tacAllocate(tac, hdr->keyNr-ii, 7);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return(ret);
  tac->tacNr=7;
  /* Set basic header information */
  tac->format=format;
  tac->isframe=1; // Data always contains frame start and end times
  tac->tunit=UNIT_SEC;
  tac->cunit=UNIT_COUNTS;
  /* Set TAC names into TAC struct */
  strcpy(tac->c[0].name, "Detector1-Coinc");
  strcpy(tac->c[1].name, "Detector1-Singl1");
  strcpy(tac->c[2].name, "Detector1-Singl2");
  strcpy(tac->c[3].name, "Detector2-Coinc");
  strcpy(tac->c[4].name, "Detector2-Singl1");
  strcpy(tac->c[5].name, "Detector2-Singl2");
  strcpy(tac->c[6].name, "AUX-counts");
 
  /* Go through the lines, extracting sample data, and deleting data lines
     from the header */
  if(verbose>2) printf("  reading data lines...\n");
  ii++;
  int i=0, stopped=0;
  double time_of_day, first_tod=0.0, time_since_start, meas_interval;
  while(ii<hdr->keyNr && i<tac->_sampleNr) {
    if(stopped) {iftDelete(hdr, ii); continue;}
    if(strnlen(hdr->item[ii].key, 3)>0 || hdr->item[ii].value==NULL) {
      iftDelete(hdr, ii); continue;}
    if(hdr->item[ii].value[0]=='#') {iftDelete(hdr, ii); continue;}
    //printf("ii=%d '%s'\n", ii, hdr->item[ii].value);
    n=sscanf(hdr->item[ii].value, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf\n", 
         &time_of_day, &time_since_start, &meas_interval, 
         &tac->c[0].y[i], &tac->c[1].y[i], &tac->c[2].y[i], &tac->c[3].y[i],
         &tac->c[4].y[i], &tac->c[5].y[i], &tac->c[6].y[i]);
    //printf("  n=%d\n", n);
    if(n!=10) {
      /* first line may contain the protocol; keep it as comment */
      if(i==0) {ii++; continue;}
      /* Later occurrence is considered as an error */
      stopped=1; iftDelete(hdr, ii); continue;
    } 
    if(time_of_day==0.0 && meas_interval==0.0) {
      stopped=1; iftDelete(hdr, ii); continue;}
    if(i==0) first_tod=time_of_day;
    tac->x1[i]=time_since_start;
    tac->x2[i]=time_since_start+meas_interval;
    i++;
    iftDelete(hdr, ii);
  }
  tac->sampleNr=i;
  if(verbose>2) printf("  %d data line(s) read.\n", i);
  if(i<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(TPCERROR_NO_DATA);
  }
  if(verbose>4) printf("  first_tod := %.1lf\n", first_tod);
  
  /* Calculate frame mid times */
  for(i=0; i<tac->sampleNr; i++) tac->x[i]=0.5*(tac->x1[i]+tac->x2[i]);
 
  /* Read scan start date and time from the first sample */
  char scan_start_time[32], sampler_start_time[32];
  time_t tim=(time_t)first_tod;
  struct tm tmtim;
  if(localtime_r(&tim, &tmtim)==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  /* Check that also date is here; if not, this is actually GEMS data */
  if(tmtim.tm_year<73) {
    if(verbose>0) printf("data is not Scanditronics but GEMS format\n");
    if(verbose>1 && 
       strftime(scan_start_time, 32, "%Y-%m-%d %H:%M:%S", &tmtim)!=0) {
      printf("first_sample_time := %s\n", scan_start_time);
    }
    tacFree(tac);
    return(tacReadGEMS(tac, hdr, status));
  }
  /* Set scan_start_time based on the first sample */
  if(strftime(scan_start_time, 32, "%Y-%m-%d %H:%M:%S", &tmtim)==0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATETIME);
    return(TPCERROR_NO_DATETIME);
  }
  /* Set sampler_start_time based on the header, or first sample, if header
     does not contain the time */
  if(start_time.tm_mday==0) { // header did not contain date and time
    strcpy(sampler_start_time, scan_start_time);
  } else {
    /* If header contains just the date but not the time, then take the time
       from samples */
    if(start_time.tm_hour==0 && start_time.tm_min==0 && start_time.tm_sec==0) {
      start_time.tm_hour=tmtim.tm_hour;
      start_time.tm_min=tmtim.tm_min;
      start_time.tm_sec=tmtim.tm_sec;
    }
    if(strftime(sampler_start_time, 32, "%Y-%m-%d %H:%M:%S", &start_time)==0)
      strcpy(sampler_start_time, scan_start_time);
  }
 
 
  /* Set all header lines to comments */
  for(ii=0; ii<hdr->keyNr; ii++) hdr->item[ii].comment=1;
  /* Copy the header contents to TAC (deletes previous contents) */
  (void)iftDuplicate(hdr, &tac->h);
  tac->h.type=3;
  /* Set the scan start time in the TAC header */
  (void)tacSetHeaderScanstarttime(&tac->h, scan_start_time);
  /* Set the sampler start time in the TAC header */
  if(sampler_start_time[0])
    (void)iftPut(&tac->h, "sampler_start_time", sampler_start_time, 1, NULL);
  /* Copy study number to the TAC header */
  ii=iftFindKey(hdr, "Patient", 0); 
  if(ii>=0 && strnlen(hdr->item[ii].value, 5)>0)
   (void)tacSetHeaderStudynr(&tac->h, hdr->item[ii].value);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead(), and tacReadGEMS().

tacReadSIF()

int tacReadSIF ( TAC * tac, CSV * csv, IFT * hdr, TPCSTATUS * status )

extern

Read SIF from CSV structure into TAC structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWriteSIF, tacRead, csvRead, TAC, CSV, tacWCopy, tacSetWeights

Parameters

tac	Pointer to TAC structure, contents of which are to be filled here. tacNr will always be set to 2, even if count data is not available. Trues will be saved or computed into a non-standard 3rd column, which is not included in tacNr, even if column is found in CSV.
csv	Pointer to CSV from which SIF data is read.
hdr	Pointer to possible header data, which, if available, if processed and copied to TAC too; enter NULL if not available.
status	Pointer to status data; enter NULL if not needed.

Definition at line 129 of file sifio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) {printf("%s(tac, csv, hdr, status)\n", __func__); fflush(stdout);}
 
 
 
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(csv==NULL || csv->row_nr<1 || csv->col_nr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Check whether CSV file even can contain SIF data */
  if(verbose>2) {printf("  checking that CSV contains SIF\n"); fflush(stdout);}
  int title_item_nr;
  title_item_nr=csvRowLength(csv, 0);
  if(title_item_nr==1 && csv->separator!=' ') {
    if(verbose>1) printf("title_item_nr := %d\n", title_item_nr);
    if(verbose>2) {printf("  SIF has not space character as column separator; fixing title line\n");}
    //printf("content='%s'\n", csv->c[0].content);
    char s1[128]; int n=0;
    int len=strTokenNCpy(csv->c[0].content, " ,;\t", n+1, s1, 128);
    if(!(len>0)) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
    n++; //printf("n=%d s1='%s'\n", n, s1);
    char s[128];
    while(strTokenNCpy(csv->c[0].content, " ,;\t", n+1, s, 128)>0) {
      n++; //printf("n=%d s='%s'\n", n, s);
      if(n==2) csvPutString(csv, s, 1); else csvPutString(csv, s, 0);
    }
    if(n>csv->col_nr) csv->col_nr=n;
    strcpy(csv->c[0].content, s1);
    int j=1;
    for(int i=1+csv->nr-n; i<csv->nr; i++) {
      //printf("content[%d]='%s'\n", i, csv->c[i].content);
      csv->c[i].row=0; csv->c[i].col=j; j++;
    }
    csv->row_nr--;
    csvReorg(csv, NULL);
    title_item_nr=csvRowLength(csv, 0);
    //csvList(csv, stdout);
  }
 
  if(csv->row_nr<2 || title_item_nr<5 ) {
    if(verbose>1) {printf("title_item_nr := %d\n", title_item_nr); csvList(csv, stdout);}
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  int ret;
 
  /* Allocate memory for TAC data */
  if(verbose>2) {printf("  allocating memory\n"); fflush(stdout);}
  ret=tacAllocate(tac, csv->row_nr-1, 3);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  if(ret!=TPCERROR_OK) return ret;
  /* Set initial SIF data size */
  tac->tacNr=2; 
  tac->sampleNr=csv->row_nr-1;
  /* Set basic header information */
  tac->format=TAC_FORMAT_SIF;
  tac->isframe=1; // SIF always contains frame start and end times
  tac->tunit=UNIT_SEC;
  tac->cunit=UNIT_COUNTS;
  
  /* Set SIF compatible titles into TAC struct */
  strcpy(tac->c[0].name, "Prompts");
  strcpy(tac->c[1].name, "Randoms");
  strcpy(tac->c[2].name, "Trues"); // computed, not saved
 
  /* Read SIF title line */
  if(verbose>2) {printf("  reading SIF header\n"); fflush(stdout);}
  /* scan start time */
  char sif_scan_start_time[20];
  ret=0;
  if(strlen(csv->c[0].content)<11 && strlen(csv->c[1].content)<9) {
    char temp[20];
    strcpy(temp, csv->c[0].content); strcat(temp, " ");
    strcat(temp, csv->c[1].content);
    if(verbose>4) printf("  datetime := '%s'\n", temp);
    ret=strDateTimeValid(temp, sif_scan_start_time);
    if(ret!=0) {
      if(verbose>1) printf("  invalid SIF date/time (%d).\n", ret);
      else if(verbose>0) printf("  invalid SIF date/time.\n");
      if(ret<0) ret=0; // its common that SIF time is 1/1/1970 etc
    }
  } else ret=1;
  if(ret!=0) {
    if(verbose>2) {
      printf(" cell0 := '%s'\n", csv->c[0].content);
      printf(" cell1 := '%s'\n", csv->c[1].content);
    }
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  if(verbose>1) printf("sif_scan_start_time := %s\n", sif_scan_start_time);
  /* Nr of frames */
  int frameNr;
  frameNr=atoi(csv->c[2].content);
  if(verbose>1) printf("sif_frame_nr := %d\n", frameNr);
  if(frameNr<1 || frameNr>tac->_sampleNr) {
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  tac->sampleNr=frameNr;
  /* Nr of columns */
  int colNr;
  colNr=atoi(csv->c[3].content);
  if(verbose>1) printf("sif_col_nr := %d\n", colNr);
  if(colNr<2) {
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* SIF version; forget about it */
  /* Study number; may be missing */
  char studynr[MAX_STUDYNR_LEN+1]; studynr[0]='\0';
  if(title_item_nr>5) {
    strlcpy(studynr, csv->c[5].content, MAX_STUDYNR_LEN+1);
    if(strcmp(studynr, ".")==0) strcpy(studynr, "");
    if(verbose>2) printf("sif_studynr := %s\n", studynr);
  }
  /* Isotope; may be missing */
  char isotope[MAX_ISOTOPE_LEN+1]; strcpy(isotope, "unknown");
  if(title_item_nr>6) {
    int isocode;
    isocode=isotopeIdentify(csv->c[6].content);
    strcpy(isotope, isotopeName(isocode));
  }
  if(verbose>1) printf("sif_isotope := %s\n", isotope);
  
  /* Read SIF frames */
  if(verbose>2) {printf("  reading SIF frames\n"); fflush(stdout);}
  ret=0;
  int fi, ri, ci;
  double v;
  for(fi=0; fi<tac->sampleNr; fi++) {
    ri=fi+1;
    /* frame start time */
    ci=0; v=atofVerified(csvCell(csv, ri, ci)); 
    if(isnan(v)) {ret++; break;} else tac->x1[fi]=v;
    /* frame end time */
    ci=1; v=atofVerified(csvCell(csv, ri, ci)); 
    if(isnan(v)) {ret++; break;} else tac->x2[fi]=v;
    tac->x[fi]=0.5*(tac->x1[fi]+tac->x2[fi]);
    /* Prompts, randoms, and trues, maybe missing */
    tac->c[0].y[fi]=0.0;
    tac->c[1].y[fi]=0.0;
    tac->c[2].y[fi]=0.0;
    if(colNr<3) continue;
    /* so prompts should be there */
    ci=2; v=atofVerified(csvCell(csv, ri, ci)); 
    if(isnan(v)) {ret++; break;} else tac->c[0].y[fi]=v;
    if(colNr<4) continue;
    /* so randoms should be there */
    ci=3; v=atofVerified(csvCell(csv, ri, ci)); 
    if(isnan(v)) {ret++; break;} else tac->c[1].y[fi]=v;
    /* If trues not available, then trues=prompts-randoms */
    if(colNr<5) {
      tac->c[2].y[fi]=tac->c[0].y[fi]-tac->c[1].y[fi];
      continue;
    }
    /* so trues should be there */
    ci=4; v=atofVerified(csvCell(csv, ri, ci)); 
    if(isnan(v)) {ret++; break;} else tac->c[2].y[fi]=v;
  }
  if(ret!=0) {
    tacFree(tac);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Set TAC header */
  /* Isotope */
  if(isotopeIdentify(isotope)<=0 && hdr!=NULL) {
    /* SIF did not contain valid isotope code, get it from argument hdr */
    ret=tacGetHeaderIsotope(hdr, isotope, NULL);
    /* and delete it from hdr */
    if(ret==TPCERROR_OK) tacSetHeaderIsotope(hdr, NULL);
  }
  if(isotopeIdentify(isotope)>0) tacSetHeaderIsotope(&tac->h, isotope);
  /* Studynumber */
  if(!studynr[0] && hdr!=NULL) {
    /* SIF did not contain studynumber, get it from argument hdr */
    ret=tacGetHeaderStudynr(hdr, studynr, NULL);
    /* and delete it from hdr */
    if(ret==TPCERROR_OK) {
      if(verbose>2) printf("sifhdr_studynr := %s\n", studynr);
      tacSetHeaderStudynr(hdr, NULL);
    }
  }
  if(studynr[0]) {
    if(verbose>3) printf("setting TAC studynr to '%s'\n", studynr);
    tacSetHeaderStudynr(&tac->h, studynr);
  }
  /* Scan start time */
  if(strDateTimeValid(sif_scan_start_time, NULL)<0 && hdr!=NULL) {
    /* SIF did not contain valid scan start time, get it from argument hdr */
    ret=tacGetHeaderScanstarttime(hdr, sif_scan_start_time, NULL);
    /* and delete it from hdr */
    if(ret==TPCERROR_OK) tacSetHeaderScanstarttime(hdr, NULL);
  }
  if(strDateTimeValid(sif_scan_start_time, NULL)==0)
    tacSetHeaderScanstarttime(&tac->h, sif_scan_start_time);
 
  if(verbose>4) {printf("  %s() out\n", __func__); fflush(stdout);}
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacReadSimple()

int tacReadSimple ( TAC * tac, CSV * csv, IFT * hdr, TPCSTATUS * status )

extern

Read simple format from CSV struct into TAC struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWriteSimple, tacReadCSV, tacReadMat, tacRead

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
csv	Pointer to CSV from which data is read; if it contains only one column, then it is assumed to represent the first y column and x column is not filled.
hdr	Pointer to possible header data, which, if available, is processed and copied to TAC too; enter NULL if not available.
status	Pointer to status data; enter NULL if not needed.

Definition at line 97 of file simpleio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(tac==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  tacFree(tac);
  if(csv==NULL || csv->row_nr<1 || csv->col_nr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
 
  /* Check that each row has same number of columns */
  if(verbose>1) {printf("  verifying CSV regularity\n"); fflush(stdout);}
  if(!csvIsRegular(csv)) {
    if(verbose>2) {
      printf("\n <-- CSV contents (irregular) ---\n");
      csvWrite(csv, 0, stdout, NULL);
      printf("\n ------------------------------->\n");
      printf("col_nr := %d\n", csv->col_nr);
      printf("row_nr := %d\n", csv->row_nr);
      if(verbose>3) {
        for(int i=0; i<csv->row_nr; i++)
          printf("columns_on_row[%d] := %d\n", 1+i, csvRowLength(csv, i));
        fflush(stdout);
      }
    }
    /* try to make it regular by removing empty columns from the right */
    if(verbose>1) {printf("  trying to make it regular\n"); fflush(stdout);}
    if(csvTrimRight(csv) || !csvIsRegular(csv)) {
      if(verbose>1) {
        printf("\n <-- CSV contents (still irregular) ---\n");
        csvWrite(csv, 0, stdout, NULL);
        printf("\n ------------------------------->\n");
        printf("col_nr := %d\n", csv->col_nr);
        printf("row_nr := %d\n", csv->row_nr);
        if(verbose>5) {
          for(int i=0; i<csv->row_nr; i++)
            printf("columns_on_row[%d] := %d\n", 1+i, csvRowLength(csv, i));
          fflush(stdout);
        }
      }
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
  }
 
  /* Check if first line contains fields starting with letter, suggesting title line */
  int withTitle=0;
  for(int i=0; i<csv->col_nr; i++) {
    char *c=csvCell(csv, 0, i);
    if(c!=NULL && isalpha(c[0])) withTitle++;
  }
  if(verbose>1 && withTitle>0) {printf("CSV seems to have title line.\n"); fflush(stdout);}
  if(withTitle>0) withTitle=1;
 
  int ret, n, m;
 
  /* Allocate memory for TAC data */
  if(verbose>2) {printf("  allocating memory for TAC data\n"); fflush(stdout);}
  n=csv->col_nr; if(n>1) n--;
  m=csv->row_nr-withTitle;
  ret=tacAllocate(tac, m, n);
  statusSet(status, __func__, __FILE__, __LINE__, ret); if(ret!=TPCERROR_OK) return ret;
  tac->tacNr=n; tac->sampleNr=m;
  tac->isframe=0;
  if(verbose>2) {
    printf("  tacNr := %d\n", tac->tacNr);
    printf("  sampleNr := %d\n", tac->sampleNr);
    fflush(stdout);
  }
 
 
  /* Copy title line contents as TAC names */
  if(withTitle) {
    if(verbose>2) {printf("  copying TAC names from the title columns\n"); fflush(stdout);}
    char *c;
    for(int ri=0; ri<tac->tacNr; ri++) {
      c=csvCell(csv, 0, 1+ri);
      if(c!=NULL) strlcpy(tac->c[ri].name, c, MAX_TACNAME_LEN+1);
    }
  }
 
  /* Copy data from CSV into TAC struct */
  if(verbose>2) {printf("  copying data from CSV to TAC\n"); fflush(stdout);}
  int fi, ri, oknr=0;
  char *c;
  for(fi=0; fi<tac->sampleNr; fi++) {
    /* Get the x value from the first column */
    c=csvCell(csv, fi+withTitle, 0);
    tac->x[fi]=atofVerified(c); if(!isnan(tac->x[fi])) oknr++;
    /* Get the y values from the next columns */
    for(ri=0; ri<tac->tacNr; ri++) {
      c=csvCell(csv, fi+withTitle, 1+ri);
      tac->c[ri].y[fi]=atofVerified(c); if(!isnan(tac->c[ri].y[fi])) oknr++;
    }
  }
  if(oknr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Copy header to TAC struct */
  iftDuplicate(hdr, &tac->h);
 
  /* Try to read units from header */
  tacGetHeaderUnit(tac, NULL);
  tacGetHeaderTimeunit(tac, NULL);
 
  tac->format=TAC_FORMAT_SIMPLE;
  if(tac->weighting==WEIGHTING_UNKNOWN) tac->weighting=WEIGHTING_OFF;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacRead().

tacSampleXRange()

int tacSampleXRange ( TAC * d, double * xmin, double * xmax )

extern

Get the range of x values (times) in TAC structure.

Data is not modified. Data does not need to be sorted. Data can contain NaNs, and x values are omitted if no finite y values exist for that x. If data contains sample weights, samples with zero weight are not included.

See also

tacXRange, tacMinX, tacIsX, tacExtractRange, tacCorrectFrameOverlap, tacYRange, tacSetWeights, tacWSampleNr

Author

Vesa Oikonen

Returns

Returns <>0 in case of failure.

Parameters

d	Pointer to TAC structure; not modified.
xmin	Pointer to variable for min x value (NULL if not needed).
xmax	Pointer to variable for max x value (NULL if not needed).

Definition at line 162 of file tacx.c.

  {
  if(xmin!=NULL) *xmin=nan("");
  if(xmax!=NULL) *xmax=nan("");
  /* Check the data */
  if(d==NULL || d->sampleNr<1) return(1);
  /* Find the min and max time */
  double mi, ma, *xi, *xa;
  mi=ma=nan("");
  if(d->isframe) {xi=d->x1; xa=d->x2;} else xi=xa=d->x;
  int weighted=tacIsWeighted(d);
  int i, j;
  for(i=0; i<d->sampleNr; i++) {
    if(!isfinite(xi[i]) || !isfinite(xa[i])) continue;
    if(weighted && !(d->w[i]>0.0)) continue;
    for(j=0; j<d->tacNr; j++) if(isfinite(d->c[j].y[i])) break;
    if(j==d->tacNr) continue;
    if(isnan(mi) || isnan(ma)) {mi=xi[i]; ma=xa[i]; continue;}
    if(xi[i]<mi) mi=xi[i]; else if(xa[i]>ma) ma=xa[i];
  }
  if(xmin!=NULL) *xmin=mi;
  if(xmax!=NULL) *xmax=ma;
  if(!isfinite(mi) || !isfinite(ma)) return(2);
  return(0);
}

Referenced by mtgaPlotSVG(), tacPlotFitSVG(), tacPlotHistogramSVG(), and tacPlotLineSVG().

tacSelectBestReference()

int tacSelectBestReference ( TAC * d )

extern

Select the best guess of reference region in case that several TACs were matching with tacSelectTACs().

Returns

the index of best region, or <0 in case of an error.

Author

Vesa Oikonen

See also

tacSelectTACs, tacSelectedTACs, tacEnsureNames, roinameMatch, tacIndividualNames

Parameters

d	Pointer to TAC structure, after using tacSelectTACs().

Definition at line 139 of file tacselect.c.

  {
  int ri, len, min_len, i;
  
  if(d==NULL || d->tacNr<1) return -1;
  if(tacSelectedTACs(d)<1) return -2;
  for(ri=0, i=-1, min_len=9999; ri<d->tacNr; ri++) {
    if(d->c[ri].sw==0) continue;
    len=strlen(d->c[ri].name);
    if(strcasestr(d->c[ri].name, "ALL")!=NULL) len-=4;
    if(strcasestr(d->c[ri].name, "AVG")!=NULL) len-=4;
    if(strcasestr(d->c[ri].name, "MEAN")!=NULL) len-=5;
    if(len<min_len) {min_len=len; i=ri;}
  }
  if(i<0) return -2; else return i;
}

Referenced by tacReadReference().

tacSelectedTACs()

int tacSelectedTACs ( TAC * d )

extern

Get the number of selected TACs (sw!=0) in TAC structure.

Returns

the number of selected TACs.

Author

Vesa Oikonen

See also

tacSelectTACs, tacSelectBestReference, roinameMatch, tacIndividualNames

Parameters

d	Pointer to TAC data.

Definition at line 103 of file tacselect.c.

  {
  int ri, n;
 
  /* Check the input */
  if(d==NULL || d->tacNr<1) return(0);
  /* Check each VOI */
  for(ri=n=0; ri<d->tacNr; ri++) if(d->c[ri].sw!=0) n++;
  return(n);
}

Referenced by tacSelectBestReference().

tacSelectTACs()

int tacSelectTACs ( TAC * d, const char * region_name, int reset, TPCSTATUS * status )

extern

Select the TAC(s) that have matching ID name or number.

Returns

the number of newly selected VOIs, or <=0 in case of an error.

Author

Vesa Oikonen

See also

tacSelectedTACs, tacSelectBestReference, roinameMatch, tacIndividualNames

Parameters

d	Pointer to TAC structure.
region_name	Name or TAC number (as string, starting from 1) which is searched; string can be inside quotation marks. Enter NULL to select all TACs, or empty string to select TACs with empty name (which really should not exist).
reset	1=Non-matching VOIs are deselected, 0=Old selections are preserved.
status	Pointer to status data; enter NULL if not needed.

Definition at line 24 of file tacselect.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL || d->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 0;
  }
 
  int ri, len, match_nr=0;
 
  /* Check if NULL was given as tac name; if, then select all */
  if(region_name==NULL) {
    for(ri=0; ri<d->tacNr; ri++) d->c[ri].sw=1;
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return(d->tacNr);
  }
 
  /* Reset all selections if required */
  if(reset!=0) for(ri=0; ri<d->tacNr; ri++) d->c[ri].sw=0;
  
  /* Remove any quotation marks from name */
  len=strlen(region_name);
  char local_name[len+1];
  if(len>1) len=strncpyClean(local_name, region_name, len+1);
  else strcpy(local_name, region_name);
 
  /* If tac name is empty, then select all tacs with missing names */
  if(len<1) {
    for(ri=0; ri<d->tacNr; ri++) {
      if(strlen(d->c[ri].name)==0) {d->c[ri].sw=1; match_nr++; continue;}
      /* maybe here should also be checked for names consisting of only space characters */
    }
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return(match_nr);
  }
 
  /* Check each TAC name */
  for(ri=0; ri<d->tacNr; ri++) {
    /* does the name match? */
    if(roinameMatch(d->c[ri].name, local_name, status)!=0) {
      d->c[ri].sw=1; match_nr++; continue;
    }
  }
  /* If at least one match was found, then we are ready */
  if(match_nr>0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return(match_nr);
  }
 
  /* Next try VOI number, if region_name is suitable */
  int n;
  if(sscanf(local_name, "%d", &n)!=1 || n<1 || n>d->tacNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(0);
  }
  d->c[n-1].sw=1; match_nr=1;
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(match_nr);
}

Referenced by tacReadReference().

tacSetHeaderDecayCorrection()

int tacSetHeaderDecayCorrection	(	IFT *	h,
		decaycorrection	dc )

Set the status of decay correction in TAC structure header. Any previous status is deleted.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacGetHeaderDecayCorrection, tacSetHeaderIsotope, tacDecayCorrection

Parameters

h	Pointer to TAC header structure.
dc	Status of decay correction: DECAY_UNKNOWN, DECAY_NOTCORRECTED, or DECAY_CORRECTED.

Definition at line 578 of file tacift.c.

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

Referenced by tacDecayCorrection().

tacSetHeaderInjectiontime()

int tacSetHeaderInjectiontime ( IFT * h, const char * s )

extern

Set injection time in TAC structure header. Any previous injection time items are deleted.

Returns

enum tpcerror (TPCERROR_OK when successful).

See also

tacGetHeaderInjectiontime, tacGetHeaderScanstarttime, tacDecayCorrection, tacSetHeaderIsotope

Author

Vesa Oikonen

Parameters

h	Pointer to TAC header structure.
s	Pointer to string containing the injection time in international format YYYY-MM-DD hh:mm:ss ; enter NULL or "" if you only want to delete it in header.

Definition at line 515 of file tacift.c.

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

tacSetHeaderIsotope()

int tacSetHeaderIsotope ( IFT * h, const char * s )

extern

Set isotope in TAC structure header. Any previous isotope items are deleted.

See also

tacSetIsotope

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

h	Pointer to TAC header structure.
s	Pointer to string containing the isotope; enter NULL or "" if you only want to delete isotope in header.

Definition at line 341 of file tacift.c.

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

Referenced by tacReadSIF(), and tacSetIsotope().

tacSetHeaderScanstarttime()

int tacSetHeaderScanstarttime ( IFT * h, const char * s )

extern

Set scan start time in TAC structure header. Any previous scan start items are deleted.

Returns

enum tpcerror (TPCERROR_OK when successful).

See also

tacGetHeaderScanstarttime, tacSetHeaderInjectiontime, tacDecayCorrection, tacSetHeaderIsotope

Author

Vesa Oikonen

Parameters

h	Pointer to TAC header structure.
s	Pointer to string containing the scan start time in international format YYYY-MM-DD hh:mm:ss ; enter NULL or "" if you only want to delete it in header.

Definition at line 427 of file tacift.c.

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

Referenced by imgToSIF(), tacReadAllogg(), tacReadGEMS(), tacReadOldAllogg(), tacReadScanditronics(), and tacReadSIF().

tacSetHeaderStudynr()

int tacSetHeaderStudynr ( IFT * h, const char * s )

extern

Set study number in TAC struct header. Any previous studynr items are deleted.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacGetHeaderStudyNr, parSetStudyNr, studynrFromFilename

Parameters

h	Pointer to TAC header struct
s	Pointer to string containing the study number; enter NULL or "" if you only want to delete studynr in header

Definition at line 79 of file tacift.c.

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

Referenced by imgToSIF(), tacRead(), tacReadAllogg(), tacReadCSV(), tacReadDFT(), tacReadGEMS(), tacReadMat(), tacReadScanditronics(), tacReadSIF(), and tacWriteDFT().

tacSetHeaderTimeunit()

int tacSetHeaderTimeunit ( IFT * h, int u )

extern

Set time (x) unit in TAC struct header. Any previous x units are deleted.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

h	Pointer to TAC header struct
u	Unit enum

Definition at line 201 of file tacift.c.

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

Referenced by tacGetHeaderTimeunit(), tacReadCSV(), tacReadDFT(), and tacReadPMOD().

tacSetHeaderUnit()

int tacSetHeaderUnit ( IFT * h, int u )

extern

Set concentration (y) unit in TAC struct header. Any previous y unit items are deleted.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

h	Pointer to TAC header struct
u	Unit enum

Definition at line 112 of file tacift.c.

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

Referenced by tacGetHeaderUnit(), tacReadCSV(), tacReadDFT(), tacReadPMOD(), and tacWriteDFT().

tacSetIsotope()

void tacSetIsotope ( TAC * tac, int isotope )

extern

Write isotope code into TAC header, overwriting any previous field.

See also

tacSetHeaderIsotope, tacGetIsotope

Author

Vesa Oikonen

Parameters

tac	Pointer to target TAC structure.
isotope	Isotope code.

Definition at line 41 of file tacdc.c.

  {
  if(tac!=NULL) tacSetHeaderIsotope(&tac->h, isotopeName(isotope));
}

Referenced by imgToSIF(), tacRead4DM(), tacReadModelingData(), tacReadReference(), and tacSetWeights().

tacSetWeights()

int tacSetWeights ( TAC * tac, weights weightMethod, int weightNr, TPCSTATUS * status )

extern

Set TAC sample weights, based on given weighting scheme.

Weights are normalized to have average weight 1.0, with the sum of weights equals the weightNr or number of frames, whichever is smaller.

See also

tacIsWeighted, tacWSampleNr, tacWCopy, tacWMove, sifWeight, tacWByFreq, tacIsX

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

tac	Pointer to TAC structure. Data must be sorted by increasing sample times.
weightMethod	Weighting scheme: WEIGHTING_ON_COUNTS, WEIGHTING_ON_F, WEIGHTING_ON_FD, WEIGHTING_OFF. With WEIGHTING_UNKNOWN weightNr (below) is applied to weights and remaining weights are re-normalized.
weightNr	Number of samples (frames) to weight; if TAC contains more samples than this, then those are set to have zero weight. Enter a large number to give weight to all available samples.
status	Pointer to status data; enter NULL if not needed

Definition at line 462 of file tacw.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) {printf("%s(tac, %d, %d)\n", __func__, weightMethod, weightNr); fflush(stdout);}
 
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(weightNr<1) weightMethod=WEIGHTING_OFF;
  if(weightNr>tac->sampleNr) weightNr=tac->sampleNr;
  int origSampleNr=tac->sampleNr;
 
  /* Get isotope from TAC data */
  isotope fisot=tacGetIsotope(tac);
  if(verbose>3) {printf("  isotope :=  %s\n", isotopeName(fisot)); fflush(stdout);}
  if(fisot==ISOTOPE_UNKNOWN) {
    if(weightMethod==WEIGHTING_ON_COUNTS || weightMethod==WEIGHTING_ON_FD) {
      tac->weighting=WEIGHTING_OFF;
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNKNOWN_ISOTOPE);
      return TPCERROR_UNKNOWN_ISOTOPE;
    }
  }
 
  if(tac->format==TAC_FORMAT_SIF && weightMethod==WEIGHTING_ON_GENERAL)
    weightMethod=WEIGHTING_ON_COUNTS;
 
  if(weightMethod==WEIGHTING_OFF) {
 
    if(verbose>2 && !tacIsWeighted(tac)) {
      printf("  Note: data did not contain weights.\n"); fflush(stdout);}
    tac->weighting=WEIGHTING_OFF;
    for(int i=0; i<tac->sampleNr; i++) tac->w[i]=0.0;
    for(int i=0; i<weightNr; i++) tac->w[i]=1.0;
    if(verbose>1) {printf("  weights removed.\n"); fflush(stdout);}
 
  } else if(weightMethod==WEIGHTING_ON_GENERAL) {
 
    if(verbose>0) {fprintf(stderr, "Error: cannot apply general weighting.\n"); fflush(stderr);}
    for(int i=0; i<tac->sampleNr; i++) tac->w[i]=0.0;
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
 
  } else if(weightMethod==WEIGHTING_UNKNOWN) {
 
    for(int i=weightNr; i<tac->sampleNr; i++) tac->w[i]=0.0;
 
    if(!tacIsWeighted(tac)) {
      if(verbose>2) {printf("  Note: data does not contain weights.\n"); fflush(stdout);}
      for(int i=0; i<weightNr; i++) tac->w[i]=1.0;
    } else {
      if(verbose>2) {printf("  Note: data contains weights.\n"); fflush(stdout);}
      tac->sampleNr=weightNr;
      int ret=tacWeightNorm(tac, status);
      tac->sampleNr=origSampleNr;
      if(ret!=TPCERROR_OK) return(ret);
    }
 
  } else if(weightMethod==WEIGHTING_ON_COUNTS) {
 
    if(verbose>2 && tacIsWeighted(tac)) {
      printf("  Note: data already contained weights.\n"); fflush(stdout);}
    tac->weighting=WEIGHTING_OFF;
    for(int i=0; i<tac->sampleNr; i++) tac->w[i]=0.0;
 
    if(tac->format==TAC_FORMAT_SIF) {
 
      /* TAC contains SIF data, just add weights */
      tac->sampleNr=weightNr;
      int ret=sifWeight(tac, fisot, status);
      tac->sampleNr=origSampleNr;
      if(ret!=TPCERROR_OK) return(ret);
      tac->weighting=WEIGHTING_ON_COUNTS;
      if(verbose>1) {printf("  weights added.\n"); fflush(stdout);}
 
    } else {
 
      double weight_moderate=100.0;
 
      /* Create temp SIF */
      if(!unitIsTime(tac->tunit) || !tacIsX(tac)) {
        statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_X);
        return TPCERROR_INVALID_X;
      }
      if(!unitIsRadioactivity(tac->cunit) && !unitIsRAConc(tac->cunit)) {
        statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
        return TPCERROR_INCOMPATIBLE_UNIT;
      }
      TAC sif; tacInit(&sif);
      if(tacAllocate(&sif, weightNr, 3)!=TPCERROR_OK) {
        statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_DATA);
        return TPCERROR_INCOMPATIBLE_DATA;
      }
      sif.sampleNr=weightNr;
      sif.tacNr=2; // 3rd contains trues that is not saved
      sif.format=TAC_FORMAT_SIF;
      sif.isframe=1; // SIF always contains frame start and end times
      sif.tunit=tac->tunit;
      sif.cunit=tac->cunit;
      tacSetIsotope(&sif, fisot);
      tacXCopy(tac, &sif, 0, sif.sampleNr-1);
      int ret=tacXUnitConvert(&sif, UNIT_SEC, status);
      if(ret!=TPCERROR_OK) {tacFree(&sif); return(ret);}
      for(int j=0; j<sif.sampleNr; j++) {
        double sum=0.0, wsum=0.0;
        for(int i=0; i<tac->tacNr; i++) {
          if(!isfinite(tac->c[i].y[j])) continue;
          double w=tac->c[i].size; if(!(w>0.0)) w=1.0;
          sum+=w*tac->c[i].y[j]; wsum+=w;
        }
        if(wsum>0.0) sif.c[0].y[j]=sum/wsum; else sif.c[0].y[j]=0.0;
      } // next time frame
      ret=tacDecayCorrection(&sif, fisot, 0, status);
      if(ret!=TPCERROR_OK) {tacFree(&sif); return(ret);}
      if(unitIsRadioactivity(sif.cunit)) {
        ret=tacYUnitConvert(&sif, UNIT_BQ, status);
      } else {
        ret=tacYUnitConvert(&sif, UNIT_BQ_PER_ML, status);
        for(int i=0; i<sif.sampleNr; i++) sif.c[0].y[i]*=1000.; // Counts from one litre
        sif.cunit=UNIT_BQ;
      }
      if(ret!=TPCERROR_OK) {tacFree(&sif); return(ret);}
      /* Multiply with frame duration (Bq/s -> Bq/frame) */
      for(int i=0; i<sif.sampleNr; i++) sif.c[0].y[i]*=(sif.x2[i]-sif.x1[i]);
      sif.cunit=UNIT_COUNTS;
      /* Set prompts, randoms, and trues */
      for(int i=0; i<sif.sampleNr; i++) {
        sif.c[2].y[i]=sif.c[0].y[i];
        sif.c[1].y[i]=0.0;
      }
      /* Calculate weights based on approximated SIF data */
      ret=sifWeight(&sif, fisot, status);
      if(ret==TPCERROR_OK) ret=tacWeightNorm(&sif, status);
      if(ret!=TPCERROR_OK) {tacFree(&sif); return(ret);}
 
      double prop=0.0; if(weight_moderate>1.0) prop=1.0/weight_moderate;
      ret=tacWeightModerate(&sif, prop, 0, 0, status);
      if(ret!=TPCERROR_OK) {tacFree(&sif); return(ret);}
 
      /* Copy weights into TAC */
      {
        int j;
        for(j=0; j<sif.sampleNr; j++) tac->w[j]=sif.w[j];
        for( ; j<tac->sampleNr; j++) tac->w[j]=0.0;
      }
      tacFree(&sif);
      tac->weighting=WEIGHTING_ON_COUNTS;
      if(verbose>1) {printf("  weights added.\n"); fflush(stdout);}
 
    }
 
  } else if(weightMethod==WEIGHTING_ON_F) {
 
    if(verbose>2 && tacIsWeighted(tac)) {
      printf("  Note: data already contained weights.\n"); fflush(stdout);}
    tac->weighting=WEIGHTING_OFF;
    for(int i=0; i<tac->sampleNr; i++) tac->w[i]=0.0;
    tac->sampleNr=weightNr;
    int ret=tacWByFreq(tac, ISOTOPE_UNKNOWN, status);
    if(ret==TPCERROR_OK) ret=tacWeightNorm(tac, status);
    tac->sampleNr=origSampleNr;
    if(ret!=TPCERROR_OK) return(ret);
    if(verbose>1) {printf("  weights added.\n"); fflush(stdout);}
 
  } else if(weightMethod==WEIGHTING_ON_FD) {
 
    if(verbose>2 && tacIsWeighted(tac)) {
      printf("  Note: data already contained weights.\n"); fflush(stdout);}
    tac->weighting=WEIGHTING_OFF;
    for(int i=0; i<tac->sampleNr; i++) tac->w[i]=0.0;
    tac->sampleNr=weightNr;
    int ret=tacWByFreq(tac, fisot, status);
    if(ret==TPCERROR_OK) ret=tacWeightNorm(tac, status);
    tac->sampleNr=origSampleNr;
    if(ret!=TPCERROR_OK) return(ret);
    if(verbose>1) {printf("  weights added.\n"); fflush(stdout);}
 
  } else {
    if(verbose>0) {fprintf(stderr, "Error: invalid weighting scheme.\n"); fflush(stderr);}
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

tacSetX()

int tacSetX ( TAC * d, TPCSTATUS * status )

extern

Set TAC x values based on x1 and x2 values, or guess x1 and x2 values based on x values.

This is not an idiot proof method, but works reasonably well in common cases.

See also

tacSortByTime, tacIsX, tacAddZeroSample, tacXCopy, tacCheckX1X2X, tacXNaNs, tacFixNaNs, tacIsXContiguous

Author

Vesa Oikonen

Returns

Returns TPCERROR status (0 if ok).

Parameters

d	Pointer to the TAC structure. TAC samples must be sorted for increasing x, if x1 and x2 are to be estimated from x values. TAC tunit should be specified as a time unit that can be internally converted to seconds to get most reliable results.
status	Pointer to status data; enter NULL if not needed.

Definition at line 653 of file tacx.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
 
  if(d==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(d->sampleNr==0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
  /* Check that some x values are there to begin with */ 
  if(!tacIsX(d)) { 
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_X);
    return TPCERROR_NO_X;
  }
 
  /* If x1 and x2 are set, then calculate x for each sample */
  if(d->isframe) {
    if(verbose>1) printf("calculating x[] based on x1[] and x2[].\n");
    int i, n, ret;
    for(i=n=0; i<d->sampleNr; i++) {
      d->x[i]=0.5*(d->x1[i]+d->x2[i]);
      if(isfinite(d->x[i])) n++;
    }
    if(n>0) ret=TPCERROR_OK; else ret=TPCERROR_NO_X; 
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return(ret);
  }
 
  /* We should start guessing x1 and x2 values based on their averages in x */
  if(verbose>1) printf("estimating x1[] and x2[] based on x[].\n");
 
  /* If reasonable x1 and x2 values already are set, then quit */
  if(tacCheckX1X2X(d)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
 
  /* If only one sample, then set x1=0 and x2=2*x, and quit */
  if(d->sampleNr==1) {
    if(verbose>2) printf("just one sample.\n");
    if(d->x[0]<=0.0) {d->x1[0]=2.0*d->x[0]; d->x2[0]=0.0;}
    else {d->x1[0]=0.0; d->x2[0]=2.0*d->x[0];}
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
 
  /* If only two samples */
  if(d->sampleNr==2) {
    if(verbose>2) printf("just two samples.\n");
    if(d->x[0]>0.0 && 2.0*d->x[0]<0.95*d->x[1]) {
      d->x1[0]=0.0; d->x2[0]=2.0*d->x[0];
      d->x1[1]=d->x2[0]; d->x2[1]=d->x2[0]+2.0*(d->x[1]-d->x2[0]);
    } else {
      double f; f=d->x[1]-d->x[0];
      d->x1[0]=d->x[0]-0.5*f; d->x2[0]=d->x[0]+0.5*f;
      d->x1[1]=d->x2[0]; d->x2[1]=d->x2[0]+2.0*f;
    }
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
 
  int i, n, ret;
 
  /* Allocate playground as TAC struct t */
  TAC t; tacInit(&t);
  n=d->tacNr; d->tacNr=1; ret=tacDuplicate(d, &t); d->tacNr=n;
  if(ret==0) ret=tacAllocateMore(&t, 1);
  if(ret) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return(ret);
  }
  double *x, *x1, *x2, *fa, *fb;
  x=t.x; x1=t.x1; x2=t.x2; fa=t.c[0].y; fb=t.c[1].y;
  n=t.sampleNr;
 
  /* Convert playground times to sec if possible */
  tacXUnitConvert(&t, UNIT_SEC, NULL);
 
  /* Set each x1 and x1 to x */
  for(i=0; i<n; i++) x1[i]=x2[i]=x[i];
 
  /* Calculate the min gap, excluding zeroes */
  double gap, v;
  gap=nan("");
  for(i=0; i<n-1; i++) {
    v=x[i+1]-x[i]; if(!isfinite(v) || v<0.001) continue;
    if(isnan(gap)) {gap=v; continue;}
    if(v<gap) gap=v;
  }
 
  if(!isfinite(gap)) {
    tacFree(&t);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_X);
    return(TPCERROR_NO_X);
  }
  if(verbose>2) printf("smallest gap := %g\n", gap);
  /* Set gap to smallest step value for frame lengths */
  if(t.tunit!=UNIT_SEC) {
    gap*=0.01;
  } else {
    /* Set to 0.5 sec, unless calculated gap is smaller */
    if(gap>0.5) gap=0.5;
  }
  if(verbose>2) printf("stepsize := %g\n", gap);
 
  /* Initiate frame lengths to 0 */
  for(i=0; i<n; i++) fa[i]=fb[i]=0.0;
  int fixed[n]; for(i=0; i<n; i++) fixed[i]=0;
 
  /* Iterate until gaps are as small as possible */
  int anr=0;
  do {
    anr=0;
    /* Set tentative frames to the last accepted frame lengths */
    for(i=0; i<n; i++) fa[i]=fb[i];
    /* Add fraction of gap to frames that have not yet been fixed */
    for(i=0; i<n; i++) if(!fixed[i]) fa[i]+=gap;
    /* Calculate x1 and x2 based on the tentative frames */
    for(i=0; i<n; i++) {x1[i]=x[i]-0.5*fa[i]; x2[i]=x[i]+0.5*fa[i];}
    /* If no overlap, then copy frame */
    i=0; 
    if(x2[i]<=x1[i+1]+0.001*gap && (x[i]<=0.0 || x1[i]>-0.001*gap)) {
      fb[i]=fa[i]; if(!fixed[i]) anr++;
    } else 
      fixed[i]=1;
    for(i=1; i<n-1; i++) {
      if(x2[i]<=x1[i+1]+0.001*gap && x1[i]>=x2[i-1]-0.001*gap) {
        fb[i]=fa[i]; if(!fixed[i]) anr++;} else fixed[i]=1;
    }
    if(x1[i]>=x2[i-1]-0.001*gap) {
      fb[i]=fa[i]; if(!fixed[i]) anr++;} else fixed[i]=1;
    if(verbose>5) {
      printf("frames:");
      for(i=0; i<n; i++) printf(" %g", fb[i]);
      printf("\n");
    }
  } while(anr>0);
 
  if(verbose>6) {
    printf("temp frames:");
    for(i=0; i<n; i++) printf(" %g", fa[i]);
    printf("\n");
  }
 
  /* Calculate final frames */
  for(i=0; i<n; i++) {x1[i]=x[i]-0.5*fb[i]; x2[i]=x[i]+0.5*fb[i];}
 
  /* Convert playground to original time units */
  tacXUnitConvert(&t, d->tunit, NULL);
 
  /* Copy the guessed x1 and x2 values from playground */
  t.isframe=1; tacXCopy(&t, d, 0, d->sampleNr-1);
 
  /* Delete playground TAC */
  tacFree(&t); 
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

Referenced by tacInput2sim().

tacSetXContiguous()

int tacSetXContiguous ( TAC * d )

extern

Set PET TAC frame times contiguous, without even tiny overlap or gaps in between.

Tiny overlaps and gaps are fixed by modifying frame times. Large gaps are filled with new frames based on linear interpolation between adjacent frames. Error is returned in case of larger frame overlaps.

See also

tacIsXContiguous, tacIsX, tacXRange, tacVerifyTimeOrder, tacSortByTime, tacMultipleSamples

Returns

If successful, TPCERROR_OK (0) is returned.

Author

Vesa Oikonen

Parameters

d	Pointer to TAC data which is sorted by increasing sample time.

Definition at line 1166 of file tacx.c.

  {
  if(d==NULL) return TPCERROR_FAIL;
  if(tacXNaNs(d)>0) return(TPCERROR_INVALID_X);
 
  /* If no frame start and end times, then just make the times increasing */
  if(d->isframe==0) return(tacSortByTime(d, NULL));
 
  /* If there are no gaps or overlap, then we're done */
  if(tacIsXContiguous(d)==TPCERROR_OK) return(TPCERROR_OK);
 
  /* Make a duplicate for editing */
  TAC tac; tacInit(&tac);
  int ret=tacDuplicate(d, &tac); if(ret!=TPCERROR_OK) return(ret);
 
  /* Check for small frame overlaps or gaps; fix small, and return error if large overlap */
  int fixed=0, large=0;
  for(int fi=0; fi<d->sampleNr-1; fi++) {
    double dif=d->x1[fi+1]-d->x2[fi]; if(dif==0.0) continue; // not gap or overlap
    double fdur1=d->x2[fi]-d->x1[fi];
    double fdur2=d->x2[fi+1]-d->x1[fi+1];
    if(dif>0) { // gap
      if(dif<0.2*fdur1 && dif<0.2*fdur2) { // small gap; increase the shorter frame duration
        if(fdur1<fdur2) tac.x2[fi]=d->x1[fi+1]; else tac.x1[fi+1]=d->x2[fi];
        fixed++;
      } else {
        large++; // large gap not fixed yet
      }
      continue;
    }
    /* Overlap */
    dif=-dif;
    if(dif>0.2*fdur1 || dif>0.2*fdur2) { // too large overlap
      tacFree(&tac); return(TPCERROR_OVERLAPPING_DATA);
    }
    /* Reduce the longer frame length */
    if(fdur1>fdur2) tac.x2[fi]=d->x1[fi+1]; else tac.x1[fi+1]=d->x2[fi];
    fixed++;
  }
 
  /* If we fixed something, then copy the fixed frame times */
  if(fixed>0) {
    for(int i=0; i<d->sampleNr; i++) {
      d->x1[i]=tac.x1[i]; d->x2[i]=tac.x2[i]; d->x[i]=0.5*(d->x1[i]+d->x2[i]);
    }
  }
 
  /* If there were no large gaps, we're done */
  if(large==0) {tacFree(&tac); return(TPCERROR_OK);}
 
  /* Fill large gaps with new frames */
  d->weighting=WEIGHTING_OFF;
  if(tacAllocateMoreSamples(d, large)!=0) {
    tacFree(&tac); return(TPCERROR_OUT_OF_MEMORY);
  }
  d->sampleNr=1;
  for(int fi=1; fi<tac.sampleNr; fi++) {
    double dif=tac.x1[fi]-tac.x2[fi-1];
    if(dif>0.0) {
      /* Add new frame times */
      d->x1[d->sampleNr]=tac.x2[fi-1]; d->x2[d->sampleNr]=tac.x1[fi];
      d->x[fi]=0.5*(d->x1[d->sampleNr]+d->x2[d->sampleNr]);
      /* Calculate y values for the new frame */
      double x1=0.5*(tac.x1[fi-1]+tac.x2[fi-1]);
      double x2=0.5*(tac.x1[fi]+tac.x2[fi]);
      for(int ri=0; ri<tac.tacNr; ri++) {
        double s=(tac.c[ri].y[fi]-tac.c[ri].y[fi-1])/(x2-x1);
        d->c[ri].y[d->sampleNr]=tac.c[ri].y[fi-1] + s*(d->x[fi]-x1);
      }
      d->sampleNr++;
    }
    /* copy the existing frame */
    d->x1[d->sampleNr]=tac.x1[fi]; d->x2[d->sampleNr]=tac.x2[fi];
    for(int ri=0; ri<tac.tacNr; ri++) d->c[ri].y[d->sampleNr]=tac.c[ri].y[fi];
    d->sampleNr++;
  }
 
  tacFree(&tac);
  return(TPCERROR_OK);
}

tacSortByAUC()

int tacSortByAUC ( TAC * d, TPCSTATUS * status )

extern

Sort TACs in decreasing order by their area-under-curve (AUC).

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSortByName, tacSortByTime

Parameters

d	Pointer to TAC structure.
status	Pointer to status data; enter NULL if not needed.

Definition at line 205 of file tacorder.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(d->tacNr<2) return TPCERROR_OK;
  /* Calculate AUCs for each TAC */
  double auc[d->tacNr], fdur, v;
  int i, j;
  for(i=0; i<d->tacNr; i++) {
    auc[i]=0.0;
    for(j=0; j<d->sampleNr; j++) {
      fdur=d->x2[0]-d->x1[0]; v=d->c[i].y[j]; 
      if(isnan(fdur) || isnan(v)) continue;
      auc[i]+=fdur*v;
    }
  }
  /* Sort */
  double a;
  for(i=0; i<d->tacNr-1; i++)
    for(j=i+1; j<d->tacNr; j++)
      if(auc[j]>auc[i]) {
        tacSwapTACCs(d, j, i); 
        a=auc[i]; auc[i]=auc[j]; auc[j]=a;
      }
  return TPCERROR_OK;
}

tacSortByConc()

int tacSortByConc ( TAC * d, const int i, TPCSTATUS * status )

extern

Sort samples (frames) in TAC structure by decreasing sample value.

See also

tacSortByTime, tacSortByAUC

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

d	Pointer to TAC structure.
i	Index of y column which the sorting is based on.
status	Pointer to status data; enter NULL if not needed.

Definition at line 122 of file tacorder.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL || d->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(i<0 || i>=d->_tacNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(d->sampleNr<1) return TPCERROR_OK;
 
  TACC *c;
  int ri, fi, fj;
  double s, a1, a2;
  for(fi=0; fi<d->sampleNr-1; fi++) for(fj=fi+1; fj<d->sampleNr; fj++) {
    a1=d->c[i].y[fi]; a2=d->c[i].y[fj];
    if(a2<=a1) continue;
    s=d->x[fi];  d->x[fi]=d->x[fj];   d->x[fj]=s;
    s=d->x1[fi]; d->x1[fi]=d->x1[fj]; d->x1[fj]=s;
    s=d->x2[fi]; d->x2[fi]=d->x2[fj]; d->x2[fj]=s;
    s=d->w[fi];  d->w[fi]=d->w[fj];   d->w[fj]=s;
    for(ri=0; ri<d->_tacNr; ri++) {
      c=d->c+ri;
      s=c->y[fi];  c->y[fi]=c->y[fj];   c->y[fj]=s;
    }
  }
  return TPCERROR_OK;
}

tacSortByName()

int tacSortByName ( TAC * d, TPCSTATUS * status )

extern

Sort TACs in alphabetical order by their TAC name.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacSortByAUC, tacSortByTime, tacSwapTACCs

Parameters

d	Pointer to TAC structure.
status	Pointer to status data; enter NULL if not needed.

Definition at line 178 of file tacorder.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(d->tacNr<2) return TPCERROR_OK;
  qsort(d->c, d->tacNr, sizeof(TACC), tacQSortName);
  return TPCERROR_OK;
}

tacSortByTime()

int tacSortByTime ( TAC * d, TPCSTATUS * status )

extern

Sort samples (frames) in TAC structure by increasing sample time.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacVerifyTimeOrder, tacMultipleSamples, tacSortByConc, tacSortByAUC, tacCorrectFrameOverlap, tacDeleteSample, tacIsX, tacMinX

Parameters

d	Pointer to TAC structure.
status	Pointer to status data; enter NULL if not needed.

Definition at line 74 of file tacorder.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL || d->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  /* All sample times must be available */
  if(tacXNaNs(d)>0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_MISSING_DATA);
    return TPCERROR_MISSING_DATA;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(d->sampleNr<1) return TPCERROR_OK;
  
  TACC *c;
  int ri, fi, fj;
  double s, a1, a2;
  for(fi=0; fi<d->sampleNr-1; fi++) for(fj=fi+1; fj<d->sampleNr; fj++) {
    if(d->isframe==0) {a1=d->x[fi]; a2=d->x[fj];}
    else {a1=0.5*(d->x1[fi]+d->x2[fi]); a2=0.5*(d->x1[fj]+d->x2[fj]);}
    if(a2>=a1) continue;
    s=d->x[fi];  d->x[fi]=d->x[fj];   d->x[fj]=s;
    s=d->x1[fi]; d->x1[fi]=d->x1[fj]; d->x1[fj]=s;
    s=d->x2[fi]; d->x2[fi]=d->x2[fj]; d->x2[fj]=s;
    s=d->w[fi];  d->w[fi]=d->w[fj];   d->w[fj]=s;
    for(ri=0; ri<d->tacNr; ri++) {
      c=d->c+ri;
      s=c->y[fi];  c->y[fi]=c->y[fj];   c->y[fj]=s;
    }
  }  
  return TPCERROR_OK;
}

Referenced by tacInput2sim(), tacReadModelingData(), tacReadModelingInput(), and tacSetXContiguous().

tacSwapTACCs()

int tacSwapTACCs ( TAC * d, int i1, int i2 )

extern

Change places between two TACCs inside TAC structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacDeleteTACC, tacMoveTACC

Parameters

d	Pointer to TAC data. Main header and tacNr are not changed.
i1	TACC index 1 [0.._tacNr-1]
i2	TACC index 2 [0.._tacNr-1]

Definition at line 282 of file tacorder.c.

  {
  TACC tacc;
  size_t taccSize;
 
  if(d==NULL || i1<0 || i2<0) return(TPCERROR_FAIL);
  if(i1>=d->_tacNr || i2>=d->_tacNr) return(TPCERROR_FAIL);
  if(i1==i2) return(TPCERROR_OK); // nothing to do
  taccSize=sizeof(TACC);
  memcpy(&tacc, d->c+i1, taccSize);
  memcpy(d->c+i1, d->c+i2, taccSize);
  memcpy(d->c+i2, &tacc, taccSize);
  return(TPCERROR_OK);
}

Referenced by tacSortByAUC().

tacToBars()

int tacToBars ( TAC * tac1, TAC * tac2 )

extern

Transform TAC data with frame start and end times into suitable form for plotting with frames as bars.

Attention

Output data must not be used for quantitative purposes.

See also

tacFramesToSteps, tacXRange, tacIsX, tacCheckX1X2X, tacExtractRange, tacSetXContiguous

Returns

Returns <>0 in case of failure.

Parameters

tac1	Pointer to input TAC structure; not modified. Must be sorted by increasing x.
tac2	Pointer to output TAC structure; must be initiated; any previous content is destroyed.

See also

tacInit, tacFree

Definition at line 888 of file tacx.c.

  {
  if(tac1==NULL || tac2==NULL || tac1->sampleNr<1 || tac1->tacNr<1) return(1);
  /* Make sure that frame start and end times are present */
  if(tac1->isframe==0) return(2);
  /* Remove any old contents in target struct */
  tacFree(tac2);
 
  /* Make a copy of the TAC data */
  if(tacDuplicate(tac1, tac2)!=0) return(3);
  /* Add room for more frames; we plot each frame as its own bar
     and therefore we may need 4x the original space */
  if(tacAllocateMoreSamples(tac2, 3*tac1->sampleNr)!=0) return(4);
 
  /* Make separate 'samples' for each frame start and end time */
  tac2->isframe=0;
  int fj=0;
  for(int fi=0; fi<tac1->sampleNr; fi++) {
    /* Do nothing if missing values */
    if(isnan(tac1->x1[fi]) || isnan(tac1->x2[fi])) continue;
    if(tac1->tacNr==1 && isnan(tac1->c[0].y[fi])) continue;
    /* Otherwise make bar of each frame */
    tac2->x[fj]=tac1->x1[fi];
    for(int ri=0; ri<tac2->tacNr; ri++) tac2->c[ri].y[fj]=0.0;
    fj++;
    tac2->x[fj]=tac1->x1[fi];
    for(int ri=0; ri<tac2->tacNr; ri++) tac2->c[ri].y[fj]=tac1->c[ri].y[fi];
    fj++;
    tac2->x[fj]=tac1->x2[fi];
    for(int ri=0; ri<tac2->tacNr; ri++) tac2->c[ri].y[fj]=tac1->c[ri].y[fi];
    fj++;
    tac2->x[fj]=tac1->x2[fi];
    for(int ri=0; ri<tac2->tacNr; ri++) tac2->c[ri].y[fj]=0.0;
    fj++;
  }
  tac2->sampleNr=fj;
  if(fj<1) {tacFree(tac2); return(5);}
  return(0);
}

tacVerifyTimeOrder()

int tacVerifyTimeOrder ( TAC * d, TPCSTATUS * status )

extern

Verify that x values (sample or frame times) in TAC structure are ordered by increasing x. Overlapping samples are ok here.

Returns

enum tpcerror (TPCERROR_OK when in increasing order).

0 if in increasing order, >0 otherwise or in case of error.

Author

Vesa Oikonen

See also

tacSortByTime, tacCorrectFrameOverlap, tacMultipleSamples, tacIsX, tacMinX.

Parameters

d	Pointer to TAC structure; not modified.
status	Pointer to status data; enter NULL if not needed

Definition at line 25 of file tacorder.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  /* Check that required data exists */
  if(d==NULL || d->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  /* All sample times must be available */
  if(tacXNaNs(d)>0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_MISSING_DATA);
    return TPCERROR_MISSING_DATA;
  }
  /* Less than two samples are always in order */
  if(d->sampleNr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
 
  int fi;
  double p, s;
 
  fi=0; if(d->isframe==0) p=d->x[fi]; else p=0.5*(d->x1[fi]+d->x2[fi]);
  for(fi=1; fi<d->sampleNr; fi++) {
    if(d->isframe==0) s=d->x[fi]; else s=0.5*(d->x1[fi]+d->x2[fi]);
    if(s<p) {
      if(verbose>2) printf("x[%d]=%g\nx[%d]=%g\n", fi-1, p, fi, s);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OVERLAPPING_DATA);
      return(TPCERROR_OVERLAPPING_DATA);
    }
    p=s;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

Referenced by tacCorrectFrameOverlap(), and tacIsXContiguous().

tacWByFreq()

int tacWByFreq ( TAC * tac, isotope isot, TPCSTATUS * status )

extern

Add weight to TAC data based on sample frequency or time frame length.

Weights are scaled so that weight sum = sample number. Any existing weighting is overwritten.

See also

tacSetWeights, tacIsWeighted, sifWeight, tacWSampleNr, tacWCopy, tacWMove, tacWeightModerate

Returns

Return enum tpcerror (TPCERROR_OK when successful).

Parameters

tac	Pointer to TAC struct where weights will be added.

Note

Samples/frames must be sorted by sample time, but duplicate samples are allowed.

Parameters

isot	Isotope code, in case the weights are calculated for decay corrected data. Enter ISOTOPE_UNKNOWN if calculating weights for non-corrected data, or when decay correction is ignored.
status	Pointer to status data; enter NULL if not needed

Definition at line 134 of file tacw.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(%s)\n", __func__, isotopeName(isot));
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  
  tac->weighting=WEIGHTING_ON_GENERAL;
  if(tac->sampleNr==1) {tac->w[0]=1.0; return(TPCERROR_OK);}
 
  if(tac->isframe!=0) { /* weights based on frame lengths */
    tac->weighting=WEIGHTING_ON_F;
 
    for(int i=0; i<tac->sampleNr; i++) {
      tac->w[i]=tac->x2[i]-tac->x1[i]; 
    }
 
  } else { /* weights based on sample distance */
    tac->weighting=WEIGHTING_ON_F;
 
    int i, i1, i2;
    double t, t1, t2, f;
    for(i=0; i<tac->sampleNr; i++) {
      t=t1=t2=tac->x[i];
      /* Find the closest sample time before this one */
      for(i1=i; i1>=0; i1--) {t1=tac->x[i1]; if(t1<t) break;} 
      /* Find the closest sample time after this one */ 
      for(i2=i; i2<tac->sampleNr; i2++) {t2=tac->x[i2]; if(t2>t) break;} 
      /* Mean sample distance */
      f=0.0;
      if(t1<t) f+=t-t1; else f+=t2-t;
      if(t2>t) f+=t2-t; else f+=t-t1;
      f*=0.5; if(f<=0.0) f=1.0;
      tac->w[i]=f; 
    }
 
  }
 
  /* Account for decay correction, if requested */
  if(isot!=ISOTOPE_UNKNOWN) {
    tac->weighting=WEIGHTING_ON_FD;
    double lambda=lambdaFromIsotope(isot);
    if(tac->tunit==UNIT_SEC) lambda/=60.; else if(tac->tunit==UNIT_MSEC) lambda/=60000.;
    if(tac->isframe!=0) {
      for(int i=0; i<tac->sampleNr; i++)
        tac->w[i]*=decayCorrectionFactorFromLambda(-lambda, tac->x1[i], (tac->x2[i]-tac->x1[i])); 
    } else {
      for(int i=0; i<tac->sampleNr; i++)
        tac->w[i]*=decayCorrectionFactorFromLambda(-lambda, tac->x[i], 0.0); 
    }
  }
 
  /* Scale weights so that sum of weights equals sample number */
  double sumw=0.0;
  for(int i=0; i<tac->sampleNr; i++) if(isfinite(tac->w[i])) sumw+=tac->w[i];
  if(!(sumw>0.0)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  sumw/=(double)tac->sampleNr;
  for(int i=0; i<tac->sampleNr; i++) tac->w[i]/=sumw;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacSetWeights().

tacWCopy()

int tacWCopy ( TAC * tac1, TAC * tac2, int i1, int i2 )

extern

Copy weights from one TAC structure to another.

See also

tacXCopy, tacWMove, sifWeight, tacWByFreq, tacIsWeighted, tacSetWeights

Author

Vesa Oikonen

Returns

Returns TPCERROR status.

Parameters

tac1	Pointer to source TAC structure.
tac2	Pointer to target TAC structure.
i1	Index of the first sample to copy.
i2	Index of the last sample to copy.

Definition at line 41 of file tacw.c.

  {
  if(tac1==NULL || tac2==NULL) return(TPCERROR_FAIL);
  if(i1<0 || i1>i2) return(TPCERROR_FAIL);
  if(i2>=tac1->_sampleNr || i2>=tac2->_sampleNr) return(TPCERROR_FAIL);
  
  for(int i=i1; i<=i2; i++) {
    tac2->w[i]=tac1->w[i];
  }
  tac2->weighting=tac1->weighting;
  return(TPCERROR_OK);
}

Referenced by tacDuplicate(), and tacExtract().

tacWeightModerate()

int tacWeightModerate ( TAC * tac, const double minprop, const int doZeroes, const int doNaNs, TPCSTATUS * status )

extern

Moderate weights so that the min weight is not less than given proportion of the maximum weight.

After moderation, all weights are normalized to have and average of one.

See also

sifWeight, tacWeighNorm, tacWCopy, tacWByFreq, tacWSampleNr, tacReadSIF

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

tac	Pointer to TAC structure (which can contain SIF or TAC data).
minprop	The minimum proportion of frame weight to maximum frame weight. Must be less than one. If proportion is lower than this limit, then weight is set to proportion times maximum. Setting minimum proportion to zero or less does not change any weights, but weights are still normalized. By default, zero weights or NaNs are not changed.
doZeroes	Set zero weights, too, to the minimum proportion of maximum frame weight.
doNaNs	Set NaN weights, too, to the minimum proportion of maximum frame weight.
status	Pointer to status data; enter NULL if not needed

Definition at line 277 of file tacw.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(%g, %d, %d)\n", __func__, minprop, doZeroes, doNaNs);
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(!isfinite(minprop) || minprop>=1.0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  if(!tacIsWeighted(tac)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_WEIGHTS);
    return TPCERROR_NO_WEIGHTS;
  }
 
  double wMax=nan("");
  for(int i=0; i<tac->sampleNr; i++) if(isfinite(tac->w[i])) {
    if(!isfinite(wMax)) {wMax=tac->w[i]; continue;}
    if(tac->w[i]>wMax) wMax=tac->w[i];
  }
  if(verbose>2) {printf("weight_maximum := %g\n", wMax); fflush(stdout);}
  if(!isfinite(wMax) || wMax<=0.0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_WEIGHTS);
    return TPCERROR_NO_WEIGHTS;
  }
 
  double wLimit=minprop*wMax;
  if(verbose>2) {printf("weight_limit := %g\n", wLimit); fflush(stdout);}
 
  int n=0;
  if(wLimit>0.0) {
    for(int i=0; i<tac->sampleNr; i++) {
      if(tac->w[i]==0.0) {
        if(doZeroes) {tac->w[i]=wLimit; n++;}
        continue;
      }
      if(isnan(tac->w[i])) {
        if(doNaNs) {tac->w[i]=wLimit; n++;}
        continue;
      }
      if(tac->w[i]<wLimit) {tac->w[i]=wLimit; n++;}
    }
  }
  if(verbose>1 && minprop>0.0) {printf("  %d weight(s) set to %g.\n", n, wLimit); fflush(stdout);}
 
  return(tacWeightNorm(tac, status));
}

Referenced by tacSetWeights().

tacWeightNorm()

int tacWeightNorm ( TAC * tac, TPCSTATUS * status )

extern

Scale weights so that average weight is 1.0, and the sum of weights equals the nr of frames.

See also

tacWeightModerate,sifWeight, tacWCopy, tacWByFreq, tacWSampleNr, tacReadSIF

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

tac	Pointer to TAC structure (which can contain SIF or TAC data).
status	Pointer to status data; enter NULL if not needed

Definition at line 237 of file tacw.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(!tacIsWeighted(tac)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_WEIGHTS);
    return TPCERROR_NO_WEIGHTS;
  }
 
  double wSum=0.0; int wNr=0;
  for(int i=0; i<tac->sampleNr; i++)
    if(isfinite(tac->w[i]) && tac->w[i]>0.0) {wSum+=tac->w[i]; wNr++;}
  if(wNr==0 || !(wSum>0.0)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    return TPCERROR_INVALID_VALUE;
  }
  double wMean=wSum/(double)wNr;
  for(int i=0; i<tac->sampleNr; i++) 
    if(isfinite(tac->w[i]) && tac->w[i]>0.0) tac->w[i]/=wMean;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

Referenced by sifWeight(), tacDecayCorrection(), tacSetWeights(), and tacWeightModerate().

tacWMove()

int tacWMove ( TAC * tac, int ow, TPCSTATUS * status )

extern

Identify column containing weights in TAC structure, and move weights to the correct place.

TAC name starting with string 'weight' is identified as weight column.

Sets tac->weighting to WEIGHTING_ON or WEIGHTING_OFF, depending on whether weight column was found or not.

See also

tacWCopy, tacSetWeights

Author

Vesa Oikonen

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

tac	Pointer to TAC structure.
ow	Overwrite (1) or do not overwrite (0) existing weights.
status	Pointer to status data; enter NULL if not needed

Definition at line 75 of file tacw.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  int ret;
 
  if(tac->weighting==WEIGHTING_UNKNOWN) tac->weighting=WEIGHTING_OFF;
 
  /* Search for the weight column */
  int wc=-1;
  for(int i=0; i<tac->tacNr; i++) {
    if(strncasecmp(tac->c[i].name, "WEIGHT", 6)!=0) continue;
    if(wc<0) wc=i;
    else if(ow==0) {
      /* Error if found more than one */
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_DUPLICATE_DATA);
      return TPCERROR_DUPLICATE_DATA;
    }
  }
  /* Error if not found */
  if(wc<0) {
    if(ow) tac->weighting=WEIGHTING_OFF;
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_WEIGHTS);
    return TPCERROR_NO_WEIGHTS;
  }
  /* Error if overwriting not allowed */
  if(ow==0 && tacIsWeighted(tac)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_DUPLICATE_DATA);
    return TPCERROR_DUPLICATE_DATA;
  }
  /* Copy weights to their right place */
  for(int i=0; i<tac->sampleNr; i++) tac->w[i]=tac->c[wc].y[i];
  tac->weighting=WEIGHTING_ON_GENERAL;
  /* Then delete the original column */
  ret=tacDeleteTACC(tac, wc);
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  return(ret);
}

Referenced by tacReadCarimasTxt(), tacReadCSV(), tacReadDFT(), and tacReadPMOD().

tacWrite()

int tacWrite ( TAC * tac, FILE * fp, tacformat format, int extra, TPCSTATUS * status )

extern

Write TAC data into specified file in specified format.

Precondition

Before using this, you may want to call tacFormatWriteSupported().

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacRead, tacFree, tacFormatWriteSupported

Parameters

tac	Pointer to TAC structure, contents of which are to be written.
fp	Output file pointer.
format	File format code; enter TAC_FORMAT_UNKNOWN to write data in the format specified inside TAC structure.
extra	Write (1) or do not write (0) also extra header fields found in IFT; not effective with SIF.
status	Pointer to status data; enter NULL if not needed.

Definition at line 332 of file tacio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Determine and verify the write format */
  if(format<=TAC_FORMAT_UNKNOWN || format>=TAC_FORMAT_LAST)
    format=tac->format;
  if(format<=TAC_FORMAT_UNKNOWN || format>=TAC_FORMAT_LAST) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(verbose>0) {
    printf("%s():\n", __func__);
    printf("writing %d TACs and %d samples in %s format\n",
      tac->tacNr, tac->sampleNr, tacFormattxt(format));
  }
 
  /* Write file */
  /* Update tacFormatWriteSupported() if you add/remove formats! */
  int ret;
  switch(format) {
    case TAC_FORMAT_SIMPLE:
      ret=tacWriteSimple(tac, fp, extra, status);
      break;
    case TAC_FORMAT_DFT:
      ret=tacWriteDFT(tac, fp, extra, status);
      break;
    case TAC_FORMAT_PMOD:
      ret=tacWritePMOD(tac, fp, extra, status);
      break;
    case TAC_FORMAT_CSV_INT:
    case TAC_FORMAT_CSV_UK:
    case TAC_FORMAT_TSV_INT:
    case TAC_FORMAT_TSV_UK:
      ret=tacWriteCSV(tac, fp, extra, format, status);
      break;
    case TAC_FORMAT_SIF:
      ret=tacWriteSIF(tac, fp, 0, status);
      break;
    case TAC_FORMAT_XML:
      ret=tacWriteXML(tac, fp, status);
      break;
    default:
      ret=TPCERROR_UNSUPPORTED;
  }
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  return(ret);
}

Referenced by imgWriteNifti().

tacWriteCSV()

int tacWriteCSV ( TAC * tac, FILE * fp, int extra, tacformat format, TPCSTATUS * status )

extern

Write TAC data into specified file pointer in CSV TAC format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacReadCSV, tacWrite

Parameters

tac	Pointer to TAC struct, contents of which are to be written
fp	File pointer
extra	Write (1) or do not write (0) also extra header fields found in IFT; note that these are not supported by other than TPC SW.
format	File format code; accepted values are TAC_FORMAT_CSV_UK, TAC_FORMAT_CSV_INT, TAC_FORMAT_TSV_UK, TAC_FORMAT_TSV_INT, and TAC_FORMAT_UNKNOWN (0); this last one uses format inside TAC struct, or if that is invalid, then the default format TAC_FORMAT_CSV_UK
status	Pointer to status data; enter NULL if not needed

Definition at line 26 of file taccsv.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  
  int ret;
 
  /* Create local copy of headers, which will be edited here and written
     into CSV file, to preserve the original headers with TAC struct */
  if(verbose>99) iftWrite(&tac->h, stdout, NULL);
  IFT localh; iftInit(&localh);
  ret=iftDuplicate(&tac->h, &localh);
  if(ret) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  CSV csv;
  csvInit(&csv);
  if(csvAllocate(&csv, (tac->tacNr+3)*(tac->sampleNr+1))) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    iftFree(&localh); return TPCERROR_FAIL;
  }
 
  /* Check and set the CSV format */
  int tointl=0; // Decimal point (0) or comma (1)
  if(format==TAC_FORMAT_UNKNOWN) format=tac->format;
  if(format==TAC_FORMAT_UNKNOWN) format=TAC_FORMAT_CSV_UK;
  if(format==TAC_FORMAT_CSV_UK) {
    tointl=0; csv.separator=',';
  } else if(format==TAC_FORMAT_CSV_INT) {
    tointl=1; csv.separator=';';
  } else if(format==TAC_FORMAT_TSV_UK) {
    tointl=0; csv.separator='\t';
  } else if(format==TAC_FORMAT_TSV_INT) {
    tointl=1; csv.separator='\t';
  } else {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    iftFree(&localh); return TPCERROR_INVALID_FORMAT;
  }
 
  /* Make sure that TAC names are available */
  tacEnsureNames(tac);
 
  /* Fill CSV struct */
  char tmp[1024];
  
  if(verbose>1) printf("  writing header\n");
 
  /* Add file format ID */
  ret=csvPutString(&csv, "TAC", 0);
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); iftFree(&localh); return ret;
  }
 
  /* Add study number */
  tacGetHeaderStudynr(&tac->h, tmp, NULL);
  ret=csvPutString(&csv, tmp, 0);
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); iftFree(&localh); return ret;
  }
 
  
  if(verbose>1) printf("  writing data table title\n");
  
  if(tac->isframe==0) {
    sprintf(tmp, "time[%s]", unitName(tac->tunit));
    ret=csvPutString(&csv, tmp, 1);
  } else {
    sprintf(tmp, "start[%s]", unitName(tac->tunit));
    ret=csvPutString(&csv, tmp, 1);
    sprintf(tmp, "end[%s]", unitName(tac->tunit));
    if(!ret) ret=csvPutString(&csv, tmp, 0);
  }
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); iftFree(&localh); return ret;
  }
 
  for(int ri=0; ri<tac->tacNr; ri++) {
    /* add TAC names, first one with unit */
    if(ri==0) {
      sprintf(tmp, "%s[%s]", tac->c[ri].name, unitName(tac->cunit));
    } else {
      sprintf(tmp, "%s", tac->c[ri].name);
    }
    ret=csvPutString(&csv, tmp, 0); if(ret) break;
  }
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); iftFree(&localh); return ret;
  }
  if(tacIsWeighted(tac)) {
    ret=csvPutString(&csv, "weight", 0);
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      csvFree(&csv); iftFree(&localh); return ret;
    }
  }
 
  if(verbose>1) printf("writing data table\n");
  
  for(int fi=0; fi<tac->sampleNr; fi++) {
    /* Time(s) (x, or x1 and x2) */
    if(tac->isframe==0) {
      ret=csvPutDouble(&csv, tac->x[fi], 1, tointl);
    } else {
      ret=csvPutDouble(&csv, tac->x1[fi], 1, tointl);
      if(!ret) ret=csvPutDouble(&csv, tac->x2[fi], 0, tointl);
    }
    if(ret!=TPCERROR_OK) break;
    /* Concentrations (y values) */
    for(int ri=0; ri<tac->tacNr; ri++) {
      ret=csvPutDouble(&csv, tac->c[ri].y[fi], 0, tointl); if(ret) break;
    }
    /* Weight */
    if(tacIsWeighted(tac)) {
      ret=csvPutDouble(&csv, tac->w[fi], 0, tointl); if(ret) break;
    }
  } // next sample
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); iftFree(&localh); return ret;
  }
 
  /* Add VOI volumes, if available */
  if(tacIsSize(tac)) {
    ret=csvPutString(&csv, "volume", 1);
    if(tac->isframe && !ret) ret=csvPutString(&csv, "", 0);
    for(int ri=0; ri<tac->tacNr && !ret; ri++) {
      ret=csvPutDouble(&csv, tac->c[ri].size, 0, tointl);
    }
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      csvFree(&csv); iftFree(&localh); return ret;
    }
  }
 
  /* Write CSV */
  ret=csvWrite(&csv, 0, fp, status);
  csvFree(&csv);
  if(ret!=TPCERROR_OK) {iftFree(&localh); return ret;}
  
  /* Write extra header */
  // scan start time etc should be added to the first line I think
  if(extra && localh.keyNr>0) {
    int ret=iftWrite(&localh, fp, status);
    if(ret!=TPCERROR_OK) {iftFree(&localh); return ret;}
  }
  
  iftFree(&localh);
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacWrite().

tacWriteDFT()

int tacWriteDFT ( TAC * tac, FILE * fp, int extra, TPCSTATUS * status )

extern

Write TAC data into specified file pointer in DFT format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWrite, tacReadDFT

Parameters

tac	Pointer to TAC struct, contents of which are to be written
fp	File pointer
extra	Write (1) or do not write (0) also extra header fields found in IFT
status	Pointer to status data; enter NULL if not needed

Definition at line 119 of file dftio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) printf("%s()\n", __func__);
 
  int ret, prec=6;
 
  /* Make sure that TAC names are available */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  tacEnsureNames(tac);
 
  /* Create local copy of headers, which will be edited here and written
     into DFT file, to preserve the original headers with TAC struct */
  if(verbose>99) iftWrite(&tac->h, stdout, NULL);
  IFT localh; iftInit(&localh);
  ret=iftDuplicate(&tac->h, &localh);
  if(ret) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  /* Writing obligatory header lines */
  if(verbose>1) printf("writing obligatory title lines\n");
  int n;
  char subname[7];
 
  /* 1st line with filetype identification string and region names */
  n=fprintf(fp, "DFT1"); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  for(int ri=0; ri<tac->tacNr; ri++) {
    n=tacNameSplit(tac->c[ri].name, subname, NULL, NULL, 6);
    fprintf(fp, "\t%s", subname);
  }
  if(tacIsWeighted(tac)) fprintf(fp, "\t%s", "weight");
  n=fprintf(fp, "\n"); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* 2nd line with study identification and 2nd subname */
  if(verbose>2) printf("  writing 2nd title line\n");
  char tmp[128];
  n=tacGetHeaderStudynr(&localh, tmp, status);
  if(n!=TPCERROR_OK) {
    strcpy(tmp, "."); if(verbose>5) printf("no studynr\n");
  } else tacSetHeaderStudynr(&localh, ""); // delete studynr from header
  n=fprintf(fp, "%s", tmp); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  for(int ri=0; ri<tac->tacNr; ri++) {
    n=tacNameSplit(tac->c[ri].name, NULL, subname, NULL, 6);
    if(n<2 || !subname[0]) strcpy(subname, ".");
    fprintf(fp, "\t%s", subname);
  }
  if(tacIsWeighted(tac)) fprintf(fp, "\t%s", ".");
  n=fprintf(fp, "\n"); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* 3rd line with calibration unit and 3rd subname */
  if(verbose>2) printf("  writing 3rd title line\n");
  tacSetHeaderUnit(&localh, UNIT_UNKNOWN); // delete any unit(s) from header
  if(tac->cunit==UNIT_UNKNOWN) strcpy(tmp, ".");
  else strcpy(tmp, unitName(tac->cunit));
  n=fprintf(fp, "%s", tmp); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  for(int ri=0; ri<tac->tacNr; ri++) {
    n=tacNameSplit(tac->c[ri].name, NULL, NULL, subname, 6);
    if(n<3 || !subname[0]) strcpy(subname, ".");
    fprintf(fp, "\t%s", subname);
  }
  if(tacIsWeighted(tac)) fprintf(fp, "\t%s", ".");
  n=fprintf(fp, "\n"); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* 4th line with x (time) type & unit and region volumes */
  if(verbose>2) printf("  writing 4th title line\n");
  if(unitIsDistance(tac->tunit)) strcpy(tmp, "Distance");
  else strcpy(tmp, "Time");
  if(tac->isframe!=0) strcat(tmp, "s");
  n=fprintf(fp, "%s (%s)", tmp, unitName(tac->tunit)); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  for(int ri=0; ri<tac->tacNr; ri++) {
    if(!isnan(tac->c[ri].size)) sprintf(tmp, "%.*e", prec, tac->c[ri].size);
    else strcpy(tmp, ".");
    fprintf(fp, "\t%s", tmp);
  }
  if(tacIsWeighted(tac)) fprintf(fp,"\t%s", ".");
  n=fprintf(fp, "\n"); if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Write data */
  if(verbose>1) printf("writing data table\n");
  double v;
  n=10;
  for(int fi=0; fi<tac->sampleNr; fi++) {
    /* x or  x1 and x2) */
    if(tac->isframe==0) v=tac->x[fi]; else v=tac->x1[fi];
    if(isnan(v)) n=fprintf(fp, "."); else n=fprintf(fp, "%.5f", v);
    if(n<1) break;
    if(tac->isframe!=0) {
      v=tac->x2[fi];
      if(isnan(v)) n=fprintf(fp, "\t."); else n=fprintf(fp, "\t%.5f", v);
      if(n<1) break;
    }
    /* Concentrations (y values) */
    for(int ri=0; ri<tac->tacNr; ri++) {
      if(isnan(tac->c[ri].y[fi])) n=fprintf(fp, "\t.");
      else n=fprintf(fp, "\t%.*e", prec, tac->c[ri].y[fi]);
      if(n<1) break;
    }
    if(n<1) break;
    /* Weight */
    if(tacIsWeighted(tac)) {
      if(isnan(tac->w[fi])) n=fprintf(fp, "\t.");
      else n=fprintf(fp, "\t%.*e", prec, tac->w[fi]);
      if(n<1) break;
    }
    if(n<1) break;
    n=fprintf(fp, "\n"); if(n<1) break;
  } // next sample
  if(n<1) {
    iftFree(&localh);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  
  /* Write extra header, if requested */
  if(extra && localh.keyNr>0) {
    int ret=iftWrite(&localh, fp, status);
    if(ret!=TPCERROR_OK) {iftFree(&localh); return ret;}
  }
 
  iftFree(&localh);
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacWrite().

tacWritePMOD()

int tacWritePMOD ( TAC * tac, FILE * fp, int extra, TPCSTATUS * status )

extern

Write TAC data into specified file pointer in PMOD.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacReadPMOD, tacWrite

Parameters

tac	Pointer to TAC structure, contents of which are to be written.
fp	File pointer to write to.
extra	Write (1) or do not write (0) also extra header fields found in IFT; note that these are not supported by other than TPC SW.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file pmodio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  char *cptr, tunit[128], cunit[128];
  int n, prec=6;
  double v;
 
  /* Set units to format accepted by PMOD */
  if(tac->tunit==UNIT_SEC) strcpy(tunit, "seconds");
  else if(tac->tunit==UNIT_MIN) strcpy(tunit, "minutes");
  else strcpy(tunit, unitName(tac->tunit));
  if(tac->cunit==UNIT_UNITLESS) strcpy(cunit, "1/1");
  else strcpy(cunit, unitName(tac->cunit));
  if(strcasestr(cunit, "dL")==NULL) {
    /* Replace mL by cc, but only if unit does not contain 'dL' */
    cptr=strcasestr(cunit, "mL"); 
    if(cptr!=NULL) {*cptr='c'; cptr++; *cptr='c';}
  }
 
  /* Make sure that TAC names are available */
  if(verbose>2) printf("constructing TAC names\n");
  tacEnsureNames(tac);
 
  /* Write obligatory header line */
  if(verbose>2) printf("writing obligatory title lines\n");
  if(tac->isframe==0) n=fprintf(fp, "time[%s]", tunit);
  else n=fprintf(fp, "start[%s]\tend[%s]", tunit, cunit);
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  for(int ri=0; ri<tac->tacNr; ri++) {
    /* write TAC names, must not include space characters */
    strReplaceChar(tac->c[ri].name, ' ', '-');
    strReplaceChar(tac->c[ri].name, '\t', '-');
    n=fprintf(fp, "\t%s", tac->c[ri].name);
    if(n<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
      return TPCERROR_CANNOT_WRITE;
    }
    /* write calibration unit when necessary */
    if(ri==0 && tac->isframe==0) fprintf(fp, "[%s]", cunit);
  }
  if(tacIsWeighted(tac)) fprintf(fp, "\t%s", "weight");
  n=fprintf(fp, "\n"); if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Write data */
  if(verbose>2) printf("writing data table\n");
  for(int fi=0, n=0; fi<tac->sampleNr; fi++) {
    /* Time(s) (x, x1, x2) */
    if(tac->isframe==0) v=tac->x[fi]; else v=tac->x1[fi];
    if(!isfinite(v)) n=fprintf(fp, "."); else n=fprintf(fp, "%.5f", v);
    if(n<1) break;
    if(tac->isframe!=0) {
      v=tac->x2[fi];
      if(!isfinite(v)) n=fprintf(fp, "\t."); else n=fprintf(fp, "\t%.5f", v);
      if(n<1) break;
    }
    /* Concentrations (y values) */
    for(int ri=0; ri<tac->tacNr; ri++) {
      if(!isfinite(tac->c[ri].y[fi])) n=fprintf(fp, "\t.");
      else fprintf(fp, "\t%.*e", prec, tac->c[ri].y[fi]);
      if(n<1) break;
    }
    /* Weight */
    if(tacIsWeighted(tac)) {
      if(!isfinite(tac->w[fi])) n=fprintf(fp, "\t.");
      else n=fprintf(fp, "\t%.*e", prec, tac->w[fi]);
      if(n<1) break;
    }
    if(n>0) n=fprintf(fp, "\n");
    if(n<1) break;
  }
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  
  /* Write extra header, if requested */
  if(extra) {
    if(tac->h.keyNr>0) {
      int ret=iftWrite(&tac->h, fp, status);
      if(ret!=TPCERROR_OK) return ret;
    }
  }
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacWrite().

tacWriteSIF()

int tacWriteSIF ( TAC * tac, FILE * fp, int extra, TPCSTATUS * status )

extern

Write SIF data stored in TAC struct in SIF format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacReadSIF, tacWrite, TAC

Parameters

tac	Pointer to TAC struct, contents of which are to be written; tacNr can be set to 0 to write only frame times.
fp	File pointer.
extra	Write (1) or do not write (0) also extra header fields found in tac->h; set this to 0, because extra header lines do not follow SIF format.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file sifio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) printf("%s()\n", __func__);
 
  int fi, ret, n;
  int m2s=0; // 1=time units converted from min to sec
  
  /* Scan start time */
  char scan_start_time[20];
  ret=tacGetHeaderScanstarttime(&tac->h, scan_start_time, NULL);
  if(ret==TPCERROR_OK) {
    int yy, mm, dd, h, m, s;
    n=sscanf(scan_start_time, "%d-%d-%d %d:%d:%d", &yy, &mm, &dd, &h, &m, &s);
    if(n==6) 
      sprintf(scan_start_time, "%d/%d/%04d %02d:%02d:%02d", dd, mm, yy, h, m, s);
    else strcpy(scan_start_time, "1/1/1970 00:00:00");
  } else { // use default date & time
    strcpy(scan_start_time, "1/1/1970 00:00:00");
  }
  /* Column nr */
  int colNr=2; // frame start and end times
  colNr+=tac->tacNr;
  /* Study number */
  char studynr[MAX_STUDYNR_LEN+1];
  ret=tacGetHeaderStudynr(&tac->h, studynr, NULL);
  if(ret!=TPCERROR_OK) strcpy(studynr, ".");
  /* Isotope */
  char isotope[MAX_ISOTOPE_LEN+1];
  ret=tacGetHeaderIsotope(&tac->h, isotope, NULL);
  if(ret!=TPCERROR_OK) strcpy(studynr, "");
  /* Write header line */
  n=fprintf(fp, "%s %d %d 1 %s %s\n", scan_start_time, tac->sampleNr, colNr, studynr, isotope);
  if(n<7) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Convert frame times to seconds because always sec in SIF */
  if(tac->tunit==UNIT_MIN) {m2s=1; tacXUnitConvert(tac, UNIT_SEC, status);}
 
  /* Check if frame times need to printed with decimals */
  int req_decimals=0;
  for(fi=1; fi<tac->sampleNr; fi++) {
    if(round(tac->x1[fi])==round(tac->x1[fi-1])) {req_decimals=1; break;}
    if(round(tac->x2[fi])==round(tac->x2[fi-1])) {req_decimals=1; break;}
  }
 
  /* Write data lines */
  ret=0;
  for(fi=0; fi<tac->sampleNr; fi++) {
    if(req_decimals==0) n=fprintf(fp, "%.0f %.0f", tac->x1[fi], tac->x2[fi]);
    else n=fprintf(fp, "%.1f %.1f", tac->x1[fi], tac->x2[fi]);
    if(n<3) {ret++; break;}
    for(int ci=0; ci<tac->tacNr; ci++) {
      n=fprintf(fp, " %.0f", tac->c[ci].y[fi]);
      if(n<2) {ret++; break;}
    }
    if(ret==0) fprintf(fp, "\n"); else break;
  }
  if(ret!=0) {
    if(m2s!=0) tacXUnitConvert(tac, UNIT_MIN, status);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Convert frame times back to min if necessary */
  if(m2s!=0) tacXUnitConvert(tac, UNIT_MIN, status);
  
  /* Write extra information */
  if(extra!=0) {
    /* do nothing at least for now */
  }
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacWrite().

tacWriteSimple()

int tacWriteSimple ( TAC * tac, FILE * fp, int extra, TPCSTATUS * status )

extern

Write TAC data into specified file pointer in Simple format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacReadSimple, tacWriteCSV

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
fp	File pointer.
extra	Write (1) or do not write (0) also extra header fields found in IFT.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file simpleio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(verbose>0) {printf("%s(%d)\n", __func__, extra); fflush(stdout);}
 
 
  int fi, ri, n, prec=6;
  double v;
 
  /* Write data */
  for(fi=0; fi<tac->sampleNr; fi++) {
    /* Time (x) */
    if(tac->isframe==0) v=tac->x[fi]; else v=0.5*(tac->x1[fi]+tac->x2[fi]);
    if(isnan(v)) n=fprintf(fp, "."); else n=fprintf(fp, "%.5f", v);
    if(n<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
      return TPCERROR_CANNOT_WRITE;
    }
    /* Concentrations (y values) */
    for(ri=0; ri<tac->tacNr; ri++) {
      if(isnan(tac->c[ri].y[fi])) n=fprintf(fp, " .");
      else fprintf(fp, " %.*e", prec, tac->c[ri].y[fi]);
      if(n<1) {
        statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
        return TPCERROR_CANNOT_WRITE;
      }
    }
    n=fprintf(fp, "\n"); if(n<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
      return TPCERROR_CANNOT_WRITE;
    }
  }
  
  /* Write extra header, if requested */
  if(extra) {
    if(tac->h.keyNr>0) {
      int ret=iftWrite(&tac->h, fp, status);
      if(ret!=TPCERROR_OK) return ret;
    }
    /* Write units */
    if(tac->cunit!=UNIT_UNKNOWN) fprintf(fp, "# unit := %s\n", unitName(tac->cunit));
    if(tac->tunit!=UNIT_UNKNOWN) fprintf(fp, "# timeunit := %s\n", unitName(tac->tunit));
  }
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacWrite().

tacWriteXML()

int tacWriteXML ( TAC * tac, FILE * fp, TPCSTATUS * status )

extern

Write TAC data into specified file pointer in Excel compatible XML format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

tacWrite

Parameters

tac	Pointer to TAC struct, contents of which are to be written.
fp	File pointer
status	Pointer to status data; enter NULL if not needed

Definition at line 26 of file tacxmlio.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  char *cptr, tunit[128], cunit[128];
  int n;
 
  /* Set units to format accepted by PMOD */
  if(tac->tunit==UNIT_SEC) strcpy(tunit, "seconds");
  else if(tac->tunit==UNIT_MIN) strcpy(tunit, "minutes");
  else strcpy(tunit, unitName(tac->tunit));
  strcpy(cunit, unitName(tac->cunit));
  if(strcasestr(cunit, "dL")==NULL) {
    /* Replace mL by cc, but only if unit does not contain 'dL' */
    cptr=strcasestr(cunit, "mL"); 
    if(cptr!=NULL) {*cptr='c'; cptr++; *cptr='c';}
  }
 
  /* Make sure that TAC names are available */
  if(verbose>2) printf("constructing TAC names\n");
  tacEnsureNames(tac);
 
  /* Write XML header */
  n=fprintf(fp, "<?xml version=\"1.0\"?>\n");
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  fprintf(fp, "<ss:Workbook xmlns:ss=\"urn:schemas-microsoft-com:office:spreadsheet\">\n");
  fprintf(fp, "  <ss:Styles>\n");
  fprintf(fp, "    <ss:Style ss:ID=\"1\">\n");
  fprintf(fp, "      <ss:Font ss:Bold=\"1\"/>\n");
  fprintf(fp, "    </ss:Style>\n");
  fprintf(fp, "  </ss:Styles>\n");
  fprintf(fp, "  <ss:Worksheet ss:Name=\"Sheet1\">\n");
  fprintf(fp, "    <ss:Table>\n");
 
  /* Set column widths */
  n=tac->tacNr+1;
  if(tac->isframe) n++;
  if(tacIsWeighted(tac)) n++;
  for(int i=0; i<n; i++) fprintf(fp, "      <ss:Column ss:Width=\"80\"/>\n");
 
  /* Write the title line */
  fprintf(fp, "      <ss:Row ss:StyleID=\"1\">\n");
  if(tac->isframe==0) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">time[%s]</ss:Data>\n", tunit);
    fprintf(fp, "        </ss:Cell>\n");
  } else {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">start[%s]</ss:Data>\n", tunit);
    fprintf(fp, "        </ss:Cell>\n");
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">end[%s]</ss:Data>\n", cunit);
    fprintf(fp, "        </ss:Cell>\n");
  }
  for(int ri=0; ri<tac->tacNr; ri++) {
    /* write TAC names */
    char *nptr=tac->c[ri].name;
    char *senc=strEncodeForXML(nptr);
    if(senc!=NULL) nptr=senc;
    fprintf(fp, "        <ss:Cell>\n");
    if(ri==0 && tac->isframe==0)
      fprintf(fp, "          <ss:Data ss:Type=\"String\">%s[%s]</ss:Data>\n", nptr, cunit);
    else
      fprintf(fp, "          <ss:Data ss:Type=\"String\">%s</ss:Data>\n", nptr);
    fprintf(fp, "        </ss:Cell>\n");
    if(senc!=NULL) free(senc);
  }
  if(tacIsWeighted(tac)) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">weight</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
  }
  n=fprintf(fp, "      </ss:Row>\n");
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Write data */
  if(verbose>2) printf("writing data table\n");
  for(int fi=0; fi<tac->sampleNr; fi++) {
 
    fprintf(fp, "      <ss:Row>\n");
 
    /* Note: missing values are written as empty cells, with string type, because with
       number type Excel seems to read those as zeroes. */
 
    /* Time(s) (x, or x1 and x2) */
    double v; if(tac->isframe==0) v=tac->x[fi]; else v=tac->x1[fi];
    fprintf(fp, "        <ss:Cell>\n");
    if(isnan(v)) fprintf(fp, "          <ss:Data ss:Type=\"String\"></ss:Data>\n");
    else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", v);
    fprintf(fp, "        </ss:Cell>\n");
 
    if(tac->isframe) {
      v=tac->x2[fi];
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(v)) fprintf(fp, "          <ss:Data ss:Type=\"String\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", v);
      fprintf(fp, "        </ss:Cell>\n");
    }
 
    /* Concentrations (y values) */
    for(int ri=0; ri<tac->tacNr; ri++) {
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(tac->c[ri].y[fi])) fprintf(fp, "          <ss:Data ss:Type=\"String\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", tac->c[ri].y[fi]);
      fprintf(fp, "        </ss:Cell>\n");
    }
 
    /* Weight */
    if(tacIsWeighted(tac)) {
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(tac->w[fi])) fprintf(fp, "          <ss:Data ss:Type=\"String\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", tac->w[fi]);
      fprintf(fp, "        </ss:Cell>\n");
    }
 
    fprintf(fp, "      </ss:Row>\n");
  }
 
  /* Write XML end part */
  fprintf(fp, "    </ss:Table>\n");
  fprintf(fp, "  </ss:Worksheet>\n");
  n=fprintf(fp, "</ss:Workbook>\n");
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacWrite().

tacWSampleNr()

unsigned int tacWSampleNr ( TAC * tac )

extern

Get the number of samples in TAC that have weight > 0. Missing (NaN) sample values are included as long as weight is not missing. If weights are not set, then nr of all samples is returned.

Returns

The number of samples with weight above zero.

See also

tacWByFreq, aicSS, parFreeNr, tacWeightModerate, tacIsWeighted, tacSetWeights

Parameters

tac	Pointer to the TAC struct.

Definition at line 219 of file tacw.c.

  {
  if(tac==NULL || tac->tacNr<1 || tac->sampleNr<1) return((unsigned int)0);
  if(tac->weighting==WEIGHTING_OFF) return((unsigned int)tac->sampleNr);
  unsigned int n=0;
  for(int i=0; i<tac->sampleNr; i++) if(tac->w[i]>0.0) n++;
  if(n==0 && tac->weighting==WEIGHTING_UNKNOWN) n=(unsigned int)tac->sampleNr;
  return(n);
}

tacXCopy()

int tacXCopy ( TAC * tac1, TAC * tac2, int i1, int i2 )

extern

Copy x values (frame times) from one TAC structure to another.

See also

tacCompareTimes, tacXMatch, tacIsX, tacCheckX1X2X, tacInterpolate, tacWCopy, tacCopyTacc

Author

Vesa Oikonen

Returns

Returns TPCERROR status.

Parameters

tac1	Pointer to source TAC structure.
tac2	Pointer to target TAC structure.
i1	Index of the first sample time to copy.
i2	Index of the last sample time to copy.

Definition at line 24 of file tacx.c.

  {
  if(tac1==NULL || tac2==NULL) return(TPCERROR_FAIL);
  if(i1<0 || i1>i2) return(TPCERROR_FAIL);
  if(i2>=tac1->_sampleNr || i2>=tac2->_sampleNr) return(TPCERROR_FAIL);
  
  for(int i=i1; i<=i2; i++) {
    tac2->x[i]=tac1->x[i];
    tac2->x1[i]=tac1->x1[i];
    tac2->x2[i]=tac1->x2[i];
  }
  return(TPCERROR_OK);
}

Referenced by bfm1TCM(), tacAllocateMoreSamples(), tacDuplicate(), tacExtract(), tacInterpolate(), tacReadReference(), tacSetWeights(), and tacSetX().

tacXMatch()

int tacXMatch ( TAC * d1, TAC * d2, const int verbose )

extern

Check whether sample (frame) times are the same (or very close to) in two TAC structures.

Data is not modified. Sort by sample time before calling this. The order of TAC structures is not important. If sampleNr is different, then only common number of samples are compared.

See also

tacCompareTimes, tacXCopy, tacSortByTime, tacIsX

Author

Vesa Oikonen

Returns

Returns 1 if times do match, 0 if not.

Parameters

d1	Pointer to the first TAC structure; not modified.
d2	Pointer to the second TAC structure; time unit does not matter if conversion can be done. Sample nr may be different than in tac1. Contents not modified.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 249 of file tacx.c.

  {
  if(verbose>0) printf("\n%s()\n", __func__);
 
  /* Check data */
  if(d1==NULL || d2==NULL) return 0;
  double xmin[2], xmax[2];
  if(tacXRange(d1, xmin, xmax) || tacXRange(d2, xmin+1, xmax+1)) return(0);
 
  /* Which has less samples? */
  int smaller_sampleNr;
  if(d1->sampleNr<d2->sampleNr) smaller_sampleNr=d1->sampleNr;
  else smaller_sampleNr=d2->sampleNr;
  if(verbose>1) printf("smaller_sampleNr := %d\n", smaller_sampleNr);
  if(smaller_sampleNr<=0) return 0;
  
  /* Get conversion factors for sample times to get those in sec */
  double ts1, ts2;
  ts1=unitConversionFactor(d1->tunit, UNIT_SEC);
  if(isnan(ts1)) {
    if(verbose>1) printf("cannot convert tac1 sample times to sec.\n");
    ts1=1.0; if(d1->tunit==UNIT_UNKNOWN) ts1=60.0; // assuming min
  }
  ts2=unitConversionFactor(d2->tunit, UNIT_SEC);
  if(isnan(ts2)) {
    if(verbose>1) printf("cannot convert tac2 sample times to sec.\n");
    ts2=1.0; if(d2->tunit==UNIT_UNKNOWN) ts2=60.0; // assuming min
  }
  /* Convert time ranges to sec */
  xmin[0]*=ts1; xmax[0]*=ts1;
  xmin[1]*=ts2; xmax[1]*=ts2;
  if(verbose>1) {
    printf("tac1->isframe := %d\n", d1->isframe);
    if(verbose>2) printf("time_range1 := %g - %g\n", xmin[0], xmax[0]);
    printf("tac2->isframe := %d\n", d2->isframe);
    if(verbose>2) printf("time_range2 := %g - %g\n", xmin[1], xmax[1]);
  }
 
  /* Set the accepted time difference */
  double f, accepted_timedif=2.2; // sec
  /* With short study the accepted time difference must be shorter */
  f=xmax[0]-xmin[0]; if((xmax[1]-xmin[1])>f) f=xmax[1]-xmin[1];
  f*=0.01; if(accepted_timedif>f) accepted_timedif=f;
  if(verbose>1) {
    printf("accepted_timedif := %g [s]\n", accepted_timedif);
    fflush(stdout);
  }
 
  /* Compare sample times frame-by-frame */
  int fi, n=0;
  if(d1->isframe==0 && d2->isframe==0) {
    if(verbose>2) {printf("frame mid times\n"); fflush(stdout);}
    for(fi=0; fi<smaller_sampleNr; fi++) {
      if(d1->x[fi]*ts1==d2->x[fi]*ts2) continue;
      if(isnan(d1->x[fi]) && isnan(d2->x[fi])) continue; // match if both NaN
      if(isnan(d1->x[fi]) || isnan(d2->x[fi])) {n++; continue;} // no match
      f=fabs(d1->x[fi]*ts1-d2->x[fi]*ts2);
      if(verbose>3) printf("timedif[%d] := %g\n", fi, f);
      if(verbose>4) printf("  %g vs %g\n", ts1*d1->x[fi], ts2*d2->x[fi]);
      if(f>accepted_timedif) n++;
    }
  } else if(d1->isframe!=0 && d2->isframe!=0) {
    if(verbose>2) {printf("frame start and end times\n"); fflush(stdout);}
    for(fi=0; fi<smaller_sampleNr; fi++) {
      if(d1->x1[fi]*ts1==d2->x1[fi]*ts2) continue;
      if(isnan(d1->x1[fi]) && isnan(d2->x1[fi])) continue; // match if both NaN
      if(isnan(d1->x1[fi]) || isnan(d2->x1[fi])) {n++; continue;} // no match
      f=fabs(d1->x1[fi]*ts1-d2->x1[fi]*ts2);
      if(verbose>3) printf("timedif[%d] := %g\n", fi, f);
      if(verbose>4) printf("  %g vs %g\n", ts1*d1->x1[fi], ts2*d2->x1[fi]);
      if(f>accepted_timedif) n++;
    }
    for(fi=0; fi<smaller_sampleNr; fi++) {
      if(d1->x2[fi]*ts1==d2->x2[fi]*ts2) continue;
      if(isnan(d1->x2[fi]) && isnan(d2->x2[fi])) continue; // match if both NaN
      if(isnan(d1->x2[fi]) || isnan(d2->x2[fi])) {n++; continue;} // no match
      f=fabs(d1->x2[fi]*ts1-d2->x2[fi]*ts2);
      if(verbose>3) printf("timedif[%d] := %g\n", fi, f);
      if(verbose>4) printf("  %g vs %g\n", ts1*d1->x2[fi], ts2*d2->x2[fi]);
      if(f>accepted_timedif) n++;
    }
  } else {
    if(verbose>2) {printf("mixed frame times\n"); fflush(stdout);}
    double x1, x2;
    for(fi=0; fi<smaller_sampleNr; fi++) {
      if(d1->isframe) x1=0.5*(d1->x1[fi]+d1->x2[fi]); else x1=d1->x[fi];
      if(d2->isframe) x2=0.5*(d2->x1[fi]+d2->x2[fi]); else x2=d2->x[fi];
      if(x1*ts1==x2*ts2) continue;
      if(isnan(x1) && isnan(x2)) continue; // match if both NaN
      if(isnan(x1) || isnan(x2)) {n++; continue;} // no match
      f=fabs(x1*ts1-x2*ts2);
      if(verbose>3) printf("timedif[%d] := %g\n", fi, f);
      if(verbose>4) printf("  %g vs %g\n", x1, x2);
      if(f>accepted_timedif) n++;
    }
  }
  if(verbose>2) {printf("nr of different frame times := %d\n", n); fflush(stdout);}
  if(n==0) return 1; else return 0; 
}

Referenced by tacInterpolate(), tacInterpolateInto(), and tacReadReference().

tacXNaNs()

int tacXNaNs ( TAC * tac )

extern

Check TAC structure for missing sample times (x, or x1 and x2).

See also

tacDeleteMissingSamples, tacIsX, tacSetX

Returns

Returns the number of missing values that were found.

Parameters

tac	Pointer to TAC structure.

Definition at line 23 of file tacnan.c.

  {
  if(tac==NULL || tac->sampleNr<1) return(0);
  
  int fi, nan_nr=0;
  if(tac->isframe) {
    for(fi=0; fi<tac->sampleNr; fi++) {
      if(!isfinite(tac->x1[fi])) nan_nr++;
      if(!isfinite(tac->x2[fi])) nan_nr++;
    }
  } else {
    for(fi=0; fi<tac->sampleNr; fi++) {
      if(!isfinite(tac->x[fi])) nan_nr++;
    }
  }
  return(nan_nr);
}

Referenced by tacDelay(), tacFixNaNs(), tacInterpolate(), tacInterpolateInto(), tacIsXContiguous(), tacNaNs(), tacSetXContiguous(), tacSortByTime(), and tacVerifyTimeOrder().

tacXRange()

int tacXRange ( TAC * d, double * xmin, double * xmax )

extern

Get the range of x values (times) in TAC structure.

Data is not modified. Data does not need to be sorted. Data can contain NaNs, but x values are not omitted if y is NaN and x is not. Samples with zero weight are included.

See also

tacSampleXRange, tacIsX, tacExtractRange, tacCorrectFrameOverlap, tacYRange

Author

Vesa Oikonen

Returns

Returns <>0 in case of failure.

Parameters

d	Pointer to TAC struct
xmin	Pointer to variable for min x value (NULL if not needed).
xmax	Pointer to variable for max x value (NULL if not needed).

Definition at line 124 of file tacx.c.

  {
  if(xmin!=NULL) *xmin=nan("");
  if(xmax!=NULL) *xmax=nan("");
  /* Check the data */
  if(d==NULL || d->sampleNr<1) return(1);
  /* Find the min and max time */
  double mi, ma, *xi, *xa;
  mi=ma=nan("");
  if(d->isframe) {xi=d->x1; xa=d->x2;} else xi=xa=d->x;
  for(int i=0; i<d->sampleNr; i++) {
    if(!isfinite(xi[i]) || !isfinite(xa[i])) continue;
    if(isnan(mi) || isnan(ma)) {mi=xi[i]; ma=xa[i]; continue;}
    if(xi[i]<mi) mi=xi[i]; else if(xa[i]>ma) ma=xa[i];
  }
  if(xmin!=NULL) *xmin=mi;
  if(xmax!=NULL) *xmax=ma;
  if(!isfinite(mi) || !isfinite(ma)) return(2);
  return(0);
}

Referenced by sifWeight(), tacAUC(), tacDelay(), tacDelayFit(), tacFittime(), tacInterpolate(), tacInterpolateInto(), tacInterpolateToEqualLengthFrames(), tacIsX(), tacReadModelingData(), and tacXMatch().

tacXUnitConvert()

int tacXUnitConvert ( TAC * tac, const int u, TPCSTATUS * status )

extern

Convert X values (sample times) in TAC struct to the specified unit.

See also

tacYUnitConvert, unitConversionFactor

Returns

Returns TPCERROR_OK (0) when successful.

Parameters

tac	Pointer to TAC struct
u	Enum unit
status	Pointer to status data; enter NULL if not needed

Definition at line 23 of file tacunits.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) {printf("%s(%s)\n", __func__, unitName(u)); fflush(stdout);}
  if(tac==NULL || tac->sampleNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* If both units are unknown, then return suitable error code */
  if(u==UNIT_UNKNOWN && tac->tunit==UNIT_UNKNOWN) {
    if(verbose>1) {printf("  unknown x units\n"); fflush(stdout);}
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNKNOWN_UNIT);
    return TPCERROR_UNKNOWN_UNIT;
  }
 
  /* Determine the correction factor */
  double cf;
  cf=unitConversionFactor(tac->tunit, u);
  if(isnan(cf)) {
    if(verbose>1) {printf("  cannot make x conversion factor\n"); fflush(stdout);}
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
    return TPCERROR_INCOMPATIBLE_UNIT;
  }
  
  /* Multiply x values */
  if(verbose>1) {printf("  converting x with factor %g\n", cf); fflush(stdout);}
  for(int i=0; i<tac->sampleNr; i++) {
    tac->x[i]*=cf; tac->x1[i]*=cf; tac->x2[i]*=cf;
  }
  /* Set new unit */
  tac->tunit=u;
  
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacInput2sim(), tacReadModelingData(), tacReadModelingInput(), tacReadReference(), tacSetWeights(), tacSetX(), and tacWriteSIF().

tacYNaNs()

int tacYNaNs ( TAC * tac, const int i )

extern

Check TAC structure for missing sample values (y).

See also

tacNaNs, tacFixNaNs

Returns

Returns the number of missing values that were found.

Parameters

tac	Pointer to TAC structure.
i	Index of TAC to test; <0 to test all TACs.

Definition at line 47 of file tacnan.c.

  {
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1 || i>=tac->tacNr) return(0);
  
  int ri, fi, nan_nr=0;
  if(i>=0) {
    for(fi=0; fi<tac->sampleNr; fi++)
      if(!isfinite(tac->c[i].y[fi])) nan_nr++;
    return(nan_nr);
  }
  for(ri=0; ri<tac->tacNr; ri++)
    for(fi=0; fi<tac->sampleNr; fi++)
      if(!isfinite(tac->c[ri].y[fi])) nan_nr++;
  return(nan_nr);
}

Referenced by tacDelay(), tacFixNaNs(), and tacNaNs().

tacYRange()

int tacYRange ( TAC * d, int i, double * ymin, double * ymax, int * smin, int * smax, int * imin, int * imax )

extern

Get the range of y values (concentrations) in TAC struct.

Data is not modified. Data does not need to be sorted. Data can contain NaNs, but y values omitted if corresponding x is NaN.

See also

tacYRangeInXRange, tacXRange, tacYUnitConvert, tacCopyTacc

Author

Vesa Oikonen

Returns

Returns <>0 in case of failure.

Parameters

d	Pointer to TAC structure.
i	Index of TAC, [0, ..., tacNr-1] ; enter <0 to search for max and/or min from all TACs.
ymin	Pointer to variable for min y value (NULL if not needed).
ymax	Pointer to variable for max y value (NULL if not needed).
smin	Pointer to variable where sample index of min y value will be stored (NULL if not needed).
smax	Pointer to variable where sample index of max y value will be stored (NULL if not needed).
imin	Pointer to variable where tac index of min y value will be stored (NULL if not needed).
imax	Pointer to variable where tac index of max y value will be stored (NULL if not needed).

Definition at line 26 of file tacy.c.

  {
  if(ymin!=NULL) *ymin=nan("");
  if(ymax!=NULL) *ymax=nan("");
  if(smin!=NULL) *smin=-1;
  if(smax!=NULL) *smax=-1;
  if(imin!=NULL) *imin=-1;
  if(imax!=NULL) *imax=-1;
  /* Check the data */
  if(d==NULL || d->sampleNr<1) return(1);
  /* Check the index */
  if(i>=d->tacNr) return(2);
 
  /* Find the min and max time */
  double *xi, *xa;
  if(d->isframe) {xi=d->x1; xa=d->x2;} else xi=xa=d->x;
  double mi, ma;
  mi=ma=nan("");
  for(int j=0; j<d->sampleNr; j++) {
    if(isnan(xi[j]) || isnan(xa[j])) continue;
    for(int k=0; k<d->tacNr; k++) {
      if(i>=0 && i!=k) continue;
      if(isnan(mi) || isnan(ma)) {
        mi=d->c[k].y[j]; ma=d->c[k].y[j]; 
        if(smin!=NULL) *smin=j;
        if(smax!=NULL) *smax=j;
        if(imin!=NULL) *imin=k;
        if(imax!=NULL) *imax=k;
        continue;
      }
      if(d->c[k].y[j]<mi) {
        mi=d->c[k].y[j]; 
        if(smin!=NULL) *smin=j;
        if(imin!=NULL) *imin=k;
      } else if(d->c[k].y[j]>ma) {
        ma=d->c[k].y[j];
        if(smax!=NULL) *smax=j;
        if(imax!=NULL) *imax=k;
      }
    }
  }
  if(ymin!=NULL) *ymin=mi;
  if(ymax!=NULL) *ymax=ma;
  if(isnan(mi) || isnan(ma)) return(2);
  return(0);
}

Referenced by mtgaPlotSVG().

tacYRangeInXRange()

int tacYRangeInXRange ( TAC * d, int i, const double xmin, const double xmax, double * ymin, double * ymax, int * smin, int * smax, int * imin, int * imax )

extern

Get the range of y values (concentrations) in TAC struct, including only samples with x (times) inside given range.

Data is not modified. Data does not need to be sorted. Data can contain NaNs, but y values omitted if corresponding x is NaN.

See also

tacYRange, tacXRange, tacYUnitConvert

Author

Vesa Oikonen

Returns

Returns <>0 in case of failure.

Parameters

d	Pointer to TAC structure.
i	Index of TAC, [0, ..., tacNr-1] ; enter <0 to search for max and/or min from all TACs.
xmin	Min x value.
xmax	Max x value.
ymin	Pointer to variable for min y value (NULL if not needed).
ymax	Pointer to variable for max y value (NULL if not needed).
smin	Pointer to variable where sample index of min y value will be stored (NULL if not needed).
smax	Pointer to variable where sample index of max y value will be stored (NULL if not needed).
imin	Pointer to variable where tac index of min y value will be stored (NULL if not needed).
imax	Pointer to variable where tac index of max y value will be stored (NULL if not needed).

Definition at line 99 of file tacy.c.

  {
  if(ymin!=NULL) *ymin=nan("");
  if(ymax!=NULL) *ymax=nan("");
  if(smin!=NULL) *smin=-1;
  if(smax!=NULL) *smax=-1;
  if(imin!=NULL) *imin=-1;
  if(imax!=NULL) *imax=-1;
  /* Check the data */
  if(d==NULL || d->sampleNr<1) return(1);
  /* Check the index */
  if(i>=d->tacNr) return(2);
  /* Check x range */
  if(xmin>xmax) return(3);
 
  /* Find the min and max time */
  double *xi, *xa, x;
  if(d->isframe) {xi=d->x1; xa=d->x2;} else xi=xa=d->x;
  double mi, ma;
  mi=ma=nan("");
  for(int j=0; j<d->sampleNr; j++) {
    if(isnan(xi[j]) || isnan(xa[j])) continue;
    x=0.5*(xi[j]+xa[j]); if(x<xmin || x>xmax) continue;
    for(int k=0; k<d->tacNr; k++) {
      if(i>=0 && i!=k) continue;
      if(isnan(mi) || isnan(ma)) {
        mi=d->c[k].y[j]; ma=d->c[k].y[j]; 
        if(smin!=NULL) *smin=j;
        if(smax!=NULL) *smax=j;
        if(imin!=NULL) *imin=k;
        if(imax!=NULL) *imax=k;
        continue;
      }
      if(d->c[k].y[j]<mi) {
        mi=d->c[k].y[j]; 
        if(smin!=NULL) *smin=j;
        if(imin!=NULL) *imin=k;
      } else if(d->c[k].y[j]>ma) {
        ma=d->c[k].y[j];
        if(smax!=NULL) *smax=j;
        if(imax!=NULL) *imax=k;
      }
    }
  }
  if(ymin!=NULL) *ymin=mi;
  if(ymax!=NULL) *ymax=ma;
  if(isnan(mi) || isnan(ma)) return(2);
  return(0);
}

Referenced by tacPlotFitSVG(), tacPlotHistogramSVG(), and tacPlotLineSVG().

tacYUnitConvert()

int tacYUnitConvert ( TAC * tac, const int u, TPCSTATUS * status )

extern

Convert Y values (concentrations) in TAC struct to the specified unit.

See also

tacXUnitConvert, unitConversionFactor

Returns

Returns TPCERROR_OK (0) when successful.

Parameters

tac	Pointer to TAC struct
u	Enum unit
status	Pointer to status data; enter NULL if not needed

Definition at line 72 of file tacunits.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(%s)\n", __func__, unitName(u));
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  
  /* If both units are unknown, then return suitable error code */
  if(u==UNIT_UNKNOWN && tac->cunit==UNIT_UNKNOWN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNKNOWN_UNIT);
    return TPCERROR_UNKNOWN_UNIT;
  }
 
  /* Determine the correction factor */
  double cf;
  cf=unitConversionFactor(tac->cunit, u);
  if(isnan(cf)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
    return TPCERROR_INCOMPATIBLE_UNIT;
  }
  
  /* Multiply y values */
  for(int j=0; j<tac->tacNr; j++) {
    for(int i=0; i<tac->sampleNr; i++) {
      tac->c[j].y[i]*=cf;
    }
  }
  /* Set new unit */
  tac->cunit=u;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by tacReadModelingData(), tacReadModelingInput(), tacReadReference(), and tacSetWeights().

tacYUnitMass2Volume()

int tacYUnitMass2Volume ( TAC * tac, const double density, TPCSTATUS * status )

extern

Convert Y values (per mass concentrations) in TAC struct to the corresponding per volume concentrations.

See also

tacYUnitVolume2Mass, tacXUnitConvert, tacYUnitConvert, unitConversionFactor

Returns

Returns TPCERROR_OK (0) when successful.

Parameters

tac	Pointer to TAC struct.
density	Density (g/mL).
status	Pointer to status data; enter NULL if not needed.

Definition at line 169 of file tacunits.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) {printf("%s(%g)\n", __func__, density); fflush(stdout);}
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1 || !(density>0.0)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Check that unit contains mass in divider */
  if(!unitDividerHasMass(tac->cunit)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
    return TPCERROR_INCOMPATIBLE_UNIT;
  }
 
  /* Try to convert the unit */
  int uu=unitDividerMassVolumeConversion(tac->cunit);
  if(uu==UNIT_UNKNOWN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
    return TPCERROR_INCOMPATIBLE_UNIT;
  }
 
  /* Multiply y values with the density */
  for(int j=0; j<tac->tacNr; j++) {
    for(int i=0; i<tac->sampleNr; i++) {
      tac->c[j].y[i]*=density;
    }
  }
  /* Set new unit */
  tac->cunit=uu;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

tacYUnitVolume2Mass()

int tacYUnitVolume2Mass ( TAC * tac, const double density, TPCSTATUS * status )

extern

Convert Y values (per volume concentrations) in TAC struct to the corresponding per mass concentrations.

See also

tacYUnitMass2Volume, tacXUnitConvert, tacYUnitConvert, unitConversionFactor

Returns

Returns TPCERROR_OK (0) when successful.

Parameters

tac	Pointer to TAC struct.
density	Density (g/mL).
status	Pointer to status data; enter NULL if not needed.

Definition at line 121 of file tacunits.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) {printf("%s(%g)\n", __func__, density); fflush(stdout);}
  if(tac==NULL || tac->sampleNr<1 || tac->tacNr<1 || !(density>0.0)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Check that unit contains volume in divider */
  if(!unitDividerHasVolume(tac->cunit)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
    return TPCERROR_INCOMPATIBLE_UNIT;
  }
 
  /* Try to convert the unit */
  int uu=unitDividerMassVolumeConversion(tac->cunit);
  if(uu==UNIT_UNKNOWN) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INCOMPATIBLE_UNIT);
    return TPCERROR_INCOMPATIBLE_UNIT;
  }
 
  /* Divide y values with the density */
  for(int j=0; j<tac->tacNr; j++) {
    for(int i=0; i<tac->sampleNr; i++) {
      tac->c[j].y[i]/=density;
    }
  }
  /* Set new unit */
  tac->cunit=uu;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}