tpcpar.h File Reference

Header file for libtpcpar. More...

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

Go to the source code of this file.

Data Structures
struct	PARR
struct	PARN
struct	PAR

Enumerations
enum	parformat {   PAR_FORMAT_UNKNOWN , PAR_FORMAT_RES , PAR_FORMAT_FIT , PAR_FORMAT_IFT ,   PAR_FORMAT_CSV_INT , PAR_FORMAT_CSV_UK , PAR_FORMAT_TSV_INT , PAR_FORMAT_TSV_UK ,   PAR_FORMAT_XML , PAR_FORMAT_HTML , PAR_FORMAT_LAST }

Functions
void	parInit (PAR *par)
void	parrInit (PARR *parr)
void	parnInit (PARN *parn)
void	parFree (PAR *par)
void	parrFree (PARR *parr)
int	parAllocate (PAR *par, int parNr, int tacNr)
int	parAllocateMore (PAR *par, int parNr, int tacNr)
int	parrAllocate (PARR *parr, int parNr)
char *	parIsStudyNr (PAR *par)
int	parSetStudyNr (PAR *par, const char *s)
void	parEnsureNames (PAR *d)
int	parIsWSS (PAR *par)
int	parIsFitRange (PAR *par)
int	parIsModel (PAR *par)
int	parSDWithPar (PAR *par, int pi)
int	parCLWithPar (PAR *par, int pi)
int	parIsFitNr (PAR *par)
int	parIsDataNr (PAR *par)
int	parDeletePar (PAR *par, int pi)
int	parDeleteTAC (PAR *par, int ti)
char *	parIsOptcrit (PAR *par)
char *	parFormattxt (parformat c)
int	parFormatIdentify (const char *s)
int	parFormatFromExtension (const char *s)
char *	parDefaultExtension (parformat c)
int	parWrite (PAR *par, FILE *fp, parformat format, int extra, TPCSTATUS *status)
int	parRead (PAR *par, const char *fname, TPCSTATUS *status)
void	parListLimits (PAR *par, FILE *fp)
int	parWriteLimits (PAR *par, const char *fname, const int verbose)
int	parReadLimits (PAR *par, const char *fname, const int verbose)
int	parWriteCSV (PAR *par, FILE *fp, parformat format, int extra, TPCSTATUS *status)
int	parReadCSV (PAR *par, CSV *csv, IFT *hdr, TPCSTATUS *status)
int	parToIFT (PAR *par, IFT *ift, TPCSTATUS *status)
int	parWriteIFT (PAR *par, FILE *fp, TPCSTATUS *status)
int	parFromIFT (PAR *par, IFT *ift, TPCSTATUS *status)
int	parWriteRES (PAR *par, FILE *fp, TPCSTATUS *status)
int	parReadRES (PAR *par, CSV *csv, IFT *ift, TPCSTATUS *status)
int	parPrintType (PAR *par, int parIndex)
int	parWriteFIT (PAR *par, FILE *fp, TPCSTATUS *status)
int	parReadFIT (PAR *par, CSV *csv, IFT *ift, TPCSTATUS *status)
int	parWriteXML (PAR *par, FILE *fp, TPCSTATUS *status)
int	parSelectByAnother (PAR *d1, PAR *d2, int *pn, int *pr, TPCSTATUS *status)
int	parCombineTACs (PAR *d1, PAR *d2, TPCSTATUS *status)
int	parCompareParameterNames (PAR *d1, PAR *d2, const int i, const int casens, TPCSTATUS *status)
int	parCompareParameterUnits (PAR *d1, PAR *d2, const int i, TPCSTATUS *status)
int	parCompareTacNames (PAR *d1, PAR *d2, const int i, const int casens, TPCSTATUS *status)
int	parCompareParameters (PAR *d1, PAR *d2, const int pi, const int ti, int checkpar, int checksd, int checkcl, const double test_abs, const double test_rel, TPCSTATUS *status)
int	parCompareWSS (PAR *d1, PAR *d2, const int ti, const double test_abs, const double test_rel, TPCSTATUS *status)
int	parSortByName (PAR *d, TPCSTATUS *status)
int	parSelectTACs (PAR *d, const char *region_name, int reset, TPCSTATUS *status)
int	parSelectedTACs (PAR *d)
int	parSelectParameters (PAR *d, const char *par_name, int reset, TPCSTATUS *status)
int	parSelectedParameters (PAR *d)
int	parFindParameter (PAR *d, const char *par_name)
double	parGetParameter (PAR *d, const char *par_name, const int ti)
int	parGetParameterUnit (PAR *d, const char *par_name)
void	parValueRange (PAR *d, const int i, double *pmin, double *pmax)
int	parExampleTTACs (PAR *d, int type, TPCSTATUS *status)
int	parExamplePerfectBolus (PAR *d, TPCSTATUS *status)
int	parExampleRadiowaterBolus (PAR *d, TPCSTATUS *status)

Detailed Description

Header file for libtpcpar.

Header file for model parameter library.

Author

Vesa Oikonen

Copyright

(c) Turku PET Centre

Definition in file tpcpar.h.

Enumeration Type Documentation

parformat

enum parformat

PAR file format codes;

See also

par_format

Enumerator
PAR_FORMAT_UNKNOWN	Unknown format.
PAR_FORMAT_RES	Model result format of Turku PET Centre.
PAR_FORMAT_FIT	Function fit format of Turku PET Centre.
PAR_FORMAT_IFT	Interfile-type data (supported for writing).
PAR_FORMAT_CSV_INT	International CSV.
PAR_FORMAT_CSV_UK	UK CSV.
PAR_FORMAT_TSV_INT	International TSV (comma as decimal separator).
PAR_FORMAT_TSV_UK	UK TSV (point as decimal separator).
PAR_FORMAT_XML	XML format (currently not supported).
PAR_FORMAT_HTML	HTML table format (currently not supported).
PAR_FORMAT_LAST	End of list.

Definition at line 27 of file tpcpar.h.

             {
  PAR_FORMAT_UNKNOWN,    
  PAR_FORMAT_RES,        
  PAR_FORMAT_FIT,        
  PAR_FORMAT_IFT,        
  PAR_FORMAT_CSV_INT,    
  PAR_FORMAT_CSV_UK,     
  PAR_FORMAT_TSV_INT,    
  PAR_FORMAT_TSV_UK,     
  PAR_FORMAT_XML,        
  PAR_FORMAT_HTML,       
  PAR_FORMAT_LAST        
} parformat;

Function Documentation

parAllocate()

int parAllocate ( PAR * par, int parNr, int tacNr )

extern

Allocate memory for PAR data.

Any previous contents are deleted.

Returns

Returns TPCERROR status.

See also

parInit, parFree, parAllocateMore, parAllocateWithTAC

Parameters

par	Pointer to initiated PAR struct data; any old contents are deleted. tacNr and parNr inside the struct are set to or kept at zero.
parNr	Nr of parameters to allocate
tacNr	Nr of parameter sets (TACs) to allocate

Definition at line 108 of file par.c.

  {
  if(par==NULL) return TPCERROR_FAIL;
  /* Delete any previous contents */
  parFree(par);
  /* If no memory is requested, then just return */
  if(parNr<1 && tacNr<1) return TPCERROR_OK;
  if(parNr<1 || tacNr<1) return TPCERROR_FAIL;
 
  /* Allocate memory for PARR data */
  int ret;
  par->r=(PARR*)malloc(tacNr*sizeof(PARR));
  if(par->r==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<tacNr; i++) {
    parrInit(&par->r[i]);
    ret=parrAllocate(par->r+i, parNr); if(ret!=TPCERROR_OK) return ret;
  }
  par->_tacNr=tacNr;
 
  /* Allocate memory for parameter names and units */
  par->n=(PARN*)malloc(parNr*sizeof(PARN));
  if(par->n==NULL) return TPCERROR_OUT_OF_MEMORY;
  for(int i=0; i<parNr; i++) parnInit(&par->n[i]);
  par->_parNr=parNr;
 
  return TPCERROR_OK;
}

Referenced by parAllocateWithTAC(), parExamplePerfectBolus(), parExampleRadiowaterBolus(), parExampleTTACs(), parFromIFT(), parReadCSV(), parReadFIT(), and parReadRES().

parAllocateMore()

int parAllocateMore ( PAR * par, int parNr, int tacNr )

extern

Allocate more memory for PAR data. Previous contents are preserved.

Returns

Returns TPCERROR status.

See also

parAllocate, parInit, parRead, parFree

Parameters

par	Pointer to initiated and previously allocated PAR struct data; any old contents are preserved, including tacNr and parNr.
parNr	Nr of additional parameters to allocate; if struct contains unused space for requested parameters already, then nothing is done.
tacNr	Nr of additional parameter sets (TACs) to allocate; if struct contains unused space for requested parameters already, then nothing is done.

Definition at line 183 of file par.c.

  {
  if(par==NULL) return TPCERROR_FAIL;
  if(par->_parNr<1 || par->_tacNr<1) return TPCERROR_FAIL;
  if(parNr<0 || tacNr<0) return TPCERROR_FAIL;
  /* Check if there is enough space already */
  int newTacNr, addTacNr, newParNr, addParNr;
  newTacNr=par->tacNr+tacNr; addTacNr=newTacNr-par->_tacNr;
  newParNr=par->parNr+parNr; addParNr=newParNr-par->_parNr;
  if(addTacNr<=0 && addParNr<=0) return TPCERROR_OK;
 
  /* Reallocate memory for parameter names and units, if necessary */
  if(addParNr>0) {
    PARN *parnPtr;
    parnPtr=realloc(par->n, sizeof(PARN)*newParNr);
    if(parnPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
    par->n=parnPtr;
    parnPtr+=par->_parNr; for(int i=0; i<addParNr; i++) parnInit(parnPtr++);
  }
 
  /* Reallocate memory for parameters of previous TACs, if necessary */
  if(addParNr>0) {
    int i, j;
    for(i=0; i<par->tacNr; i++) {
      par->r[i].p=realloc(par->r[i].p, sizeof(double)*newParNr);
      par->r[i].sd=realloc(par->r[i].sd, sizeof(double)*newParNr);
      par->r[i].cl1=realloc(par->r[i].cl1, sizeof(double)*newParNr);
      par->r[i].cl2=realloc(par->r[i].cl2, sizeof(double)*newParNr);
      if(par->r[i].p==NULL || par->r[i].sd==NULL || par->r[i].cl1==NULL || par->r[i].cl2==NULL) 
        return TPCERROR_OUT_OF_MEMORY;
      for(j=par->parNr; j<newParNr; j++)
        par->r[i].p[j]=par->r[i].sd[j]=par->r[i].cl1[j]=par->r[i].cl2[j]=nan("");
    }
  }
 
  /* Allocate memory for more TACs, if necessary */
  if(addTacNr>0) {
    PARR *parrPtr;
    parrPtr=realloc(par->r, sizeof(PARR)*newTacNr);
    if(parrPtr==NULL) return TPCERROR_OUT_OF_MEMORY;
    par->r=parrPtr;
    parrPtr+=par->_tacNr; 
    for(int i=0; i<addTacNr; i++, parrPtr++) {
      parrInit(parrPtr);
      if(parrAllocate(parrPtr, newParNr)!=TPCERROR_OK)
        return TPCERROR_OUT_OF_MEMORY;
    }
  }
  
  par->_parNr=newParNr;
  par->_tacNr=newTacNr;
  return TPCERROR_OK;
}

Referenced by parCombineTACs().

parCLWithPar()

int parCLWithPar ( PAR * par, int pi )

extern

Check if specified parameter has confidence limits in at least one of the regions.

See also

parSDWithPar, parIsWSS

Returns

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

Parameters

par	Pointer to parameter data.
pi	Index of parameter [0..parNr-1] to check.

Definition at line 325 of file par.c.

  {
  if(par==NULL || par->tacNr<1 || pi<0 || pi>=par->parNr) return(0);
  for(int i=0; i<par->tacNr; i++)
    if(!isnan(par->r[i].cl1[pi]) && !isnan(par->r[i].cl2[pi])) return(1);
  return(0);
}

Referenced by parWriteCSV(), and parWriteXML().

parCombineTACs()

int parCombineTACs	(	PAR *	d1,
		PAR *	d2,
		TPCSTATUS *	status )

Copy parameters from source PAR structure to target structure for TACs that are available in both structures.

Returns

enum tpcerror (TPCERROR_OK when successful).

See also

parSelectByAnother, parSelectTACs, parEnsureNames

Parameters

d1	Pointer to target PAR structure.
d2	Pointer to source PAR structure; not modified.
status	Pointer to status data; enter NULL if not needed.

Definition at line 99 of file parcomb.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
 
  /* Check what there is to copy */
  int tacNr;
  int ret=parSelectByAnother(d1, d2, NULL, &tacNr, status);
  if(ret!=TPCERROR_OK) return(ret);
  if(tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  int parNr=d2->parNr;
  if(verbose>1) printf("%d TACs and %d parameters to copy.\n", tacNr, parNr);
 
  /* Allocate memory for the new parameters */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  ret=parAllocateMore(d1, parNr, 0);
  if(ret!=TPCERROR_OK) return(ret);
 
  /* Copy new parameter names */
  for(int i=0; i<d2->parNr; i++) {
    strcpy(d1->n[i+d1->parNr].name, d2->n[i].name);
    d1->n[i+d1->parNr].unit=d2->n[i].unit;
    d1->n[i+d1->parNr].lim1=d2->n[i].lim1;
    d1->n[i+d1->parNr].lim2=d2->n[i].lim2;
    d1->n[i+d1->parNr].tol=d2->n[i].tol;
  }
 
  /* Copy contents for common TACs */
  for(int i=0; i<d1->tacNr; i++) {
    /* find matching TAC name */
    if(strnlen(d1->r[i].name, 1)<1) continue;
    int j;
    for(j=0; j<d2->tacNr; j++) {
      if(strnlen(d2->r[j].name, 1)<1) continue;
      if(strcasecmp(d1->r[i].name, d2->r[j].name)==0) break;
      /* Allow mixed '-' and '_' */
      char *buf1, *buf2;
      buf1=strdup(d1->r[i].name); strReplaceChar(buf1, '-', '_');
      buf2=strdup(d2->r[j].name); strReplaceChar(buf2, '-', '_');
      int ret=strcasecmp(buf1, buf2);
      free(buf1); free(buf2);
      if(ret==0) break;
    }
    if(j==d2->tacNr) continue; // matching name not found, leave values as NaN
 
    /* Copy new parameter values */
    for(int k=0; k<d2->parNr; k++) {
      d1->r[i].p[k+d1->parNr]=d2->r[j].p[k];
      d1->r[i].sd[k+d1->parNr]=d2->r[j].sd[k];
      d1->r[i].cl1[k+d1->parNr]=d2->r[j].cl1[k];
      d1->r[i].cl2[k+d1->parNr]=d2->r[j].cl2[k];
    }
  }
 
  d1->parNr+=d2->parNr;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

parCompareParameterNames()

int parCompareParameterNames ( PAR * d1, PAR * d2, const int i, const int casens, TPCSTATUS * status )

extern

Check whether parameter names are the same in two PAR data.

Comparison is very strict, thus the 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

Parameters

d1	Pointer to PAR struct.
d2	Pointer to PAR struct.
i	Parameter index [0..parNr-1] to compare; enter <0 to verify all.
casens	Case-sensitivity: 0=case does not have to match; <>0=case must match.
status	Pointer to status data; enter NULL if not needed.

Definition at line 28 of file parcomp.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->parNr<1 || d2->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
  /* If index is specified, then verify that that parameter is available */
  if(i>=0 && (i>=d1->parNr || i>=d2->parNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 1;
  }
 
  /* If index is not specified, then parNr must match */
  if(i<0 && (d1->parNr!=d2->parNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different parameter nr.\n");
    return(1);
  }
 
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  int vr;
  for(int pi=0; pi<d1->parNr; pi++) if(i<0 || i==pi) {
    if(casens==0) vr=strcasecmp(d1->n[pi].name, d2->n[pi].name);
    else vr=strcmp(d1->n[pi].name, d2->n[pi].name);
    if(vr==0) continue;
    /* No problem, if difference is '_' versus '-' */
    if(strchr(d1->n[pi].name, '-') || strchr(d1->n[pi].name, '_')) {
      char *buf1, *buf2;
      buf1=strdup(d1->n[pi].name); strReplaceChar(buf1, '-', '_');
      buf2=strdup(d2->n[pi].name); strReplaceChar(buf2, '-', '_');
      if(verbose>100) printf("'%s' vs '%s'\n", buf1, buf2);
      if(casens==0) vr=strcasecmp(buf1, buf2); else vr=strcmp(buf1, buf2);
      free(buf1); free(buf2);
    }
    if(vr==0) continue;
    /* No problem, if difference is '_' versus ' ' */
    if(strchr(d1->n[pi].name, '_') || strchr(d2->n[pi].name, '_')) {
      char *buf1, *buf2;
      buf1=strdup(d1->n[pi].name); strReplaceChar(buf1, '_', ' ');
      buf2=strdup(d2->n[pi].name); strReplaceChar(buf2, '_', ' ');
      if(verbose>100) printf("'%s' vs '%s'\n", buf1, buf2);
      if(casens==0) vr=strcasecmp(buf1, buf2); else vr=strcmp(buf1, buf2);
      free(buf1); free(buf2);
    }
    if(vr==0) continue;
    if(verbose>0) {
      printf("par1.n[%d].name := '%s'\n", pi, d1->n[pi].name);
      printf("par2.n[%d].name := '%s'\n", pi, d2->n[pi].name);
    }
    return(1);
  }
  return(0);
}

parCompareParameters()

int parCompareParameters ( PAR * d1, PAR * d2, const int pi, const int ti, int checkpar, int checksd, int checkcl, const double test_abs, const double test_rel, TPCSTATUS * status )

extern

Check whether parameter values are the same in two PAR 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

parCompareParameterUnits.

Returns

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

Author

Vesa Oikonen

Parameters

d1	Pointer to PAR structure.
d2	Pointer to PAR structure.
pi	PAR index [0..parNr-1] to compare; enter <0 to verify all parameters.
ti	TAC index [0..tacNr-1] to compare; enter <0 to verify all TACs.
checkpar	Check parameter values (1) or do not check (0).
checksd	Check parameter SD values (1) or do not check (0).
checkcl	Check parameter CL values (1) or do not check (0).
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 237 of file parcomp.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->parNr<1 || d2->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
  /* Check that at least something is tested */
  if(!checkpar && !checksd && !checkcl) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 1;
  }
  /* If index is specified, then verify that TAC or PAR is available */
  if(pi>=0 && (pi>=d1->parNr || pi>=d2->parNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 2;
  }
  if(ti>=0 && (ti>=d1->tacNr || ti>=d2->tacNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 2;
  }
 
  /* If index is not specified, then parNr or tacNr must match */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(pi<0 && (d1->parNr!=d2->parNr)) {
    if(verbose>0) printf("different parameter nr.\n");
    return(3);
  }
  if(ti<0 && (d1->tacNr!=d2->tacNr)) {
    if(verbose>0) printf("different TAC nr.\n");
    return(3);
  }
 
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  int pj, tj;
  if(checkpar) {
    for(tj=0; tj<d1->tacNr; tj++) if(ti<0 || tj==ti) {
      for(pj=0; pj<d1->parNr; pj++) if(pi<0 || pj==pi) {
        if(doubleMatch(d1->r[tj].p[pj], d2->r[tj].p[pj], test_abs)==1) continue;
        if(test_rel>0.0 && doubleMatchRel(d1->r[tj].p[pj], d2->r[tj].p[pj], test_rel)==1) continue;
        if(verbose>0) {
          double s=fabs(d1->r[tj].p[pj]-d2->r[tj].p[pj]);
          printf("par1.r[%d].p[%d] := %g\n", tj, pj, d1->r[tj].p[pj]);
          printf("par2.r[%d].p[%d] := %g\n", tj, pj, d2->r[tj].p[pj]);
          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);
      }
    }
  }
  if(checksd) {
    for(tj=0; tj<d1->tacNr; tj++) if(ti<0 || tj==ti) {
      for(pj=0; pj<d1->parNr; pj++) if(pi<0 || pj==pi) {
        if(doubleMatch(d1->r[tj].sd[pj], d2->r[tj].sd[pj], test_abs)==1) continue;
        if(test_rel>0.0 && doubleMatchRel(d1->r[tj].sd[pj], d2->r[tj].sd[pj], test_rel)==1) continue;
        if(verbose>0) {
          double s=fabs(d1->r[tj].sd[pj]-d2->r[tj].sd[pj]);
          printf("par1.r[%d].sd[%d] := %g\n", tj, pj, d1->r[tj].sd[pj]);
          printf("par2.r[%d].sd[%d] := %g\n", tj, pj, d2->r[tj].sd[pj]);
          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);
      }
    }
  }
  if(checkcl) {
    for(tj=0; tj<d1->tacNr; tj++) if(ti<0 || tj==ti) {
      for(pj=0; pj<d1->parNr; pj++) if(pi<0 || pj==pi) {
        if(doubleMatch(d1->r[tj].cl1[pj], d2->r[tj].cl1[pj], test_abs)==1) continue;
        if(test_rel>0.0 && doubleMatchRel(d1->r[tj].cl1[pj], d2->r[tj].cl1[pj], test_rel)==1) continue;
        if(verbose>0) {
          double s=fabs(d1->r[tj].cl1[pj]-d2->r[tj].cl1[pj]);
          printf("par1.r[%d].cl1[%d] := %g\n", tj, pj, d1->r[tj].cl1[pj]);
          printf("par2.r[%d].cl1[%d] := %g\n", tj, pj, d2->r[tj].cl1[pj]);
          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);
      }
    }
    for(tj=0; tj<d1->tacNr; tj++) if(ti<0 || tj==ti) {
      for(pj=0; pj<d1->parNr; pj++) if(pi<0 || pj==pi) {
        if(doubleMatch(d1->r[tj].cl2[pj], d2->r[tj].cl2[pj], test_abs)==1) continue;
        if(test_rel>0.0 && doubleMatchRel(d1->r[tj].cl2[pj], d2->r[tj].cl2[pj], test_rel)==1) continue;
        if(verbose>0) {
          double s=fabs(d1->r[tj].cl2[pj]-d2->r[tj].cl2[pj]);
          printf("par1.r[%d].cl2[%d] := %g\n", tj, pj, d1->r[tj].cl2[pj]);
          printf("par2.r[%d].cl2[%d] := %g\n", tj, pj, d2->r[tj].cl2[pj]);
          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);
}

parCompareParameterUnits()

int parCompareParameterUnits ( PAR * d1, PAR * d2, const int i, TPCSTATUS * status )

extern

Check whether parameter units are the same in two PAR data.

Returns

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

Author

Vesa Oikonen

Parameters

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

Definition at line 103 of file parcomp.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->parNr<1 || d2->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return 1;
  }
  /* If index is specified, then verify that parameter is available */
  if(i>=0 && (i>=d1->parNr || i>=d2->parNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 1;
  }
 
  /* If index is not specified, then parNr must match */
  if(i<0 && (d1->parNr!=d2->parNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    if(verbose>0) printf("different parameter nr.\n");
    return(1);
  }
 
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  for(int pi=0; pi<d1->parNr; pi++) if(i<0 || i==pi) {
    if(d1->n[pi].unit!=d2->n[pi].unit) {
      if(verbose>0) {
        printf("par1.n[%d].unit := '%s'\n", pi, unitName(d1->n[pi].unit));
        printf("par2.n[%d].unit := '%s'\n", pi, unitName(d2->n[pi].unit));
      }
      return(1);
    }
  }
  return(0);
}

parCompareTacNames()

int parCompareTacNames ( PAR * d1, PAR * d2, const int i, const int casens, TPCSTATUS * status )

extern

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

Comparison is very strict, thus the 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

Parameters

d1	Pointer to PAR structure.
d2	Pointer to PAR structure.
i	Parameter index [0..tacNr-1] to compare; enter <0 to verify all.
casens	Case-sensitivity: 0=case does not have to match; <>0=case must match.
status	Pointer to status data; enter NULL if not needed.

Definition at line 157 of file parcomp.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 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);
  int vr;
  for(int ri=0; ri<d1->tacNr; ri++) if(i<0 || i==ri) {
    if(casens==0) vr=strcasecmp(d1->r[ri].name, d2->r[ri].name);
    else vr=strcmp(d1->r[ri].name, d2->r[ri].name);
    if(vr==0) continue;
    /* No problem, if difference is '_' versus '-' */
    if(strchr(d1->r[ri].name, '-') || strchr(d1->r[ri].name, '_')) {
      char *buf1, *buf2;
      buf1=strdup(d1->r[ri].name); strReplaceChar(buf1, '-', '_');
      buf2=strdup(d2->r[ri].name); strReplaceChar(buf2, '-', '_');
      if(verbose>100) printf("'%s' vs '%s'\n", buf1, buf2);
      if(casens==0) vr=strcasecmp(buf1, buf2); else vr=strcmp(buf1, buf2);
      free(buf1); free(buf2);
    }
    if(vr==0) continue;
    /* No problem, if difference is '_' versus ' ' */
    if(strchr(d1->r[ri].name, '_') || strchr(d2->r[ri].name, '_')) {
      char *buf1, *buf2;
      buf1=strdup(d1->r[ri].name); strReplaceChar(buf1, '_', ' ');
      buf2=strdup(d2->r[ri].name); strReplaceChar(buf2, '_', ' ');
      if(verbose>100) printf("'%s' vs '%s'\n", buf1, buf2);
      if(casens==0) vr=strcasecmp(buf1, buf2); else vr=strcmp(buf1, buf2);
      free(buf1); free(buf2);
    }
    if(vr==0) continue;
    if(verbose>0) {
      printf("par1.r[%d].name := '%s'\n", ri, d1->r[ri].name);
      printf("par2.r[%d].name := '%s'\n", ri, d2->r[ri].name);
    }
    return(1);
  }
  return(0);
}

parCompareWSS()

int parCompareWSS ( PAR * d1, PAR * d2, const int ti, const double test_abs, const double test_rel, TPCSTATUS * status )

extern

Check whether fit WSS values are the same in two PAR 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

parCompareParameters.

Returns

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

Author

Vesa Oikonen

Parameters

d1	Pointer to PAR structure.
d2	Pointer to PAR structure.
ti	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 378 of file parcomp.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 TAC is available */
  if(ti>=0 && (ti>=d1->tacNr || ti>=d2->tacNr)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return 2;
  }
 
  /* If index is not specified, then tacNr must match */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(ti<0 && (d1->tacNr!=d2->tacNr)) {
    if(verbose>0) printf("different TAC nr.\n");
    return(3);
  }
 
  /* Compare */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  int tj;
  for(tj=0; tj<d1->tacNr; tj++) if(ti<0 || tj==ti) {
    if(doubleMatch(d1->r[tj].wss, d2->r[tj].wss, test_abs)==1) 
      continue;
    if(test_rel>0.0 && doubleMatchRel(d1->r[tj].wss, d2->r[tj].wss, test_rel)==1) 
      continue;
    if(verbose>0) {
      double s=fabs(d1->r[tj].wss-d2->r[tj].wss);
      printf("par1.r[%d].wss := %g\n", tj, d1->r[tj].wss);
      printf("par2.r[%d].wss := %g\n", tj, d2->r[tj].wss);
      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);
}

parDefaultExtension()

char * parDefaultExtension ( parformat c )

extern

Return pointer to default PAR file name extension, including the dot, based on the PAR format code.

Returns

pointer to the file name extension string.

See also

parformat, parFormatFromExtension, parFormattxt, parWrite

Author

Vesa Oikonen

Parameters

c	PAR format code

Definition at line 133 of file pario.c.

  {
  if(c<PAR_FORMAT_UNKNOWN || c>=PAR_FORMAT_LAST) return NULL;
  return (char*)par_fn_ext[c];
}

parDeletePar()

int parDeletePar ( PAR * par, int pi )

extern

Deletes the specified parameter (column) from data.

Returns

Returns TPCERROR status.

See also

parDeleteTAC

Parameters

par	Pointer to parameter data.
pi	Index of parameter [0..parNr-1] to remove.

Definition at line 478 of file par.c.

  {
  if(par==NULL || par->tacNr<1 || pi<0 || pi>=par->parNr) return(TPCERROR_FAIL);
  if(pi==par->parNr-1) {par->parNr--; return(TPCERROR_OK);}
 
  int i, j;
 
  /* Parameter name and unit */
  PARN parn;
  memcpy(&parn, &par->n[pi], sizeof(PARN));
  for(i=pi+1; i<par->parNr; i++)
    memcpy(&par->n[i-1], &par->n[i], sizeof(PARN));
  memcpy(&par->n[par->parNr-1], &parn, sizeof(PARN));
 
  /* Parameter values */
  double p, sd, cl1, cl2;
  for(j=0; j<par->tacNr; j++) {
    p=par->r[j].p[pi]; sd=par->r[j].sd[pi];
    cl1=par->r[j].cl1[pi]; cl2=par->r[j].cl2[pi];
    for(i=pi+1; i<par->parNr; i++) {
      par->r[j].p[i-1]=par->r[j].p[i]; par->r[j].sd[i-1]=par->r[j].sd[i];
      par->r[j].cl1[i-1]=par->r[j].cl1[i]; par->r[j].cl2[i-1]=par->r[j].cl2[i];
    }
    par->r[j].p[par->parNr-1]=p; par->r[j].sd[par->parNr-1]=sd;
    par->r[j].cl1[par->parNr-1]=cl1; par->r[j].cl2[par->parNr-1]=cl2;
  }
 
  par->parNr--;
  return(TPCERROR_OK);
}

Referenced by parReadCSV(), and parReadRES().

parDeleteTAC()

int parDeleteTAC ( PAR * par, int ti )

extern

Deletes the specified TAC (row) from data.

Returns

Returns TPCERROR status.

See also

parDeletePar, parSortByName

Parameters

par	Pointer to parameter data.
ti	Index of TAC [0..tacNr-1] to remove.

Definition at line 519 of file par.c.

  {
  if(par==NULL || par->tacNr<1 || ti<0 || ti>=par->tacNr) return(TPCERROR_FAIL);
  /* Free the memory allocated for the TAC */
  parrFree(par->r+ti);
  /* If the last TAC is to be deleted, then just reduce the tacNr */
  if(ti==par->tacNr-1) {par->tacNr--; return(TPCERROR_OK);}
  /* Otherwise move the following TACs in its place */
  for(int i=ti+1; i<par->tacNr; i++) par->r[i-1]=par->r[i];
  par->tacNr--; parrInit(par->r+par->tacNr);
  return(TPCERROR_OK);
}

parEnsureNames()

void parEnsureNames ( PAR * d )

extern

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

See also

parSetStudyNr, parSortByName

Parameters

d	Pointer to parameter data.

Definition at line 449 of file par.c.

  {
  if(d==NULL || d->tacNr<1 || d->parNr<1) return;
  /* Ensure TAC names */
  int u, n;
  u=d->tacNr; n=1; while((u/=10)>=1) n++;
  if(n>MAX_TACNAME_LEN) n=MAX_TACNAME_LEN;
  for(int i=0; i<d->tacNr; i++) {
    if(strlen(d->r[i].name)<1 || strcmp(d->r[i].name, ".")==0)
      sprintf(d->r[i].name, "%0*d", n, 1+i);
  }
  /* Ensure parameter names */
  u=d->parNr; n=1; while((u/=10)>=1) n++;
  if(n>MAX_PARNAME_LEN-1) n=MAX_PARNAME_LEN-1;
  for(int i=0; i<d->parNr; i++) {
    if(strlen(d->n[i].name)<1 || strcmp(d->n[i].name, ".")==0)
      sprintf(d->n[i].name, "P%0*d", n, 1+i);
  }
  return;
}

parExamplePerfectBolus()

int parExamplePerfectBolus ( PAR * d, TPCSTATUS * status )

extern

Create PAR data containing function parameters for perfect bolus TAC, starting from zero and approaching zero after the peak.

Note

For use in algorithm and software tests.

Creates Gamma variate function (gammav) function with zero delay and with p[1]=1. Maximum is at 1.2 s and max value is 100 kBq/mL. Integral from 0 to infinity is 326.19382 (p[0]*p[2]^2).

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parInit, parExampleTTACs, simBTAC

Parameters

d	Pointer to initiated PAR struct, which will be allocated and filled here; any previous content will be deleted.
status	Pointer to status data; enter NULL if not needed

Definition at line 120 of file parexample.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(par)\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);
 
  int ret, pi, parNr;
  
  /* Allocate memory */
  parNr=modelParNr(modelCodeIndex("gammav"));
  ret=parAllocate(d, parNr, 1); if(ret!=TPCERROR_OK) return(ret);
  d->tacNr=1; d->parNr=4;
  d->format=PAR_FORMAT_CSV_INT;
  /* Set header fields */
  iftPut(&d->h, "studynr", "ptac1401", 1, NULL);
  iftPut(&d->h, "analysis_time", "2016-07-05 15:40:03", 1, NULL);
  iftPut(&d->h, "program", "libtpcpar (c) 2016", 1, NULL);
  iftPut(&d->h, "datafile","ptac1401.tac",1,NULL);
  iftPut(&d->h, "weighting", "no", 1, NULL);
  iftPut(&d->h, "unit", unitName(UNIT_KBQ_PER_ML), 1, NULL);
  iftPut(&d->h, "timeunit", unitName(UNIT_SEC), 1, NULL);
  /* Set parameter names */
  pi=0; strcpy(d->n[pi].name, "A"); d->n[pi].unit=UNIT_KBQ_PER_ML;
  pi++; strcpy(d->n[pi].name, "B"); d->n[pi].unit=UNIT_UNITLESS;
  pi++; strcpy(d->n[pi].name, "C"); d->n[pi].unit=UNIT_PER_SEC;
  pi++; strcpy(d->n[pi].name, "tDelay"); d->n[pi].unit=UNIT_SEC;
  /* Set region names */
  sprintf(d->r[0].name, "bolus");
  /* Set regional fit options */
  d->r[0].model=modelCodeIndex("gammav");
  d->r[0].fitNr=parNr;
  d->r[0].dataNr=100;
  d->r[0].start=0.0;
  d->r[0].end=60.0;
  d->r[0].wss=0.0E+000;
  /* Set parameter values and region names */
  pi=0; d->r[0].p[pi]=226.523;
  pi++; d->r[0].p[pi]=1.0;
  pi++; d->r[0].p[pi]=1.2;
  pi++; d->r[0].p[pi]=0.0;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

parExampleRadiowaterBolus()

int parExampleRadiowaterBolus ( PAR * d, TPCSTATUS * status )

extern

Create PAR data containing function parameters for bolus injection radiowater BTAC.

Note

For use in algorithm and software tests.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parInit, parExampleTTACs, simBTAC, parExamplePerfectBolus

Parameters

d	Pointer to initiated PAR structure, which will be allocated and filled here; any previous content will be deleted.
status	Pointer to status data; enter NULL if not needed

Definition at line 184 of file parexample.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(par)\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);
 
  int ret, pi, parNr;
  
  /* Allocate memory */
  parNr=modelParNr(modelCodeIndex("fengm2"));
  ret=parAllocate(d, parNr, 1); if(ret!=TPCERROR_OK) return(ret);
  d->tacNr=1; d->parNr=7;
  d->format=PAR_FORMAT_CSV_INT;
  /* Set header fields */
  iftPut(&d->h, "studynr", "btac1313", 1, NULL);
  iftPut(&d->h, "analysis_time", "2025-11-14 11:46:02", 1, NULL);
  iftPut(&d->h, "program", "libtpcpar (c) 2025", 1, NULL);
  iftPut(&d->h, "datafile","meanaorta.tac",1,NULL);
  iftPut(&d->h, "weighting", "no", 1, NULL);
  iftPut(&d->h, "unit", unitName(UNIT_KBQ_PER_ML), 1, NULL);
  iftPut(&d->h, "timeunit", unitName(UNIT_SEC), 1, NULL);
  /* Set parameter names */
  pi=0; strcpy(d->n[pi].name, "A1"); d->n[pi].unit=UNIT_UNITLESS;
  pi++; strcpy(d->n[pi].name, "L1"); d->n[pi].unit=UNIT_UNITLESS;
  pi++; strcpy(d->n[pi].name, "A2"); d->n[pi].unit=UNIT_UNITLESS;
  pi=0; strcpy(d->n[pi].name, "L2"); d->n[pi].unit=UNIT_UNITLESS;
  pi++; strcpy(d->n[pi].name, "A3"); d->n[pi].unit=UNIT_UNITLESS;
  pi++; strcpy(d->n[pi].name, "L3"); d->n[pi].unit=UNIT_UNITLESS;
  pi++; strcpy(d->n[pi].name, "tDelay"); d->n[pi].unit=UNIT_SEC;
  /* Set region names */
  sprintf(d->r[0].name, "bolus");
  /* Set regional fit options */
  d->r[0].model=modelCodeIndex("fengm2");
  d->r[0].fitNr=parNr;
  d->r[0].dataNr=100;
  d->r[0].start=0.0;
  d->r[0].end=420.0;
  d->r[0].wss=0.0E+000;
  /* Set parameter values and region names */
  pi=0; d->r[0].p[pi]=66.;
  pi++; d->r[0].p[pi]=-0.14;
  pi++; d->r[0].p[pi]=50.;
  pi++; d->r[0].p[pi]=-0.024;
  pi++; d->r[0].p[pi]=40;
  pi++; d->r[0].p[pi]=-0.001;
  pi++; d->r[0].p[pi]=10.; // delay time
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

parExampleTTACs()

int parExampleTTACs ( PAR * d, int type, TPCSTATUS * status )

extern

Create PAR data containing function parameters for typical-looking PET TTACs for use in algorithm and software tests.

Creates three fengm2 functions with zero delay.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parInit, parExamplePerfectBolus

Parameters

d	Pointer to initiated PAR struct, which will be allocated and filled here; any previous content will be deleted.
type	TTAC type; currently unused
status	Pointer to status data; enter NULL if not needed

Definition at line 24 of file parexample.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s(par, %d)\n", __func__, type);
 
  /* 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);
 
  int ret, pi, ri, parNr;
  
  /* Allocate memory */
  parNr=modelParNr(modelCodeIndex("fengm2"));
  ret=parAllocate(d, parNr, 3); if(ret!=TPCERROR_OK) return(ret);
  d->tacNr=3; d->parNr=5;
  d->format=PAR_FORMAT_CSV_INT;
  /* Set header fields */
  iftPut(&d->h, "studynr", "ttac1313", 1, NULL);
  iftPut(&d->h, "analysis_time", "2016-07-01 15:05:43", 1, NULL);
  iftPut(&d->h, "program", "libtpcpar (c) 2016", 1, NULL);
  iftPut(&d->h, "datafile","ttac1313.tac",1,NULL);
  iftPut(&d->h, "weighting", "no", 1, NULL);
  iftPut(&d->h, "unit", unitName(UNIT_KBQ_PER_ML), 1, NULL);
  iftPut(&d->h, "timeunit", unitName(UNIT_MIN), 1, NULL);
  /* Set parameter names */
  pi=0; strcpy(d->n[pi].name, "A1"); d->n[pi].unit=UNIT_KBQ_PER_ML;
  pi++; strcpy(d->n[pi].name, "L1"); d->n[pi].unit=UNIT_PER_MIN;
  pi++; strcpy(d->n[pi].name, "A2"); d->n[pi].unit=UNIT_KBQ_PER_ML;
  pi++; strcpy(d->n[pi].name, "L2"); d->n[pi].unit=UNIT_PER_MIN;
  pi++; strcpy(d->n[pi].name, "A3"); d->n[pi].unit=UNIT_KBQ_PER_ML;
  pi++; strcpy(d->n[pi].name, "L4"); d->n[pi].unit=UNIT_PER_MIN;
  pi++; strcpy(d->n[pi].name, "tDelay"); d->n[pi].unit=UNIT_MIN;
  /* Set regional fit options */
  for(ri=0; ri<d->tacNr; ri++) {
    d->r[ri].model=modelCodeIndex("fengm2");
    d->r[ri].fitNr=parNr;
    d->r[ri].dataNr=100;
    d->r[ri].start=0.0;
    d->r[ri].end=60.0;
    d->r[ri].wss=0.0E+000;
  }
  /* Set parameter values and region names */
  ri=0; 
  strcpy(d->r[ri].name, "fast");
  pi=0; d->r[ri].p[pi]=200.;
  pi++; d->r[ri].p[pi]=-0.8;
  pi++; d->r[ri].p[pi]=50.;
  pi++; d->r[ri].p[pi]=-0.2;
  pi++; d->r[ri].p[pi]=20.;
  pi++; d->r[ri].p[pi]=-0.005;
  pi++; d->r[ri].p[pi]=0.0;
  ri++; 
  strcpy(d->r[ri].name, "moder");
  pi=0; d->r[ri].p[pi]=50.;
  pi++; d->r[ri].p[pi]=-0.2;
  pi++; d->r[ri].p[pi]=50.;
  pi++; d->r[ri].p[pi]=-0.02;
  pi++; d->r[ri].p[pi]=3.;
  pi++; d->r[ri].p[pi]=-0.001;
  pi++; d->r[ri].p[pi]=0.0;
  ri++; 
  strcpy(d->r[ri].name, "slow");
  pi=0; d->r[ri].p[pi]=5.;
  pi++; d->r[ri].p[pi]=-0.05;
  pi++; d->r[ri].p[pi]=70.;
  pi++; d->r[ri].p[pi]=-0.001;
  pi++; d->r[ri].p[pi]=30.;
  pi++; d->r[ri].p[pi]=-0.0005;
  pi++; d->r[ri].p[pi]=0.0;
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

parFindParameter()

int parFindParameter ( PAR * d, const char * par_name )

extern

Searches PAR structure for the given parameter name (case insensitive).

Returns

the index [0..parNr-1] of the parameter, or <0 if not found.

Author

Vesa Oikonen

See also

parGetParameter, parSelectParameters

Parameters

d	Pointer to PAR structure.
par_name	Name of the parameter. Comparison is case-insensitive, but otherwise strict match is required.

Definition at line 219 of file parselect.c.

  {
  /* Check that required data exists */
  if(d==NULL || d->parNr<1 || par_name==NULL) return(-1);
  /* Find the name */
  for(int i=0; i<d->parNr; i++) {
    if(strcasecmp(par_name, d->n[i].name)==0) return(i);
  }
  return(-1);
}

parFormatFromExtension()

int parFormatFromExtension ( const char * s )

extern

Identify the PAR file format from the extension of file name.

Returns

enum parformat, or 0 (enum PAR_FORMAT_UNKNOWN) if not identified.

Author

Vesa Oikonen

See also

parFormattxt, parformat, parFormatIdentify, parWrite

Parameters

s	Pointer to file name with or without path; mere extension is not accepted here. For example /path/filename.res or filename.fit.bak are accepted.

Definition at line 102 of file pario.c.

  {
  if(s==NULL || strlen(s)<1) return PAR_FORMAT_UNKNOWN;
  /* Get pointer to the extensions */
  char *cptr=filenameGetExtensions(s);
  if(cptr==NULL) return PAR_FORMAT_UNKNOWN;
  /* Try to find some known extensions */
  if(strcasestr(cptr, ".res")) return PAR_FORMAT_RES;
  if(strcasestr(cptr, ".fit")) return PAR_FORMAT_FIT;
  if(strcasestr(cptr, ".ift")) return PAR_FORMAT_IFT;
  if(strcasestr(cptr, ".csv")) return PAR_FORMAT_CSV_UK;
  if(strcasestr(cptr, ".tsv")) return PAR_FORMAT_TSV_UK;
  if(strcasestr(cptr, ".txt")) return PAR_FORMAT_TSV_UK;
  if(strcasestr(cptr, ".par")) return PAR_FORMAT_TSV_UK;
  if(strcasestr(cptr, ".lim")) return PAR_FORMAT_TSV_UK;
  if(strcasestr(cptr, ".dat")) return PAR_FORMAT_TSV_UK;
  if(strcasestr(cptr, ".xml")) return PAR_FORMAT_XML;
  if(strcasestr(cptr, ".htm")) return PAR_FORMAT_HTML;
  return PAR_FORMAT_UNKNOWN;
}

parFormatIdentify()

int parFormatIdentify ( const char * s )

extern

Identify the string representations of the PAR file format.

Returns

enum parformat, or 0 (enum PAR_FORMAT_UNKNOWN) if not identified.

Author

Vesa Oikonen

See also

parFormattxt, parformat, parFormatFromExtension, parRead

Parameters

s	PAR format as a string.

Definition at line 74 of file pario.c.

  {
  if(s==NULL || strlen(s)<1) return PAR_FORMAT_UNKNOWN;
  /* Try if string can be found directly in the table */
  for(int i=0; i<PAR_FORMAT_LAST; i++) {
    if(strcasecmp(par_format[i], s)==0) return i;
  }
  /* Format string is not following TPC standard, lets try something else */
  if(     strcasecmp(s, "dat")==0)              return PAR_FORMAT_TSV_UK;
  else if(strcasecmp(s, "txt")==0)              return PAR_FORMAT_TSV_UK;
  else if(strcasecmp(s, "par")==0)              return PAR_FORMAT_CSV_UK;
  else if(strcasecmp(s, "lim")==0)              return PAR_FORMAT_TSV_UK;
  else if(strcasecmp(s, "htm")==0)              return PAR_FORMAT_HTML;
  else if(strcasecmp(s, "csv")==0)              return PAR_FORMAT_CSV_UK;
  else if(strcasecmp(s, "tsv")==0)              return PAR_FORMAT_TSV_UK;
 
  return PAR_FORMAT_UNKNOWN;
}

parFormattxt()

char * parFormattxt ( parformat c )

extern

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

Returns

pointer to the PAR file format string.

See also

parformat, parFormatIdentify, parFormatFromExtension

Author

Vesa Oikonen

Parameters

c	PAR format code.

Definition at line 59 of file pario.c.

  {
  if(c<PAR_FORMAT_UNKNOWN || c>=PAR_FORMAT_LAST) return NULL;
  return (char*)par_format[c];
}

Referenced by parRead(), parWrite(), and parWriteCSV().

parFree()

void parFree ( PAR * par )

extern

Free memory allocated for PAR. All data is cleared.

See also

parInit, parAllocate, parRead

Parameters

par	Pointer to PAR struct

Definition at line 75 of file par.c.

  {
  if(par==NULL) return;
  for(int i=0; i<par->_tacNr; i++) parrFree(par->r+i);
  free(par->r);
  free(par->n);
  iftFree(&par->h);
  parInit(par);
}

Referenced by parAllocate(), parFromIFT(), parRead(), parReadCSV(), parReadFIT(), and parReadRES().

parFromIFT()

int parFromIFT ( PAR * par, IFT * ift, TPCSTATUS * status )

extern

Copy parameters data in IFT into PAR struct. IFT contents must be in specific format and order.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to initiated target PAR struct; any previous contents are deleted
ift	Pointer to source IFT struct, contents of which are to be copied
status	Pointer to status data; enter NULL if not needed

Definition at line 207 of file parift.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(par==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>0) printf("%s()\n", __func__);
  if(ift==NULL || ift->keyNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Verify that IFT contains results */
  if(strcasecmp(ift->item[0].key, "content") ||
     strcasecmp(ift->item[0].value, "parameters")
  ) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
 
  int ret, parNr, tacNr;
  /* Read the nr of parameters */
  if(iftGetInt(ift, iftFindKey(ift, "par_nr", 0), &parNr)!=0 || parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  if(verbose>5) printf("parNr := %d\n", parNr);  
  /* Read the nr of parameter sets (tacs) */
  tacNr=iftFindNrOfKeys(ift, "parameter-set");
  if(tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  if(verbose>5) printf("tacNr := %d\n", tacNr);  
 
  /* Allocate memory for PAR */
  parFree(par);
  ret=parAllocate(par, parNr, tacNr);
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
  par->parNr=parNr; par->tacNr=tacNr;
 
  /* Read header contents */
  for(int i=1, ret=0; i<ift->keyNr && ret==TPCERROR_OK; i++) {
    /* not if value is missing */
    if(ift->item[i].value==NULL || strlen(ift->item[i].value)<1) continue;
    /* not if key is missing */
    if(ift->item[i].key==NULL || strlen(ift->item[i].key)<1) continue;
    /* end of header? */
    if(strcasecmp(ift->item[i].key, "parameter-set")==0) break;
    /* not needed */
    if(strcasecmp(ift->item[i].key, "par_nr")==0) continue;
    if(strcasecmp(ift->item[i].key, "format")==0) continue;
    if(strcasecmp(ift->item[i].key, "tac_nr")==0) continue;
    /* ok to copy */
    ret=iftPut(&par->h, ift->item[i].key, ift->item[i].value, 1, NULL);
  }
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  /* Read parameter values */
  int i, pi=0, ri=0; ret=0;
  char tmp[128];
  i=iftFindKey(ift, "parameter-set", 0);
  for(i++; i<ift->keyNr && ret==TPCERROR_OK; i++) {
    if(verbose>60)
      printf("i=%d key='%s' value='%s'\n",
             i, ift->item[i].key, ift->item[i].value);
    /* new parameter-set? */
    if(strcasecmp(ift->item[i].key, "parameter-set")==0) {
      ri++; pi=0; if(ri<par->tacNr) continue; else break;}
    /* parameter set info? */
    if(strcasecmp(ift->item[i].key, "tac_name")==0) {
      strncpy(par->r[ri].name, ift->item[i].value, MAX_TACNAME_LEN);
      par->r[ri].name[MAX_TACNAME_LEN]='\0';
      continue;
    }
    if(strcasecmp(ift->item[i].key, "wss")==0) {
      if(iftGetDouble(ift, i, &par->r[ri].wss)) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "model")==0) {
      if(iftGetUInt(ift, i, &par->r[ri].model)) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "data_nr")==0) {
      if(iftGetInt(ift, i, &par->r[ri].dataNr)) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "fit_nr")==0) {
      if(iftGetInt(ift, i, &par->r[ri].fitNr)) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "fit_start")==0) {
      if(iftGetDouble(ift, i, &par->r[ri].start)) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "fit_end")==0) {
      if(iftGetDouble(ift, i, &par->r[ri].end)) {ret++; break;}
      continue;
    }
    /* SD or CL ? */
    if(strcasecmp(ift->item[i].key, "SD")==0) {
      if(iftGetDouble(ift, i, &par->r[ri].sd[pi])) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "95%CL1")==0) {
      if(iftGetDouble(ift, i, &par->r[ri].cl1[pi])) {ret++; break;}
      continue;
    }
    if(strcasecmp(ift->item[i].key, "95%CL2")==0) {
      if(iftGetDouble(ift, i, &par->r[ri].cl2[pi])) {ret++; break;}
      continue;
    }
    /* Ok this should be parameter */
    if(pi>=par->parNr) {ret++; break;}
    strncpy(par->n[pi].name, ift->item[i].key, MAX_PARNAME_LEN);
    par->n[pi].name[MAX_PARNAME_LEN]='\0';
    if(iftGetDouble(ift, i, &par->r[ri].p[pi])) {ret++; break;}
    /* next token, if one exists, should be the unit */
    if(strTokenNr(ift->item[i].value, " \t")==2) {
      if(strTokenNCpy(ift->item[i].value, " \t", 2, tmp, 64)>0)
        par->n[pi].unit=unitIdentify(tmp);
    }
    pi++;
  }
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  /* Set format in struct */
  par->format=PAR_FORMAT_IFT;
 
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parRead().

parGetParameter()

double parGetParameter ( PAR * d, const char * par_name, const int ti )

extern

Searches PAR structure for the given parameter name (case insensitive).

Returns

the value of the parameter for specified TAC, or NaN if not found.

Author

Vesa Oikonen

See also

parGetParameterUnit, parFindParameter, parSelectParameters

Parameters

d	Pointer to PAR structure.
par_name	Name of the parameter. Comparison is case-insensitive, but otherwise strict match is required.
ti	TAC index [0..tacNr-1].

Definition at line 242 of file parselect.c.

  {
  double v=nan("");
  /* Check that required data exists */
  if(d==NULL || d->parNr<1 || ti<0 || ti>=d->tacNr || par_name==NULL) return(v);
  /* Find the name */
  for(int pi=0; pi<d->parNr; pi++)
    if(strcasecmp(par_name, d->n[pi].name)==0) v=d->r[ti].p[pi];
  return(v);
}

parGetParameterUnit()

int parGetParameterUnit ( PAR * d, const char * par_name )

extern

Searches PAR structure for the given parameter name (case insensitive).

Returns

the enum of the unit of the parameter, or UNIT_UNKNOWN if not found.

Author

Vesa Oikonen

See also

parFindParameter, parGetParameter

Parameters

d	Pointer to PAR structure.
par_name	Name of the parameter. Comparison is case-insensitive, but otherwise strict match is required.

Definition at line 267 of file parselect.c.

  {
  int u=UNIT_UNKNOWN;
  /* Check that required data exists */
  if(d==NULL || d->parNr<1 || par_name==NULL) return(u);
  /* Find the name */
  for(int pi=0; pi<d->parNr; pi++) if(strcasecmp(par_name, d->n[pi].name)==0) u=d->n[pi].unit;
  return(u);
}

parInit()

void parInit ( PAR * par )

extern

Initiate the PAR struct before any use.

Author

Vesa Oikonen

See also

parrInit, parnInit, parFree, parAllocate, parRead

Parameters

par	Pointer to PAR

Definition at line 25 of file par.c.

  {
  if(par==NULL) return;
  par->format=PAR_FORMAT_UNKNOWN;
  par->tacNr=par->_tacNr=0;
  par->parNr=par->_parNr=0;
  par->n=NULL;
  par->r=NULL;
  iftInit(&par->h);
}

Referenced by parFree().

parIsDataNr()

int parIsDataNr ( PAR * par )

extern

Check if any of parameter sets has dataNr specified.

See also

parIsFitNr, parIsWSS

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data

Definition at line 362 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].dataNr>0) ret=1;
    if(ri>0 && par->r[ri].dataNr!=par->r[ri-1].dataNr) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsFitNr()

int parIsFitNr ( PAR * par )

extern

Check if any of parameter sets has fitNr specified.

See also

parIsDataNr, parIsWSS

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data.

Definition at line 343 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].fitNr>0) ret=1;
    if(ri>0 && par->r[ri].fitNr!=par->r[ri-1].fitNr) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsFitRange()

int parIsFitRange ( PAR * par )

extern

Check if any of parameter sets has fit range specified.

See also

parIsFitNr, parIsDataNr, parIsWSS

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data.

Definition at line 267 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(!isnan(par->r[ri].start) || !isnan(par->r[ri].end)) ret=1;
    if(ri==0 || ret==0) continue;
    if(!doubleMatch(par->r[ri].start, par->r[0].start, 0.01)) {ret=2; break;}
    if(!doubleMatch(par->r[ri].end,   par->r[0].end,   0.01)) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsModel()

int parIsModel ( PAR * par )

extern

Check if any of parameter sets has model id specified.

See also

parIsFitNr, parIsWSS, parRead, parIsOptcrit

Returns

Returns 0 if not, 1 if the same in each set, and 2 if variable.

Parameters

par	Pointer to parameter data.

Definition at line 288 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  int ri, ret=0;
  for(ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].model>0) ret=1;
    if(ri>0 && par->r[ri].model!=par->r[ri-1].model) {ret=2; break;}
  }
  return(ret);
}

Referenced by parToIFT(), parWriteCSV(), and parWriteXML().

parIsOptcrit()

char * parIsOptcrit ( PAR * par )

extern

Check if PAR data contains optimality criterion.

See also

parIsModel, parIsWSS, studynrFromFilename

Returns

Returns pointer to optimization criterion name, or NULL if not found.

Parameters

par	Pointer to parameter data.

Definition at line 381 of file par.c.

  {
  if(par==NULL || par->h.keyNr<1) return((char*)NULL);
  int li=iftFindKey(&par->h, "optimality_criterion", 0);
  if(li<0) li=iftFindKey(&par->h, "optcrit", 0);
  if(li<0) return((char*)NULL);
  if(par->h.item[li].value==NULL || strlen(par->h.item[li].value)<1) return((char*)NULL);
  return(par->h.item[li].value);
}

parIsStudyNr()

char * parIsStudyNr ( PAR * par )

extern

Check if PAR data contains study number.

See also

parSetStudyNr, parIsModel, parIsWSS, studynrFromFilename, parEnsureNames

Returns

Returns pointer to study number, or NULL if not found.

Parameters

par	Pointer to parameter data.

Definition at line 399 of file par.c.

  {
  if(par==NULL || par->h.keyNr<1) return((char*)NULL);
  int li=iftFindKey(&par->h, "studynr", 0);
  if(li<0) li=iftFindKey(&par->h, "study_number", 0);
  if(li<0) return((char*)NULL);
  if(par->h.item[li].value==NULL || strlen(par->h.item[li].value)<1) return((char*)NULL);
  return(par->h.item[li].value);
}

parIsWSS()

int parIsWSS ( PAR * par )

extern

Check if any of parameter sets has WSS.

See also

parIsFitNr, parIsDataNr, parCLWithPar, parSDWithPar, parIsOptcrit

Returns

Returns 1 if WSS exists, and 0 if not (or in case of an error).

Parameters

par	Pointer to parameter data.

Definition at line 252 of file par.c.

  {
  if(par==NULL || par->tacNr<1) return(0);
  for(int ri=0; ri<par->tacNr; ri++) if(!isnan(par->r[ri].wss)) return(1);
  return(0);
}

Referenced by parWriteCSV(), parWriteRES(), and parWriteXML().

parListLimits()

void parListLimits ( PAR * par, FILE * fp )

extern

List parameter limits in PAR structure.

See also

parWriteLimits, parWrite, parFree

Parameters

par	Pointer to PAR structure, from which the limits are printed.
fp	File pointer for the output; usually stdout.

Definition at line 406 of file pario.c.

  {
  //printf("%s()\n", __func__);
  if(par==NULL || par->parNr<1) {fprintf(fp, "No parameter limits.\n"); return;}
 
  fprintf(fp, "Parameter limits:\n");
  for(int i=0; i<par->parNr; i++) {
    if(strlen(par->n[i].name)>0) fprintf(fp, "%s", par->n[i].name);
    else fprintf(fp, "p%d", 1+i);
    fprintf(fp, "\t%g\t%g\n", par->n[i].lim1, par->n[i].lim2);
  }
  fprintf(fp, "\n");
  return;
}

parnInit()

void parnInit ( PARN * parn )

extern

Initiate the PARN struct before any use.

Author

Vesa Oikonen

See also

parInit, parrInit

Parameters

parn	Pointer to PARN

Definition at line 59 of file par.c.

  {
  if(parn==NULL) return;
  parn->name[0]='\0';
  parn->unit=UNIT_UNKNOWN;
  parn->lim1=parn->lim2=parn->tol=nan("");
  parn->sw=0;
}

Referenced by parAllocate(), and parAllocateMore().

parPrintType()

int parPrintType ( PAR * par, int parIndex )

extern

Determine whether the parameter should be printed as integer (0), float (1), or exponential (2).

Returns

Returns the code, or <0 in case of an error.

Parameters

par	Pointer to the PAR structure.
parIndex	Index of the parameter to test.

Definition at line 584 of file parres.c.

  {
  int vi, partype=0;
  double x, m=0.0, pint;
 
  if(par==NULL || par->tacNr<1 || parIndex<0 || parIndex>=par->tacNr)
    return(-1);
  for(vi=0; vi<par->tacNr; vi++) {
    x=par->r[vi].p[parIndex];
    if(modf(x, &pint)!=0.0) partype=1;
    x=fabs(x); if(x>m) m=x;
  }
  if(partype==1 && (m>=10.0 || m<0.1)) partype=2;
  return(partype);
}

Referenced by parWriteRES().

parrAllocate()

int parrAllocate ( PARR * parr, int parNr )

extern

Allocate memory for PARR data. Any previous contents are deleted.

See also

parrInit, parrFree, parAllocate

Returns

Returns TPCERROR status.

Parameters

parr	Pointer to initiated PARR struct data; any old contents are deleted.
parNr	Nr of parameters to allocate.

Definition at line 150 of file par.c.

  {
  if(parr==NULL) return TPCERROR_FAIL;
  /* Delete any previous contents */
  parrFree(parr);
  /* If no memory is requested, then just return */
  if(parNr<1) return TPCERROR_OK;
 
  /* Allocate memory for PARR data */
  parr->p=malloc(parNr*sizeof(double));
  parr->sd=malloc(parNr*sizeof(double));
  parr->cl1=malloc(parNr*sizeof(double));
  parr->cl2=malloc(parNr*sizeof(double));
  if(parr->p==NULL || parr->sd==NULL || parr->cl1==NULL || parr->cl2==NULL)
    return TPCERROR_OUT_OF_MEMORY;
  /* Initiate values to NaNs */
  for(int i=0; i<parNr; i++)
    parr->p[i]=parr->sd[i]=parr->cl1[i]=parr->cl2[i]=nan("");
 
  return TPCERROR_OK;
}

Referenced by parAllocate(), and parAllocateMore().

parRead()

int parRead ( PAR * par, const char * fname, TPCSTATUS * status )

extern

Read parameter file contents into PAR data structure. This function reads RES and FIT format, and some CSV formats.

Author

Vesa Oikonen

Returns

code tpcerror, TPCERROR_OK (0) when successful.

See also

parWrite, parInit, parFree

Parameters

par	Pointer to initiated PAR struct where parameter data will be written; any old content is deleted. Call parInit() before first use.
fname	Pointer to the file name; this string is not modified.
status	Pointer to status data; enter NULL if not needed.

Definition at line 232 of file pario.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(fname==NULL || strlen(fname)<1 || par==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>1) {printf("%s(%s)\n", __func__, fname); fflush(stdout);}
  int format=PAR_FORMAT_UNKNOWN;
 
  /* Delete any previous data */
  parFree(par);
 
  /* Try to read the file as CSV file */
  if(verbose>1) {printf("opening file\n"); fflush(stdout);}
  FILE *fp;
  fp=fopen(fname, "r");
  if(fp==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_OPEN);
    return TPCERROR_CANNOT_OPEN;
  }
  int ret;
  CSV csv; csvInit(&csv);
  ret=csvRead(&csv, fp, status);
  fclose(fp);
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); return ret;
  }
  if(verbose>20) {
    printf("\n --- CSV contents ---\n");
    csvWrite(&csv, 0, stdout, status);
  }
 
  /* Try to identify file format from a magic number in the start */
  if(verbose>1) {printf("checking for magic number\n"); fflush(stdout);}
  if(strncasecmp(csv.c[0].content, "FIT1", 4)==0) {
    format=PAR_FORMAT_FIT;
  } else if(strncasecmp(csv.c[0].content, "<?xml version", 5)==0) {
    format=PAR_FORMAT_XML;
  } else if(strcasecmp(csv.c[0].content, "Parameters")==0) {
    /* now determine the field and decimal separators */
    if(csv.separator==';') format=PAR_FORMAT_CSV_INT;
    else if(csv.separator==',') format=PAR_FORMAT_CSV_UK;
    else if(csv.separator=='\t' || csv.separator==' ') {
      // either UK or INT, we'll decide it later
      format=PAR_FORMAT_TSV_UK;
    }
  }
  if(verbose>3) {printf("format := %s\n", parFormattxt(format)); fflush(stdout);}
 
  /* If identified already, then read data and return */
  if(format!=PAR_FORMAT_UNKNOWN) {
    if(verbose>1) {printf("format := %s\n", parFormattxt(format)); fflush(stdout);}
    IFT hdr; iftInit(&hdr);
    /* These formats may contain additional header information in comment
       lines; read headers from those into TAC struct for further processing */
    if(format==PAR_FORMAT_CSV_UK || format==PAR_FORMAT_CSV_INT ||
       format==PAR_FORMAT_TSV_UK || format==PAR_FORMAT_TSV_INT
    ) {
      fp=fopen(fname, "r");
      if(fp!=NULL) {
        if(iftRead(&hdr, fp, 1, 2, status)!=TPCERROR_OK) iftFree(&hdr); 
        fclose(fp);
      }
      /* Header may not exist, therefore do not worry about errors here */
    }
    /* FIT (and RES) formats are easier to read partially from IFT struct */
    if(format==PAR_FORMAT_FIT) {
      fp=fopen(fname, "r");
      if(fp==NULL) ret=TPCERROR_CANNOT_OPEN; // these formats must have header
      else {
        ret=iftRead(&hdr, fp, 0, 1, status); 
        fclose(fp);
      }
      if(ret!=TPCERROR_OK) {
        csvFree(&csv); iftFree(&hdr);
        statusSet(status, __func__, __FILE__, __LINE__, ret);
        return ret;
      }
    }
    switch(format) {
      case PAR_FORMAT_FIT:
        ret=parReadFIT(par, &csv, &hdr, status);
        break;
      case PAR_FORMAT_CSV_INT:
        /* __attribute__((fallthrough)); */
      case PAR_FORMAT_CSV_UK:
        /* __attribute__((fallthrough)); */
      case PAR_FORMAT_TSV_INT:
        /* __attribute__((fallthrough)); */
      case PAR_FORMAT_TSV_UK:
        /* __attribute__((fallthrough)); */
      default:
        ret=parReadCSV(par, &csv, &hdr, status);
        break;
    }
    csvFree(&csv); iftFree(&hdr);
    if(ret!=TPCERROR_OK) {
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      parFree(par); return ret;
    }
    /* Set study number, if not yet set, based on file name */
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
 
  /* The rest of the formats are a bit more difficult to identify */
 
  /* Try to read as IFT */
  if(verbose>3) {printf("trying IFT format\n"); fflush(stdout);}
  fp=fopen(fname, "r");
  if(fp!=NULL) {
    IFT hdr; iftInit(&hdr);
    iftRead(&hdr, fp, 1, 1, status); fclose(fp);
    if(hdr.keyNr>0) {
      if(!strcasecmp(hdr.item[0].key, "content") && !strcasecmp(hdr.item[0].value, "parameters"))
        format=PAR_FORMAT_IFT;
    }
    if(format==PAR_FORMAT_IFT) {
      if(verbose>1) printf("format := %s\n", parFormattxt(format));
      ret=parFromIFT(par, &hdr, status);
      csvFree(&csv); iftFree(&hdr);
      if(ret!=TPCERROR_OK) {parFree(par); return ret;}
      /* Set study number, if not yet set, based on file name */
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
      return TPCERROR_OK;
    }
    if(verbose>3) printf("not IFT\n");
    iftFree(&hdr);
  }
 
  /* Try to read as RES file */
  if(verbose>3) {printf("trying RES format\n"); fflush(stdout);}
  /* Header is obligatory, read that to IFT */
  fp=fopen(fname, "r");
  if(fp!=NULL) {
    IFT hdr; iftInit(&hdr);
    ret=iftRead(&hdr, fp, 0, 1, status); fclose(fp);
    if(ret!=TPCERROR_OK) {
      csvFree(&csv); iftFree(&hdr);
      statusSet(status, __func__, __FILE__, __LINE__, ret);
      return ret;
    }
    ret=parReadRES(par, &csv, &hdr, status);
    iftFree(&hdr);
    if(ret==TPCERROR_OK) {
      csvFree(&csv);
      /* Set study number, if not yet set, based on file name */
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
      return TPCERROR_OK;
    }
  }
 
  /* Currently any other format cannot be read */
  if(verbose>3) {printf("currently not supported format\n"); fflush(stdout);}
  csvFree(&csv);
  parFree(par);
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
  return TPCERROR_UNSUPPORTED;
}

parReadCSV()

int parReadCSV ( PAR * par, CSV * csv, IFT * hdr, TPCSTATUS * status )

extern

Read parameter data into PAR structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parWriteCSV, parRead, parFormatIdentify

Parameters

par	Pointer to target PAR structure.
csv	Pointer to CSV from which data is read.
hdr	Pointer to possible header data, which, if available, is processed and copied to PAR too; enter NULL if not available.
status	Pointer to status data; enter NULL if not needed.

Definition at line 221 of file parcsv.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(par==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
 
  parFree(par);
  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__);
 
  /* Check that this is valid CSV or TSV parameter file */
  if(strcasecmp(csv->c[0].content, "Parameters")) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
 
  /* Remove initial and trailing space characters from CSV.
     Those may exist in manually made files. */
  csvCleanSpaces(csv);
 
  /* Calculate the number of parameters from the title line */
  int colNr=1, parNr=0;
  for(int i=1; i<csv->nr; i++) {
    if(csv->c[i].row==0) { // title line
      colNr++;
      /* do not count special columns */
      if(strncasecmp(csv->c[i].content, "SD", 2)==0) continue;
      if(strncasecmp(csv->c[i].content, "95%CL", 5)==0) continue;
      if(strcasecmp(csv->c[i].content, "WSS")==0) continue;
      if(strcasecmp(csv->c[i].content, "Model")==0) continue;
      if(strcasecmp(csv->c[i].content, "Start[min]")==0) continue;
      if(strcasecmp(csv->c[i].content, "End[min]")==0) continue;
      if(strcasecmp(csv->c[i].content, "dataNr")==0) continue;
      if(strcasecmp(csv->c[i].content, "fitNr")==0) continue;
      parNr++;
    } else break; // this is not more in title line
  }
  if(parNr<1 || csv->row_nr<2) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(verbose>2) printf("  parNr := %d\n  colNr := %d\n", parNr, colNr);
 
  /* Allocate memory for parameters */
  int ret;
  ret=parAllocate(par, parNr, csv->row_nr-1);
  if(ret!=TPCERROR_OK) {statusSet(status, __func__, __FILE__, __LINE__, ret); return ret;}
  par->parNr=parNr; par->tacNr=csv->row_nr-1;
 
 
  /* Read CSV contents into PAR struct */
  int decimal_comma=-1;
  ret=0; if(csv->separator==',') decimal_comma=0;
  /* Read TAC names from column 1 */
  for(int ri=1; ri<csv->row_nr; ri++) {
    int i=ri*colNr; if(i>=csv->nr || csv->c[i].col!=0) {ret++; break;}
    strlcpy(par->r[ri-1].name, csv->c[i].content, MAX_TACNAME_LEN);
  }
 
  /* Read one column at a time */
  parNr=0;
  for(int ci=1; ci<colNr && ret==0; ci++) {
    //printf("parNr=%d / %d\n", parNr, par->parNr);
    if(parNr>par->parNr) {ret++; break;}
    int ri=0; int i=ri*colNr+ci;
    if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
    if(strcasecmp(csv->c[i].content, "Model")==0) {
      for(ri=1; ri<csv->row_nr; ri++) {
        int i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].model=modelCodeIndex(csv->c[i].content);
      }
      continue;
    }
    if(strncasecmp(csv->c[i].content, "SD", 2)==0) {
      if(parNr==0) {ret++; break;}
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].sd[parNr-1]=atofVerified(csv->c[i].content);
      }
      continue;
    }
    if(strncasecmp(csv->c[i].content, "95%CL1", 6)==0) {
      if(parNr==0) {ret++; break;}
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].cl1[parNr-1]=atofVerified(csv->c[i].content);
      }
      continue;
    }
    if(strncasecmp(csv->c[i].content, "95%CL2", 6)==0) {
      if(parNr==0) {ret++; break;}
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].cl2[parNr-1]=atofVerified(csv->c[i].content);
      }
      continue;
    }
    if(strcasecmp(csv->c[i].content, "WSS")==0 || strcasecmp(csv->c[i].content, "SS")==0) {
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].wss=atofVerified(csv->c[i].content);
      }
      continue;
    }
    if(strncasecmp(csv->c[i].content, "Start", 5)==0) {
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].start=atofVerified(csv->c[i].content);
      }
      continue;
    }
    if(strncasecmp(csv->c[i].content, "End", 3)==0) {
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].end=atofVerified(csv->c[i].content);
      }
      continue;
    }
    if(strcasecmp(csv->c[i].content, "dataNr")==0) {
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].dataNr=atoi(csv->c[i].content);
      }
      continue;
    }
    if(strcasecmp(csv->c[i].content, "fitNr")==0) {
      for(ri=1; ri<csv->row_nr; ri++) {
        i=ri*colNr+ci;
        if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
        par->r[ri-1].fitNr=atoi(csv->c[i].content);
      }
      continue;
    }
    /* then this column is a parameter */
    char tmp[128];
    /* parameter name may contain unit */
    if(strTokenNCpy(csv->c[i].content, "[] \t", 1, par->n[parNr].name, MAX_PARNAME_LEN)==0) 
      {ret++; break;}
    if(strTokenNCpy(csv->c[i].content, "[] \t", 2, tmp, 128)>0)
      par->n[parNr].unit=unitIdentify(tmp);
    //strncpy(par->n[parNr].name, csv->c[i].content, MAX_PARNAME_LEN);
    //par->n[parNr].name[MAX_PARNAME_LEN]='\0';
    /* Read parameter values */
    for(ri=1; ri<csv->row_nr; ri++) {
      i=ri*colNr+ci;
      if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
      par->r[ri-1].p[parNr]=atofVerified(csv->c[i].content);
      if(decimal_comma<1) {
        /* Try to determine whether file format is UK or INT */
        if(strchr(csv->c[i].content, '.')!=NULL) decimal_comma=0;
        else if(strchr(csv->c[i].content, ',')!=NULL) decimal_comma=1;
      }
    }
    parNr++;
  }
  if(ret>0) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
 
  /* If one 'parameter' is named WSS or SS, then move its contents to
     correct place inside the struct */
  {
    int ci=-1;
    for(int i=0; i<par->parNr; i++) {
      if(!strcasecmp(par->n[i].name, "WSS") || !strcasecmp(par->n[i].name, "SS")) ci=i;
    }
    if(ci>=0 && ci<par->parNr && par->parNr>1) {
      if(verbose>4) {
        printf("column %d contains WSS, moving to correct place\n", 1+ci); fflush(stdout);}
      for(int i=0; i<par->tacNr; i++) par->r[i].wss=par->r[i].p[ci];
      /* delete the parameter column */
      parDeletePar(par, ci);
    }
  }
 
 
  /* Set format in struct */
  if(csv->separator==';') {
    if(decimal_comma==1) par->format=PAR_FORMAT_CSV_INT;
    else par->format=PAR_FORMAT_CSV_UK;
  } else if(csv->separator==',') {
    par->format=PAR_FORMAT_CSV_UK;
  } else if(csv->separator=='\t' || csv->separator==' ') {
    if(decimal_comma==1) par->format=PAR_FORMAT_TSV_INT;
    else par->format=PAR_FORMAT_TSV_UK;
  } else {
    if(decimal_comma==1) par->format=PAR_FORMAT_TSV_INT;
    else par->format=PAR_FORMAT_TSV_UK;
  }
 
 
 
  /* Copy header */
  if(hdr!=NULL && hdr->keyNr>0) {
    if(verbose>4) {
       printf("copying header contents (%d items) to PAR struct\n", hdr->keyNr); fflush(stdout);}
    if(iftDuplicate(hdr, &par->h)!=TPCERROR_OK) {
      if(verbose>0) {printf("  error in iftDuplicate()\n"); fflush(stdout);}
      parFree(par);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_HEADER);
      return TPCERROR_INVALID_HEADER;
    }
    /* Move standard fields from header to struct */
    double v, f;
    int i, n, u;
    char key[32];
 
    strcpy(key, "fit_start");
    if(!iftGetDoubleWithUnit(&par->h, iftFindKey(&par->h, key, 0), &v, &u)) {
      f=unitConversionFactor(u, UNIT_MIN); if(!isnan(f)) v*=f;
      for(i=0; i<par->tacNr; i++) if(isnan(par->r[i].start)) par->r[i].start=v;
    }
    strcpy(key, "fit_end");
    if(!iftGetDoubleWithUnit(&par->h, iftFindKey(&par->h, key, 0), &v, &u)) {
      f=unitConversionFactor(u, UNIT_MIN); if(!isnan(f)) v*=f;
      for(i=0; i<par->tacNr; i++) if(isnan(par->r[i].end)) par->r[i].end=v;
    }
    strcpy(key, "dataNr");
    if(!iftGetInt(&par->h, iftFindKey(&par->h, key, 0), &n)) {
      for(i=0; i<par->tacNr; i++) if(par->r[i].dataNr<=0) par->r[i].dataNr=n;
    }
    strcpy(key, "model");
    i=iftFindKey(&par->h, key, 0);
    if(i>=0) {
      unsigned int n=modelCodeIndex(par->h.item[i].value);
      iftDelete(&par->h, i);
      for(i=0; i<par->tacNr; i++) par->r[i].model=n;
    }
  }
 
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parRead().

parReadFIT()

int parReadFIT ( PAR * par, CSV * csv, IFT * ift, TPCSTATUS * status )

extern

Read (old) fit data into PAR struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parRead, parWriteFIT

Parameters

par	Pointer to target PAR struct.
csv	Pointer to source CSV from which data is read.
ift	Pointer to source IFT struct which contains whole result file data, in case the data could not be read into CSV.
status	Pointer to status data; enter NULL if not needed

Definition at line 131 of file parfit.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(par==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  parFree(par);
  
  if(csv==NULL || ift==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__);
 
  if(verbose>10) {
    printf("\n CSV contents shown with separator ; \n\n");
    char sep=csv->separator;
    csv->separator=';'; csvWrite(csv, 0, stdout, NULL); csv->separator=sep;
    printf("\n IFT contents \n\n");
    iftWrite(ift, stdout, NULL);
    printf("\n");
  }
 
  int i, n, ret, titlerow, tunit=UNIT_UNKNOWN;
  char *cptr, tmp[256];
 
  /* TAC nr */
  i=iftFindKey(ift, "Nr of VOIs", 0);
  if(i<0) i=iftFindKey(ift, "voiNr", 0);
  if(i<0) i=iftFindKey(ift, "tacNr", 0);
  if(i<0) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  int tacNr=atoi(ift->item[i].value);
 
  /* Find (and ignore) the parameter title line */
  i=0; if(verbose>2) printf("estimating parNr\n"); 
  while(i<csv->nr) {
    i=csvSearchField(csv, "Region", i); if(i<0) break; 
    if(i>=0 && csv->c[i].col==0) break;
    i++;
  }
  if(i<0 || i==csv->nr) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  titlerow=csv->c[i].row; if(verbose>3) printf("titlerow := %d\n", titlerow);
#if(1)
  /* Parameter nr from the row with most columns */
  int parNr=0;
  for(int r=0; r<tacNr; r++) {
    int n=csvRowLength(csv, r+titlerow+1); if(verbose>5) printf("n=%d at row %d\n", n, r+titlerow+1);
    if(n>parNr) parNr=n;
  }
  if(verbose>4) printf("  initial_parNr := %d\n", parNr);
#else
  /* Parameter nr from the next row */
  int parNr=csvRowLength(csv, titlerow+1);
#endif
  if(csv->separator!=' ') parNr-=7; else parNr-=9;
  if(verbose>2) {
    printf("  parNr := %d\n", parNr);
    printf("  tacNr := %d\n", tacNr);
  }
  if(parNr<1 || tacNr<1) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Allocate space for parameters */
  ret=parAllocate(par, parNr, tacNr); if(ret!=TPCERROR_OK) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
  par->parNr=parNr; par->tacNr=tacNr;
 
  /* Check magic string and get program name from the first non-comment IFT field */
  i=0; 
  while(ift->item[i].comment && i<ift->keyNr && ift->item[i].key!=NULL) i++;
  if(verbose>3) {
    printf("ift->item[%d].value := '%s'\n", i, ift->item[i].value);
  }
  if(i==ift->keyNr || strncasecmp(ift->item[i].value, "FIT1", 4)) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  cptr=ift->item[i].value+4;
  if(strncpyCleanSpaces(tmp, cptr, 256)<1) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  iftPut(&par->h, "program", tmp, 0, NULL);
 
  /* Get analysis time from IFT struct */
  i=iftFindKey(ift, "Date", 0);
  if(i>=0) iftPut(&par->h, "analysis_time", ift->item[i].value, 0, NULL);
 
  /* Filename of the original data */
  i=iftFindKey(ift, "Data file", 0);
  if(i>=0) iftPut(&par->h, "datafile", ift->item[i].value, 0, NULL);
 
  /* Study number */
  i=iftFindKey(ift, "Study number", 0);
  if(i<0) i=iftFindKey(ift, "studynr", 0);
  if(i>=0) iftPut(&par->h, "studynr", ift->item[i].value, 0, NULL);
 
  /* Units of the original data */
  i=iftFindKey(ift, "Data unit", 0);
  if(i>=0) iftPut(&par->h, "unit", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Time unit", 0);
  if(i>=0) {
    iftPut(&par->h, "timeunit", ift->item[i].value, 0, NULL);
    tunit=unitIdentify(ift->item[i].value);
  }
 
  /* Set parameter names */
  for(i=0; i<parNr; i++) sprintf(par->n[i].name, "p%d", 1+i);
 
  /* Read TAC parameters */
  ret=0; if(verbose>2) {printf("reading individual parameter values...\n"); fflush(stdout);}
  for(int j=0; j<tacNr; j++) {
    n=csvRowLength(csv, 1+j+titlerow); if(csv->separator!=' ') n-=7; else n-=9;
    if(n>parNr) {ret++; break;}
    i=0; n=1+j+titlerow;
    /* copy tac name */
    strlcpy(par->r[j].name, csvCell(csv, n, i), MAX_TACNAME_LEN);
    if(csv->separator==' ') {
      i++; 
      strlcat(par->r[j].name, " ", MAX_TACNAME_LEN);
      strlcat(par->r[j].name, cptr=csvCell(csv, n, i), MAX_TACNAME_LEN);
      i++;
      strlcat(par->r[j].name, " ", MAX_TACNAME_LEN);
      strlcat(par->r[j].name, cptr=csvCell(csv, n, i), MAX_TACNAME_LEN);
    }
    /* fit start and end times */
    i++; par->r[j].start=atofVerified(csvCell(csv, n, i));
    i++; par->r[j].end=atofVerified(csvCell(csv, n, i));
    if(tunit==UNIT_SEC) {par->r[j].start/=60.; par->r[j].end/=60.;}
    /* nr of fitted samples */
    i++; par->r[j].dataNr=atoi(csvCell(csv, n, i));
    /* (W)SS */
    i++; par->r[j].wss=atofVerified(csvCell(csv, n, i));
    /* nr of parameters for this TAC; this is not the same as the nr of fitted (free) 
       parameters that would be stored in PAR struct */
    i++; int tacParNr=atoi(csvCell(csv, n, i));
    par->r[j].fitNr=0; 
    /* function id */
    i++; par->r[j].model=modelOld2New(atoi(csvCell(csv, n, i)));
    /* function parameter values */
#if(1)
    int k; // read the ones that actually are saved... and then fill the rest with NaNs
    for(k=0; k<tacParNr; k++) {
      i++; par->r[j].p[k]=atofVerified(csvCell(csv, n, i));
    }
    for(; k<parNr; k++) par->r[j].p[k]=nan("");
#else
    for(int k=0; k<parNr; k++) {
      i++; par->r[j].p[k]=atofVerified(csvCell(csv, n, i));}
#endif
  }
  if(ret>0) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
 
  /* Fix region names (mainly, remove dots) */
  {
    int i, tac;
    char fnsp[3][MAX_TACNAME_LEN+1];
    for(tac=0; tac<par->tacNr; tac++) {
      for(i=0; i<3; i++) {
        if(roinameSubpart(par->r[tac].name, "_ ", i, fnsp[i], MAX_TACNAME_LEN)==NULL ||
           strcmp(fnsp[i], ".")==0)
          strcpy(fnsp[i], "");
      }
      strcpy(par->r[tac].name, fnsp[0]);
      if(strlen(fnsp[1]) || strlen(fnsp[2])) strcat(par->r[tac].name, "_");
      if(strlen(fnsp[1])) strcat(par->r[tac].name, fnsp[1]);
      if(strlen(fnsp[2])) {strcat(par->r[tac].name, "_"); strcat(par->r[tac].name, fnsp[2]);}
    }
  }
 
  /* Set format in struct */
  par->format=PAR_FORMAT_FIT;
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parRead().

parReadLimits()

int parReadLimits ( PAR * par, const char * fname, const int verbose )

extern

Read the specified file and try to find constraints and tolerance for parameters listed in PAR structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parWriteLimits, parWrite, parFree

Parameters

par	Pointer to PAR structure, into which the limits are saved. This must also list the parameter names that are searched for from the file.
fname	Input file name.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout.

Definition at line 489 of file pario.c.

  {
  if(verbose>0) {printf("%s(%s)\n", __func__, fname); fflush(stdout);}
  if(par==NULL || par->parNr<1) return TPCERROR_NO_DATA;
  if(strlen(fname)<1) return(TPCERROR_INVALID_FILENAME);
 
  /* Open file */
  if(verbose>1) printf("  opening %s\n", fname);
  FILE *fp=fopen(fname, "r");
  if(fp==NULL) return TPCERROR_CANNOT_READ;
 
  /* Read file into IFT struct */
  if(verbose>1) printf("  reading into IFT\n");
  IFT ift; iftInit(&ift);
  if(iftRead(&ift, fp, 1, 0, NULL)!=TPCERROR_OK) {fclose(fp); return TPCERROR_CANNOT_READ;}
  fclose(fp);
  if(verbose>1) printf("  keyNr=%d\n", ift.keyNr);
 
  /* Search for parameter limits in the IFT */
  char pname[MAX_PARNAME_LEN+10];
  int n=0;
  double f;
  for(int i=0; i<par->parNr; i++) {
    if(strlen(par->n[i].name)>0) strcpy(pname, par->n[i].name);
    else sprintf(pname, "p%d", 1+i);
    strcat(pname, "_lower");
    if(iftGetDoubleValue(&ift, pname, 0, &f)>=0 && !isnan(f)) {par->n[i].lim1=f; n++;}
    if(verbose>2) printf("  %s -> %g\n", pname, f);
    pname[strlen(pname)-6]=(char)0; strcat(pname, "_upper");
    if(iftGetDoubleValue(&ift, pname, 0, &f)>=0 && !isnan(f)) {par->n[i].lim2=f; n++;}
    if(verbose>2) printf("  %s -> %g\n", pname, f);
    pname[strlen(pname)-6]=(char)0; strcat(pname, "_tol");
    if(iftGetDoubleValue(&ift, pname, 0, &f)>=0 && !isnan(f)) {par->n[i].tol=f; n++;}
    if(verbose>2) printf("  %s -> %g\n", pname, f);
  }
  iftFree(&ift);
  if(verbose>1) printf("  n=%d\n", n);
  if(n==0) return TPCERROR_NO_DATA;
 
  return TPCERROR_OK;
}

parReadRES()

int parReadRES ( PAR * par, CSV * csv, IFT * ift, TPCSTATUS * status )

extern

Read result (RES) data into PAR struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to target PAR struct.
csv	Pointer to CSV from which data is read.
ift	Pointer to IFT struct which contains whole result file data, in case the data could not be read into CSV (which happens when spaces were used as field separator).
status	Pointer to status data; enter NULL if not needed.

Definition at line 268 of file parres.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) {printf("%s()\n", __func__); fflush(stdout);}
  if(par==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  parFree(par);
  
  if(csv==NULL || ift==NULL || csv->row_nr<1 || csv->col_nr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }  
 
  if(verbose>10) {
    printf("\n CSV contents shown with separator ; \n\n");
    char sep=csv->separator;
    csv->separator=';'; csvWrite(csv, 0, stdout, NULL); csv->separator=sep;
    printf("\n IFT contents \n\n");
    iftWrite(ift, stdout, NULL);
  }
 
  int i, ret, titlerow;
  int ri, ci, parNr=0, tacNr=0;
  char *cptr;
 
  /* Find the result title line; get initial parameter and tac nr */
  i=0; if(verbose>2) printf("estimating parNr and tacNr\n"); 
  while(i<csv->nr) {
    i=csvFindField(csv, "Region", i); if(i<0) break; 
    if(i>=0 && csv->c[i].col==0) break;
    i++;
  }
  if(i<0 || i==csv->nr) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  titlerow=csv->c[i].row;
  /* Get parameter nr */
  parNr=csvRowLength(csv, titlerow)-1;
  // sometimes empty cells in the end
  ci=parNr; while(ci>0 && strlen(csv->c[ci].content)<1) {ci--; parNr--;}
  // sometimes an empty cell before parameter names
  if(strlen(csv->c[i+1].content)<1) parNr--;
  /* Get region nr */
  ri=1+titlerow; ci=0;
  cptr=csvCell(csv, ri, ci);
  while(cptr!=NULL) {
    if(csv->separator!=' ') {
      if(strncasecmp(cptr, "SD . .", 3) && strncasecmp(cptr, "CL 95% ", 7)) tacNr++;
    } else {
      if(strcasecmp(cptr, "SD") && strcasecmp(cptr, "CL")) tacNr++;
    }
    ri++; cptr=csvCell(csv, ri, ci);
  }
  if(verbose>2) {
    printf("  parNr := %d\n", parNr);
    printf("  tacNr := %d\n", tacNr);
  }
  if(parNr<1 || tacNr<1) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  /* Allocate space for parameters */
  ret=parAllocate(par, parNr, tacNr); if(ret!=TPCERROR_OK) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
  par->parNr=parNr; par->tacNr=tacNr;
 
  /* Get program name from the first non-comment IFT field */
  if(verbose>2) printf("searching obligatory program name\n");
  i=0; 
  while(ift->item[i].comment && i<ift->keyNr && ift->item[i].key!=NULL) i++;
  if(verbose>3) {
    printf("ift->item[%d].value := '%s'\n", i, ift->item[i].value);
  }
  if(i==ift->keyNr || !strcasestr(ift->item[i].value, "(c)")) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
    return TPCERROR_UNSUPPORTED;
  }
  iftPut(&par->h, "program", ift->item[i].value, 0, NULL);
 
  /* Get analysis time from IFT struct */
  i=iftFindKey(ift, "Date", 0);
  if(i>=0) iftPut(&par->h, "analysis_time", ift->item[i].value, 0, NULL);
 
  /* Study number */
  i=iftFindKey(ift, "Study", 0);
  if(i>=0) iftPut(&par->h, "studynr", ift->item[i].value, 0, NULL);
 
  /* Optional filenames etc */
  i=iftFindKey(ift, "Data file", 0);
  if(i>=0) iftPut(&par->h, "datafile", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Plasma file", 0);
  if(i>=0) iftPut(&par->h, "plasmafile", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "2nd plasma file", 0);
  if(i>=0) iftPut(&par->h, "plasmafile2", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Blood file", 0);
  if(i>=0) iftPut(&par->h, "bloodfile", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Reference file", 0);
  if(i>=0) iftPut(&par->h, "reffile", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Reference region", 0);
  if(i>=0) iftPut(&par->h, "refname", ift->item[i].value, 0, NULL);
 
  /* Fit method (optional) */
  i=iftFindKey(ift, "Fit method", 0);
  if(i>=0) iftPut(&par->h, "fitmethod", ift->item[i].value, 0, NULL);
 
  /* Constants (optional) */
  i=iftFindKey(ift, "Tissue density", 0);
  if(i>=0) iftPut(&par->h, "density", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Lumped constant", 0);
  if(i>=0) iftPut(&par->h, "LC", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Concentration", 0);
  if(i>=0) iftPut(&par->h, "concentration", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Beta", 0);
  if(i>=0) iftPut(&par->h, "beta", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Vb", 0);
  if(i>=0) iftPut(&par->h, "Vb", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "fA", 0);
  if(i>=0) iftPut(&par->h, "fA", ift->item[i].value, 0, NULL);
  i=iftFindKey(ift, "Extraction", 0);
  if(i>=0) iftPut(&par->h, "E", ift->item[i].value, 0, NULL);
 
  /* Weighting (obligatory) */
  if(verbose>2) printf("searching obligatory information on weighting\n");
  if(iftSearchValue(ift, "not weighted", 0)>=0) {
    iftPut(&par->h, "weighting", "no", 0, NULL);
  } else if(iftSearchValue(ift, "was weighted", 0)>=0) {
    iftPut(&par->h, "weighting", "yes", 0, NULL);
  } else {
    i=iftFindKey(ift, "Weighting", 0);
    if(i>=0) { 
      iftPut(&par->h, "weighting", ift->item[i].value, 0, NULL);
    } else {
      parFree(par);
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
      return TPCERROR_INVALID_FORMAT;
    }
  }
 
  /* Read parameter names (possibly reorganized later) */
  ri=titlerow; ci=1; cptr=csvCell(csv, ri, ci);
  if(strlen(cptr)<1) {ci++; cptr=csvCell(csv, ri, ci);}  
  for(i=0; i<parNr; i++) {
    strlcpy(par->n[i].name, cptr, MAX_PARNAME_LEN);
    ci++; cptr=csvCell(csv, ri, ci);
  }
 
  /* Read parameter values for each region */
  int tac=0;
  double *dptr;
  ri=1+titlerow; ret=TPCERROR_OK;
  do {
    ci=0; cptr=csvCell(csv, ri, ci); 
    if(cptr==NULL) {if(tac<tacNr) ret=TPCERROR_INVALID_FORMAT; break;}
    //printf("  cell='%s'\n", cptr);
    //printf("  ri=%d ci=%d tac=%d\n", ri, ci, tac);
    /* check if this is SD line */
    dptr=NULL;
    if(csv->separator==' ') {
      if(!strcasecmp(cptr, "SD")) {
        if(tac<1) {ret=TPCERROR_INVALID_FORMAT; break;}
        ci=3; dptr=par->r[tac-1].sd;
      } else if(!strcasecmp(cptr, "CL")) {
        if(tac<1) {ret=TPCERROR_INVALID_FORMAT; break;}
        if(!strcasecmp(csvCell(csv, ri, 2), "Lower")) {
          ci=3; dptr=par->r[tac-1].cl1;
        } else if(!strcasecmp(csvCell(csv, ri, 2), "Upper")) {
          ci=3; dptr=par->r[tac-1].cl2;
        }
      }
    } else {
      if(!strncasecmp(cptr, "SD . .", 3)) {
        if(tac<1) {ret=TPCERROR_INVALID_FORMAT; break;}
        ci=1; dptr=par->r[tac-1].sd;
      } else if(!strncasecmp(cptr, "CL 95% Lower", 8)) {
        if(tac<1) {ret=TPCERROR_INVALID_FORMAT; break;}
        ci=1; dptr=par->r[tac-1].cl1;
      } else if(!strncasecmp(cptr, "CL 95% Upper", 8)) {
        if(tac<1) {ret=TPCERROR_INVALID_FORMAT; break;}
        ci=1; dptr=par->r[tac-1].cl2;
      }
    }
    if(dptr!=NULL) {
      //printf("  sd or cl\n");
      for(i=0; i<parNr; i++) {
        cptr=csvCell(csv, ri, ci);
        if(cptr==NULL) {ret=TPCERROR_INVALID_FORMAT; break;}
        dptr[i]=atofVerified(cptr);
        ci++;
      }
      ri++; continue;
    }
    if(tac>=tacNr) break;
    //printf("  param\n");
    /* copy tac name */
    strlcpy(par->r[tac].name, cptr, MAX_TACNAME_LEN);
    if(csv->separator==' ') {
      ci++; cptr=csvCell(csv, ri, ci);
      strlcat(par->r[tac].name, " ", MAX_TACNAME_LEN);
      strlcat(par->r[tac].name, cptr, MAX_TACNAME_LEN);
      ci++; cptr=csvCell(csv, ri, ci);
      strlcat(par->r[tac].name, " ", MAX_TACNAME_LEN);
      strlcat(par->r[tac].name, cptr, MAX_TACNAME_LEN);
    }
    /* copy parameter values */
    ci++; //cptr=csvCell(csv, ri, ci); //if(strlen(cptr)<1) ci++;
    for(i=0; i<parNr; i++) {
      cptr=csvCell(csv, ri, ci);
      if(cptr==NULL) {ret=TPCERROR_INVALID_FORMAT; break;}
      par->r[tac].p[i]=atofVerified(cptr);
      ci++;
    }
    if(ret!=TPCERROR_OK) break;
    ri++; tac++;
  } while(1);
  if(ret!=TPCERROR_OK) {
    parFree(par);
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  /* Read parameter units, if available */
  i=iftFindKey(ift, "Units", 0);
  if(i>0) {
    int n=strTokenNr(ift->item[i].value, " \t");
    if(n>parNr) n=parNr;
    char tmp[256];
    for(int j=0; j<n; j++) {
      strTokenNCpy(ift->item[i].value, " \t", 1+j, tmp, 256);
      par->n[j].unit=unitIdentify(tmp);
    }
  }
 
  /* Fix region names (mainly, remove dots) */
  {
    int i, tac;
    char fnsp[3][MAX_TACNAME_LEN+1];
    for(tac=0; tac<par->tacNr; tac++) {
      for(i=0; i<3; i++) {
        if(roinameSubpart(par->r[tac].name, "_ ", i, fnsp[i], MAX_TACNAME_LEN)==NULL ||
           strcmp(fnsp[i], ".")==0)
          strcpy(fnsp[i], "");
      }
      strcpy(par->r[tac].name, fnsp[0]);
      if(strlen(fnsp[1]) || strlen(fnsp[2])) strcat(par->r[tac].name, "_");
      if(strlen(fnsp[1])) strcat(par->r[tac].name, fnsp[1]);
      if(strlen(fnsp[2])) {
        strcat(par->r[tac].name, "_"); strcat(par->r[tac].name, fnsp[2]);}
    }
  }
 
  /* Data range (optional) */
  i=iftFindKey(ift, "Data range", 0);
  if(i>=0) {
    double t1, t2;
    char tmp[256];
    int n;
    n=sscanf(ift->item[i].value, "%lf - %lf %s", &t1, &t2, tmp);
    if(n==3 && unitIdentify(tmp)==UNIT_SEC) {
      t1/=60.; t2/=60.;
    }
    if(n>=2) for(i=0; i<par->tacNr; i++) {par->r[i].start=t1; par->r[i].end=t2;}
  }
 
 
  /* Data nr (optional) */
  i=iftFindKey(ift, "Data nr", 0);
  if(i>=0) {
    int n; n=atoi(ift->item[i].value);
    for(i=0; i<par->tacNr; i++) par->r[i].dataNr=n;
  }
 
  /* If one 'parameter' is named WSS or SS, then move its contents to
     correct place inside the struct */
  ci=-1;
  for(i=0; i<par->parNr; i++) {
    if(!strcasecmp(par->n[i].name, "WSS") || !strcasecmp(par->n[i].name, "SS"))
      ci=i;
  }
  if(ci>=0 && ci<par->parNr && par->parNr>1) {
    if(verbose>4) printf("column %d contains WSS, moving to correct place\n", 1+ci);
    for(i=0; i<par->tacNr; i++) par->r[i].wss=par->r[i].p[ci];
    /* delete the parameter column */
    parDeletePar(par, ci);
  }
 
  /* Set format in struct */
  par->format=PAR_FORMAT_RES;
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parRead().

parrFree()

void parrFree ( PARR * parr )

extern

Free memory allocated for PARR. All data is cleared.

Parameters

parr	Pointer to PARR struct

Definition at line 87 of file par.c.

  {
  if(parr==NULL) return;
  free(parr->p);
  free(parr->sd);
  free(parr->cl1);
  free(parr->cl2);
  parrInit(parr);
}

Referenced by parDeleteTAC(), parFree(), and parrAllocate().

parrInit()

void parrInit ( PARR * parr )

extern

Initiate the PARR struct before any use.

Author

Vesa Oikonen

See also

parInit, parnInit

Parameters

parr	Pointer to PARR

Definition at line 41 of file par.c.

  {
  if(parr==NULL) return;
  parr->model=0;
  parr->name[0]='\0';
  parr->start=parr->end=nan("");
  parr->fitNr=0;
  parr->dataNr=0;
  parr->p=parr->sd=parr->cl1=parr->cl2=NULL;
  parr->wss=nan("");
  parr->sw=0;
}

Referenced by parAllocate(), parAllocateMore(), parDeleteTAC(), and parrFree().

parSDWithPar()

int parSDWithPar ( PAR * par, int pi )

extern

Check if specified parameter has SD in at least one of the regions.

See also

parCLWithPar, parIsWSS

Returns

Returns 1 if SD exists, and 0 if not (or in case of an error).

Parameters

par	Pointer to parameter data.
pi	Index of parameter [0..parNr-1] to check.

Definition at line 307 of file par.c.

  {
  //printf("%s(%d)\n", __func__, pi); fflush(stdout);
  if(par==NULL || par->tacNr<1 || pi<0 || pi>=par->parNr) return(0);
  for(int i=0; i<par->tacNr; i++) if(!isnan(par->r[i].sd[pi])) return(1);
  return(0);
}

Referenced by parWriteCSV(), and parWriteXML().

parSelectByAnother()

int parSelectByAnother	(	PAR *	d1,
		PAR *	d2,
		int *	pn,
		int *	pr,
		TPCSTATUS *	status )

Select parameters and regions in a PAR structure that are available in another PAR structure.

Returns

enum tpcerror (TPCERROR_OK when successful).

See also

parSelectTACs, parEnsureNames, parCompareParameterNames, parCompareTacNames, parSelectedParameters, parSelectedTACs

Parameters

d1	Pointer to target PAR structure, in which the PARN and PARR switches are set.
d2	Pointer to PAR structure to which the first is compared to; not modified.
pn	Pointer to store the number of available parameters; enter NULL, if not needed.
pr	Pointer to store the number of available regions; enter NULL, if not needed.
status	Pointer to status data; enter NULL if not needed.

Definition at line 22 of file parcomb.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(verbose>0) printf("%s()\n", __func__);
  if(pn!=NULL) *pn=0;
  if(pr!=NULL) *pr=0;
  /* Check that required data exists */
  if(d1==NULL || d1->parNr<1 || d1->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  /* Unselect all */
  for(int i=0; i<d1->parNr; i++) d1->n[i].sw=0;
  for(int i=0; i<d1->tacNr; i++) d1->r[i].sw=0;
  /* If no data to compare to, then that is it */
  if(d2==NULL || d2->parNr<1 || d2->tacNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
    return TPCERROR_OK;
  }
 
  /* Search for parameter names */
  for(int i=0; i<d1->parNr; i++) {
    if(strnlen(d1->n[i].name, 1)<1) continue;
    for(int j=0; j<d2->parNr; j++) {
      if(strnlen(d2->n[j].name, 1)<1) continue;
      if(strcasecmp(d1->n[i].name, d2->n[j].name)==0) {d1->n[i].sw=1; continue;}
      /* Allow mixed '-' and '_' */
      char *buf1, *buf2;
      buf1=strdup(d1->n[i].name); strReplaceChar(buf1, '-', '_');
      buf2=strdup(d2->n[j].name); strReplaceChar(buf2, '-', '_');
      int ret=strcasecmp(buf1, buf2);
      free(buf1); free(buf2);
      if(ret==0) {d1->n[i].sw=1; continue;}
    }
  }
 
  /* Search for TAC names */
  for(int i=0; i<d1->tacNr; i++) {
    if(strnlen(d1->r[i].name, 1)<1) continue;
    for(int j=0; j<d2->tacNr; j++) {
      if(strnlen(d2->r[j].name, 1)<1) continue;
      if(strcasecmp(d1->r[i].name, d2->r[j].name)==0) {d1->r[i].sw=1; continue;}
      /* Allow mixed '-' and '_' */
      char *buf1, *buf2;
      buf1=strdup(d1->r[i].name); strReplaceChar(buf1, '-', '_');
      buf2=strdup(d2->r[j].name); strReplaceChar(buf2, '-', '_');
      int ret=strcasecmp(buf1, buf2);
      free(buf1); free(buf2);
      if(ret==0) {d1->r[i].sw=1; continue;}
    }
  }
 
  /* Count the selected numbers, if needed */
  if(pn!=NULL) *pn=parSelectedParameters(d1);
  if(pr!=NULL) *pr=parSelectedTACs(d1);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return TPCERROR_OK;
}

Referenced by parCombineTACs().

parSelectedParameters()

int parSelectedParameters ( PAR * d )

extern

Get the number of selected parameters (sw!=0) in PAR structure.

Returns

the number of selected parameters.

Author

Vesa Oikonen

See also

parSelectParameters, parFindParameter, parSelectByAnother

Parameters

d	Pointer to PAR data

Definition at line 199 of file parselect.c.

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

Referenced by parSelectByAnother().

parSelectedTACs()

int parSelectedTACs ( PAR * d )

extern

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

Returns

the number of selected TACs.

Author

Vesa Oikonen

See also

parSelectTACs, parSortByName, parSelectByAnother

Parameters

d	Pointer to PAR data.

Definition at line 100 of file parselect.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->r[ri].sw!=0) n++;
  return(n);
}

Referenced by parSelectByAnother().

parSelectParameters()

int parSelectParameters ( PAR * d, const char * par_name, int reset, TPCSTATUS * status )

extern

Select the parameter(s) in PAR struct that have matching name or number.

Returns

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

Author

Vesa Oikonen

See also

parSelectedParameters, parFindParameter, parSelectTACs, parSelectByAnother, parEnsureNames

Parameters

d	Pointer to PAR structure.
par_name	Name of parameter, or parameter numbers (as string, for example '1-3' or '1,2,3'); string can be given with quotation marks. Enter NULL to select all parameters, or empty string to select parameters with empty name (which really should not exist).
reset	1=Non-matching parameters are deselected, 0=Old selections are preserved.
status	Pointer to status data; enter NULL if not needed.

Definition at line 120 of file parselect.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->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return(0);
  }
 
  int pi, len, match_nr=0;
 
  /* Check if NULL was given as parameter name; if, then select all */
  if(par_name==NULL) {
    for(pi=0; pi<d->parNr; pi++) d->n[pi].sw=1;
    return(d->parNr);
  }
 
  /* Reset all selections if required */
  if(reset!=0) for(pi=0; pi<d->parNr; pi++) d->n[pi].sw=0;
  
  /* Remove any quotation marks from the name */
  len=strlen(par_name);
  char local_name[len+1];
  if(len>1) len=strncpyClean(local_name, par_name, len+1);
  else strcpy(local_name, par_name);
 
  /* If parameter name is empty, then select all tacs with missing names */
  if(len<1 || strcmp(local_name, ".")==0) {
    for(pi=0; pi<d->parNr; pi++) {
      if(strlen(d->n[pi].name)==0) {d->n[pi].sw=1; match_nr++; continue;}
      /* maybe here should also be checked for names consisting of only space characters */
    }
    return(match_nr);
  }
 
  /* Check each parameter name */
  for(pi=0; pi<d->parNr; pi++) {
    /* does the name match? */
    if(strcasecmp(d->n[pi].name, local_name)==0) {
      d->n[pi].sw=1; match_nr++; continue;
    }
  }
  /* If at least one match was found, then we are ready */
  if(match_nr>0) return(match_nr);
 
  /* Since there was no match with names, we'll try with numbers */
  INTLIST li; intlistInit(&li);
  if(intlistExpandFromString(local_name, ", ", &li, 1)<1) {intlistFree(&li); return(0);}
  intlistSort(&li);
  for(int i=0; i<li.nr; i++) {
    if(li.i[i]<1) continue;
    if(li.i[i]>d->parNr) break;
    d->n[li.i[i]-1].sw=1; match_nr++;
  }
  intlistFree(&li);
 
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(match_nr);
}

parSelectTACs()

int parSelectTACs ( PAR * d, const char * region_name, int reset, TPCSTATUS * status )

extern

Select the TAC(s) in PAR structure 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

parSelectedTACs, parSelectParameters, parSortByName, parSelectByAnother, parEnsureNames

Parameters

d	Pointer to PAR structure.
region_name	Name of TAC, or TAC numbers (as string, for example '1-3' or '1,2,3'); string can be given with quotation marks. Enter NULL to select all TACs, or empty string to select TACs with empty name fields (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 parselect.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->r[ri].sw=1;
    return(d->tacNr);
  }
 
  /* Reset all selections if required */
  if(reset!=0) for(ri=0; ri<d->tacNr; ri++) d->r[ri].sw=0;
  
  /* Remove any quotation marks from the 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 || strcmp(local_name, ".")==0) {
    for(ri=0; ri<d->tacNr; ri++) {
      if(strlen(d->r[ri].name)==0) {d->r[ri].sw=1; match_nr++; continue;}
      /* maybe here should also be checked for names consisting of only space characters */
    }
    return(match_nr);
  }
 
  /* Check each TAC name */
  for(ri=0; ri<d->tacNr; ri++) {
    /* does the name match? */
    if(roinameMatch(d->r[ri].name, local_name, status)!=0) {d->r[ri].sw=1; match_nr++; continue;}
  }
  /* If at least one match was found, then we are ready */
  if(match_nr>0) return(match_nr);
 
  /* Since there was no match with names, we'll try with numbers */
  INTLIST li; intlistInit(&li);
  if(intlistExpandFromString(local_name, ", ", &li, 1)<1) {intlistFree(&li); return(0);}
  intlistSort(&li);
  for(int i=0; i<li.nr; i++) {
    if(li.i[i]<1) continue;
    if(li.i[i]>d->tacNr) break;
    d->r[li.i[i]-1].sw=1; match_nr++;
  }
  intlistFree(&li);
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(match_nr);
}

parSetStudyNr()

int parSetStudyNr ( PAR * par, const char * s )

extern

Set study number in PAR data, overwriting any previous study number.

See also

parIsStudyNr, tacSetHeaderStudynr, tacGetHeaderStudynr, studynrFromFilename

Returns

enum tpcerror (TPCERROR_OK when successful).

Parameters

par	Pointer to parameter data.
s	Pointer to string containing the study number; enter NULL or "" if you only want to delete studynr in header.

Definition at line 417 of file par.c.

  {
  if(par==NULL) return TPCERROR_FAIL;
 
  /* Find and delete previous studynr(s) */
  int i=0, start=0;
  while(1) {
    i=iftFindKey(&par->h, "studynr", start);
    if(i<0) i=iftFindKey(&par->h, "study_number", start);
    if(i<0) i=iftFindKey(&par->h, "study number", start);
    if(i<0) break;
    iftDelete(&par->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(&par->h, "studynr", s, (char)1, NULL));
}

parSortByName()

int parSortByName ( PAR * d, TPCSTATUS * status )

extern

Sort TACs in alphabetical order by their TAC name.

Returns

enum tpcerror (TPCERROR_OK when successful).

See also

parSelectTACs, tacSortByName, parEnsureNames

Parameters

d	Pointer to PAR struct.
status	Pointer to status data; enter NULL if not needed.

Definition at line 30 of file parorder.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;
  }
  if(d->tacNr>d->_tacNr) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  if(d->tacNr<2) return TPCERROR_OK;
  qsort(d->r, d->tacNr, sizeof(PARR), parQSortName);
  return TPCERROR_OK;
}

parToIFT()

int parToIFT ( PAR * par, IFT * ift, TPCSTATUS * status )

extern

Copy PAR data into IFT struct.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to source PAR struct, contents of which are to be copied
ift	Pointer to initiated target IFT struct; any previous contents are deleted
status	Pointer to status data; enter NULL if not needed

Definition at line 24 of file parift.c.

  {
  int verbose=0; if(status!=NULL) verbose=status->verbose;
  if(ift==NULL) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
  if(verbose>0) printf("%s():\n", __func__);
  if(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Set decimal and item separators */
  int tointl=0;
  if(par->format==PAR_FORMAT_CSV_INT || par->format==PAR_FORMAT_TSV_INT)
    tointl=1;
 
  int ret;
  char tmp[128];
 
  /* Set content id */
  ret=iftPut(ift, "content", "parameters", 1, NULL);
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  /* Copy PAR headers */
  sprintf(tmp, "%d", par->parNr);
  ret=iftPut(ift, "par_nr", tmp, 1, NULL);
  for(int i=0; i<par->h.keyNr && ret==TPCERROR_OK; i++) {
    /* not if value is missing */
    if(par->h.item[i].value==NULL || strlen(par->h.item[i].value)<1) continue;
    /* not if key is missing */
    if(par->h.item[i].key==NULL || strlen(par->h.item[i].key)<1) continue;
    /* not if this will be written later */
    if(strcasecmp(par->h.item[i].key, "model")==0) continue;
    if(strcasecmp(par->h.item[i].key, "dataNr")==0) continue;
    if(strcasecmp(par->h.item[i].key, "fitNr")==0) continue;
    if(strcasecmp(par->h.item[i].key, "fit_start")==0) continue;
    if(strcasecmp(par->h.item[i].key, "fit_end")==0) continue;
    /* ok to copy */
    ret=iftPut(ift, par->h.item[i].key, par->h.item[i].value, 1, NULL);
  }
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
 
  if(parIsModel(par)==1) {
    sprintf(tmp, "%d", par->r[0].model);
    iftPut(ift, "model", tmp, 0, NULL);
  }
  if(parIsDataNr(par)==1) {
    sprintf(tmp, "%d", par->r[0].dataNr);
    iftPut(ift, "data_nr", tmp, 0, NULL);
  }
  if(parIsFitNr(par)==1) {
    sprintf(tmp, "%d", par->r[0].fitNr);
    iftPut(ift, "fit_nr", tmp, 0, NULL);
  }
  if(parIsFitRange(par)==1) {
    sprintf(tmp, "%g min", par->r[0].start);
    if(tointl) strReplaceChar(tmp, '.', ',');
    iftPut(ift, "fit_start", tmp, 0, NULL);
    sprintf(tmp, "%g min", par->r[0].end);
    if(tointl) strReplaceChar(tmp, '.', ',');
    iftPut(ift, "fit_end", tmp, 0, NULL);
  }
 
  /* Copy parameter table contents into IFT */
  int ri, pi;
  for(ri=0; ri<par->tacNr; ri++) {
    sprintf(tmp, "%d", 1+ri);
    iftPut(ift, "parameter-set", tmp, 0, NULL);
    iftPut(ift, "tac_name", par->r[ri].name, 0, NULL);
    if(parIsModel(par)==2) {
      sprintf(tmp, "%d", par->r[ri].model);
      iftPut(ift, "model", tmp, 0, NULL);
    }
    if(parIsDataNr(par)==2) {
      sprintf(tmp, "%d", par->r[ri].dataNr);
      iftPut(ift, "dataNr", tmp, 0, NULL);
    }
    if(parIsFitNr(par)==2) {
      sprintf(tmp, "%d", par->r[ri].fitNr);
      iftPut(ift, "fitNr", tmp, 0, NULL);
    }
    if(parIsFitRange(par)==2) {
      sprintf(tmp, "%g min", par->r[ri].start);
      if(tointl) strReplaceChar(tmp, '.', ',');
      iftPut(ift, "fit_start", tmp, 0, NULL);
      sprintf(tmp, "%g min", par->r[ri].end);
      if(tointl) strReplaceChar(tmp, '.', ',');
      iftPut(ift, "fit_end", tmp, 0, NULL);
    }
    if(!isnan(par->r[ri].wss)) {
      sprintf(tmp, "%g", par->r[ri].wss);
      if(tointl) strReplaceChar(tmp, '.', ',');
      iftPut(ift, "wss", tmp, 0, NULL);
    }
    for(pi=0; pi<par->parNr; pi++) if(!isnan(par->r[ri].p[pi])) {
      if(par->n[pi].unit==UNIT_UNKNOWN) sprintf(tmp, "%g", par->r[ri].p[pi]);
      else sprintf(tmp, "%g %s", par->r[ri].p[pi], unitName(par->n[pi].unit));
      if(tointl) strReplaceChar(tmp, '.', ',');
      iftPut(ift, par->n[pi].name, tmp, 0, NULL);
      if(!isnan(par->r[ri].sd[pi])) {
        sprintf(tmp, "%g", par->r[ri].sd[pi]);
        if(tointl) strReplaceChar(tmp, '.', ',');
        iftPut(ift, "SD", tmp, 0, NULL);
      }
      if(!isnan(par->r[ri].cl1[pi])) {
        sprintf(tmp, "%g", par->r[ri].cl1[pi]);
        if(tointl) strReplaceChar(tmp, '.', ',');
        iftPut(ift, "95%CL1", tmp, 0, NULL);
      }
      if(!isnan(par->r[ri].cl2[pi])) {
        sprintf(tmp, "%g", par->r[ri].cl2[pi]);
        if(tointl) strReplaceChar(tmp, '.', ',');
        iftPut(ift, "95%CL2", tmp, 0, NULL);
      }
    } // next parameter
  } // next tac
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  return(ret);
}

Referenced by parWriteIFT().

parValueRange()

void parValueRange ( PAR * d, const int i, double * pmin, double * pmax )

extern

Finds the min and max parameter value in PAR structure.

Author

Vesa Oikonen

See also

parFindParameter, parGetParameter, parSelectParameters

Parameters

d	Pointer to PAR structure.
i	Parameter index [0..parNr-1].
pmin	Pointer to min parameter value; NULL if not needed.
pmax	Pointer to max parameter value; NULL if not needed.

Definition at line 287 of file parselect.c.

  {
  if(pmin!=NULL) *pmin=nan("");
  if(pmax!=NULL) *pmax=nan("");
  if(d==NULL || i<0 || i>=d->parNr || d->tacNr<1) return;
  
  double mi, ma; mi=ma=d->r[0].p[i];
  for(int j=1; j<d->tacNr; j++) {
    if(d->r[j].p[i]<mi) mi=d->r[j].p[i];
    else if(d->r[j].p[i]>ma) ma=d->r[j].p[i];
  }
  if(pmin!=NULL) *pmin=mi;
  if(pmax!=NULL) *pmax=ma;
  return;
}

parWrite()

int parWrite ( PAR * par, FILE * fp, parformat format, int extra, TPCSTATUS * status )

extern

Write PAR data into specified file in specified format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parRead, parFree, parAllocate, parFormatFromExtension

Parameters

par	Pointer to PAR struct, contents of which are to be written.
fp	Output file pointer.
format	File format code; enter PAR_FORMAT_UNKNOWN (0) to write data in the format specified inside the PAR struct.
extra	Write (1) or do not write (0) also extra header fields found in PAR; only effective with CSV formats.
status	Pointer to status data; enter NULL if not needed.

Definition at line 148 of file pario.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(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
  if(par->tacNr>par->_tacNr || par->parNr>par->_parNr) { // programmers fail
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
    return TPCERROR_FAIL;
  }
 
  /* Determine and verify the write format */
  if(format<=PAR_FORMAT_UNKNOWN || format>=PAR_FORMAT_LAST)
    format=par->format;
  if(format<=PAR_FORMAT_UNKNOWN || format>=PAR_FORMAT_LAST) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(verbose>0) {
    printf("%s():\n", __func__);
    printf("writing %d parameters from %d TACs in %s format\n",
      par->parNr, par->tacNr, parFormattxt(format));
    fflush(stdout);
  }
 
  /* Write file */
  int ret;
  switch(format) {
    case PAR_FORMAT_CSV_INT:
      /* __attribute__((fallthrough)); */
    case PAR_FORMAT_CSV_UK:
      /* __attribute__((fallthrough)); */
    case PAR_FORMAT_TSV_INT:
      /* __attribute__((fallthrough)); */
    case PAR_FORMAT_TSV_UK:
      ret=parWriteCSV(par, fp, format, extra, status);
      break;
    case PAR_FORMAT_RES:
      ret=parWriteRES(par, fp, status);
      break;
    case PAR_FORMAT_FIT:
      ret=parWriteFIT(par, fp, status);
      break;
    case PAR_FORMAT_IFT:
      ret=parWriteIFT(par, fp, status);
      break;
    case PAR_FORMAT_XML:
      ret=parWriteXML(par, fp, status);
      break;
    default:
      ret=TPCERROR_INVALID_FORMAT;
  }
  fflush(fp); fflush(stderr);
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  return(ret);
}

parWriteCSV()

int parWriteCSV ( PAR * par, FILE * fp, parformat format, int extra, TPCSTATUS * status )

extern

Write PAR data into specified file pointer in specified CSV or TSV format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parReadCSV, parWrite

Parameters

par	Pointer to source PAR structure, contents of which are to be written.
fp	Output file pointer.
format	File format code; enter PAR_FORMAT_UNKNOWN (0) to write data in the format specified inside PAR structure.
extra	Write (1) or do not write (0) also extra header fields found in PAR.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file parcsv.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(verbose>0) {printf("%s():\n", __func__); fflush(stdout);}
  if(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Determine and verify the write format */
  if(format<=PAR_FORMAT_UNKNOWN || format>=PAR_FORMAT_LAST) format=par->format;
  /* Set decimal and item separators */
  int tointl=0;
  char separator;
  if(format==PAR_FORMAT_CSV_INT) {
    tointl=1; separator=';';
  } else if(format==PAR_FORMAT_CSV_UK) {
    tointl=0; separator=',';
  } else if(format==PAR_FORMAT_TSV_INT) {
    tointl=1; separator='\t';
  } else if(format==PAR_FORMAT_TSV_UK) {
    tointl=0; separator='\t';
  } else {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
    return TPCERROR_INVALID_FORMAT;
  }
  if(verbose>0) {
    printf("writing %d parameters from %d TACs in %s format\n",
      par->parNr, par->tacNr, parFormattxt(format));
  }
 
  int ret;
 
  /* Write header if requested */
  if(extra) {
    if(verbose>1) printf("  add common info into header\n");
    char tmp[128];
    if(parIsModel(par)==1) { // same model in each TAC
      iftDeleteKey(&par->h, "model");
      sprintf(tmp, "%s", modelCode(par->r[0].model));
      iftPut(&par->h, "model", tmp, 1, NULL);
    }
    if(parIsDataNr(par)==1) {
      iftDeleteKey(&par->h, "dataNr");
      sprintf(tmp, "%d", par->r[0].dataNr);
      iftPut(&par->h, "dataNr", tmp, 1, NULL);
    }
    if(parIsFitNr(par)==1) {
      iftDeleteKey(&par->h, "fitNr");
      sprintf(tmp, "%d", par->r[0].fitNr);
      iftPut(&par->h, "fitNr", tmp, 1, NULL);
    }
    if(parIsFitRange(par)==1) {
      char unittext[60];
      int tunit=UNIT_UNKNOWN;
      int i=iftFindKey(&par->h, "timeunit", 0);
      if(i<0) i=iftFindKey(&par->h, "time_unit", 0);
      if(i>=0) tunit=unitIdentify(par->h.item[i].value);
      if(unitIsTime(tunit)) sprintf(unittext, " %s", unitName(tunit)); else strcpy(unittext, "");
      iftDeleteKey(&par->h, "fit_start");
      sprintf(tmp, "%g%s", par->r[0].start, unittext);
      iftPut(&par->h, "fit_start", tmp, 1, NULL);
      iftDeleteKey(&par->h, "fit_end");
      sprintf(tmp, "%g%s", par->r[0].end, unittext);
      iftPut(&par->h, "fit_end", tmp, 1, NULL);
    }
    if(verbose>1) {printf("  writing parameter header\n"); fflush(stdout);}
    for(int i=0; i<par->h.keyNr; i++) par->h.item[i].comment=1;
    ret=iftWrite(&par->h, fp, status); if(ret!=TPCERROR_OK) return ret;
    //fprintf(fp, "\n");
    fflush(fp);
  }
 
  /* Allocate initial space for CSV structure; more will be added later when necessary */
  CSV csv; csvInit(&csv);
  ret=csvAllocate(&csv, (par->parNr+1)*(par->tacNr+1));
  if(ret!=TPCERROR_OK) {
    if(verbose>1) {fprintf(stderr, "Error: cannot allocate memory for CSV.\n"); fflush(stderr);}
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    return ret;
  }
  csv.separator=separator;
 
  /* Write parameter table into CSV */
  if(verbose>1) {printf("  writing parameter table\n"); fflush(stdout);}
  int pi, ri;
  /* Parameter names */
  if(verbose>2) {printf("  writing parameter names\n"); fflush(stdout);}
  char pstr[MAX_PARNAME_LEN+MAX_UNITS_LEN+3];
  ret=csvPutString(&csv, "Parameters", 0);
  /* Column for model id, if different models fitted to TACs */
  if(parIsModel(par)==2 && ret==TPCERROR_OK) 
    ret=csvPutString(&csv, "Model", 0);
  for(pi=0; pi<par->parNr && ret==TPCERROR_OK; pi++) {
    if(par->n[pi].unit==UNIT_UNKNOWN) {
      ret=csvPutString(&csv, par->n[pi].name, 0);
    } else {
      sprintf(pstr, "%s[%s]", par->n[pi].name, unitName(par->n[pi].unit));
      ret=csvPutString(&csv, pstr, 0);
    }
    if(ret==TPCERROR_OK && parSDWithPar(par, pi)) {
      ret=csvPutString(&csv, "SD", 0);
    }
    if(ret==TPCERROR_OK && parCLWithPar(par, pi)) {
      ret=csvPutString(&csv, "95%CL1", 0);
      if(ret==TPCERROR_OK) ret=csvPutString(&csv, "95%CL2", 0);
    }
  }
  if(ret==TPCERROR_OK && parIsWSS(par))
    ret=csvPutString(&csv, "WSS", 0);
  if(ret==TPCERROR_OK && parIsFitRange(par)==2) {
    ret=csvPutString(&csv, "Start[min]", 0);
    if(ret==TPCERROR_OK) ret=csvPutString(&csv, "End[min]", 0);
  }
  if(ret==TPCERROR_OK && parIsDataNr(par)==2)
    ret=csvPutString(&csv, "DataNr", 0);
  if(ret==TPCERROR_OK && parIsFitNr(par)==2)
    ret=csvPutString(&csv, "FitNr", 0);
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); return ret;
  }
  /* Data table */
  if(verbose>2) {printf("  writing parameter values\n"); fflush(stdout);}
  for(ri=0; ri<par->tacNr && ret==TPCERROR_OK; ri++) {
    if(verbose>3) {printf("    for region %d\n", 1+ri); fflush(stdout);}
    /* Region names and parameter values */
    if(strlen(par->r[ri].name)>0) {
      ret=csvPutString(&csv, par->r[ri].name, 1);
    } else {
      char buf[16]; sprintf(buf, "tac%d", 1+ri);
      ret=csvPutString(&csv, buf, 1);
    }
    if(parIsModel(par)==2 && ret==TPCERROR_OK)
      ret=csvPutString(&csv, modelCode(par->r[ri].model), 0);
    for(pi=0; pi<par->parNr && ret==TPCERROR_OK; pi++) {
      ret=csvPutDouble(&csv, par->r[ri].p[pi], 0, tointl);
      if(ret==TPCERROR_OK && parSDWithPar(par, pi))
        ret=csvPutDouble(&csv, par->r[ri].sd[pi], 0, tointl);
      if(ret==TPCERROR_OK && parCLWithPar(par, pi)) {
        ret=csvPutDouble(&csv, par->r[ri].cl1[pi], 0, tointl);
        if(ret==TPCERROR_OK)
          ret=csvPutDouble(&csv, par->r[ri].cl2[pi], 0, tointl);
      }
    }
    /* WSS etc */
    if(ret==TPCERROR_OK && parIsWSS(par))
      ret=csvPutDouble(&csv, par->r[ri].wss, 0, tointl);
    if(ret==TPCERROR_OK && parIsFitRange(par)==2) {
      ret=csvPutDouble(&csv, par->r[ri].start, 0, tointl);
      if(ret==TPCERROR_OK) ret=csvPutDouble(&csv, par->r[ri].end, 0, tointl);
    }
    if(ret==TPCERROR_OK && parIsDataNr(par)==2)
      ret=csvPutInt(&csv, par->r[ri].dataNr, 0);
    if(ret==TPCERROR_OK && parIsFitNr(par)==2)
      ret=csvPutInt(&csv, par->r[ri].fitNr, 0);
  }
  if(ret!=TPCERROR_OK) {
    statusSet(status, __func__, __FILE__, __LINE__, ret);
    csvFree(&csv); return ret;
  }
 
  /* Write CSV into file pointer */
  if(verbose>2) {printf("  actually writing CSV in file\n"); fflush(stdout);}
  ret=csvWrite(&csv, 0, fp, status);
  csvFree(&csv); fflush(fp);
  if(ret!=TPCERROR_OK) {csvFree(&csv); return ret;}
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, ret);
  return(ret);
}

Referenced by parWrite().

parWriteFIT()

int parWriteFIT ( PAR * par, FILE * fp, TPCSTATUS * status )

extern

Write FIT data into specified file pointer in (old) fit file format.

See also

parWrite

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to PAR struct, contents of which are to be written.
fp	Output file pointer.
status	Pointer to status data; enter NULL if not needed.

Definition at line 27 of file parfit.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(verbose>0) printf("%s():\n", __func__);
  if(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  int i, j, n;
  char tmp[256];
 
  /* Write magic string and fit program name */
  i=iftFindKey(&par->h, "program", 0);
  if(i<0 || !strnlen(par->h.item[i].value, 10)) strcpy(tmp, "libtpcpar");
  else strlcpy(tmp, par->h.item[i].value, 256);
  n=fprintf(fp, "%-11.11s %s\n", "FIT1", tmp);
  if(n<5) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Write fit date and time */
  i=iftFindKey(&par->h, "analysis_time", 0);
  if(i>=0) strlcpy(tmp, par->h.item[i].value, 256); else strcpy(tmp, "");
  fprintf(fp, "Date:\t%s\n", tmp);
 
  /* Write the name of the original datafile */
  i=iftFindKey(&par->h, "datafile", 0);
  if(i>=0) fprintf(fp, "Data file:\t%s\n", par->h.item[i].value);
  else fprintf(fp, "Data file:\t\n");
 
  /* Write the study number */
  i=iftFindKey(&par->h, "studynr", 0);
  if(i<0) i=iftFindKey(&par->h, "study_number", 0);
  if(i>=0) fprintf(fp, "Study number:\t%s\n", par->h.item[i].value);
 
  /* Write the concentration (y) unit of the original data */
  i=iftFindKey(&par->h, "unit", 0);
  if(i<0) i=iftFindKey(&par->h, "calibration_unit", 0);
  if(i>=0) fprintf(fp, "Data unit:\t%s\n", par->h.item[i].value);
  else fprintf(fp, "Data unit:\t\n");
 
  /* Write the time (x) unit of the original data */
  i=iftFindKey(&par->h, "timeunit", 0);
  if(i<0) i=iftFindKey(&par->h, "time_unit", 0);
  if(i>=0) fprintf(fp, "Time unit:\t%s\n", par->h.item[i].value);
  else fprintf(fp, "Time unit:\t\n");
 
  /* Write the tacNr to be saved */
  fprintf(fp, "Nr of VOIs:\t%d\n", par->tacNr);
 
  /* Write the Fit title */
  fprintf(fp, "%s %s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n",
    "Region", "Plane", "Start", "End", "dataNr", "WSS", "parNr", "Type", "Parameters");
 
  /* Write the individual fits */
  for(i=0; i<par->tacNr; i++) {
    /* Tac id */
    if(strlen(par->r[i].name)>0) {
      if(!roinameSubpart(par->r[i].name, "_- ", 0, tmp, 7)) strcpy(tmp, ".");
      fprintf(fp, "%s ", tmp);
      if(!roinameSubpart(par->r[i].name, "_- ", 1, tmp, 7)) strcpy(tmp, ".");
      fprintf(fp, "%s ", tmp);
      if(!roinameSubpart(par->r[i].name, "_- ", 2, tmp, 7)) strcpy(tmp, ".");
      fprintf(fp, "%s", tmp);
    } else {
      fprintf(fp, "tac%d . .", 1+i);
    }
    /* Time range, sample nr, (W)SS, parameter nr, function id */
    fprintf(fp, "\t%.3f\t%.3f\t%d\t%.2E\t%d\t%04d",
       par->r[i].start, par->r[i].end, par->r[i].dataNr,
       par->r[i].wss, par->parNr, modelOldId(par->r[i].model) );
    /* Function parameters */
    for(j=0; j<par->parNr; j++) fprintf(fp, "\t%.6E", par->r[i].p[j]);
    n=fprintf(fp, "\n");
  } // next fit
  if(n==0) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parWrite().

parWriteIFT()

int parWriteIFT ( PAR * par, FILE * fp, TPCSTATUS * status )

extern

Write PAR data into specified file pointer in IFT format.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to source PAR struct, contents of which are to be written
fp	Output file pointer
status	Pointer to status data; enter NULL if not needed

Definition at line 167 of file parift.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(verbose>0) printf("%s()\n", __func__);
  if(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  int ret;
  IFT ift;
  iftInit(&ift);
  ret=parToIFT(par, &ift, status);
  if(ret!=TPCERROR_OK) {iftFree(&ift); return ret;}
  ret=iftWrite(&ift, fp, status);
  iftFree(&ift);
  if(ret!=TPCERROR_OK) return ret;
 
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parWrite().

parWriteLimits()

int parWriteLimits ( PAR * par, const char * fname, const int verbose )

extern

Write parameter constraints from PAR structure into specified file.

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

See also

parReadLimits, parWrite, parFree, parListLimits

Parameters

par	Pointer to PAR structure, from which the limits are to be written.
fname	Output file name. Enter 'stdout' to print to stdout.
verbose	Verbose level; if zero, then nothing is printed to stderr or stdout

Definition at line 432 of file pario.c.

  {
  if(verbose>0) {printf("%s(%s)\n", __func__, fname); fflush(stdout);}
  if(par==NULL || par->parNr<1) return TPCERROR_NO_DATA;
  if(strlen(fname)<1) return(TPCERROR_INVALID_FILENAME);
 
  /* Copy limits into IFT struct */
  IFT ift; iftInit(&ift);
  char pname[MAX_PARNAME_LEN+10];
  for(int i=0; i<par->parNr; i++) {
    if(!isnan(par->n[i].lim1)) {
      if(strlen(par->n[i].name)>0) strcpy(pname, par->n[i].name); else sprintf(pname, "p%d", 1+i);
      strcat(pname, "_lower"); iftPutDouble(&ift, pname, par->n[i].lim1, 0, NULL);
    }
    if(!isnan(par->n[i].lim2)) {
      if(strlen(par->n[i].name)>0) strcpy(pname, par->n[i].name); else sprintf(pname, "p%d", 1+i);
      strcat(pname, "_upper"); iftPutDouble(&ift, pname, par->n[i].lim2, 0, NULL);
    }
    if(!isnan(par->n[i].tol)) {
      if(strlen(par->n[i].name)>0) strcpy(pname, par->n[i].name); else sprintf(pname, "p%d", 1+i);
      strcat(pname, "_tol"); iftPutDouble(&ift, pname, par->n[i].tol, 0, NULL);
    }
  }
  if(verbose>1) printf("  keyNr=%d\n", ift.keyNr);
  if(ift.keyNr<1) {iftFree(&ift); return TPCERROR_NO_DATA;}
 
  /* Write IFT */
  if(strcasecmp(fname, "stdout")==0) { // into stdout
    iftWrite(&ift, stdout, NULL);
  } else { // into specified file
    if(verbose>1) printf("  opening %s\n", fname);
    FILE *fp=fopen(fname, "w");
    if(fp==NULL) {iftFree(&ift); return TPCERROR_CANNOT_WRITE;}
    if(verbose>1) printf("  writing in %s\n", fname);
    if(iftWrite(&ift, fp, NULL)!=TPCERROR_OK) {
      iftFree(&ift); fclose(fp); return TPCERROR_CANNOT_WRITE;
    }
    fclose(fp);
  }
  iftFree(&ift); 
 
  return TPCERROR_OK;
}

parWriteRES()

int parWriteRES ( PAR * par, FILE * fp, TPCSTATUS * status )

extern

Write PAR data into specified file pointer in result (RES) file format.

See also

parWrite

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to source PAR struct, contents of which are to be written.
fp	Output file pointer.
status	Pointer to status data; enter NULL if not needed.

Definition at line 26 of file parres.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(verbose>0) {printf("%s():\n", __func__); fflush(stdout);}
  if(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  int i, j, n;
  char tmp[256];
 
  /* RES format has quite strict rules on the header, therefore 
     it is written here directly and not through IFT struct etc. */
 
  /* Analysis program name (obligatory, with (c)) */
  i=iftFindKey(&par->h, "program", 0);
  if(i<0 || !strcasestr(par->h.item[i].value, "(c)")) {
    //statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    //return TPCERROR_INVALID_VALUE;
    n=fprintf(fp, "results (c) none\n\n");
  } else {
    n=fprintf(fp, "%s\n\n", par->h.item[i].value);
  }
  if(n<6) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Write calculation date and time (obligatory) */
  i=iftFindKey(&par->h, "analysis_time", 0);
  if(i<0) {
    //statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_VALUE);
    //return TPCERROR_INVALID_VALUE;
    time_t t=time(NULL);
    fprintf(fp, "Date:\t%s\n", ctime_r_int(&t, tmp));
  } else {
    fprintf(fp, "Date:\t%s\n", par->h.item[i].value);
  }
 
  /* Write the studynr (optional) */
  i=iftFindKey(&par->h, "studynr", 0);
  if(i<0) i=iftFindKey(&par->h, "study_number", 0);
  if(i>=0) fprintf(fp, "Study:\t%s\n", par->h.item[i].value);
 
  /* Write the names of the original datafiles (optional) */
  i=iftFindKey(&par->h, "datafile", 0);
  if(i>=0) fprintf(fp, "Data file:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "plasmafile", 0);
  if(i>=0) fprintf(fp, "Plasma file:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "plasmafile2", 0);
  if(i>=0) fprintf(fp, "2nd Plasma file:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "bloodfile", 0);
  if(i>=0) fprintf(fp, "Blood file:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "reffile", 0);
  if(i>=0) fprintf(fp, "Reference file:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "refname", 0);
  if(i>=0) fprintf(fp, "Reference region:\t%s\n", par->h.item[i].value);
 
  /* Write data range, nr, and fit method (optional) */
  if(!isnan(par->r[0].start) && !isnan(par->r[0].end))
    fprintf(fp, "Data range:\t%g - %g min\n", par->r[0].start, par->r[0].end);
  if(par->r[0].dataNr>0)
    fprintf(fp, "Data nr:\t%d\n", par->r[0].dataNr);
  i=iftFindKey(&par->h, "fitmethod", 0);
  if(i>=0) fprintf(fp, "Fit method:\t%s\n", par->h.item[i].value);
 
  /* Write constants (optional) */
  i=iftFindKey(&par->h, "density", 0);
  if(i>=0) fprintf(fp, "Tissue density:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "LC", 0);
  if(i>=0) fprintf(fp, "Lumped constant:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "concentration", 0);
  if(i>=0) fprintf(fp, "Concentration:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "beta", 0);
  if(i>=0) fprintf(fp, "Beta:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "Vb", 0);
  if(i>=0) fprintf(fp, "Vb:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "fA", 0);
  if(i>=0) fprintf(fp, "fA:\t%s\n", par->h.item[i].value);
  i=iftFindKey(&par->h, "E", 0);
  if(i<0) i=iftFindKey(&par->h, "extraction", 0);
  if(i>=0) fprintf(fp, "Extraction:\t%s\n", par->h.item[i].value);
 
  /* Weighting (obligatory) */
  i=iftFindKey(&par->h, "weighting", 0);
  if(i>=0) fprintf(fp, "Weighting:\t%s\n", par->h.item[i].value);
  else fprintf(fp, "Weighting:\t%s\n", "unknown");
 
  /* Should column be printed as integers (0), floats (1) or exponentials (2)? */
  int partype[par->parNr]; /* 0=int, 1=double, 2=exp */
  for(i=0; i<par->parNr; i++) partype[i]=parPrintType(par, i);
 
  /* Title line (obligatory) */
  fprintf(fp, "\n%s", "Region");
  for(i=0; i<par->parNr; i++) {
    if(strlen(par->n[i].name)<1) strcpy(tmp, ".");
    else strcpy(tmp, par->n[i].name);
    fprintf(fp, "\t%s", tmp);
  }
  if(parIsWSS(par)) fprintf(fp, "\tWSS");
  fprintf(fp, "\n");
 
  /* Write units, if they exist, as comment line */
  for(i=j=0; i<par->parNr; i++) if(par->n[i].unit!=UNIT_UNKNOWN) j++;
  if(j>0) {
    fprintf(fp, "%s", "# Units:");
    for(i=0; i<par->parNr; i++) {
      fprintf(fp, "\t%s", unitName(par->n[i].unit));
    }
    if(parIsWSS(par)) fprintf(fp, "\t.");
    fprintf(fp, "\n");
  }
 
 
  /* Write regional results */
  for(i=0; i<par->tacNr; i++) {
    if(strlen(par->r[i].name)>0) {
      if(!roinameSubpart(par->r[i].name, "_- ", 0, tmp, 7)) strcpy(tmp, ".");
      fprintf(fp, "%s ", tmp);
      if(!roinameSubpart(par->r[i].name, "_- ", 1, tmp, 7)) strcpy(tmp, ".");
      fprintf(fp, "%s ", tmp);
      if(!roinameSubpart(par->r[i].name, "_- ", 2, tmp, 7)) strcpy(tmp, ".");
      fprintf(fp, "%s", tmp);
    } else {
      fprintf(fp, "tac%d . .", 1+i);
    }
    for(j=0; j<par->parNr; j++) {
      if(isnan(par->r[i].p[j])) {fprintf(fp, "\t."); continue;}
      switch(partype[j]) {
        case 0: fprintf(fp, "\t%.0f", par->r[i].p[j]); break;
        case 1:
          if(par->r[i].p[j]>=0) n=4; else n=3;
          fprintf(fp, "\t%.*f", n, par->r[i].p[j]);
          break;
        default:
          if(par->r[i].p[j]>=0) n=4; else n=3;
          fprintf(fp, "\t%.*e", n, par->r[i].p[j]);
        break;
      }
    }
    if(parIsWSS(par)) {
      if(isnan(par->r[i].wss)) fprintf(fp, "\t."); 
      else fprintf(fp, "\t%g", par->r[i].wss);
    }
    fprintf(fp, "\n");
    /* Write SD's, if they exist */
    for(j=n=0; j<par->parNr; j++) if(!isnan(par->r[i].sd[j])) n++;
    if(n>0) {
      fprintf(fp, "SD . .");
      for(j=0; j<par->parNr; j++) {
        if(!isnan(par->r[i].sd[j])) {
          switch(partype[j]) {
            case 0: fprintf(fp, "\t%.0f", par->r[i].sd[j]); break;
            case 1:
              if(par->r[i].sd[j]>=0) n=4; else n=3;
              fprintf(fp, "\t%.*f", n, par->r[i].sd[j]);
              break;
            default:
              if(par->r[i].sd[j]>=0) n=4; else n=3;
              fprintf(fp, "\t%.*e", n, par->r[i].sd[j]);
              break;
          }
        } else {
          fprintf(fp, "\t.");
        }
      }
      if(parIsWSS(par)) fprintf(fp, "\t.");
      fprintf(fp, "\n");
    }
    /* Write lower confidence limits, if they exist */
    for(j=n=0; j<par->parNr; j++) if(!isnan(par->r[i].cl1[j])) n++;
    if(n>0) {
      fprintf(fp, "CL 95%% Lower");
      for(j=0; j<par->parNr; j++) {
        if(!isnan(par->r[i].cl1[j])) {
          switch(partype[j]) {
            case 0: fprintf(fp, "\t%.0f", par->r[i].cl1[j]); break;
            case 1:
              if(par->r[i].cl1[j]>=0) n=4; else n=3;
              fprintf(fp, "\t%.*f", n, par->r[i].cl1[j]);
              break;
            default:
              if(par->r[i].cl1[j]>=0) n=4; else n=3;
              fprintf(fp, "\t%.*e", n, par->r[i].cl1[j]);
              break;
          }
        } else {
          fprintf(fp, "\t.");
        }
      }
      if(parIsWSS(par)) fprintf(fp, "\t.");
      fprintf(fp, "\n");
    }
    /* Write upper confidence limits, if they exist */
    for(j=n=0; j<par->parNr; j++) if(!isnan(par->r[i].cl2[j])) n++;
    if(n>0) {
      fprintf(fp, "CL 95%% Upper");
      for(j=0; j<par->parNr; j++) {
        if(!isnan(par->r[i].cl2[j])) {
          switch(partype[j]) {
            case 0: fprintf(fp, "\t%.0f", par->r[i].cl2[j]); break;
            case 1:
              if(par->r[i].cl2[j]>=0) n=4; else n=3;
              fprintf(fp, "\t%.*f", n, par->r[i].cl2[j]);
              break;
            default:
              if(par->r[i].cl2[j]>=0) n=4; else n=3;
              fprintf(fp, "\t%.*e", n, par->r[i].cl2[j]);
              break;
          }
        } else {
          fprintf(fp, "\t.");
        }
      }
      if(parIsWSS(par)) fprintf(fp, "\t.");
      fprintf(fp, "\n");
    }
  } /* next region */
 
  
  /* Quit */
  statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
  return(TPCERROR_OK);
}

Referenced by parWrite().

parWriteXML()

int parWriteXML ( PAR * par, FILE * fp, TPCSTATUS * status )

extern

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

See also

parWrite, parRead, parWriteCSV

Returns

enum tpcerror (TPCERROR_OK when successful).

Author

Vesa Oikonen

Parameters

par	Pointer to source PAR 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 parxmlio.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(par==NULL || par->tacNr<1 || par->parNr<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
    return TPCERROR_NO_DATA;
  }
 
  /* Calculate column number */
  int colNr=par->parNr+1; // including tac name
  if(parIsModel(par)>0) colNr++;
  for(int pi=0; pi<par->parNr; pi++) {
    if(parSDWithPar(par, pi)) colNr++;
    if(parCLWithPar(par, pi)) colNr+=2;
  }
  if(parIsWSS(par)) colNr++;
  if(parIsFitRange(par)>0) colNr+=2;
  if(parIsDataNr(par)>0) colNr++;
  if(parIsFitNr(par)>0) colNr++;
  if(verbose>1) printf("  colNr := %d\n", colNr);
 
  /* Write XML header */
  if(verbose>2) printf("writing XML header\n");
  int 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 */
  for(int i=0; i<colNr; i++) fprintf(fp, "      <ss:Column ss:Width=\"80\"/>\n");
 
  /* Write the title line */
  if(verbose>2) printf("writing title line\n");
  fprintf(fp, "      <ss:Row ss:StyleID=\"1\">\n");
  fprintf(fp, "        <ss:Cell>\n");
  fprintf(fp, "          <ss:Data ss:Type=\"String\">Parameters</ss:Data>\n");
  fprintf(fp, "        </ss:Cell>\n");
  /* model id */
  if(parIsModel(par)>0) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">Model</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
  } 
  /* parameter names with units, and SD and/or CLs, if available */
  for(int pi=0; pi<par->parNr; pi++) {
    if(par->n[pi].unit==UNIT_UNKNOWN) {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"String\">%s</ss:Data>\n", par->n[pi].name);
      fprintf(fp, "        </ss:Cell>\n");
    } else {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"String\">%s[%s]</ss:Data>\n",
              par->n[pi].name, unitName(par->n[pi].unit));
      fprintf(fp, "        </ss:Cell>\n");
    }
    if(parSDWithPar(par, pi)) {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"String\">SD</ss:Data>\n");
      fprintf(fp, "        </ss:Cell>\n");
    }
    if(parCLWithPar(par, pi)) {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"String\">95%%CL1</ss:Data>\n");
      fprintf(fp, "        </ss:Cell>\n");
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"String\">95%%CL2</ss:Data>\n");
      fprintf(fp, "        </ss:Cell>\n");
    }
  }
  if(parIsWSS(par)) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">WSS</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
  }
  if(parIsFitRange(par)>0) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">Start[min]</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">End[min]</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
  }
  if(parIsDataNr(par)>0) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">DataNr</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
  }
  if(parIsFitNr(par)>0) {
    fprintf(fp, "        <ss:Cell>\n");
    fprintf(fp, "          <ss:Data ss:Type=\"String\">FitNr</ss:Data>\n");
    fprintf(fp, "        </ss:Cell>\n");
  }
  /* End the title line */
  n=fprintf(fp, "      </ss:Row>\n");
  if(n<1) {
    statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
    return TPCERROR_CANNOT_WRITE;
  }
 
  /* Write parameters */
  if(verbose>2) printf("writing data table\n");
  for(int ri=0; ri<par->tacNr; ri++) {
    if(verbose>3) printf("    for region %d\n", 1+ri);
    /* Start the line */
    fprintf(fp, "      <ss:Row>\n");
    /* Region names and parameter values */
    fprintf(fp, "        <ss:Cell>\n");
    char *senc=strEncodeForXML(par->r[ri].name);
    if(senc==NULL) fprintf(fp, "          <ss:Data ss:Type=\"String\">%s</ss:Data>\n", par->r[ri].name);
    else {fprintf(fp, "          <ss:Data ss:Type=\"String\">%s</ss:Data>\n", senc); free(senc);}
    fprintf(fp, "        </ss:Cell>\n");
    if(parIsModel(par)>0) {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"String\">%s</ss:Data>\n", modelCode(par->r[ri].model));
      fprintf(fp, "        </ss:Cell>\n");
    }
    for(int pi=0; pi<par->parNr; pi++) {
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(par->r[ri].p[pi])) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].p[pi]);
      fprintf(fp, "        </ss:Cell>\n");
      if(parSDWithPar(par, pi)) {
        fprintf(fp, "        <ss:Cell>\n");
        if(isnan(par->r[ri].sd[pi])) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
        else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].sd[pi]);
        fprintf(fp, "        </ss:Cell>\n");
      }
      if(parCLWithPar(par, pi)) {
        fprintf(fp, "        <ss:Cell>\n");
        if(isnan(par->r[ri].cl1[pi])) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
        else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].cl1[pi]);
        fprintf(fp, "        </ss:Cell>\n");
        fprintf(fp, "        <ss:Cell>\n");
        if(isnan(par->r[ri].cl2[pi])) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
        else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].cl2[pi]);
        fprintf(fp, "        </ss:Cell>\n");
      }
    }
    /* WSS etc */
    if(parIsWSS(par)) {
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(par->r[ri].wss)) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].wss);
      fprintf(fp, "        </ss:Cell>\n");
    }
    if(parIsFitRange(par)>0) {
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(par->r[ri].start)) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].start);
      fprintf(fp, "        </ss:Cell>\n");
      fprintf(fp, "        <ss:Cell>\n");
      if(isnan(par->r[ri].end)) fprintf(fp, "          <ss:Data ss:Type=\"Number\"></ss:Data>\n");
      else fprintf(fp, "          <ss:Data ss:Type=\"Number\">%g</ss:Data>\n", par->r[ri].end);
      fprintf(fp, "        </ss:Cell>\n");
    }
    if(parIsDataNr(par)>0) {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"Number\">%d</ss:Data>\n", par->r[ri].dataNr);
      fprintf(fp, "        </ss:Cell>\n");
    }
    if(parIsFitNr(par)>0) {
      fprintf(fp, "        <ss:Cell>\n");
      fprintf(fp, "          <ss:Data ss:Type=\"Number\">%d</ss:Data>\n", par->r[ri].fitNr);
      fprintf(fp, "        </ss:Cell>\n");
    }
    /* End the line */
    n=fprintf(fp, "      </ss:Row>\n");
    if(n<1) {
      statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
      return TPCERROR_CANNOT_WRITE;
    }
  }
 
  /* 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 parWrite().