src/gromacs/gmxlib/readinp.c

   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 "gromacs/legacyheaders/readinp.h"
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43
  44 #include "gromacs/fileio/gmxfio.h"
  45 #include "gromacs/legacyheaders/macros.h"
  46 #include "gromacs/legacyheaders/names.h"
  47 #include "gromacs/legacyheaders/typedefs.h"
  48 #include "gromacs/legacyheaders/warninp.h"
  49 #include "gromacs/utility/cstringutil.h"
  50 #include "gromacs/utility/fatalerror.h"
  51 #include "gromacs/utility/futil.h"
  52 #include "gromacs/utility/qsort_threadsafe.h"
  53 #include "gromacs/utility/smalloc.h"
  54
  55 t_inpfile *read_inpfile(const char *fn, int *ninp,
  56                         warninp_t wi)
  57 {
  58     FILE      *in;
  59     char       buf[STRLEN], lbuf[STRLEN], rbuf[STRLEN], warn_buf[STRLEN];
  60     char      *ptr, *cptr;
  61     t_inpfile *inp = NULL;
  62     int        nin, lc, i, j, k;
  63     /* setting cppopts from command-line options would be cooler */
  64     gmx_bool   allow_override = FALSE;
  65
  66
  67     if (debug)
  68     {
  69         fprintf(debug, "Reading MDP file %s\n", fn);
  70     }
  71
  72     in = gmx_ffopen(fn, "r");
  73
  74     nin = lc  = 0;
  75     do
  76     {
  77         ptr = fgets2(buf, STRLEN-1, in);
  78         lc++;
  79         set_warning_line(wi, fn, lc);
  80         if (ptr)
  81         {
  82             /* Strip comment */
  83             if ((cptr = strchr(buf, COMMENTSIGN)) != NULL)
  84             {
  85                 *cptr = '\0';
  86             }
  87             /* Strip spaces */
  88             trim(buf);
  89
  90             for (j = 0; (buf[j] != '=') && (buf[j] != '\0'); j++)
  91             {
  92                 ;
  93             }
  94             if (buf[j] == '\0')
  95             {
  96                 if (j > 0)
  97                 {
  98                     if (debug)
  99                     {
 100                         fprintf(debug, "No = on line %d in file %s, ignored\n", lc, fn);
 101                     }
 102                 }
 103             }
 104             else
 105             {
 106                 for (i = 0; (i < j); i++)
 107                 {
 108                     lbuf[i] = buf[i];
 109                 }
 110                 lbuf[i] = '\0';
 111                 trim(lbuf);
 112                 if (lbuf[0] == '\0')
 113                 {
 114                     if (debug)
 115                     {
 116                         fprintf(debug, "Empty left hand side on line %d in file %s, ignored\n", lc, fn);
 117                     }
 118                 }
 119                 else
 120                 {
 121                     for (i = j+1, k = 0; (buf[i] != '\0'); i++, k++)
 122                     {
 123                         rbuf[k] = buf[i];
 124                     }
 125                     rbuf[k] = '\0';
 126                     trim(rbuf);
 127                     if (rbuf[0] == '\0')
 128                     {
 129                         if (debug)
 130                         {
 131                             fprintf(debug, "Empty right hand side on line %d in file %s, ignored\n", lc, fn);
 132                         }
 133                     }
 134                     else
 135                     {
 136                         /* Now finally something sensible */
 137                         int found_index;
 138
 139                         /* first check whether we hit the 'multiple_entries' option */
 140                         if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptName], lbuf) == 0)
 141                         {
 142                             /* we now check whether to allow overrides from here or not */
 143                             if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptNo], rbuf) == 0)
 144                             {
 145                                 allow_override = FALSE;
 146                             }
 147                             else if (gmx_strcasecmp_min(eMultentOpt_names[eMultentOptLast], rbuf) == 0)
 148                             {
 149                                 allow_override = TRUE;
 150                             }
 151                             else
 152                             {
 153                                 sprintf(warn_buf,
 154                                         "Parameter \"%s\" should either be %s or %s\n",
 155                                         lbuf,
 156                                         eMultentOpt_names[eMultentOptNo],
 157                                         eMultentOpt_names[eMultentOptLast]);
 158                                 warning_error(wi, warn_buf);
 159                             }
 160                         }
 161                         else
 162                         {
 163                             /* it is a regular option; check for duplicates */
 164                             found_index = search_einp(nin, inp, lbuf);
 165
 166                             if (found_index == -1)
 167                             {
 168                                 /* add a new item */
 169                                 srenew(inp, ++nin);
 170                                 inp[nin-1].inp_count  = 1;
 171                                 inp[nin-1].count      = 0;
 172                                 inp[nin-1].bObsolete  = FALSE;
 173                                 inp[nin-1].bSet       = FALSE;
 174                                 inp[nin-1].name       = gmx_strdup(lbuf);
 175                                 inp[nin-1].value      = gmx_strdup(rbuf);
 176                             }
 177                             else
 178                             {
 179                                 if (!allow_override)
 180                                 {
 181                                     sprintf(warn_buf,
 182                                             "Parameter \"%s\" doubly defined (and multiple assignments not allowed)\n",
 183                                             lbuf);
 184                                     warning_error(wi, warn_buf);
 185                                 }
 186                                 else
 187                                 {
 188                                     /* override */
 189                                     sfree(inp[found_index].value);
 190                                     inp[found_index].value = gmx_strdup(rbuf);
 191                                     sprintf(warn_buf,
 192                                             "Overriding existing parameter \"%s\" with value \"%s\"\n",
 193                                             lbuf, rbuf);
 194                                     warning_note(wi, warn_buf);
 195                                 }
 196                             }
 197                         }
 198                     }
 199                 }
 200             }
 201         }
 202     }
 203     while (ptr);
 204
 205     gmx_ffclose(in);
 206
 207     if (debug)
 208     {
 209         fprintf(debug, "Done reading MDP file, there were %d entries in there\n",
 210                 nin);
 211     }
 212
 213     *ninp = nin;
 214
 215     return inp;
 216 }
 217
 218
 219
 220
 221 static int inp_comp(const void *a, const void *b)
 222 {
 223     return ((t_inpfile *)a)->count - ((t_inpfile *)b)->count;
 224 }
 225
 226 static void sort_inp(int ninp, t_inpfile inp[])
 227 {
 228     int i, mm;
 229
 230     mm = -1;
 231     for (i = 0; (i < ninp); i++)
 232     {
 233         mm = max(mm, inp[i].count);
 234     }
 235     for (i = 0; (i < ninp); i++)
 236     {
 237         if (inp[i].count == 0)
 238         {
 239             inp[i].count = mm++;
 240         }
 241     }
 242     gmx_qsort(inp, ninp, (size_t)sizeof(inp[0]), inp_comp);
 243 }
 244
 245 void write_inpfile(const char *fn, int ninp, t_inpfile inp[], gmx_bool bHaltOnUnknown,
 246                    warninp_t wi)
 247 {
 248     FILE *out;
 249     int   i;
 250     char  warn_buf[STRLEN];
 251
 252     sort_inp(ninp, inp);
 253     out = gmx_fio_fopen(fn, "w");
 254     nice_header(out, fn);
 255     for (i = 0; (i < ninp); i++)
 256     {
 257         if (inp[i].bSet)
 258         {
 259             if (inp[i].name[0] == ';' || (strlen(inp[i].name) > 2 && inp[i].name[1] == ';'))
 260             {
 261                 fprintf(out, "%-24s\n", inp[i].name);
 262             }
 263             else
 264             {
 265                 fprintf(out, "%-24s = %s\n", inp[i].name, inp[i].value ? inp[i].value : "");
 266             }
 267         }
 268         else if (!inp[i].bObsolete)
 269         {
 270             sprintf(warn_buf, "Unknown left-hand '%s' in parameter file\n",
 271                     inp[i].name);
 272             if (bHaltOnUnknown)
 273             {
 274                 warning_error(wi, warn_buf);
 275             }
 276             else
 277             {
 278                 warning(wi, warn_buf);
 279             }
 280         }
 281     }
 282     gmx_fio_fclose(out);
 283
 284     check_warning_error(wi, FARGS);
 285 }
 286
 287 void replace_inp_entry(int ninp, t_inpfile *inp, const char *old_entry, const char *new_entry)
 288 {
 289     int  i;
 290
 291     for (i = 0; (i < ninp); i++)
 292     {
 293         if (gmx_strcasecmp_min(old_entry, inp[i].name) == 0)
 294         {
 295             if (new_entry)
 296             {
 297                 fprintf(stderr, "Replacing old mdp entry '%s' by '%s'\n",
 298                         inp[i].name, new_entry);
 299                 sfree(inp[i].name);
 300                 inp[i].name = gmx_strdup(new_entry);
 301             }
 302             else
 303             {
 304                 fprintf(stderr, "Ignoring obsolete mdp entry '%s'\n",
 305                         inp[i].name);
 306                 inp[i].bObsolete = TRUE;
 307             }
 308         }
 309     }
 310 }
 311
 312 int search_einp(int ninp, const t_inpfile *inp, const char *name)
 313 {
 314     int i;
 315
 316     if (inp == NULL)
 317     {
 318         return -1;
 319     }
 320     for (i = 0; i < ninp; i++)
 321     {
 322         if (gmx_strcasecmp_min(name, inp[i].name) == 0)
 323         {
 324             return i;
 325         }
 326     }
 327     return -1;
 328 }
 329
 330 static int get_einp(int *ninp, t_inpfile **inp, const char *name)
 331 {
 332     int    i;
 333     int    notfound = FALSE;
 334     char   warn_buf[STRLEN];
 335
 336 /*  if (inp==NULL)
 337     return -1;
 338    for(i=0; (i<(*ninp)); i++)
 339     if (gmx_strcasecmp_min(name,(*inp)[i].name) == 0)
 340       break;
 341    if (i == (*ninp)) {*/
 342     i = search_einp(*ninp, *inp, name);
 343     if (i == -1)
 344     {
 345         notfound = TRUE;
 346         i        = (*ninp)++;
 347         srenew(*inp, (*ninp));
 348         (*inp)[i].name = gmx_strdup(name);
 349         (*inp)[i].bSet = TRUE;
 350     }
 351     (*inp)[i].count = (*inp)[0].inp_count++;
 352     (*inp)[i].bSet  = TRUE;
 353     if (debug)
 354     {
 355         fprintf(debug, "Inp %d = %s\n", (*inp)[i].count, (*inp)[i].name);
 356     }
 357
 358     /*if (i == (*ninp)-1)*/
 359     if (notfound)
 360     {
 361         return -1;
 362     }
 363     else
 364     {
 365         return i;
 366     }
 367 }
 368
 369 int get_eint(int *ninp, t_inpfile **inp, const char *name, int def,
 370              warninp_t wi)
 371 {
 372     char buf[32], *ptr, warn_buf[STRLEN];
 373     int  ii;
 374     int  ret;
 375
 376     ii = get_einp(ninp, inp, name);
 377
 378     if (ii == -1)
 379     {
 380         sprintf(buf, "%d", def);
 381         (*inp)[(*ninp)-1].value = gmx_strdup(buf);
 382
 383         return def;
 384     }
 385     else
 386     {
 387         ret = strtol((*inp)[ii].value, &ptr, 10);
 388         if (ptr == (*inp)[ii].value)
 389         {
 390             sprintf(warn_buf, "Right hand side '%s' for parameter '%s' in parameter file is not an integer value\n", (*inp)[ii].value, (*inp)[ii].name);
 391             warning_error(wi, warn_buf);
 392         }
 393
 394         return ret;
 395     }
 396 }
 397
 398 gmx_int64_t get_eint64(int *ninp, t_inpfile **inp,
 399                        const char *name, gmx_int64_t def,
 400                        warninp_t wi)
 401 {
 402     char            buf[32], *ptr, warn_buf[STRLEN];
 403     int             ii;
 404     gmx_int64_t     ret;
 405
 406     ii = get_einp(ninp, inp, name);
 407
 408     if (ii == -1)
 409     {
 410         sprintf(buf, "%"GMX_PRId64, def);
 411         (*inp)[(*ninp)-1].value = gmx_strdup(buf);
 412
 413         return def;
 414     }
 415     else
 416     {
 417         ret = str_to_int64_t((*inp)[ii].value, &ptr);
 418         if (ptr == (*inp)[ii].value)
 419         {
 420             sprintf(warn_buf, "Right hand side '%s' for parameter '%s' in parameter file is not an integer value\n", (*inp)[ii].value, (*inp)[ii].name);
 421             warning_error(wi, warn_buf);
 422         }
 423
 424         return ret;
 425     }
 426 }
 427
 428 double get_ereal(int *ninp, t_inpfile **inp, const char *name, double def,
 429                  warninp_t wi)
 430 {
 431     char   buf[32], *ptr, warn_buf[STRLEN];
 432     int    ii;
 433     double ret;
 434
 435     ii = get_einp(ninp, inp, name);
 436
 437     if (ii == -1)
 438     {
 439         sprintf(buf, "%g", def);
 440         (*inp)[(*ninp)-1].value = gmx_strdup(buf);
 441
 442         return def;
 443     }
 444     else
 445     {
 446         ret = strtod((*inp)[ii].value, &ptr);
 447         if (ptr == (*inp)[ii].value)
 448         {
 449             sprintf(warn_buf, "Right hand side '%s' for parameter '%s' in parameter file is not a real value\n", (*inp)[ii].value, (*inp)[ii].name);
 450             warning_error(wi, warn_buf);
 451         }
 452
 453         return ret;
 454     }
 455 }
 456
 457 const char *get_estr(int *ninp, t_inpfile **inp, const char *name, const char *def)
 458 {
 459     char buf[32];
 460     int  ii;
 461
 462     ii = get_einp(ninp, inp, name);
 463
 464     if (ii == -1)
 465     {
 466         if (def)
 467         {
 468             sprintf(buf, "%s", def);
 469             (*inp)[(*ninp)-1].value = gmx_strdup(buf);
 470         }
 471         else
 472         {
 473             (*inp)[(*ninp)-1].value = NULL;
 474         }
 475
 476         return def;
 477     }
 478     else
 479     {
 480         return (*inp)[ii].value;
 481     }
 482 }
 483
 484 int get_eeenum(int *ninp, t_inpfile **inp, const char *name, const char **defs,
 485                warninp_t wi)
 486 {
 487     int  ii, i, j;
 488     int  n = 0;
 489     char buf[STRLEN];
 490
 491     ii = get_einp(ninp, inp, name);
 492
 493     if (ii == -1)
 494     {
 495         (*inp)[(*ninp)-1].value = gmx_strdup(defs[0]);
 496
 497         return 0;
 498     }
 499
 500     for (i = 0; (defs[i] != NULL); i++)
 501     {
 502         if (gmx_strcasecmp_min(defs[i], (*inp)[ii].value) == 0)
 503         {
 504             break;
 505         }
 506     }
 507
 508     if (defs[i] == NULL)
 509     {
 510         n += sprintf(buf, "Invalid enum '%s' for variable %s, using '%s'\n",
 511                      (*inp)[ii].value, name, defs[0]);
 512         n += sprintf(buf+n, "Next time use one of:");
 513         j  = 0;
 514         while (defs[j])
 515         {
 516             n += sprintf(buf+n, " '%s'", defs[j]);
 517             j++;
 518         }
 519         if (wi != NULL)
 520         {
 521             warning_error(wi, buf);
 522         }
 523         else
 524         {
 525             fprintf(stderr, "%s\n", buf);
 526         }
 527
 528         (*inp)[ii].value = gmx_strdup(defs[0]);
 529
 530         return 0;
 531     }
 532
 533     return i;
 534 }
 535
 536 int get_eenum(int *ninp, t_inpfile **inp, const char *name, const char **defs)
 537 {
 538     int dum = 0;
 539
 540     return get_eeenum(ninp, inp, name, defs, NULL);
 541 }