/*! \brief Get the path to the main folder storing OpenCL kernels.
*
* By default, this function constructs the full path to the OpenCL from
* the known location of the binary that is running, so that we handle
* both in-source and installed builds. The user can override this
* behavior by defining GMX_OCL_FILE_PATH environment variable.
*
* \return OS-normalized path string to the main folder storing OpenCL kernels
*
* \throws std::bad_alloc if out of memory.
* FileIOError if GMX_OCL_FILE_PATH does not specify a readable path
*/
static std::string
getKernelRootPath()
{
std::string kernelRootPath;
/* Use GMX_OCL_FILE_PATH if the user has defined it */
const char *gmxOclFilePath = getenv("GMX_OCL_FILE_PATH");
if (gmxOclFilePath == nullptr)
{
/* Normal way of getting ocl_root_dir. First get the right
root path from the path to the binary that is running. */
InstallationPrefixInfo info = getProgramContext().installationPrefix();
std::string dataPathSuffix = (info.bSourceLayout ?
"src/gromacs/mdlib/nbnxn_ocl" :
OCL_INSTALL_DIR);
kernelRootPath = Path::join(info.path, dataPathSuffix);
}
else
{
if (!Directory::exists(gmxOclFilePath))
{
GMX_THROW(FileIOError(formatString("GMX_OCL_FILE_PATH must point to the directory where OpenCL"
"kernels are found, but '%s' does not exist", gmxOclFilePath)));
}
kernelRootPath = gmxOclFilePath;
}
// Make sure we return an OS-correct path format
return Path::normalize(kernelRootPath);
}
void printFatalErrorHeader(FILE *fp, const char *title,
const char *func, const char *file, int line)
{
// In case ProgramInfo is not initialized and there is an issue with the
// initialization, fall back to "GROMACS".
const char *programName = "GROMACS";
try
{
programName = getProgramContext().displayName();
}
catch (const std::exception &)
{
}
std::fprintf(fp, "\n-------------------------------------------------------\n");
std::fprintf(fp, "Program: %s, version %s\n", programName, gmx_version());
if (file != nullptr)
{
std::fprintf(fp, "Source file: %s (line %d)\n",
Path::stripSourcePrefix(file), line);
}
if (func != nullptr)
{
std::fprintf(fp, "Function: %s\n", func);
}
if (gmx_node_num() > 1)
{
std::fprintf(fp, "MPI rank: %d (out of %d)\n", gmx_node_rank(), gmx_node_num());
}
std::fprintf(fp, "\n");
std::fprintf(fp, "%s:\n", title);
}
std::string DataFileFinder::Impl::getDefaultPath()
{
const InstallationPrefixInfo installPrefix
= getProgramContext().installationPrefix();
if (!isNullOrEmpty(installPrefix.path))
{
const char *const dataPath
= installPrefix.bSourceLayout ? "share" : GMX_INSTALL_GMXDATADIR;
return Path::join(installPrefix.path, dataPath, "top");
}
return std::string();
}
void
AbstractPlotModule::dataStarted(AbstractAnalysisData * /* data */)
{
if (!impl_->filename_.empty())
{
if (impl_->bPlain_)
{
impl_->fp_ = gmx_fio_fopen(impl_->filename_.c_str(), "w");
}
else
{
time_unit_t time_unit
= static_cast<time_unit_t>(impl_->settings_.timeUnit() + 1);
xvg_format_t xvg_format
= (impl_->settings_.plotFormat() > 0
? static_cast<xvg_format_t>(impl_->settings_.plotFormat())
: exvgNONE);
output_env_t oenv;
output_env_init(&oenv, getProgramContext(), time_unit, FALSE, xvg_format, 0);
boost::shared_ptr<output_env> oenvGuard(oenv, &output_env_done);
impl_->fp_ = xvgropen(impl_->filename_.c_str(), impl_->title_.c_str(),
impl_->xlabel_.c_str(), impl_->ylabel_.c_str(),
oenv);
const SelectionCollection *selections
= impl_->settings_.selectionCollection();
if (selections != NULL)
{
selections->printXvgrInfo(impl_->fp_, oenv);
}
if (!impl_->subtitle_.empty())
{
xvgr_subtitle(impl_->fp_, impl_->subtitle_.c_str(), oenv);
}
if (output_env_get_print_xvgr_codes(oenv)
&& !impl_->legend_.empty())
{
std::vector<const char *> legend;
legend.reserve(impl_->legend_.size());
for (size_t i = 0; i < impl_->legend_.size(); ++i)
{
legend.push_back(impl_->legend_[i].c_str());
}
xvgr_legend(impl_->fp_, legend.size(), &legend[0], oenv);
}
}
}
}
void printFatalErrorHeader(FILE *fp, const char *title,
const char *func, const char *file, int line)
{
// In case ProgramInfo is not initialized and there is an issue with the
// initialization, fall back to "GROMACS".
const char *programName = "GROMACS";
try
{
programName = getProgramContext().displayName();
}
catch (const std::exception &)
{
}
std::fprintf(fp, "\n-------------------------------------------------------\n");
std::fprintf(fp, "Program: %s, %s\n", programName, gmx_version());
if (file != NULL)
{
// TODO: Check whether this works on Windows. If it doesn't, perhaps
// add Path::startsWith().
if (startsWith(file, CMAKE_SOURCE_DIR))
{
file += std::strlen(CMAKE_SOURCE_DIR);
if (file[0] == '/' || file[0] == '\\')
{
++file;
}
}
std::fprintf(fp, "Source file: %s (line %d)\n", file, line);
}
if (func != NULL)
{
std::fprintf(fp, "Function: %s\n", func);
}
std::fprintf(fp, "\n");
std::fprintf(fp, "%s:\n", title);
}
void HelpWriterContext::Impl::initDefaultReplacements()
{
const char *program = getProgramContext().programName();
addReplacement("[PROGRAM]", program);
}
void
TrajectoryAnalysisRunnerCommon::Impl::initFirstFrame()
{
// Return if we have already initialized the trajectory.
if (fr != NULL)
{
return;
}
time_unit_t time_unit
= static_cast<time_unit_t>(settings_.timeUnit() + 1);
output_env_init(&oenv_, getProgramContext(), time_unit, FALSE, exvgNONE, 0);
int frflags = settings_.frflags();
frflags |= TRX_NEED_X;
snew(fr, 1);
if (hasTrajectory())
{
if (!read_first_frame(oenv_, &status_, trjfile_.c_str(), fr, frflags))
{
GMX_THROW(FileIOError("Could not read coordinates from trajectory"));
}
bTrajOpen_ = true;
if (topInfo_.hasTopology())
{
const int topologyAtomCount = topInfo_.topology()->atoms.nr;
if (fr->natoms > topologyAtomCount)
{
const std::string message
= formatString("Trajectory (%d atoms) does not match topology (%d atoms)",
fr->natoms, topologyAtomCount);
GMX_THROW(InconsistentInputError(message));
}
}
}
else
{
// Prepare a frame from topology information.
// TODO: Initialize more of the fields.
if (frflags & (TRX_NEED_V))
{
GMX_THROW(NotImplementedError("Velocity reading from a topology not implemented"));
}
if (frflags & (TRX_NEED_F))
{
GMX_THROW(InvalidInputError("Forces cannot be read from a topology"));
}
fr->natoms = topInfo_.topology()->atoms.nr;
fr->bX = TRUE;
snew(fr->x, fr->natoms);
memcpy(fr->x, topInfo_.xtop_,
sizeof(*fr->x) * fr->natoms);
fr->bBox = TRUE;
copy_mat(topInfo_.boxtop_, fr->box);
}
set_trxframe_ePBC(fr, topInfo_.ePBC());
if (topInfo_.hasTopology() && settings_.hasRmPBC())
{
gpbc_ = gmx_rmpbc_init(&topInfo_.topology()->idef, topInfo_.ePBC(),
fr->natoms);
}
}
void
TrajectoryAnalysisRunnerCommon::initFirstFrame()
{
// Return if we have already initialized the trajectory.
if (impl_->fr)
{
return;
}
time_unit_t time_unit
= static_cast<time_unit_t>(impl_->settings_.timeUnit() + 1);
output_env_init(&impl_->oenv_, getProgramContext(), time_unit, FALSE, exvgNONE, 0);
int frflags = impl_->settings_.frflags();
frflags |= TRX_NEED_X;
snew(impl_->fr, 1);
const TopologyInformation &top = impl_->topInfo_;
if (hasTrajectory())
{
if (!read_first_frame(impl_->oenv_, &impl_->status_,
impl_->trjfile_.c_str(), impl_->fr, frflags))
{
GMX_THROW(FileIOError("Could not read coordinates from trajectory"));
}
impl_->bTrajOpen_ = true;
if (top.hasTopology() && impl_->fr->natoms > top.topology()->atoms.nr)
{
GMX_THROW(InconsistentInputError(formatString(
"Trajectory (%d atoms) does not match topology (%d atoms)",
impl_->fr->natoms, top.topology()->atoms.nr)));
}
}
else
{
// Prepare a frame from topology information.
// TODO: Initialize more of the fields.
if (frflags & (TRX_NEED_V))
{
GMX_THROW(NotImplementedError("Velocity reading from a topology not implemented"));
}
if (frflags & (TRX_NEED_F))
{
GMX_THROW(InvalidInputError("Forces cannot be read from a topology"));
}
impl_->fr->flags = frflags;
impl_->fr->natoms = top.topology()->atoms.nr;
impl_->fr->bX = TRUE;
snew(impl_->fr->x, impl_->fr->natoms);
memcpy(impl_->fr->x, top.xtop_,
sizeof(*impl_->fr->x) * impl_->fr->natoms);
impl_->fr->bBox = TRUE;
copy_mat(const_cast<rvec *>(top.boxtop_), impl_->fr->box);
}
set_trxframe_ePBC(impl_->fr, top.ePBC());
if (top.hasTopology() && impl_->settings_.hasRmPBC())
{
impl_->gpbc_ = gmx_rmpbc_init(&top.topology()->idef, top.ePBC(),
impl_->fr->natoms);
}
}