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(
 110                 formatString("A reciprocal grid of %d x %d x %d cells was used with %dth order "
 111                              "B-spline interpolation.",
 112                              ir.nkx, ir.nky, ir.nkz, ir.pme_order));
 113     }
 114     writer->writeLine(formatString(
 115             "A single cut-off of %g nm was used for Van der Waals interactions.", ir.rlist));
 116     if (ir.etc != 0)
 117     {
 118         writer->writeLine(formatString("Temperature coupling was done with the %s algorithm.",
 119                                        etcoupl_names[ir.etc]));
 120     }
 121     if (ir.epc != 0)
 122     {
 123         writer->writeLine(formatString("Pressure coupling was done with the %s algorithm.",
 124                                        epcoupl_names[ir.epc]));
 125     }
 126     writer->ensureEmptyLine();
 127 }
 128
 129 void writeInformation(TextOutputFile*   outputStream,
 130                       const t_inputrec& ir,
 131                       const gmx_mtop_t& top,
 132                       bool              writeFormattedText,
 133                       bool              notStdout)
 134 {
 135     TextWriter writer(outputStream);
 136     writer.ensureEmptyLine();
 137     writeHeader(&writer, "Methods", "section", writeFormattedText);
 138     writeSystemInformation(&writer, top, writeFormattedText);
 139     writeParameterInformation(&writer, ir, writeFormattedText);
 140     writer.ensureEmptyLine();
 141
 142     if (notStdout)
 143     {
 144         writer.close();
 145     }
 146 }
 147
 148 namespace
 149 {
 150
 151 class ReportMethods : public ICommandLineOptionsModule
 152 {
 153 public:
 154     ReportMethods() : writeLatex_(false), writePlainText_(false) {}
 155
 156     // From ICommandLineOptionsModule
 157     void init(CommandLineModuleSettings* /*settings*/) override {}
 158     void initOptions(IOptionsContainer* options, ICommandLineOptionsModuleSettings* settings) override;
 159     void optionsFinished() override;
 160     int  run() override;
 161
 162 private:
 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, ICommandLineOptionsModuleSettings* settings)
 176 {
 177     const char* const desc[] = { "[THISMODULE] reports basic system information for the run input",
 178                                  "file specfied with [TT]-s[tt] either to the",
 179                                  "terminal, to a LaTeX formatted output file if run with",
 180                                  "the [TT]-m[tt] option or to an unformatted file with",
 181                                  "the [TT]-o[tt] option.",
 182                                  "The functionality has been moved here from its previous",
 183                                  "place in [gmx-check]." };
 184
 185     settings->setHelpText(desc);
 186
 187     options->addOption(FileNameOption("s")
 188                                .filetype(eftTopology)
 189                                .inputFile()
 190                                .required()
 191                                .store(&inputTopology_)
 192                                .defaultBasename("topol")
 193                                .description("Run input file for report"));
 194
 195     // TODO: Replace use of legacyType.
 196     options->addOption(FileNameOption("m")
 197                                .legacyType(efTEX)
 198                                .outputFile()
 199                                .store(&outputFileLatex_)
 200                                .storeIsSet(&writeLatex_)
 201                                .defaultBasename("report")
 202                                .description("LaTeX formatted report output"));
 203     options->addOption(FileNameOption("o")
 204                                .legacyType(efOUT)
 205                                .outputFile()
 206                                .store(&outputFileUnformatted_)
 207                                .storeIsSet(&writePlainText_)
 208                                .defaultBasename("report")
 209                                .description("Unformatted report output to file"));
 210 }
 211
 212 void ReportMethods::optionsFinished() {}
 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