src/gromacs/tools/dump.cpp

   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-2013, The GROMACS development team.
   6  * Copyright (c) 2013,2014,2015,2016,2017 by the GROMACS development team.
   7  * Copyright (c) 2018,2019,2020,2021, by the GROMACS development team, led by
   8  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   9  * and including many others, as listed in the AUTHORS file in the
  10  * top-level source directory and at http://www.gromacs.org.
  11  *
  12  * GROMACS is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public License
  14  * as published by the Free Software Foundation; either version 2.1
  15  * of the License, or (at your option) any later version.
  16  *
  17  * GROMACS is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with GROMACS; if not, see
  24  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  25  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  26  *
  27  * If you want to redistribute modifications to GROMACS, please
  28  * consider that scientific software is very special. Version
  29  * control is crucial - bugs must be traceable. We will be happy to
  30  * consider code for inclusion in the official distribution, but
  31  * derived work must not be called official GROMACS. Details are found
  32  * in the README & COPYING files - if they are missing, get the
  33  * official version at http://www.gromacs.org.
  34  *
  35  * To help us fund GROMACS development, we humbly ask that you cite
  36  * the research papers on the package. Check out http://www.gromacs.org.
  37  */
  38 /*! \internal \file
  39  * \brief Implements gmx dump utility.
  40  *
  41  * \ingroup module_tools
  42  */
  43 #include "gmxpre.h"
  44
  45 #include "dump.h"
  46
  47 #include "config.h"
  48
  49 #include <cassert>
  50 #include <cmath>
  51 #include <cstdio>
  52 #include <cstring>
  53
  54 #include "gromacs/commandline/cmdlineoptionsmodule.h"
  55 #include "gromacs/fileio/checkpoint.h"
  56 #include "gromacs/fileio/enxio.h"
  57 #include "gromacs/fileio/filetypes.h"
  58 #include "gromacs/fileio/gmxfio.h"
  59 #include "gromacs/fileio/mtxio.h"
  60 #include "gromacs/fileio/tngio.h"
  61 #include "gromacs/fileio/tpxio.h"
  62 #include "gromacs/fileio/trrio.h"
  63 #include "gromacs/fileio/xtcio.h"
  64 #include "gromacs/gmxpreprocess/gmxcpp.h"
  65 #include "gromacs/math/vecdump.h"
  66 #include "gromacs/mdrun/mdmodules.h"
  67 #include "gromacs/mdtypes/forcerec.h"
  68 #include "gromacs/mdtypes/inputrec.h"
  69 #include "gromacs/mdtypes/md_enums.h"
  70 #include "gromacs/mdtypes/state.h"
  71 #include "gromacs/options/basicoptions.h"
  72 #include "gromacs/options/filenameoption.h"
  73 #include "gromacs/options/ioptionscontainer.h"
  74 #include "gromacs/topology/mtop_util.h"
  75 #include "gromacs/topology/topology.h"
  76 #include "gromacs/trajectory/energyframe.h"
  77 #include "gromacs/trajectory/trajectoryframe.h"
  78 #include "gromacs/utility/arraysize.h"
  79 #include "gromacs/utility/basedefinitions.h"
  80 #include "gromacs/utility/fatalerror.h"
  81 #include "gromacs/utility/futil.h"
  82 #include "gromacs/utility/smalloc.h"
  83 #include "gromacs/utility/txtdump.h"
  84
  85 namespace gmx
  86 {
  87
  88 namespace
  89 {
  90
  91 //! Dump a TPR file
  92 void list_tpr(const char* fn,
  93               gmx_bool    bShowNumbers,
  94               gmx_bool    bShowParameters,
  95               const char* mdpfn,
  96               gmx_bool    bSysTop,
  97               gmx_bool    bOriginalInputrec)
  98 {
  99     FILE*      gp;
 100     int        indent, atot;
 101     t_state    state;
 102     gmx_mtop_t mtop;
 103     t_topology top;
 104
 105     TpxFileHeader tpx = readTpxHeader(fn, true);
 106     t_inputrec    ir;
 107
 108     read_tpx_state(fn, tpx.bIr ? &ir : nullptr, &state, tpx.bTop ? &mtop : nullptr);
 109     if (tpx.bIr && !bOriginalInputrec)
 110     {
 111         MDModules().adjustInputrecBasedOnModules(&ir);
 112     }
 113
 114     if (mdpfn && tpx.bIr)
 115     {
 116         gp = gmx_fio_fopen(mdpfn, "w");
 117         pr_inputrec(gp, 0, nullptr, &ir, TRUE);
 118         gmx_fio_fclose(gp);
 119     }
 120
 121     if (!mdpfn)
 122     {
 123         if (bSysTop)
 124         {
 125             top = gmx_mtop_t_to_t_topology(&mtop, false);
 126         }
 127
 128         if (available(stdout, &tpx, 0, fn))
 129         {
 130             indent = 0;
 131             pr_title(stdout, indent, fn);
 132             pr_inputrec(stdout, 0, "inputrec", tpx.bIr ? &ir : nullptr, FALSE);
 133
 134             pr_tpxheader(stdout, indent, "header", &(tpx));
 135
 136             if (!bSysTop)
 137             {
 138                 pr_mtop(stdout, indent, "topology", &(mtop), bShowNumbers, bShowParameters);
 139             }
 140             else
 141             {
 142                 pr_top(stdout, indent, "topology", &(top), bShowNumbers, bShowParameters);
 143             }
 144
 145             pr_rvecs(stdout, indent, "box", tpx.bBox ? state.box : nullptr, DIM);
 146             pr_rvecs(stdout, indent, "box_rel", tpx.bBox ? state.box_rel : nullptr, DIM);
 147             pr_rvecs(stdout, indent, "boxv", tpx.bBox ? state.boxv : nullptr, DIM);
 148             pr_rvecs(stdout, indent, "pres_prev", tpx.bBox ? state.pres_prev : nullptr, DIM);
 149             pr_rvecs(stdout, indent, "svir_prev", tpx.bBox ? state.svir_prev : nullptr, DIM);
 150             pr_rvecs(stdout, indent, "fvir_prev", tpx.bBox ? state.fvir_prev : nullptr, DIM);
 151             /* leave nosehoover_xi in for now to match the tpr version */
 152             pr_doubles(stdout, indent, "nosehoover_xi", state.nosehoover_xi.data(), state.ngtc);
 153             /*pr_doubles(stdout,indent,"nosehoover_vxi",state.nosehoover_vxi,state.ngtc);*/
 154             /*pr_doubles(stdout,indent,"therm_integral",state.therm_integral,state.ngtc);*/
 155             pr_rvecs(stdout, indent, "x", tpx.bX ? state.x.rvec_array() : nullptr, state.natoms);
 156             pr_rvecs(stdout, indent, "v", tpx.bV ? state.v.rvec_array() : nullptr, state.natoms);
 157         }
 158
 159         const SimulationGroups& groups = mtop.groups;
 160
 161         gmx::EnumerationArray<SimulationAtomGroupType, std::vector<int>> gcount;
 162         for (auto group : keysOf(gcount))
 163         {
 164             gcount[group].resize(groups.groups[group].size());
 165         }
 166
 167         for (int i = 0; (i < mtop.natoms); i++)
 168         {
 169             for (auto group : keysOf(gcount))
 170             {
 171                 gcount[group][getGroupType(groups, group, i)]++;
 172             }
 173         }
 174         printf("Group statistics\n");
 175         for (auto group : keysOf(gcount))
 176         {
 177             atot = 0;
 178             printf("%-12s: ", shortName(group));
 179             for (const auto& entry : gcount[group])
 180             {
 181                 printf("  %5d", entry);
 182                 atot += entry;
 183             }
 184             printf("  (total %d atoms)\n", atot);
 185         }
 186     }
 187 }
 188
 189 //! Dump a topology file
 190 void list_top(const char* fn)
 191 {
 192     int status, done;
 193     // Legacy string length macro
 194     char      buf[STRLEN];
 195     gmx_cpp_t handle;
 196     char*     cppopts[] = { nullptr };
 197
 198     status = cpp_open_file(fn, &handle, cppopts);
 199     if (status != 0)
 200     {
 201         gmx_fatal(FARGS, "%s", cpp_error(&handle, status));
 202     }
 203     do
 204     {
 205         status = cpp_read_line(&handle, STRLEN, buf);
 206         done   = static_cast<int>(status == eCPP_EOF);
 207         if (!done)
 208         {
 209             if (status != eCPP_OK)
 210             {
 211                 gmx_fatal(FARGS, "%s", cpp_error(&handle, status));
 212             }
 213             else
 214             {
 215                 printf("%s\n", buf);
 216             }
 217         }
 218     } while (done == 0);
 219     status = cpp_close_file(&handle);
 220     if (status != eCPP_OK)
 221     {
 222         gmx_fatal(FARGS, "%s", cpp_error(&handle, status));
 223     }
 224 }
 225
 226 //! Dump a TRR file
 227 void list_trr(const char* fn)
 228 {
 229     t_fileio*        fpread;
 230     int              nframe, indent;
 231     char             buf[256];
 232     rvec *           x, *v, *f;
 233     matrix           box;
 234     gmx_trr_header_t trrheader;
 235     gmx_bool         bOK;
 236
 237     fpread = gmx_trr_open(fn, "r");
 238
 239     nframe = 0;
 240     while (gmx_trr_read_frame_header(fpread, &trrheader, &bOK))
 241     {
 242         snew(x, trrheader.natoms);
 243         snew(v, trrheader.natoms);
 244         snew(f, trrheader.natoms);
 245         if (gmx_trr_read_frame_data(fpread,
 246                                     &trrheader,
 247                                     trrheader.box_size ? box : nullptr,
 248                                     trrheader.x_size ? x : nullptr,
 249                                     trrheader.v_size ? v : nullptr,
 250                                     trrheader.f_size ? f : nullptr))
 251         {
 252             sprintf(buf, "%s frame %d", fn, nframe);
 253             indent = 0;
 254             indent = pr_title(stdout, indent, buf);
 255             pr_indent(stdout, indent);
 256             fprintf(stdout,
 257                     "natoms=%10d  step=%10" PRId64 "  time=%12.7e  lambda=%10g\n",
 258                     trrheader.natoms,
 259                     trrheader.step,
 260                     trrheader.t,
 261                     trrheader.lambda);
 262             if (trrheader.box_size)
 263             {
 264                 pr_rvecs(stdout, indent, "box", box, DIM);
 265             }
 266             if (trrheader.x_size)
 267             {
 268                 pr_rvecs(stdout, indent, "x", x, trrheader.natoms);
 269             }
 270             if (trrheader.v_size)
 271             {
 272                 pr_rvecs(stdout, indent, "v", v, trrheader.natoms);
 273             }
 274             if (trrheader.f_size)
 275             {
 276                 pr_rvecs(stdout, indent, "f", f, trrheader.natoms);
 277             }
 278         }
 279         else
 280         {
 281             fprintf(stderr, "\nWARNING: Incomplete frame: nr %d, t=%g\n", nframe, trrheader.t);
 282         }
 283
 284         sfree(x);
 285         sfree(v);
 286         sfree(f);
 287         nframe++;
 288     }
 289     if (!bOK)
 290     {
 291         fprintf(stderr, "\nWARNING: Incomplete frame header: nr %d, t=%g\n", nframe, trrheader.t);
 292     }
 293     gmx_trr_close(fpread);
 294 }
 295
 296 //! Dump an xtc file
 297 void list_xtc(const char* fn)
 298 {
 299     t_fileio* xd;
 300     int       indent;
 301     char      buf[256];
 302     rvec*     x;
 303     matrix    box;
 304     int       nframe, natoms;
 305     int64_t   step;
 306     real      prec, time;
 307     gmx_bool  bOK;
 308
 309     xd = open_xtc(fn, "r");
 310     read_first_xtc(xd, &natoms, &step, &time, box, &x, &prec, &bOK);
 311
 312     nframe = 0;
 313     do
 314     {
 315         sprintf(buf, "%s frame %d", fn, nframe);
 316         indent = 0;
 317         indent = pr_title(stdout, indent, buf);
 318         pr_indent(stdout, indent);
 319         fprintf(stdout, "natoms=%10d  step=%10" PRId64 "  time=%12.7e  prec=%10g\n", natoms, step, time, prec);
 320         pr_rvecs(stdout, indent, "box", box, DIM);
 321         pr_rvecs(stdout, indent, "x", x, natoms);
 322         nframe++;
 323     } while (read_next_xtc(xd, natoms, &step, &time, box, x, &prec, &bOK) != 0);
 324     if (!bOK)
 325     {
 326         fprintf(stderr, "\nWARNING: Incomplete frame at time %g\n", time);
 327     }
 328     sfree(x);
 329     close_xtc(xd);
 330 }
 331
 332 #if GMX_USE_TNG
 333
 334 /*! \brief Callback used by list_tng_for_gmx_dump. */
 335 void list_tng_inner(const char* fn,
 336                     gmx_bool    bFirstFrame,
 337                     real*       values,
 338                     int64_t     step,
 339                     double      frame_time,
 340                     int64_t     n_values_per_frame,
 341                     int64_t     n_atoms,
 342                     real        prec,
 343                     int64_t     nframe,
 344                     char*       block_name)
 345 {
 346     char buf[256];
 347     int  indent = 0;
 348
 349     if (bFirstFrame)
 350     {
 351         sprintf(buf, "%s frame %" PRId64, fn, nframe);
 352         indent = 0;
 353         indent = pr_title(stdout, indent, buf);
 354         pr_indent(stdout, indent);
 355         fprintf(stdout, "natoms=%10" PRId64 "  step=%10" PRId64 "  time=%12.7e", n_atoms, step, frame_time);
 356         if (prec > 0)
 357         {
 358             fprintf(stdout, "  prec=%10g", prec);
 359         }
 360         fprintf(stdout, "\n");
 361     }
 362     pr_reals_of_dim(stdout, indent, block_name, values, n_atoms, n_values_per_frame);
 363 }
 364
 365 #endif
 366
 367 //! Dump a TNG file
 368 void list_tng(const char* fn)
 369 {
 370 #if GMX_USE_TNG
 371     gmx_tng_trajectory_t tng;
 372     int64_t              nframe = 0;
 373     int64_t              i, *block_ids = nullptr, step, ndatablocks;
 374     gmx_bool             bOK;
 375     real*                values = nullptr;
 376
 377     gmx_tng_open(fn, 'r', &tng);
 378     gmx_print_tng_molecule_system(tng, stdout);
 379
 380     bOK = gmx_get_tng_data_block_types_of_next_frame(tng, -1, 0, nullptr, &step, &ndatablocks, &block_ids);
 381     do
 382     {
 383         for (i = 0; i < ndatablocks; i++)
 384         {
 385             double  frame_time;
 386             real    prec;
 387             int64_t n_values_per_frame, n_atoms;
 388             char    block_name[STRLEN];
 389
 390             gmx_get_tng_data_next_frame_of_block_type(tng,
 391                                                       block_ids[i],
 392                                                       &values,
 393                                                       &step,
 394                                                       &frame_time,
 395                                                       &n_values_per_frame,
 396                                                       &n_atoms,
 397                                                       &prec,
 398                                                       block_name,
 399                                                       STRLEN,
 400                                                       &bOK);
 401             if (!bOK)
 402             {
 403                 /* Can't write any output because we don't know what
 404                    arrays are valid. */
 405                 fprintf(stderr, "\nWARNING: Incomplete frame at time %g, will not write output\n", frame_time);
 406             }
 407             else
 408             {
 409                 list_tng_inner(
 410                         fn, (0 == i), values, step, frame_time, n_values_per_frame, n_atoms, prec, nframe, block_name);
 411             }
 412         }
 413         nframe++;
 414     } while (gmx_get_tng_data_block_types_of_next_frame(
 415             tng, step, 0, nullptr, &step, &ndatablocks, &block_ids));
 416
 417     if (block_ids)
 418     {
 419         sfree(block_ids);
 420     }
 421     sfree(values);
 422     gmx_tng_close(&tng);
 423 #else
 424     GMX_UNUSED_VALUE(fn);
 425 #endif
 426 }
 427
 428 //! Dump a trajectory file
 429 void list_trx(const char* fn)
 430 {
 431     switch (fn2ftp(fn))
 432     {
 433         case efXTC: list_xtc(fn); break;
 434         case efTRR: list_trr(fn); break;
 435         case efTNG: list_tng(fn); break;
 436         default:
 437             fprintf(stderr, "File %s is of an unsupported type. Try using the command\n 'less %s'\n", fn, fn);
 438     }
 439 }
 440
 441 //! Dump an energy file
 442 void list_ene(const char* fn)
 443 {
 444     ener_file_t  in;
 445     gmx_bool     bCont;
 446     gmx_enxnm_t* enm = nullptr;
 447     t_enxframe*  fr;
 448     int          i, j, nre, b;
 449     char         buf[22];
 450
 451     printf("gmx dump: %s\n", fn);
 452     in = open_enx(fn, "r");
 453     do_enxnms(in, &nre, &enm);
 454     assert(enm);
 455
 456     printf("energy components:\n");
 457     for (i = 0; (i < nre); i++)
 458     {
 459         printf("%5d  %-24s (%s)\n", i, enm[i].name, enm[i].unit);
 460     }
 461
 462     snew(fr, 1);
 463     do
 464     {
 465         bCont = do_enx(in, fr);
 466
 467         if (bCont)
 468         {
 469             printf("\n%24s  %12.5e  %12s  %12s\n", "time:", fr->t, "step:", gmx_step_str(fr->step, buf));
 470             printf("%24s  %12s  %12s  %12s\n", "", "", "nsteps:", gmx_step_str(fr->nsteps, buf));
 471             printf("%24s  %12.5e  %12s  %12s\n", "delta_t:", fr->dt, "sum steps:", gmx_step_str(fr->nsum, buf));
 472             if (fr->nre == nre)
 473             {
 474                 printf("%24s  %12s  %12s  %12s\n",
 475                        "Component",
 476                        "Energy",
 477                        "Av. Energy",
 478                        "Sum Energy");
 479                 if (fr->nsum > 0)
 480                 {
 481                     for (i = 0; (i < nre); i++)
 482                     {
 483                         printf("%24s  %12.5e  %12.5e  %12.5e\n",
 484                                enm[i].name,
 485                                fr->ener[i].e,
 486                                fr->ener[i].eav,
 487                                fr->ener[i].esum);
 488                     }
 489                 }
 490                 else
 491                 {
 492                     for (i = 0; (i < nre); i++)
 493                     {
 494                         printf("%24s  %12.5e\n", enm[i].name, fr->ener[i].e);
 495                     }
 496                 }
 497             }
 498             for (b = 0; b < fr->nblock; b++)
 499             {
 500                 const char* typestr = "";
 501
 502                 t_enxblock* eb = &(fr->block[b]);
 503                 printf("Block data %2d (%3d subblocks, id=%d)\n", b, eb->nsub, eb->id);
 504
 505                 if (eb->id < enxNR)
 506                 {
 507                     typestr = enx_block_id_name[eb->id];
 508                 }
 509                 printf("  id='%s'\n", typestr);
 510                 for (i = 0; i < eb->nsub; i++)
 511                 {
 512                     t_enxsubblock* sb = &(eb->sub[i]);
 513                     printf("  Sub block %3d (%5d elems, type=%s) values:\n",
 514                            i,
 515                            sb->nr,
 516                            enumValueToString(sb->type));
 517
 518                     switch (sb->type)
 519                     {
 520                         case XdrDataType::Float:
 521                             for (j = 0; j < sb->nr; j++)
 522                             {
 523                                 printf("%14d   %8.4f\n", j, sb->fval[j]);
 524                             }
 525                             break;
 526                         case XdrDataType::Double:
 527                             for (j = 0; j < sb->nr; j++)
 528                             {
 529                                 printf("%14d   %10.6f\n", j, sb->dval[j]);
 530                             }
 531                             break;
 532                         case XdrDataType::Int:
 533                             for (j = 0; j < sb->nr; j++)
 534                             {
 535                                 printf("%14d %10d\n", j, sb->ival[j]);
 536                             }
 537                             break;
 538                         case XdrDataType::Int64:
 539                             for (j = 0; j < sb->nr; j++)
 540                             {
 541                                 printf("%14d %s\n", j, gmx_step_str(sb->lval[j], buf));
 542                             }
 543                             break;
 544                         case XdrDataType::Char:
 545                             for (j = 0; j < sb->nr; j++)
 546                             {
 547                                 printf("%14d %1c\n", j, sb->cval[j]);
 548                             }
 549                             break;
 550                         case XdrDataType::String:
 551                             for (j = 0; j < sb->nr; j++)
 552                             {
 553                                 printf("%14d %80s\n", j, sb->sval[j]);
 554                             }
 555                             break;
 556                         default: gmx_incons("Unknown subblock type");
 557                     }
 558                 }
 559             }
 560         }
 561     } while (bCont);
 562
 563     close_enx(in);
 564
 565     free_enxframe(fr);
 566     sfree(fr);
 567     sfree(enm);
 568 }
 569
 570 //! Dump a (Hessian) matrix file
 571 void list_mtx(const char* fn)
 572 {
 573     int                 nrow, ncol, i, j, k;
 574     real *              full   = nullptr, value;
 575     gmx_sparsematrix_t* sparse = nullptr;
 576
 577     gmx_mtxio_read(fn, &nrow, &ncol, &full, &sparse);
 578
 579     if (full == nullptr)
 580     {
 581         snew(full, nrow * ncol);
 582         for (i = 0; i < nrow * ncol; i++)
 583         {
 584             full[i] = 0;
 585         }
 586
 587         for (i = 0; i < sparse->nrow; i++)
 588         {
 589             for (j = 0; j < sparse->ndata[i]; j++)
 590             {
 591                 k                  = sparse->data[i][j].col;
 592                 value              = sparse->data[i][j].value;
 593                 full[i * ncol + k] = value;
 594                 full[k * ncol + i] = value;
 595             }
 596         }
 597         gmx_sparsematrix_destroy(sparse);
 598     }
 599
 600     printf("%d %d\n", nrow, ncol);
 601     for (i = 0; i < nrow; i++)
 602     {
 603         for (j = 0; j < ncol; j++)
 604         {
 605             printf(" %g", full[i * ncol + j]);
 606         }
 607         printf("\n");
 608     }
 609
 610     sfree(full);
 611 }
 612
 613 class Dump : public ICommandLineOptionsModule
 614 {
 615 public:
 616     Dump() {}
 617
 618     // From ICommandLineOptionsModule
 619     void init(CommandLineModuleSettings* /*settings*/) override {}
 620
 621     void initOptions(IOptionsContainer* options, ICommandLineOptionsModuleSettings* settings) override;
 622
 623     void optionsFinished() override;
 624
 625     int run() override;
 626
 627 private:
 628     //! Commandline options
 629     //! \{
 630     bool bShowNumbers_      = true;
 631     bool bShowParams_       = false;
 632     bool bSysTop_           = false;
 633     bool bOriginalInputrec_ = false;
 634     //! \}
 635     //! Commandline file options
 636     //! \{
 637     std::string inputTprFilename_;
 638     std::string inputTrajectoryFilename_;
 639     std::string inputEnergyFilename_;
 640     std::string inputCheckpointFilename_;
 641     std::string inputTopologyFilename_;
 642     std::string inputMatrixFilename_;
 643     std::string outputMdpFilename_;
 644     //! \}
 645 };
 646
 647 void Dump::initOptions(IOptionsContainer* options, ICommandLineOptionsModuleSettings* settings)
 648 {
 649     const char* desc[] = { "[THISMODULE] reads a run input file ([REF].tpr[ref]),",
 650                            "a trajectory ([REF].trr[ref]/[REF].xtc[ref]/[TT]tng[tt]), an energy",
 651                            "file ([REF].edr[ref]), a checkpoint file ([REF].cpt[ref])",
 652                            "or topology file ([REF].top[ref])",
 653                            "and prints that to standard output in a readable format.",
 654                            "This program is essential for checking your run input file in case of",
 655                            "problems." };
 656     settings->setHelpText(desc);
 657
 658     const char* bugs[] = {
 659         "The [REF].mdp[ref] file produced by [TT]-om[tt] can not be read by grompp."
 660     };
 661     settings->setBugText(bugs);
 662     // TODO If this ancient note acknowledging a bug is still true,
 663     // fix it or block that run path:
 664     //   Position restraint output from -sys -s is broken
 665
 666     options->addOption(FileNameOption("s")
 667                                .filetype(OptionFileType::RunInput)
 668                                .inputFile()
 669                                .store(&inputTprFilename_)
 670                                .description("Run input file to dump"));
 671     options->addOption(FileNameOption("f")
 672                                .filetype(OptionFileType::Trajectory)
 673                                .inputFile()
 674                                .store(&inputTrajectoryFilename_)
 675                                .description("Trajectory file to dump"));
 676     options->addOption(FileNameOption("e")
 677                                .filetype(OptionFileType::Energy)
 678                                .inputFile()
 679                                .store(&inputEnergyFilename_)
 680                                .description("Energy file to dump"));
 681     options->addOption(
 682             FileNameOption("cp").legacyType(efCPT).inputFile().store(&inputCheckpointFilename_).description("Checkpoint file to dump"));
 683     options->addOption(
 684             FileNameOption("p").legacyType(efTOP).inputFile().store(&inputTopologyFilename_).description("Topology file to dump"));
 685     options->addOption(
 686             FileNameOption("mtx").legacyType(efMTX).inputFile().store(&inputMatrixFilename_).description("Hessian matrix to dump"));
 687     options->addOption(FileNameOption("om")
 688                                .legacyType(efMDP)
 689                                .outputFile()
 690                                .store(&outputMdpFilename_)
 691                                .description("grompp input file from run input file"));
 692
 693     options->addOption(
 694             BooleanOption("nr").store(&bShowNumbers_).defaultValue(true).description("Show index numbers in output (leaving them out makes comparison easier, but creates a useless topology)"));
 695     options->addOption(
 696             BooleanOption("param").store(&bShowParams_).defaultValue(false).description("Show parameters for each bonded interaction (for comparing dumps, it is useful to combine this with -nonr)"));
 697     options->addOption(
 698             BooleanOption("sys").store(&bShowParams_).defaultValue(false).description("List the atoms and bonded interactions for the whole system instead of for each molecule type"));
 699     options->addOption(
 700             BooleanOption("orgir").store(&bShowParams_).defaultValue(false).description("Show input parameters from tpr as they were written by the version that produced the file, instead of how the current version reads them"));
 701 }
 702
 703 void Dump::optionsFinished()
 704 {
 705     // TODO Currently gmx dump ignores user input that seeks to dump
 706     // multiple files. Here, we could enforce that the user only asks
 707     // to dump one file.
 708 }
 709
 710 int Dump::run()
 711 {
 712     if (!inputTprFilename_.empty())
 713     {
 714         list_tpr(inputTprFilename_.c_str(),
 715                  bShowNumbers_,
 716                  bShowParams_,
 717                  outputMdpFilename_.empty() ? nullptr : outputMdpFilename_.c_str(),
 718                  bSysTop_,
 719                  bOriginalInputrec_);
 720     }
 721     else if (!inputTrajectoryFilename_.empty())
 722     {
 723         list_trx(inputTrajectoryFilename_.c_str());
 724     }
 725     else if (!inputEnergyFilename_.empty())
 726     {
 727         list_ene(inputEnergyFilename_.c_str());
 728     }
 729     else if (!inputCheckpointFilename_.empty())
 730     {
 731         list_checkpoint(inputCheckpointFilename_.c_str(), stdout);
 732     }
 733     else if (!inputTopologyFilename_.empty())
 734     {
 735         list_top(inputTopologyFilename_.c_str());
 736     }
 737     else if (!inputMatrixFilename_.empty())
 738     {
 739         list_mtx(inputMatrixFilename_.c_str());
 740     }
 741
 742     return 0;
 743 }
 744
 745 } // namespace
 746
 747 const char                       DumpInfo::name[]             = "dump";
 748 const char                       DumpInfo::shortDescription[] = "Make binary files human readable";
 749 ICommandLineOptionsModulePointer DumpInfo::create()
 750 {
 751     return std::make_unique<Dump>();
 752 }
 753
 754 } // namespace gmx