?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Work around memory leak in t_state
[gromacs.git] / src / gromacs / fileio / xvgr.cpp
blob6034a4f811eaa2e3f3cc8155647d2f9e9d8a494d
1 /*
2 * This file is part of the GROMACS molecular simulation package.
3 *
4 * Copyright (c) 1991-2000, University of Groningen, The Netherlands.
5 * Copyright (c) 2001-2004, The GROMACS development team.
6 * Copyright (c) 2013,2014,2015, by the GROMACS development team, led by
7 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
8 * and including many others, as listed in the AUTHORS file in the
9 * top-level source directory and at http://www.gromacs.org.
10 *
11 * GROMACS is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public License
13 * as published by the Free Software Foundation; either version 2.1
14 * of the License, or (at your option) any later version.
15 *
16 * GROMACS is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with GROMACS; if not, see
23 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
24 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 *
26 * If you want to redistribute modifications to GROMACS, please
27 * consider that scientific software is very special. Version
28 * control is crucial - bugs must be traceable. We will be happy to
29 * consider code for inclusion in the official distribution, but
30 * derived work must not be called official GROMACS. Details are found
31 * in the README & COPYING files - if they are missing, get the
32 * official version at http://www.gromacs.org.
33 *
34 * To help us fund GROMACS development, we humbly ask that you cite
35 * the research papers on the package. Check out http://www.gromacs.org.
36 */
37 #include "gmxpre.h"
38
39 #include "xvgr.h"
40
41 #include <cctype>
42 #include <cstring>
43
44 #include <string>
45
46 #include "gromacs/fileio/gmxfio.h"
47 #include "gromacs/fileio/oenv.h"
48 #include "gromacs/math/vec.h"
49 #include "gromacs/utility/binaryinformation.h"
50 #include "gromacs/utility/coolstuff.h"
51 #include "gromacs/utility/cstringutil.h"
52 #include "gromacs/utility/exceptions.h"
53 #include "gromacs/utility/fatalerror.h"
54 #include "gromacs/utility/futil.h"
55 #include "gromacs/utility/smalloc.h"
56 #include "gromacs/utility/sysinfo.h"
57
58 gmx_bool output_env_get_print_xvgr_codes(const gmx_output_env_t *oenv)
59 {
60 int xvg_format;
61
62 xvg_format = output_env_get_xvg_format(oenv);
63
64 return (xvg_format == exvgXMGRACE || xvg_format == exvgXMGR);
65 }
66
67 static char *xvgrstr(const char *gmx, const gmx_output_env_t *oenv,
68 char *buf, int buflen)
69 {
70 /* Supported greek letter names and corresponding xmgrace/xmgr symbols */
71 const char *sym[] = { "beta", "chi", "delta", "eta", "lambda", "mu", "omega", "phi", "psi", "rho", "theta", NULL };
72 const char symc[] = { 'b', 'c', 'd', 'h', 'l', 'm', 'w', 'f', 'y', 'r', 'q', '\0' };
73 int xvgf;
74 gmx_bool bXVGR;
75 int g, b, i;
76 char c;
77
78 xvgf = output_env_get_xvg_format(oenv);
79 bXVGR = (xvgf == exvgXMGRACE || xvgf == exvgXMGR);
80
81 g = 0;
82 b = 0;
83 while (gmx[g] != '\0')
84 {
85 /* Check with the largest string we have ("lambda"), add one for \0 */
86 if (b + 6 + 1 >= buflen)
87 {
88 gmx_fatal(FARGS, "Output buffer length in xvgstr (%d) too small to process xvg input string '%s'", buflen, gmx);
89 }
90 if (gmx[g] == '\\')
91 {
92 g++;
93 if (gmx[g] == 's')
94 {
95 /* Subscript */
96 if (bXVGR)
97 {
98 buf[b++] = '\\';
99 buf[b++] = 's';
100 }
101 else
102 {
103 buf[b++] = '_';
104 }
105 g++;
106 }
107 else if (gmx[g] == 'S')
108 {
109 /* Superscript */
110 if (bXVGR)
111 {
112 buf[b++] = '\\';
113 buf[b++] = 'S';
114 }
115 else
116 {
117 buf[b++] = '^';
118 }
119 g++;
120 }
121 else if (gmx[g] == 'N')
122 {
123 /* End sub/superscript */
124 if (bXVGR)
125 {
126 buf[b++] = '\\';
127 buf[b++] = 'N';
128 }
129 else
130 {
131 if (gmx[g+1] != ' ')
132 {
133 buf[b++] = ' ';
134 }
135 }
136 g++;
137 }
138 else if (gmx[g] == '4')
139 {
140 /* Backward compatibility for xmgr normal font "\4" */
141 switch (xvgf)
142 {
143 case exvgXMGRACE:
144 sprintf(buf+b, "%s", "\\f{}");
145 break;
146 case exvgXMGR:
147 sprintf(buf+b, "%s", "\\4");
148 break;
149 default:
150 buf[b] = '\0';
151 break;
152 }
153 g++;
154 b = strlen(buf);
155 }
156 else if (gmx[g] == '8')
157 {
158 /* Backward compatibility for xmgr symbol font "\8" */
159 switch (xvgf)
160 {
161 case exvgXMGRACE:
162 sprintf(buf+b, "%s", "\\x");
163 break;
164 case exvgXMGR:
165 sprintf(buf+b, "%s", "\\8");
166 break;
167 default:
168 buf[b] = '\0';
169 break;
170 }
171 g++;
172 b = std::strlen(buf);
173 }
174 else
175 {
176 /* Check for special symbol */
177 i = 0;
178 while (sym[i] != NULL &&
179 gmx_strncasecmp(sym[i], gmx+g, std::strlen(sym[i])) != 0)
180 {
181 i++;
182 }
183 if (sym[i] != NULL)
184 {
185 c = symc[i];
186 if (std::isupper(gmx[g]))
187 {
188 c = std::toupper(c);
189 }
190 switch (xvgf)
191 {
192 case exvgXMGRACE:
193 sprintf(buf+b, "%s%c%s", "\\x", c, "\\f{}");
194 break;
195 case exvgXMGR:
196 sprintf(buf+b, "%s%c%s", "\\8", c, "\\4");
197 break;
198 default:
199 std::strncat(buf+b, gmx+g, std::strlen(sym[i]));
200 b += std::strlen(sym[i]);
201 if (gmx[g+std::strlen(sym[i])] != ' ')
202 {
203 buf[b++] = ' ';
204 }
205 buf[b] = '\0';
206 break;
207 }
208 g += std::strlen(sym[i]);
209 b = std::strlen(buf);
210 }
211 else
212 {
213 /* Unknown escape sequence, this should not happen.
214 * We do not generate a fatal error, since that might
215 * stop otherwise functioning code from working.
216 * Copy the backslash to the output and continue processing.
217 */
218 buf[b++] = '\\';
219 }
220 }
221 }
222 else
223 {
224 buf[b++] = gmx[g++];
225 }
226 }
227
228 buf[b++] = '\0';
229
230 return buf;
231 }
232
233 void xvgr_header(FILE *fp, const char *title, const char *xaxis,
234 const char *yaxis, int exvg_graph_type,
235 const gmx_output_env_t *oenv)
236 {
237 char buf[STRLEN];
238
239 if (output_env_get_print_xvgr_codes(oenv))
240 {
241 gmx_format_current_time(buf, STRLEN);
242 fprintf(fp, "# This file was created %s", buf);
243 try
244 {
245 gmx::BinaryInformationSettings settings;
246 settings.generatedByHeader(true);
247 settings.linePrefix("# ");
248 gmx::printBinaryInformation(fp, output_env_get_program_context(oenv),
249 settings);
250 }
251 GMX_CATCH_ALL_AND_EXIT_WITH_FATAL_ERROR;
252 fprintf(fp, "# %s is part of G R O M A C S:\n#\n",
253 output_env_get_program_display_name(oenv));
254 fprintf(fp, "# %s\n#\n", gmx::bromacs().c_str());
255 fprintf(fp, "@ title \"%s\"\n", xvgrstr(title, oenv, buf, STRLEN));
256 fprintf(fp, "@ xaxis label \"%s\"\n",
257 xvgrstr(xaxis, oenv, buf, STRLEN));
258 fprintf(fp, "@ yaxis label \"%s\"\n",
259 xvgrstr(yaxis, oenv, buf, STRLEN));
260 switch (exvg_graph_type)
261 {
262 case exvggtXNY:
263 if (output_env_get_xvg_format(oenv) == exvgXMGR)
264 {
265 fprintf(fp, "@TYPE nxy\n");
266 }
267 else
268 {
269 fprintf(fp, "@TYPE xy\n");
270 }
271 break;
272 case exvggtXYDY:
273 fprintf(fp, "@TYPE xydy\n");
274 break;
275 case exvggtXYDYDY:
276 fprintf(fp, "@TYPE xydydy\n");
277 break;
278 }
279 }
280 }
281
282 FILE *xvgropen_type(const char *fn, const char *title, const char *xaxis,
283 const char *yaxis, int exvg_graph_type,
284 const gmx_output_env_t *oenv)
285 {
286 FILE *fp;
287
288 fp = gmx_fio_fopen(fn, "w");
289
290 xvgr_header(fp, title, xaxis, yaxis, exvg_graph_type, oenv);
291
292 return fp;
293 }
294
295 FILE *xvgropen(const char *fn, const char *title, const char *xaxis,
296 const char *yaxis, const gmx_output_env_t *oenv)
297 {
298 return xvgropen_type(fn, title, xaxis, yaxis, exvggtXNY, oenv);
299 }
300
301 void
302 xvgrclose(FILE *fp)
303 {
304 gmx_fio_fclose(fp);
305 }
306
307 void xvgr_subtitle(FILE *out, const char *subtitle, const gmx_output_env_t *oenv)
308 {
309 char buf[STRLEN];
310
311 if (output_env_get_print_xvgr_codes(oenv))
312 {
313 fprintf(out, "@ subtitle \"%s\"\n", xvgrstr(subtitle, oenv, buf, STRLEN));
314 }
315 }
316
317 void xvgr_view(FILE *out, real xmin, real ymin, real xmax, real ymax,
318 const gmx_output_env_t *oenv)
319 {
320 if (output_env_get_print_xvgr_codes(oenv))
321 {
322 fprintf(out, "@ view %g, %g, %g, %g\n", xmin, ymin, xmax, ymax);
323 }
324 }
325
326 void xvgr_world(FILE *out, real xmin, real ymin, real xmax, real ymax,
327 const gmx_output_env_t *oenv)
328 {
329 if (output_env_get_print_xvgr_codes(oenv))
330 {
331 fprintf(out, "@ world xmin %g\n"
332 "@ world ymin %g\n"
333 "@ world xmax %g\n"
334 "@ world ymax %g\n", xmin, ymin, xmax, ymax);
335 }
336 }
337
338 void xvgr_legend(FILE *out, int nsets, const char** setname,
339 const gmx_output_env_t *oenv)
340 {
341 int i;
342 char buf[STRLEN];
343
344 if (output_env_get_print_xvgr_codes(oenv))
345 {
346 xvgr_view(out, 0.15, 0.15, 0.75, 0.85, oenv);
347 fprintf(out, "@ legend on\n");
348 fprintf(out, "@ legend box on\n");
349 fprintf(out, "@ legend loctype view\n");
350 fprintf(out, "@ legend %g, %g\n", 0.78, 0.8);
351 fprintf(out, "@ legend length %d\n", 2);
352 for (i = 0; (i < nsets); i++)
353 {
354 if (setname[i])
355 {
356 if (output_env_get_xvg_format(oenv) == exvgXMGR)
357 {
358 fprintf(out, "@ legend string %d \"%s\"\n",
359 i, xvgrstr(setname[i], oenv, buf, STRLEN));
360 }
361 else
362 {
363 fprintf(out, "@ s%d legend \"%s\"\n",
364 i, xvgrstr(setname[i], oenv, buf, STRLEN));
365 }
366 }
367 }
368 }
369 }
370
371 void xvgr_new_dataset(FILE *out, int nr_first, int nsets,
372 const char **setname,
373 const gmx_output_env_t *oenv)
374 {
375 int i;
376 char buf[STRLEN];
377
378 if (output_env_get_print_xvgr_codes(oenv))
379 {
380 fprintf(out, "@\n");
381 for (i = 0; (i < nsets); i++)
382 {
383 if (setname[i])
384 {
385 if (output_env_get_xvg_format(oenv) == exvgXMGR)
386 {
387 fprintf(out, "@ legend string %d \"%s\"\n",
388 i+nr_first, xvgrstr(setname[i], oenv, buf, STRLEN));
389 }
390 else
391 {
392 fprintf(out, "@ s%d legend \"%s\"\n",
393 i+nr_first, xvgrstr(setname[i], oenv, buf, STRLEN));
394 }
395 }
396 }
397 }
398 else
399 {
400 fprintf(out, "\n");
401 }
402 }
403
404 void xvgr_line_props(FILE *out, int NrSet, int LineStyle, int LineColor,
405 const gmx_output_env_t *oenv)
406 {
407 if (output_env_get_print_xvgr_codes(oenv))
408 {
409 fprintf(out, "@ with g0\n");
410 fprintf(out, "@ s%d linestyle %d\n", NrSet, LineStyle);
411 fprintf(out, "@ s%d color %d\n", NrSet, LineColor);
412 }
413 }
414
415 static const char *LocTypeStr[] = { "view", "world" };
416 static const char *BoxFillStr[] = { "none", "color", "pattern" };
417
418 void xvgr_box(FILE *out,
419 int LocType,
420 real xmin, real ymin, real xmax, real ymax,
421 int LineStyle, int LineWidth, int LineColor,
422 int BoxFill, int BoxColor, int BoxPattern, const gmx_output_env_t *oenv)
423 {
424 if (output_env_get_print_xvgr_codes(oenv))
425 {
426 fprintf(out, "@with box\n");
427 fprintf(out, "@ box on\n");
428 fprintf(out, "@ box loctype %s\n", LocTypeStr[LocType]);
429 fprintf(out, "@ box %g, %g, %g, %g\n", xmin, ymin, xmax, ymax);
430 fprintf(out, "@ box linestyle %d\n", LineStyle);
431 fprintf(out, "@ box linewidth %d\n", LineWidth);
432 fprintf(out, "@ box color %d\n", LineColor);
433 fprintf(out, "@ box fill %s\n", BoxFillStr[BoxFill]);
434 fprintf(out, "@ box fill color %d\n", BoxColor);
435 fprintf(out, "@ box fill pattern %d\n", BoxPattern);
436 fprintf(out, "@box def\n");
437 }
438 }
439
440 /* reads a line into ptr, adjusting len and renewing ptr if neccesary */
441 static char *fgets3(FILE *fp, char **ptr, int *len, int maxlen)
442 {
443 int len_remaining = *len; /* remaining amount of allocated bytes in buf */
444 int curp = 0; /* current position in buf to read into */
445
446 do
447 {
448 if (len_remaining < 2)
449 {
450 if (*len + STRLEN < maxlen)
451 {
452 /* This line is longer than len characters, let's increase len! */
453 *len += STRLEN;
454 len_remaining += STRLEN;
455 srenew(*ptr, *len);
456 }
457 else
458 {
459 /*something is wrong, we'll just keep reading and return NULL*/
460 len_remaining = STRLEN;
461 curp = 0;
462 }
463 }
464 if (fgets(*ptr + curp, len_remaining, fp) == NULL)
465 {
466 /* if last line, skip */
467 return NULL;
468 }
469 curp += len_remaining-1; /* overwrite the nul char in next iteration */
470 len_remaining = 1;
471 }
472 while ((std::strchr(*ptr, '\n') == NULL) && (!feof(fp)));
473
474 if (*len + STRLEN >= maxlen)
475 {
476 return NULL; /* this line was too long */
477 }
478
479 if (feof(fp))
480 {
481 /* We reached EOF before '\n', skip this last line. */
482 return NULL;
483 }
484 {
485 /* now remove newline */
486 int slen = std::strlen(*ptr);
487 if ((*ptr)[slen-1] == '\n')
488 {
489 (*ptr)[slen-1] = '\0';
490 }
491 }
492
493 return *ptr;
494 }
495
496 static int wordcount(char *ptr)
497 {
498 int i, n = 0, is[2];
499 int cur = 0;
500 #define prev (1-cur)
501
502 if (NULL != ptr)
503 {
504 for (i = 0; (ptr[i] != '\0'); i++)
505 {
506 is[cur] = std::isspace(ptr[i]);
507 if ((0 == i) && !is[cur])
508 {
509 n++;
510 }
511 else if ((i > 0) && (!is[cur] && is[prev]))
512 {
513 n++;
514 }
515 cur = prev;
516 }
517 }
518 return n;
519 }
520
521 static char *read_xvgr_string(const char *line)
522 {
523 const char *ptr0, *ptr1;
524 char *str;
525
526 ptr0 = std::strchr(line, '"');
527 if (ptr0 != NULL)
528 {
529 ptr0++;
530 ptr1 = std::strchr(ptr0, '"');
531 if (ptr1 != NULL)
532 {
533 str = gmx_strdup(ptr0);
534 str[ptr1-ptr0] = '\0';
535 }
536 else
537 {
538 str = gmx_strdup("");
539 }
540 }
541 else
542 {
543 str = gmx_strdup("");
544 }
545
546 return str;
547 }
548
549 int read_xvg_legend(const char *fn, double ***y, int *ny,
550 char **subtitle, char ***legend)
551 {
552 FILE *fp;
553 char *ptr;
554 char *base = NULL;
555 char *fmt = NULL;
556 int k, line = 0, nny, nx, maxx, rval, legend_nalloc, set, nchar;
557 double lf;
558 double **yy = NULL;
559 char *tmpbuf;
560 int len = STRLEN;
561 *ny = 0;
562 nny = 0;
563 nx = 0;
564 maxx = 0;
565 fp = gmx_fio_fopen(fn, "r");
566
567 snew(tmpbuf, len);
568 if (subtitle != NULL)
569 {
570 *subtitle = NULL;
571 }
572 legend_nalloc = 0;
573 if (legend != NULL)
574 {
575 *legend = NULL;
576 }
577
578 while ((ptr = fgets3(fp, &tmpbuf, &len, 10*STRLEN)) != NULL && ptr[0] != '&')
579 {
580 line++;
581 trim(ptr);
582 if (ptr[0] == '@')
583 {
584 if (legend != NULL)
585 {
586 ptr++;
587 trim(ptr);
588 set = -1;
589 if (std::strncmp(ptr, "subtitle", 8) == 0)
590 {
591 ptr += 8;
592 if (subtitle != NULL)
593 {
594 *subtitle = read_xvgr_string(ptr);
595 }
596 }
597 else if (std::strncmp(ptr, "legend string", 13) == 0)
598 {
599 ptr += 13;
600 sscanf(ptr, "%d%n", &set, &nchar);
601 ptr += nchar;
602 }
603 else if (ptr[0] == 's')
604 {
605 ptr++;
606 sscanf(ptr, "%d%n", &set, &nchar);
607 ptr += nchar;
608 trim(ptr);
609 if (std::strncmp(ptr, "legend", 6) == 0)
610 {
611 ptr += 6;
612 }
613 else
614 {
615 set = -1;
616 }
617 }
618 if (set >= 0)
619 {
620 if (set >= legend_nalloc)
621 {
622 legend_nalloc = set + 1;
623 srenew(*legend, legend_nalloc);
624 (*legend)[set] = read_xvgr_string(ptr);
625 }
626 }
627 }
628 }
629 else if (ptr[0] != '#')
630 {
631 if (nny == 0)
632 {
633 (*ny) = nny = wordcount(ptr);
634 /* fprintf(stderr,"There are %d columns in your file\n",nny);*/
635 if (nny == 0)
636 {
637 return 0;
638 }
639 snew(yy, nny);
640 snew(fmt, 3*nny+1);
641 snew(base, 3*nny+1);
642 }
643 /* Allocate column space */
644 if (nx >= maxx)
645 {
646 maxx += 1024;
647 for (k = 0; (k < nny); k++)
648 {
649 srenew(yy[k], maxx);
650 }
651 }
652 /* Initiate format string */
653 fmt[0] = '\0';
654 base[0] = '\0';
655
656 /* fprintf(stderr,"ptr='%s'\n",ptr);*/
657 for (k = 0; (k < nny); k++)
658 {
659 std::strcpy(fmt, base);
660 std::strcat(fmt, "%lf");
661 rval = sscanf(ptr, fmt, &lf);
662 /* fprintf(stderr,"rval = %d\n",rval);*/
663 if ((rval == EOF) || (rval == 0))
664 {
665 break;
666 }
667 yy[k][nx] = lf;
668 srenew(fmt, 3*(nny+1)+1);
669 srenew(base, 3*nny+1);
670 std::strcat(base, "%*s");
671 }
672 if (k != nny)
673 {
674 fprintf(stderr, "Only %d columns on line %d in file %s\n",
675 k, line, fn);
676 for (; (k < nny); k++)
677 {
678 yy[k][nx] = 0.0;
679 }
680 }
681 nx++;
682 }
683 }
684 gmx_fio_fclose(fp);
685
686 *y = yy;
687 sfree(tmpbuf);
688 sfree(base);
689 sfree(fmt);
690
691 if (legend_nalloc > 0)
692 {
693 if (*ny - 1 > legend_nalloc)
694 {
695 srenew(*legend, *ny-1);
696 for (set = legend_nalloc; set < *ny-1; set++)
697 {
698 (*legend)[set] = NULL;
699 }
700 }
701 }
702
703 return nx;
704 }
705
706 int read_xvg(const char *fn, double ***y, int *ny)
707 {
708 return read_xvg_legend(fn, y, ny, NULL, NULL);
709 }
710
711 void write_xvg(const char *fn, const char *title, int nx, int ny, real **y,
712 const char **leg, const gmx_output_env_t *oenv)
713 {
714 FILE *fp;
715 int i, j;
716
717 fp = xvgropen(fn, title, "X", "Y", oenv);
718 if (leg)
719 {
720 xvgr_legend(fp, ny-1, leg, oenv);
721 }
722 for (i = 0; (i < nx); i++)
723 {
724 for (j = 0; (j < ny); j++)
725 {
726 fprintf(fp, " %12.5e", y[j][i]);
727 }
728 fprintf(fp, "\n");
729 }
730 xvgrclose(fp);
731 }
732
733 real **read_xvg_time(const char *fn,
734 gmx_bool bHaveT, gmx_bool bTB, real tb, gmx_bool bTE, real te,
735 int nsets_in, int *nset, int *nval, real *dt, real **t)
736 {
737 FILE *fp;
738 #define MAXLINELEN 16384
739 char line0[MAXLINELEN];
740 char *line;
741 int t_nalloc, *val_nalloc, a, narg, n, sin, set, nchar;
742 double dbl;
743 gmx_bool bEndOfSet, bTimeInRange, bFirstLine = TRUE;
744 real **val;
745
746 t_nalloc = 0;
747 *t = NULL;
748 val = NULL;
749 val_nalloc = NULL;
750 *nset = 0;
751 *dt = 0;
752 fp = gmx_fio_fopen(fn, "r");
753 for (sin = 0; sin < nsets_in; sin++)
754 {
755 if (nsets_in == 1)
756 {
757 narg = 0;
758 }
759 else
760 {
761 narg = bHaveT ? 2 : 1;
762 }
763 n = 0;
764 bEndOfSet = FALSE;
765 while (!bEndOfSet && fgets(line0, MAXLINELEN, fp))
766 {
767 line = line0;
768 /* Remove whitespace */
769 while (line[0] == ' ' || line[0] == '\t')
770 {
771 line++;
772 }
773 bEndOfSet = (line[0] == '&');
774 if (line[0] != '#' && line[0] != '@' && line[0] != '\n' && !bEndOfSet)
775 {
776 if (bFirstLine && bHaveT)
777 {
778 /* Check the first line that should contain data */
779 a = sscanf(line, "%lf%lf", &dbl, &dbl);
780 if (a == 0)
781 {
782 gmx_fatal(FARGS, "Expected a number in %s on line:\n%s", fn, line0);
783 }
784 else if (a == 1)
785 {
786 fprintf(stderr, "Found only 1 number on line, "
787 "assuming no time is present.\n");
788 bHaveT = FALSE;
789 if (nsets_in > 1)
790 {
791 narg = 1;
792 }
793 }
794 }
795
796 a = 0;
797 bTimeInRange = TRUE;
798 while ((a < narg || (nsets_in == 1 && n == 0)) &&
799 sscanf(line, "%lf%n", &dbl, &nchar) == 1 && bTimeInRange)
800 {
801 /* Use set=-1 as the time "set" */
802 if (sin)
803 {
804 if (!bHaveT || (a > 0))
805 {
806 set = sin;
807 }
808 else
809 {
810 set = -1;
811 }
812 }
813 else
814 {
815 if (!bHaveT)
816 {
817 set = a;
818 }
819 else
820 {
821 set = a-1;
822 }
823 }
824 if (set == -1 && ((bTB && dbl < tb) || (bTE && dbl > te)))
825 {
826 bTimeInRange = FALSE;
827 }
828
829 if (bTimeInRange)
830 {
831 if (n == 0)
832 {
833 if (nsets_in == 1)
834 {
835 narg++;
836 }
837 if (set >= 0)
838 {
839 *nset = set+1;
840 srenew(val, *nset);
841 srenew(val_nalloc, *nset);
842 val_nalloc[set] = 0;
843 val[set] = NULL;
844 }
845 }
846 if (set == -1)
847 {
848 if (sin == 0)
849 {
850 if (n >= t_nalloc)
851 {
852 t_nalloc = over_alloc_small(n);
853 srenew(*t, t_nalloc);
854 }
855 (*t)[n] = dbl;
856 }
857 /* else we should check the time of the next sets with set 0 */
858 }
859 else
860 {
861 if (n >= val_nalloc[set])
862 {
863 val_nalloc[set] = over_alloc_small(n);
864 srenew(val[set], val_nalloc[set]);
865 }
866 val[set][n] = (real)dbl;
867 }
868 }
869 a++;
870 line += nchar;
871 }
872 if (line0[strlen(line0)-1] != '\n')
873 {
874 fprintf(stderr, "File %s does not end with a newline, ignoring the last line\n", fn);
875 }
876 else if (bTimeInRange)
877 {
878 if (a == 0)
879 {
880 fprintf(stderr, "Ignoring invalid line in %s:\n%s", fn, line0);
881 }
882 else
883 {
884 if (a != narg)
885 {
886 fprintf(stderr, "Invalid line in %s:\n%s"
887 "Using zeros for the last %d sets\n",
888 fn, line0, narg-a);
889 }
890 n++;
891 }
892 }
893 if (a > 0)
894 {
895 bFirstLine = FALSE;
896 }
897 }
898 }
899 if (sin == 0)
900 {
901 *nval = n;
902 if (!bHaveT)
903 {
904 snew(*t, n);
905 for (a = 0; a < n; a++)
906 {
907 (*t)[a] = a;
908 }
909 }
910 if (n > 1)
911 {
912 *dt = (real)((*t)[n-1]-(*t)[0])/(n-1.0);
913 }
914 else
915 {
916 *dt = 1;
917 }
918 }
919 else
920 {
921 if (n < *nval)
922 {
923 fprintf(stderr, "Set %d is shorter (%d) than the previous set (%d)\n",
924 sin+1, n, *nval);
925 *nval = n;
926 fprintf(stderr, "Will use only the first %d points of every set\n",
927 *nval);
928 }
929 }
930 }
931 gmx_fio_fclose(fp);
932
933 sfree(val_nalloc);
934
935 return val;
936 }
The ultimate molecular dynamics simulation package