TPCCLIB
Loading...
Searching...
No Matches
Functions
parcsv.c File Reference

CSV and TSV I/O functions for TPC parameter files. More...

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

Go to the source code of this file.

Functions

int parWriteCSV (PAR *par, FILE *fp, parformat format, int extra, TPCSTATUS *status)
 
int parReadCSV (PAR *par, CSV *csv, IFT *hdr, TPCSTATUS *status)
 

Detailed Description

CSV and TSV I/O functions for TPC parameter files.

Definition in file parcsv.c.

Function Documentation

◆ parReadCSV()

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

Read parameter data into PAR structure.

Returns
enum tpcerror (TPCERROR_OK when successful).
Author
Vesa Oikonen
See also
parWriteCSV, parRead, parFormatIdentify
Parameters
parPointer to target PAR structure.
csvPointer to CSV from which data is read.
hdrPointer to possible header data, which, if available, is processed and copied to PAR too; enter NULL if not available.
statusPointer to status data; enter NULL if not needed.

Definition at line 221 of file parcsv.c.

231 {
232 int verbose=0; if(status!=NULL) verbose=status->verbose;
233 if(par==NULL) {
234 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_FAIL);
235 return TPCERROR_FAIL;
236 }
237
238 parFree(par);
239 if(csv==NULL || csv->row_nr<1 || csv->col_nr<1) {
240 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
241 return TPCERROR_NO_DATA;
242 }
243 if(verbose>0) printf("%s()\n", __func__);
244
245 /* Check that this is valid CSV or TSV parameter file */
246 if(strcasecmp(csv->c[0].content, "Parameters")) {
247 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_UNSUPPORTED);
248 return TPCERROR_UNSUPPORTED;
249 }
250
251 /* Remove initial and trailing space characters from CSV.
252 Those may exist in manually made files. */
253 csvCleanSpaces(csv);
254
255 /* Calculate the number of parameters from the title line */
256 int colNr=1, parNr=0;
257 for(int i=1; i<csv->nr; i++) {
258 if(csv->c[i].row==0) { // title line
259 colNr++;
260 /* do not count special columns */
261 if(strncasecmp(csv->c[i].content, "SD", 2)==0) continue;
262 if(strncasecmp(csv->c[i].content, "95%CL", 5)==0) continue;
263 if(strcasecmp(csv->c[i].content, "WSS")==0) continue;
264 if(strcasecmp(csv->c[i].content, "Model")==0) continue;
265 if(strcasecmp(csv->c[i].content, "Start[min]")==0) continue;
266 if(strcasecmp(csv->c[i].content, "End[min]")==0) continue;
267 if(strcasecmp(csv->c[i].content, "dataNr")==0) continue;
268 if(strcasecmp(csv->c[i].content, "fitNr")==0) continue;
269 parNr++;
270 } else break; // this is not more in title line
271 }
272 if(parNr<1 || csv->row_nr<2) {
273 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
274 return TPCERROR_INVALID_FORMAT;
275 }
276 if(verbose>2) printf(" parNr := %d\n colNr := %d\n", parNr, colNr);
277
278 /* Allocate memory for parameters */
279 int ret;
280 ret=parAllocate(par, parNr, csv->row_nr-1);
281 if(ret!=TPCERROR_OK) {statusSet(status, __func__, __FILE__, __LINE__, ret); return ret;}
282 par->parNr=parNr; par->tacNr=csv->row_nr-1;
283
284
285 /* Read CSV contents into PAR struct */
286 int decimal_comma=-1;
287 ret=0; if(csv->separator==',') decimal_comma=0;
288 /* Read TAC names from column 1 */
289 for(int ri=1; ri<csv->row_nr; ri++) {
290 int i=ri*colNr; if(i>=csv->nr || csv->c[i].col!=0) {ret++; break;}
291 strlcpy(par->r[ri-1].name, csv->c[i].content, MAX_TACNAME_LEN);
292 }
293
294 /* Read one column at a time */
295 parNr=0;
296 for(int ci=1; ci<colNr && ret==0; ci++) {
297 //printf("parNr=%d / %d\n", parNr, par->parNr);
298 if(parNr>par->parNr) {ret++; break;}
299 int ri=0; int i=ri*colNr+ci;
300 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
301 if(strcasecmp(csv->c[i].content, "Model")==0) {
302 for(ri=1; ri<csv->row_nr; ri++) {
303 int i=ri*colNr+ci;
304 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
305 par->r[ri-1].model=modelCodeIndex(csv->c[i].content);
306 }
307 continue;
308 }
309 if(strncasecmp(csv->c[i].content, "SD", 2)==0) {
310 if(parNr==0) {ret++; break;}
311 for(ri=1; ri<csv->row_nr; ri++) {
312 i=ri*colNr+ci;
313 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
314 par->r[ri-1].sd[parNr-1]=atofVerified(csv->c[i].content);
315 }
316 continue;
317 }
318 if(strncasecmp(csv->c[i].content, "95%CL1", 6)==0) {
319 if(parNr==0) {ret++; break;}
320 for(ri=1; ri<csv->row_nr; ri++) {
321 i=ri*colNr+ci;
322 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
323 par->r[ri-1].cl1[parNr-1]=atofVerified(csv->c[i].content);
324 }
325 continue;
326 }
327 if(strncasecmp(csv->c[i].content, "95%CL2", 6)==0) {
328 if(parNr==0) {ret++; break;}
329 for(ri=1; ri<csv->row_nr; ri++) {
330 i=ri*colNr+ci;
331 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
332 par->r[ri-1].cl2[parNr-1]=atofVerified(csv->c[i].content);
333 }
334 continue;
335 }
336 if(strcasecmp(csv->c[i].content, "WSS")==0 || strcasecmp(csv->c[i].content, "SS")==0) {
337 for(ri=1; ri<csv->row_nr; ri++) {
338 i=ri*colNr+ci;
339 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
340 par->r[ri-1].wss=atofVerified(csv->c[i].content);
341 }
342 continue;
343 }
344 if(strncasecmp(csv->c[i].content, "Start", 5)==0) {
345 for(ri=1; ri<csv->row_nr; ri++) {
346 i=ri*colNr+ci;
347 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
348 par->r[ri-1].start=atofVerified(csv->c[i].content);
349 }
350 continue;
351 }
352 if(strncasecmp(csv->c[i].content, "End", 3)==0) {
353 for(ri=1; ri<csv->row_nr; ri++) {
354 i=ri*colNr+ci;
355 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
356 par->r[ri-1].end=atofVerified(csv->c[i].content);
357 }
358 continue;
359 }
360 if(strcasecmp(csv->c[i].content, "dataNr")==0) {
361 for(ri=1; ri<csv->row_nr; ri++) {
362 i=ri*colNr+ci;
363 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
364 par->r[ri-1].dataNr=atoi(csv->c[i].content);
365 }
366 continue;
367 }
368 if(strcasecmp(csv->c[i].content, "fitNr")==0) {
369 for(ri=1; ri<csv->row_nr; ri++) {
370 i=ri*colNr+ci;
371 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
372 par->r[ri-1].fitNr=atoi(csv->c[i].content);
373 }
374 continue;
375 }
376 /* then this column is a parameter */
377 char tmp[128];
378 /* parameter name may contain unit */
379 if(strTokenNCpy(csv->c[i].content, "[] \t", 1, par->n[parNr].name, MAX_PARNAME_LEN)==0)
380 {ret++; break;}
381 if(strTokenNCpy(csv->c[i].content, "[] \t", 2, tmp, 128)>0)
382 par->n[parNr].unit=unitIdentify(tmp);
383 //strncpy(par->n[parNr].name, csv->c[i].content, MAX_PARNAME_LEN);
384 //par->n[parNr].name[MAX_PARNAME_LEN]='\0';
385 /* Read parameter values */
386 for(ri=1; ri<csv->row_nr; ri++) {
387 i=ri*colNr+ci;
388 if(i>=csv->nr || csv->c[i].col!=ci) {ret++; break;}
389 par->r[ri-1].p[parNr]=atofVerified(csv->c[i].content);
390 if(decimal_comma<1) {
391 /* Try to determine whether file format is UK or INT */
392 if(strchr(csv->c[i].content, '.')!=NULL) decimal_comma=0;
393 else if(strchr(csv->c[i].content, ',')!=NULL) decimal_comma=1;
394 }
395 }
396 parNr++;
397 }
398 if(ret>0) {
399 parFree(par);
400 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
401 return TPCERROR_INVALID_FORMAT;
402 }
403
404
405 /* If one 'parameter' is named WSS or SS, then move its contents to
406 correct place inside the struct */
407 {
408 int ci=-1;
409 for(int i=0; i<par->parNr; i++) {
410 if(!strcasecmp(par->n[i].name, "WSS") || !strcasecmp(par->n[i].name, "SS")) ci=i;
411 }
412 if(ci>=0 && ci<par->parNr && par->parNr>1) {
413 if(verbose>4) {
414 printf("column %d contains WSS, moving to correct place\n", 1+ci); fflush(stdout);}
415 for(int i=0; i<par->tacNr; i++) par->r[i].wss=par->r[i].p[ci];
416 /* delete the parameter column */
417 parDeletePar(par, ci);
418 }
419 }
420
421
422 /* Set format in struct */
423 if(csv->separator==';') {
424 if(decimal_comma==1) par->format=PAR_FORMAT_CSV_INT;
425 else par->format=PAR_FORMAT_CSV_UK;
426 } else if(csv->separator==',') {
427 par->format=PAR_FORMAT_CSV_UK;
428 } else if(csv->separator=='\t' || csv->separator==' ') {
429 if(decimal_comma==1) par->format=PAR_FORMAT_TSV_INT;
430 else par->format=PAR_FORMAT_TSV_UK;
431 } else {
432 if(decimal_comma==1) par->format=PAR_FORMAT_TSV_INT;
433 else par->format=PAR_FORMAT_TSV_UK;
434 }
435
436
437
438 /* Copy header */
439 if(hdr!=NULL && hdr->keyNr>0) {
440 if(verbose>4) {
441 printf("copying header contents (%d items) to PAR struct\n", hdr->keyNr); fflush(stdout);}
442 if(iftDuplicate(hdr, &par->h)!=TPCERROR_OK) {
443 if(verbose>0) {printf(" error in iftDuplicate()\n"); fflush(stdout);}
444 parFree(par);
445 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_HEADER);
446 return TPCERROR_INVALID_HEADER;
447 }
448 /* Move standard fields from header to struct */
449 double v, f;
450 int i, n, u;
451 char key[32];
452
453 strcpy(key, "fit_start");
454 if(!iftGetDoubleWithUnit(&par->h, iftFindKey(&par->h, key, 0), &v, &u)) {
455 f=unitConversionFactor(u, UNIT_MIN); if(!isnan(f)) v*=f;
456 for(i=0; i<par->tacNr; i++) if(isnan(par->r[i].start)) par->r[i].start=v;
457 }
458 strcpy(key, "fit_end");
459 if(!iftGetDoubleWithUnit(&par->h, iftFindKey(&par->h, key, 0), &v, &u)) {
460 f=unitConversionFactor(u, UNIT_MIN); if(!isnan(f)) v*=f;
461 for(i=0; i<par->tacNr; i++) if(isnan(par->r[i].end)) par->r[i].end=v;
462 }
463 strcpy(key, "dataNr");
464 if(!iftGetInt(&par->h, iftFindKey(&par->h, key, 0), &n)) {
465 for(i=0; i<par->tacNr; i++) if(par->r[i].dataNr<=0) par->r[i].dataNr=n;
466 }
467 strcpy(key, "model");
468 i=iftFindKey(&par->h, key, 0);
469 if(i>=0) {
470 unsigned int n=modelCodeIndex(par->h.item[i].value);
471 iftDelete(&par->h, i);
472 for(i=0; i<par->tacNr; i++) par->r[i].model=n;
473 }
474 }
475
476 /* Quit */
477 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_OK);
478 return(TPCERROR_OK);
479}
csvCleanSpaces
int csvCleanSpaces(CSV *csv)
Definition csvio.c:422
atofVerified
double atofVerified(const char *s)
Definition decpoint.c:75
iftDelete
int iftDelete(IFT *ift, int index)
Definition ift.c:206
iftDuplicate
int iftDuplicate(IFT *ift1, IFT *ift2)
Definition ift.c:236
iftFindKey
int iftFindKey(IFT *ift, const char *key, int start_index)
Definition iftfind.c:30
iftGetDoubleWithUnit
int iftGetDoubleWithUnit(IFT *ift, int index, double *v, int *unit)
Definition iftget.c:129
iftGetInt
int iftGetInt(IFT *ift, int index, int *v)
Definition iftget.c:76
modelCodeIndex
unsigned int modelCodeIndex(const char *s)
Definition modell.c:236
parDeletePar
int parDeletePar(PAR *par, int pi)
Definition par.c:478
parFree
void parFree(PAR *par)
Definition par.c:75
parAllocate
int parAllocate(PAR *par, int parNr, int tacNr)
Definition par.c:108
statusSet
void statusSet(TPCSTATUS *s, const char *func, const char *srcfile, int srcline, tpcerror error)
Definition statusmsg.c:142
strTokenNCpy
int strTokenNCpy(const char *s1, const char *s2, int i, char *s3, int count)
Definition stringext.c:53
strlcpy
size_t strlcpy(char *dst, const char *src, size_t dstsize)
Definition stringext.c:632
CSV_item::col
int col
Definition tpccsv.h:28
CSV_item::row
int row
Definition tpccsv.h:26
CSV_item::content
char * content
Definition tpccsv.h:30
CSV::row_nr
int row_nr
Definition tpccsv.h:44
CSV::col_nr
int col_nr
Definition tpccsv.h:46
CSV::separator
char separator
Definition tpccsv.h:49
CSV::c
CSV_item * c
Definition tpccsv.h:38
CSV::nr
int nr
Definition tpccsv.h:42
IFT_ITEM::value
char * value
Definition tpcift.h:37
IFT::item
IFT_ITEM * item
Definition tpcift.h:57
IFT::keyNr
int keyNr
Definition tpcift.h:47
PAR::format
int format
Definition tpcpar.h:103
PAR::h
IFT h
Optional (but often useful) header information.
Definition tpcpar.h:148
PAR::parNr
int parNr
Definition tpcpar.h:109
PAR::tacNr
int tacNr
Definition tpcpar.h:105
PAR::r
PARR * r
Definition tpcpar.h:115
PAR::n
PARN * n
Definition tpcpar.h:113
PARN::unit
int unit
Definition tpcpar.h:87
PARN::name
char name[MAX_PARNAME_LEN+1]
Definition tpcpar.h:83
PARR::wss
double wss
Definition tpcpar.h:73
PARR::fitNr
int fitNr
Definition tpcpar.h:59
PARR::name
char name[MAX_TACNAME_LEN+1]
Definition tpcpar.h:50
PARR::dataNr
int dataNr
Definition tpcpar.h:63
PARR::cl2
double * cl2
Definition tpcpar.h:71
PARR::model
unsigned int model
Definition tpcpar.h:48
PARR::p
double * p
Definition tpcpar.h:65
PARR::start
double start
Definition tpcpar.h:52
PARR::sd
double * sd
Definition tpcpar.h:67
PARR::cl1
double * cl1
Definition tpcpar.h:69
PARR::end
double end
Definition tpcpar.h:54
TPCSTATUS::verbose
int verbose
Verbose level, used by statusPrint() etc.
Definition tpcextensions.h:242
MAX_TACNAME_LEN
#define MAX_TACNAME_LEN
Max length of TAC ID name (not including trailing zero)
Definition tpcextensions.h:35
UNIT_MIN
@ UNIT_MIN
minutes
Definition tpcextensions.h:90
MAX_PARNAME_LEN
#define MAX_PARNAME_LEN
Max string length for PAR name.
Definition tpcextensions.h:39
TPCERROR_FAIL
@ TPCERROR_FAIL
General error.
Definition tpcextensions.h:192
TPCERROR_INVALID_FORMAT
@ TPCERROR_INVALID_FORMAT
Invalid file format.
Definition tpcextensions.h:201
TPCERROR_INVALID_HEADER
@ TPCERROR_INVALID_HEADER
Invalid header contents.
Definition tpcextensions.h:223
TPCERROR_UNSUPPORTED
@ TPCERROR_UNSUPPORTED
Unsupported file type.
Definition tpcextensions.h:202
TPCERROR_OK
@ TPCERROR_OK
No error.
Definition tpcextensions.h:191
TPCERROR_NO_DATA
@ TPCERROR_NO_DATA
File contains no data.
Definition tpcextensions.h:203
unitIdentify
int unitIdentify(const char *s)
Definition units.c:162
unitConversionFactor
double unitConversionFactor(const int u1, const int u2)
Definition units.c:487
PAR_FORMAT_CSV_UK
@ PAR_FORMAT_CSV_UK
UK CSV.
Definition tpcpar.h:33
PAR_FORMAT_CSV_INT
@ PAR_FORMAT_CSV_INT
International CSV.
Definition tpcpar.h:32
PAR_FORMAT_TSV_INT
@ PAR_FORMAT_TSV_INT
International TSV (comma as decimal separator)
Definition tpcpar.h:34
PAR_FORMAT_TSV_UK
@ PAR_FORMAT_TSV_UK
UK TSV (point as decimal separator)
Definition tpcpar.h:35

Referenced by parRead().

◆ parWriteCSV()

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

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
parPointer to source PAR structure, contents of which are to be written.
fpOutput file pointer.
formatFile format code; enter PAR_FORMAT_UNKNOWN (0) to write data in the format specified inside PAR structure.
extraWrite (1) or do not write (0) also extra header fields found in PAR.
statusPointer to status data; enter NULL if not needed.

Definition at line 26 of file parcsv.c.

38 {
39 int verbose=0; if(status!=NULL) verbose=status->verbose;
40 if(fp==NULL) {
41 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_CANNOT_WRITE);
42 return TPCERROR_CANNOT_WRITE;
43 }
44 if(verbose>0) {printf("%s():\n", __func__); fflush(stdout);}
45 if(par==NULL || par->tacNr<1 || par->parNr<1) {
46 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_NO_DATA);
47 return TPCERROR_NO_DATA;
48 }
49
50 /* Determine and verify the write format */
51 if(format<=PAR_FORMAT_UNKNOWN || format>=PAR_FORMAT_LAST) format=par->format;
52 /* Set decimal and item separators */
53 int tointl=0;
54 char separator;
55 if(format==PAR_FORMAT_CSV_INT) {
56 tointl=1; separator=';';
57 } else if(format==PAR_FORMAT_CSV_UK) {
58 tointl=0; separator=',';
59 } else if(format==PAR_FORMAT_TSV_INT) {
60 tointl=1; separator='\t';
61 } else if(format==PAR_FORMAT_TSV_UK) {
62 tointl=0; separator='\t';
63 } else {
64 statusSet(status, __func__, __FILE__, __LINE__, TPCERROR_INVALID_FORMAT);
65 return TPCERROR_INVALID_FORMAT;
66 }
67 if(verbose>0) {
68 printf("writing %d parameters from %d TACs in %s format\n",
69 par->parNr, par->tacNr, parFormattxt(format));
70 }
71
72 int ret;
73
74 /* Write header if requested */
75 if(extra) {
76 if(verbose>1) printf(" add common info into header\n");
77 char tmp[128];
78 if(parIsModel(par)==1) { // same model in each TAC
79 iftDeleteKey(&par->h, "model");
80 sprintf(tmp, "%s", modelCode(par->r[0].model));
81 iftPut(&par->h, "model", tmp, 1, NULL);
82 }
83 if(parIsDataNr(par)==1) {
84 iftDeleteKey(&par->h, "dataNr");
85 sprintf(tmp, "%d", par->r[0].dataNr);
86 iftPut(&par->h, "dataNr", tmp, 1, NULL);
87 }
88 if(parIsFitNr(par)==1) {
89 iftDeleteKey(&par->h, "fitNr");
90 sprintf(tmp, "%d", par->r[0].fitNr);
91 iftPut(&par->h, "fitNr", tmp, 1, NULL);
92 }
93 if(parIsFitRange(par)==1) {
94 char unittext[60];
95 int tunit=UNIT_UNKNOWN;
96 int i=iftFindKey(&par->h, "timeunit", 0);
97 if(i<0) i=iftFindKey(&par->h, "time_unit", 0);
98 if(i>=0) tunit=unitIdentify(par->h.item[i].value);
99 if(unitIsTime(tunit)) sprintf(unittext, " %s", unitName(tunit)); else strcpy(unittext, "");
100 iftDeleteKey(&par->h, "fit_start");
101 sprintf(tmp, "%g%s", par->r[0].start, unittext);
102 iftPut(&par->h, "fit_start", tmp, 1, NULL);
103 iftDeleteKey(&par->h, "fit_end");
104 sprintf(tmp, "%g%s", par->r[0].end, unittext);
105 iftPut(&par->h, "fit_end", tmp, 1, NULL);
106 }
107 if(verbose>1) {printf(" writing parameter header\n"); fflush(stdout);}
108 for(int i=0; i<par->h.keyNr; i++) par->h.item[i].comment=1;
109 ret=iftWrite(&par->h, fp, status); if(ret!=TPCERROR_OK) return ret;
110 //fprintf(fp, "\n");
111 fflush(fp);
112 }
113
114 /* Allocate initial space for CSV structure; more will be added later when necessary */
115 CSV csv; csvInit(&csv);
116 ret=csvAllocate(&csv, (par->parNr+1)*(par->tacNr+1));
117 if(ret!=TPCERROR_OK) {
118 if(verbose>1) {fprintf(stderr, "Error: cannot allocate memory for CSV.\n"); fflush(stderr);}
119 statusSet(status, __func__, __FILE__, __LINE__, ret);
120 return ret;
121 }
122 csv.separator=separator;
123
124 /* Write parameter table into CSV */
125 if(verbose>1) {printf(" writing parameter table\n"); fflush(stdout);}
126 int pi, ri;
127 /* Parameter names */
128 if(verbose>2) {printf(" writing parameter names\n"); fflush(stdout);}
129 char pstr[MAX_PARNAME_LEN+MAX_UNITS_LEN+3];
130 ret=csvPutString(&csv, "Parameters", 0);
131 /* Column for model id, if different models fitted to TACs */
132 if(parIsModel(par)==2 && ret==TPCERROR_OK)
133 ret=csvPutString(&csv, "Model", 0);
134 for(pi=0; pi<par->parNr && ret==TPCERROR_OK; pi++) {
135 if(par->n[pi].unit==UNIT_UNKNOWN) {
136 ret=csvPutString(&csv, par->n[pi].name, 0);
137 } else {
138 sprintf(pstr, "%s[%s]", par->n[pi].name, unitName(par->n[pi].unit));
139 ret=csvPutString(&csv, pstr, 0);
140 }
141 if(ret==TPCERROR_OK && parSDWithPar(par, pi)) {
142 ret=csvPutString(&csv, "SD", 0);
143 }
144 if(ret==TPCERROR_OK && parCLWithPar(par, pi)) {
145 ret=csvPutString(&csv, "95%CL1", 0);
146 if(ret==TPCERROR_OK) ret=csvPutString(&csv, "95%CL2", 0);
147 }
148 }
149 if(ret==TPCERROR_OK && parIsWSS(par))
150 ret=csvPutString(&csv, "WSS", 0);
151 if(ret==TPCERROR_OK && parIsFitRange(par)==2) {
152 ret=csvPutString(&csv, "Start[min]", 0);
153 if(ret==TPCERROR_OK) ret=csvPutString(&csv, "End[min]", 0);
154 }
155 if(ret==TPCERROR_OK && parIsDataNr(par)==2)
156 ret=csvPutString(&csv, "DataNr", 0);
157 if(ret==TPCERROR_OK && parIsFitNr(par)==2)
158 ret=csvPutString(&csv, "FitNr", 0);
159 if(ret!=TPCERROR_OK) {
160 statusSet(status, __func__, __FILE__, __LINE__, ret);
161 csvFree(&csv); return ret;
162 }
163 /* Data table */
164 if(verbose>2) {printf(" writing parameter values\n"); fflush(stdout);}
165 for(ri=0; ri<par->tacNr && ret==TPCERROR_OK; ri++) {
166 if(verbose>3) {printf(" for region %d\n", 1+ri); fflush(stdout);}
167 /* Region names and parameter values */
168 if(strlen(par->r[ri].name)>0) {
169 ret=csvPutString(&csv, par->r[ri].name, 1);
170 } else {
171 char buf[16]; sprintf(buf, "tac%d", 1+ri);
172 ret=csvPutString(&csv, buf, 1);
173 }
174 if(parIsModel(par)==2 && ret==TPCERROR_OK)
175 ret=csvPutString(&csv, modelCode(par->r[ri].model), 0);
176 for(pi=0; pi<par->parNr && ret==TPCERROR_OK; pi++) {
177 ret=csvPutDouble(&csv, par->r[ri].p[pi], 0, tointl);
178 if(ret==TPCERROR_OK && parSDWithPar(par, pi))
179 ret=csvPutDouble(&csv, par->r[ri].sd[pi], 0, tointl);
180 if(ret==TPCERROR_OK && parCLWithPar(par, pi)) {
181 ret=csvPutDouble(&csv, par->r[ri].cl1[pi], 0, tointl);
182 if(ret==TPCERROR_OK)
183 ret=csvPutDouble(&csv, par->r[ri].cl2[pi], 0, tointl);
184 }
185 }
186 /* WSS etc */
187 if(ret==TPCERROR_OK && parIsWSS(par))
188 ret=csvPutDouble(&csv, par->r[ri].wss, 0, tointl);
189 if(ret==TPCERROR_OK && parIsFitRange(par)==2) {
190 ret=csvPutDouble(&csv, par->r[ri].start, 0, tointl);
191 if(ret==TPCERROR_OK) ret=csvPutDouble(&csv, par->r[ri].end, 0, tointl);
192 }
193 if(ret==TPCERROR_OK && parIsDataNr(par)==2)
194 ret=csvPutInt(&csv, par->r[ri].dataNr, 0);
195 if(ret==TPCERROR_OK && parIsFitNr(par)==2)
196 ret=csvPutInt(&csv, par->r[ri].fitNr, 0);
197 }
198 if(ret!=TPCERROR_OK) {
199 statusSet(status, __func__, __FILE__, __LINE__, ret);
200 csvFree(&csv); return ret;
201 }
202
203 /* Write CSV into file pointer */
204 if(verbose>2) {printf(" actually writing CSV in file\n"); fflush(stdout);}
205 ret=csvWrite(&csv, 0, fp, status);
206 csvFree(&csv); fflush(fp);
207 if(ret!=TPCERROR_OK) {csvFree(&csv); return ret;}
208
209 /* Quit */
210 statusSet(status, __func__, __FILE__, __LINE__, ret);
211 return(ret);
212}
csvInit
void csvInit(CSV *csv)
Definition csv.c:22
csvPutInt
int csvPutInt(CSV *csv, int v, int newline)
Definition csv.c:222
csvAllocate
int csvAllocate(CSV *csv, int nr)
Definition csv.c:58
csvPutString
int csvPutString(CSV *csv, const char *s, int newline)
Definition csv.c:144
csvPutDouble
int csvPutDouble(CSV *csv, double v, int newline, int tointl)
Definition csv.c:193
csvFree
void csvFree(CSV *csv)
Definition csv.c:38
csvWrite
int csvWrite(CSV *csv, int regular, FILE *fp, TPCSTATUS *status)
Definition csvio.c:52
iftPut
int iftPut(IFT *ift, const char *key, const char *value, char comment, TPCSTATUS *status)
Definition ift.c:63
iftDeleteKey
void iftDeleteKey(IFT *ift, const char *key)
Definition iftfind.c:169
iftWrite
int iftWrite(IFT *ift, FILE *fp, TPCSTATUS *status)
Definition iftio.c:98
modelCode
char * modelCode(const unsigned int i)
Definition modell.c:175
parIsFitRange
int parIsFitRange(PAR *par)
Definition par.c:267
parSDWithPar
int parSDWithPar(PAR *par, int pi)
Definition par.c:307
parCLWithPar
int parCLWithPar(PAR *par, int pi)
Definition par.c:325
parIsFitNr
int parIsFitNr(PAR *par)
Definition par.c:343
parIsWSS
int parIsWSS(PAR *par)
Definition par.c:252
parIsDataNr
int parIsDataNr(PAR *par)
Definition par.c:362
parIsModel
int parIsModel(PAR *par)
Definition par.c:288
parFormattxt
char * parFormattxt(parformat c)
Definition pario.c:59
CSV
Definition tpccsv.h:36
IFT_ITEM::comment
char comment
Definition tpcift.h:27
UNIT_UNKNOWN
@ UNIT_UNKNOWN
Unknown unit.
Definition tpcextensions.h:85
TPCERROR_CANNOT_WRITE
@ TPCERROR_CANNOT_WRITE
Cannot write file.
Definition tpcextensions.h:199
unitName
char * unitName(int unit_code)
Definition units.c:143
MAX_UNITS_LEN
#define MAX_UNITS_LEN
Define max units string length.
Definition tpcextensions.h:28
unitIsTime
int unitIsTime(int u)
Definition units.c:359
PAR_FORMAT_LAST
@ PAR_FORMAT_LAST
End of list.
Definition tpcpar.h:38

Referenced by parWrite().

Generated on Sat Dec 6 2025 15:22:01 for TPCCLIB by doxygen 1.12.0