2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 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.
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.
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.
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.
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.
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.
36 * \brief Exports TPR I/O tools during Python module initialization.
38 * Provides _gmxapi.SimulationParameters and _gmxapi.TprFile classes, as well
39 * as module functions read_tprfile, write_tprfile, copy_tprfile, and rewrite_tprfile.
41 * TprFile is a Python object that holds a gmxapicompat::TprReadHandle.
43 * SimulationParameters is the Python type for data sources providing the
44 * simulation parameters aspect of input to simulation operations.
46 * \author M. Eric Irrgang <ericirrgang@gmail.com>
47 * \ingroup module_python
50 #include "gmxapi/exceptions.h"
52 #include "gmxapi/gmxapicompat.h"
53 #include "gmxapi/compat/mdparams.h"
54 #include "gmxapi/compat/tpr.h"
58 using gmxapi::GmxapiType;
64 void detail::export_tprfile(pybind11::module &module)
66 namespace py = pybind11;
67 using gmxapicompat::GmxMdParams;
68 using gmxapicompat::TprReadHandle;
69 using gmxapicompat::readTprFile;
71 py::class_<GmxMdParams> mdparams(module, "SimulationParameters");
72 // We don't want Python users to create invalid params objects, so don't
73 // export a constructor until we can default initialize a valid one.
74 // mdparams.def(py::init());
75 mdparams.def("extract",
76 [](const GmxMdParams &self)
79 for (const auto &key: gmxapicompat::keys(self))
83 // TODO: More complete typing and dispatching.
84 // This only handles the two types described in the initial implementation.
85 // Less trivial types (strings, maps, arrays) warrant additional
86 // design discussion before being exposed through an interface
88 // Also reference https://redmine.gromacs.org/issues/2993
90 // We can use templates and/or tag dispatch in a more complete
91 // future implementation.
92 const auto ¶mType = gmxapicompat::mdParamToType(key);
93 if (paramType == GmxapiType::FLOAT64)
95 dictionary[key.c_str()] = extractParam(self, key, double());
97 else if (paramType == GmxapiType::INT64)
99 dictionary[key.c_str()] = extractParam(self, key, int64_t());
102 catch (const gmxapicompat::ValueError &e)
104 throw gmxapi::ProtocolError(std::string("Unknown parameter: ") + key);
109 "Get a dictionary of the parameters.");
111 // Overload a setter for each known type and None
113 [](GmxMdParams* self, const std::string &key, py::int_ value)
115 gmxapicompat::setParam(self, key, py::cast<int64_t>(value));
117 py::arg("key").none(false),
118 py::arg("value").none(false),
119 "Use a dictionary to update simulation parameters.");
121 [](GmxMdParams* self, const std::string &key, py::float_ value)
123 gmxapicompat::setParam(self, key, py::cast<double>(value));
125 py::arg("key").none(false),
126 py::arg("value").none(false),
127 "Use a dictionary to update simulation parameters.");
129 [](GmxMdParams* self, const std::string &key, py::none)
131 // unsetParam(self, key);
133 py::arg("key").none(false),
135 "Use a dictionary to update simulation parameters.");
138 py::class_<TprReadHandle> tprfile(module, "TprFile");
139 tprfile.def("params",
140 [](const TprReadHandle &self)
142 auto params = gmxapicompat::getMdParams(self);
146 module.def("read_tprfile",
149 "Get a handle to a TPR file resource for a given file name.");
151 module.def("write_tprfile",
152 [](std::string filename, const GmxMdParams ¶meterObject)
154 auto tprReadHandle = gmxapicompat::getSourceFileHandle(parameterObject);
155 auto params = gmxapicompat::getMdParams(tprReadHandle);
156 auto structure = gmxapicompat::getStructureSource(tprReadHandle);
157 auto state = gmxapicompat::getSimulationState(tprReadHandle);
158 auto topology = gmxapicompat::getTopologySource(tprReadHandle);
159 gmxapicompat::writeTprFile(filename, *params, *structure, *state, *topology);
161 py::arg("filename").none(false),
162 py::arg("parameters"),
163 "Write a new TPR file with the provided data.");
165 module.def("copy_tprfile",
166 [](const gmxapicompat::TprReadHandle &input, std::string outFile)
168 return gmxapicompat::copy_tprfile(input, outFile);
171 py::arg("destination"),
172 "Copy a TPR file from `source` to `destination`."
175 module.def("rewrite_tprfile",
176 [](std::string input, std::string output, double end_time)
178 return gmxapicompat::rewrite_tprfile(input, output, end_time);
181 py::arg("destination"),
183 "Copy a TPR file from `source` to `destination`, replacing `nsteps` with `end_time`.");
186 } // end namespace gmxpy