src/gromacs/tools/report-methods.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2018,2019, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 #include "gmxpre.h"
  36
  37 #include "report-methods.h"
  38
  39 #include "gromacs/commandline/cmdlineoptionsmodule.h"
  40 #include "gromacs/fileio/confio.h"
  41 #include "gromacs/fileio/filetypes.h"
  42 #include "gromacs/fileio/tpxio.h"
  43 #include "gromacs/mdtypes/inputrec.h"
  44 #include "gromacs/mdtypes/state.h"
  45 #include "gromacs/options/basicoptions.h"
  46 #include "gromacs/options/filenameoption.h"
  47 #include "gromacs/options/ioptionscontainer.h"
  48 #include "gromacs/selection/selectionoptionbehavior.h"
  49 #include "gromacs/topology/mtop_util.h"
  50 #include "gromacs/utility/fatalerror.h"
  51 #include "gromacs/utility/fileredirector.h"
  52 #include "gromacs/utility/filestream.h"
  53 #include "gromacs/utility/stringutil.h"
  54
  55 namespace gmx
  56 {
  57
  58 void writeHeader(TextWriter *writer, const std::string &text, const std::string &section, bool writeFormattedText)
  59 {
  60     std::string formattedText;
  61     if (writeFormattedText)
  62     {
  63         formattedText = "\\" + section + "{" + text + "}\n";
  64     }
  65     else
  66     {
  67         formattedText = section + ": " + text + "\n";
  68     }
  69     writer->writeString(formattedText);
  70 }
  71
  72 void writeSystemInformation(TextWriter *writer, const gmx_mtop_t &top, bool writeFormattedText)
  73 {
  74     int                       nmol, nvsite = 0;
  75     gmx_mtop_atomloop_block_t aloop;
  76     const t_atom             *atom;
  77
  78     writeHeader(writer, "Simulation system", "subsection", writeFormattedText);
  79     aloop = gmx_mtop_atomloop_block_init(&top);
  80     while (gmx_mtop_atomloop_block_next(aloop, &atom, &nmol))
  81     {
  82         if (atom->ptype == eptVSite)
  83         {
  84             nvsite += nmol;
  85         }
  86     }
  87     {
  88         writer->writeLine(formatString("A system of %d molecules (%d atoms) was simulated.",
  89                                        gmx_mtop_num_molecules(top), top.natoms-nvsite));
  90     }
  91     if (nvsite)
  92     {
  93         writer->writeLine(formatString("Virtual sites were used in some of the molecules."));
  94     }
  95     writer->ensureEmptyLine();
  96 }
  97
  98 void writeParameterInformation(TextWriter *writer, const t_inputrec &ir, bool writeFormattedText)
  99 {
 100     writeHeader(writer, "Simulation settings", "subsection", writeFormattedText);
 101     writer->writeLine(formatString("A total of %g ns were simulated with a time step of %g fs.",
 102                                    ir.nsteps*ir.delta_t*0.001, 1000*ir.delta_t));
 103     writer->writeLine(formatString("Neighbor searching was performed every %d steps.", ir.nstlist));
 104     writer->writeLine(formatString("The %s algorithm was used for electrostatic interactions.",
 105                                    EELTYPE(ir.coulombtype)));
 106     writer->writeLine(formatString("with a cut-off of %g nm.", ir.rcoulomb));
 107     if (ir.coulombtype == eelPME)
 108     {
 109         writer->writeLine(formatString("A reciprocal grid of %d x %d x %d cells was used with %dth order B-spline interpolation.", ir.nkx, ir.nky, ir.nkz, ir.pme_order));
 110     }
 111     writer->writeLine(formatString("A single cut-off of %g nm was used for Van der Waals interactions.", ir.rlist));
 112     if (ir.etc != 0)
 113     {
 114         writer->writeLine(formatString("Temperature coupling was done with the %s algorithm.",
 115                                        etcoupl_names[ir.etc]));
 116     }
 117     if (ir.epc != 0)
 118     {
 119         writer->writeLine(formatString("Pressure coupling was done with the %s algorithm.",
 120                                        epcoupl_names[ir.epc]));
 121     }
 122     writer->ensureEmptyLine();
 123 }
 124
 125 void writeInformation(TextOutputFile *outputStream, const t_inputrec &ir,
 126                       const gmx_mtop_t &top, bool writeFormattedText, bool notStdout)
 127 {
 128     TextWriter              writer(outputStream);
 129     writer.ensureEmptyLine();
 130     writeHeader(&writer, "Methods", "section", writeFormattedText);
 131     writeSystemInformation(&writer, top, writeFormattedText);
 132     writeParameterInformation(&writer, ir, writeFormattedText);
 133     writer.ensureEmptyLine();
 134
 135     if (notStdout)
 136     {
 137         writer.close();
 138     }
 139 }
 140
 141 namespace
 142 {
 143
 144 class ReportMethods : public ICommandLineOptionsModule
 145 {
 146     public:
 147         ReportMethods()
 148             : writeLatex_(false), writePlainText_(false)
 149         {
 150         }
 151
 152         // From ICommandLineOptionsModule
 153         void init(CommandLineModuleSettings * /*settings*/) override
 154         {
 155         }
 156         void initOptions(IOptionsContainer                 *options,
 157                          ICommandLineOptionsModuleSettings *settings) override;
 158         void optionsFinished() override;
 159         int run() override;
 160
 161     private:
 162
 163         //! File name for the output LaTeX file or empty.
 164         std::string         outputFileLatex_;
 165         //! File name for the unformatted output file or empty.
 166         std::string         outputFileUnformatted_;
 167         //! File name of the run input file with full topology.
 168         std::string         inputTopology_;
 169         //! Boolean reporting if writing to the LaTeX output file is requested.
 170         bool                writeLatex_;
 171         //! Boolean reporting if writing to unformatted output is requested.
 172         bool                writePlainText_;
 173 };
 174
 175 void ReportMethods::initOptions(IOptionsContainer                 *options,
 176                                 ICommandLineOptionsModuleSettings *settings)
 177 {
 178     const char *const desc[] = {
 179         "[THISMODULE] reports basic system information for the run input",
 180         "file specfied with [TT]-s[tt] either to the",
 181         "terminal, to a LaTeX formatted output file if run with",
 182         "the [TT]-m[tt] option or to an unformatted file with",
 183         "the [TT]-o[tt] option.",
 184         "The functionality has been moved here from its previous",
 185         "place in [gmx-check]."
 186     };
 187
 188     settings->setHelpText(desc);
 189
 190     options->addOption(FileNameOption("s")
 191                            .filetype(eftTopology).inputFile().required()
 192                            .store(&inputTopology_)
 193                            .defaultBasename("topol")
 194                            .description("Run input file for report"));
 195
 196     // TODO: Replace use of legacyType.
 197     options->addOption(FileNameOption("m")
 198                            .legacyType(efTEX).outputFile()
 199                            .store(&outputFileLatex_).storeIsSet(&writeLatex_)
 200                            .defaultBasename("report")
 201                            .description("LaTeX formatted report output"));
 202     options->addOption(FileNameOption("o")
 203                            .legacyType(efOUT).outputFile()
 204                            .store(&outputFileUnformatted_).storeIsSet(&writePlainText_)
 205                            .defaultBasename("report")
 206                            .description("Unformatted report output to file"));
 207
 208 }
 209
 210 void ReportMethods::optionsFinished()
 211 {
 212 }
 213
 214 int ReportMethods::run()
 215 {
 216     t_state    state;
 217     t_inputrec ir;
 218     gmx_mtop_t top;
 219     read_tpx_state(inputTopology_.c_str(), &ir, &state, &top);
 220     if (writeLatex_)
 221     {
 222         TextOutputFile file(outputFileLatex_);
 223         writeInformation(&file, ir, top, true, true);
 224     }
 225     if (writePlainText_)
 226     {
 227         TextOutputFile file(outputFileUnformatted_);
 228         writeInformation(&file, ir, top, false, true);
 229     }
 230     TextOutputFile         &stdoutFile = TextOutputFile::standardOutput();
 231     writeInformation(&stdoutFile, ir, top, false, false);
 232
 233     return 0;
 234 }
 235
 236 }   // namespace
 237
 238 const char ReportMethodsInfo::name[]             = "report-methods";
 239 const char ReportMethodsInfo::shortDescription[] =
 240     "Write short summary about the simulation setup to a text file "
 241     "and/or to the standard output.";
 242 ICommandLineOptionsModulePointer ReportMethodsInfo::create()
 243 {
 244     return ICommandLineOptionsModulePointer(std::make_unique<ReportMethods>());
 245 }
 246
 247 } // namespace gmx