PAR struct processing. More...

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

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	parrAllocate (PARR *parr, int parNr)
int	parAllocateMore (PAR *par, int parNr, int tacNr)
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)
char *	parIsOptcrit (PAR *par)
char *	parIsStudyNr (PAR *par)
int	parSetStudyNr (PAR par, const char s)
void	parEnsureNames (PAR *d)
int	parDeletePar (PAR *par, int pi)
int	parDeleteTAC (PAR *par, int ti)

Detailed Description

PAR struct processing.

Definition in file par.c.

Function Documentation

◆ parAllocate()

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

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 parAllocate(), parAllocateWithTAC(), parExamplePerfectBolus(), parExampleRadiowaterBolus(), parExampleTTACs(), parFromIFT(), parReadCSV(), parReadFIT(), and parReadRES().

◆ parAllocateMore()

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

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 parAllocateMore(), and parCombineTACs().

◆ parCLWithPar()

int parCLWithPar	(	PAR *	par,
		int	pi )

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 326 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 parCLWithPar(), parWriteCSV(), and parWriteXML().

◆ parDeletePar()

int parDeletePar	(	PAR *	par,
		int	pi )

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 479 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 parDeletePar(), parReadCSV(), and parReadRES().

◆ parDeleteTAC()

int parDeleteTAC	(	PAR *	par,
		int	ti )

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

Referenced by parDeleteTAC().

◆ parEnsureNames()

void parEnsureNames ( PAR * d )

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

Referenced by parEnsureNames().

◆ parFree()

void parFree ( PAR * par )

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(), parFree(), parFromIFT(), parRead(), parReadCSV(), parReadFIT(), and parReadRES().

◆ parInit()

void parInit ( PAR * par )

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(), and parInit().

◆ parIsDataNr()

int parIsDataNr ( PAR * par )

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 363 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 parIsDataNr(), parToIFT(), parWriteCSV(), and parWriteXML().

◆ parIsFitNr()

int parIsFitNr ( PAR * par )

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 344 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 parIsFitNr(), parToIFT(), parWriteCSV(), and parWriteXML().

◆ parIsFitRange()

int parIsFitRange ( PAR * par )

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 parIsFitRange(), parToIFT(), parWriteCSV(), and parWriteXML().

◆ parIsModel()

int parIsModel ( PAR * par )

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 ret=0;
  unsigned int mn=modelNr();;
  for(int ri=0; ri<par->tacNr; ri++) {
    if(ret==0 && par->r[ri].model>0 && par->r[ri].model<=mn) ret=1;
    if(ri>0 && par->r[ri].model!=par->r[ri-1].model) {ret=2; break;}
  }
  return(ret);
}

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

◆ parIsOptcrit()

char * parIsOptcrit ( PAR * par )

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

Referenced by parIsOptcrit().

◆ parIsStudyNr()

char * parIsStudyNr ( PAR * par )

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

Referenced by parIsStudyNr().

◆ parIsWSS()

int parIsWSS ( PAR * par )

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 parIsWSS(), parWriteCSV(), parWriteRES(), and parWriteXML().

◆ parnInit()

void parnInit ( PARN * parn )

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(), parAllocateMore(), and parnInit().

◆ parrAllocate()

int parrAllocate	(	PARR *	parr,
		int	parNr )

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(), parAllocateMore(), and parrAllocate().

◆ parrFree()

void parrFree ( PARR * parr )

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(), parrAllocate(), and parrFree().

◆ parrInit()

void parrInit ( PARR * parr )

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(), parrFree(), and parrInit().

◆ parSDWithPar()

int parSDWithPar	(	PAR *	par,
		int	pi )

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 308 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 parSDWithPar(), parWriteCSV(), and parWriteXML().

◆ parSetStudyNr()

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

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

Referenced by parSetStudyNr().

Functions

Detailed Description

Function Documentation

◆ parAllocate()

◆ parAllocateMore()

◆ parCLWithPar()

◆ parDeletePar()

◆ parDeleteTAC()

◆ parEnsureNames()

◆ parFree()

◆ parInit()

◆ parIsDataNr()

◆ parIsFitNr()

◆ parIsFitRange()

◆ parIsModel()

◆ parIsOptcrit()

◆ parIsStudyNr()

◆ parIsWSS()

◆ parnInit()

◆ parrAllocate()

◆ parrFree()

◆ parrInit()

◆ parSDWithPar()

◆ parSetStudyNr()