1499 lines
48 KiB
C++
1499 lines
48 KiB
C++
// clang-format off
|
|
/* ----------------------------------------------------------------------
|
|
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
|
|
https://www.lammps.org/, Sandia National Laboratories
|
|
LAMMPS development team: developers@lammps.org
|
|
|
|
Copyright (2003) Sandia Corporation. Under the terms of Contract
|
|
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
|
|
certain rights in this software. This software is distributed under
|
|
the GNU General Public License.
|
|
|
|
See the README file in the top-level LAMMPS directory.
|
|
------------------------------------------------------------------------- */
|
|
|
|
/* ----------------------------------------------------------------------
|
|
Contributing authors: Axel Kohlmeyer (Temple U),
|
|
Richard Berger (Temple U)
|
|
------------------------------------------------------------------------- */
|
|
|
|
#include "info.h"
|
|
|
|
#include "accelerator_kokkos.h"
|
|
#include "angle.h"
|
|
#include "atom.h"
|
|
#include "bond.h"
|
|
#include "comm.h"
|
|
#include "compute.h"
|
|
#include "dihedral.h"
|
|
#include "domain.h"
|
|
#include "dump.h"
|
|
#include "error.h"
|
|
#include "fix.h"
|
|
#include "force.h"
|
|
#include "group.h"
|
|
#include "improper.h"
|
|
#include "input.h"
|
|
#include "json.h"
|
|
#include "lmpfftsettings.h"
|
|
#include "modify.h"
|
|
#include "neighbor.h"
|
|
#include "output.h"
|
|
#include "pair.h"
|
|
#include "pair_hybrid.h"
|
|
#include "region.h"
|
|
#include "update.h"
|
|
#include "variable.h"
|
|
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
|
|
#include "fmt/chrono.h"
|
|
#endif
|
|
|
|
#include <cctype>
|
|
#include <cmath>
|
|
#include <cstring>
|
|
#include <ctime>
|
|
#include <map>
|
|
|
|
#ifdef _WIN32
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#endif
|
|
#define PSAPI_VERSION 1
|
|
#include <windows.h>
|
|
#include <cstdint>
|
|
#include <psapi.h>
|
|
#else
|
|
#include <sys/resource.h>
|
|
#endif
|
|
|
|
#if defined(__linux__)
|
|
#include <features.h>
|
|
#include <malloc.h>
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
namespace LAMMPS_NS {
|
|
|
|
enum {COMPUTES=1<<0,
|
|
DUMPS=1<<1,
|
|
FIXES=1<<2,
|
|
GROUPS=1<<3,
|
|
REGIONS=1<<4,
|
|
CONFIG=1<<5,
|
|
TIME=1<<6,
|
|
MEMORY=1<<7,
|
|
VARIABLES=1<<8,
|
|
SYSTEM=1<<9,
|
|
COMM=1<<10,
|
|
COEFFS=1<<11,
|
|
ATOM_STYLES=1<<12,
|
|
INTEGRATE_STYLES=1<<13,
|
|
MINIMIZE_STYLES=1<<14,
|
|
PAIR_STYLES=1<<15,
|
|
BOND_STYLES=1<<16,
|
|
ANGLE_STYLES=1<<17,
|
|
DIHEDRAL_STYLES=1<<18,
|
|
IMPROPER_STYLES=1<<19,
|
|
KSPACE_STYLES=1<<20,
|
|
FIX_STYLES=1<<21,
|
|
COMPUTE_STYLES=1<<22,
|
|
REGION_STYLES=1<<23,
|
|
DUMP_STYLES=1<<24,
|
|
COMMAND_STYLES=1<<25,
|
|
ACCELERATOR=1<<26,
|
|
FFT=1<<27,
|
|
ALL=~0};
|
|
|
|
static const int STYLES = ATOM_STYLES | INTEGRATE_STYLES | MINIMIZE_STYLES
|
|
| PAIR_STYLES | BOND_STYLES | ANGLE_STYLES
|
|
| DIHEDRAL_STYLES | IMPROPER_STYLES | KSPACE_STYLES
|
|
| FIX_STYLES | COMPUTE_STYLES | REGION_STYLES
|
|
| DUMP_STYLES | COMMAND_STYLES;
|
|
}
|
|
|
|
using namespace LAMMPS_NS;
|
|
|
|
static const char *mapstyles[] = { "none", "array", "hash", "yes" };
|
|
|
|
static const char *commstyles[] = { "brick", "tiled" };
|
|
static const char *commlayout[] = { "uniform", "nonuniform", "irregular" };
|
|
|
|
static const char bstyles[] = "pfsm";
|
|
|
|
template<typename ValueType>
|
|
static void print_columns(FILE *fp, std::map<std::string, ValueType> *styles);
|
|
|
|
template<typename ValueType>
|
|
static bool find_style(const LAMMPS *lmp, std::map<std::string, ValueType> *styles,
|
|
const std::string &name, bool suffix_check);
|
|
|
|
template<typename ValueType>
|
|
static std::vector<std::string> get_style_names(std::map<std::string, ValueType> *styles);
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void Info::command(int narg, char **arg)
|
|
{
|
|
FILE *out=screen;
|
|
int flags=0;
|
|
|
|
if (comm->me != 0) return;
|
|
|
|
// parse arguments
|
|
int idx = 0;
|
|
|
|
while (idx < narg) {
|
|
if (strncmp(arg[idx],"all",3) == 0) {
|
|
flags |= ALL;
|
|
++idx;
|
|
} else if ((idx+1 < narg) && (strncmp(arg[idx],"out",3) == 0)
|
|
&& (strncmp(arg[idx+1],"screen",3) == 0)) {
|
|
if ((out != screen) && (out != logfile)) fclose(out);
|
|
out = screen;
|
|
idx += 2;
|
|
} else if ((idx+1 < narg) && (strncmp(arg[idx],"out",3) == 0)
|
|
&& (strncmp(arg[idx+1],"log",3) == 0)) {
|
|
if ((out != screen) && (out != logfile)) fclose(out);
|
|
out = logfile;
|
|
idx += 2;
|
|
} else if ((idx+2 < narg) && (strncmp(arg[idx],"out",3) == 0)
|
|
&& (strncmp(arg[idx+1],"append",3) == 0)) {
|
|
if ((out != screen) && (out != logfile)) fclose(out);
|
|
out = fopen(arg[idx+2],"a");
|
|
idx += 3;
|
|
} else if ((idx+2 < narg) && (strncmp(arg[idx],"out",3) == 0)
|
|
&& (strncmp(arg[idx+1],"overwrite",3) == 0)) {
|
|
if ((out != screen) && (out != logfile)) fclose(out);
|
|
out = fopen(arg[idx+2],"w");
|
|
idx += 3;
|
|
} else if (strncmp(arg[idx],"communication",4) == 0) {
|
|
flags |= COMM;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"computes",4) == 0) {
|
|
flags |= COMPUTES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"dumps",3) == 0) {
|
|
flags |= DUMPS;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"fixes",3) == 0) {
|
|
flags |= FIXES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"groups",3) == 0) {
|
|
flags |= GROUPS;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"regions",3) == 0) {
|
|
flags |= REGIONS;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"config",3) == 0) {
|
|
flags |= CONFIG;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"time",3) == 0) {
|
|
flags |= TIME;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"memory",3) == 0) {
|
|
flags |= MEMORY;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"variables",3) == 0) {
|
|
flags |= VARIABLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"system",3) == 0) {
|
|
flags |= SYSTEM;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"coeffs",3) == 0) {
|
|
flags |= COEFFS;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"accelerator",3) == 0) {
|
|
flags |= ACCELERATOR;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"fft",3) == 0) {
|
|
flags |= FFT;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"styles",3) == 0) {
|
|
if (idx+1 < narg) {
|
|
++idx;
|
|
if (strncmp(arg[idx],"all",3) == 0) {
|
|
flags |= STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"atom",3) == 0) {
|
|
flags |= ATOM_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"integrate",3) == 0) {
|
|
flags |= INTEGRATE_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"minimize",3) == 0) {
|
|
flags |= MINIMIZE_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"pair",3) == 0) {
|
|
flags |= PAIR_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"bond",3) == 0) {
|
|
flags |= BOND_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"angle",3) == 0) {
|
|
flags |= ANGLE_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"dihedral",3) == 0) {
|
|
flags |= DIHEDRAL_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"improper",3) == 0) {
|
|
flags |= IMPROPER_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"kspace",3) == 0) {
|
|
flags |= KSPACE_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"fix",3) == 0) {
|
|
flags |= FIX_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"compute",4) == 0) {
|
|
flags |= COMPUTE_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"region",3) == 0) {
|
|
flags |= REGION_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"dump",3) == 0) {
|
|
flags |= DUMP_STYLES;
|
|
++idx;
|
|
} else if (strncmp(arg[idx],"command",4) == 0) {
|
|
flags |= COMMAND_STYLES;
|
|
++idx;
|
|
} else {
|
|
flags |= STYLES;
|
|
}
|
|
} else {
|
|
flags |= STYLES;
|
|
++idx;
|
|
}
|
|
} else {
|
|
error->warning(FLERR,"Ignoring unknown or incorrect info command flag: {}",arg[idx]);
|
|
++idx;
|
|
}
|
|
}
|
|
|
|
if (out == nullptr) return;
|
|
|
|
fputs("\nInfo-Info-Info-Info-Info-Info-Info-Info-Info-Info-Info\n",out);
|
|
#if defined(FMT_STATIC_THOUSANDS_SEPARATOR)
|
|
{
|
|
time_t tv = time(nullptr);
|
|
struct tm *now = localtime(&tv);
|
|
utils::print(out, "Printed on {}", asctime(now));
|
|
}
|
|
#else
|
|
std::tm now = fmt::localtime(std::time(nullptr));
|
|
utils::print(out,"Printed on {}", std::asctime(&now));
|
|
#endif
|
|
|
|
if (flags & CONFIG) {
|
|
utils::print(out,"\nLAMMPS version: {} / {}\n", lmp->version, lmp->num_ver);
|
|
|
|
if (LAMMPS::has_git_info())
|
|
utils::print(out,"Git info: {} / {} / {}\n",
|
|
LAMMPS::git_branch(), LAMMPS::git_descriptor(),LAMMPS::git_commit());
|
|
|
|
utils::print(out,"\nOS information: {}\n\n",platform::os_info());
|
|
|
|
utils::print(out,"sizeof(smallint): {}-bit\n"
|
|
"sizeof(imageint): {}-bit\n"
|
|
"sizeof(tagint): {}-bit\n"
|
|
"sizeof(bigint): {}-bit\n",
|
|
sizeof(smallint)*8, sizeof(imageint)*8,
|
|
sizeof(tagint)*8, sizeof(bigint)*8);
|
|
|
|
utils::print(out,"\nCompiler: {} with {}\nC++ standard: {}\n",
|
|
platform::compiler_info(),platform::openmp_standard(),platform::cxx_standard());
|
|
fputs(get_fmt_info().c_str(), out);
|
|
fputs(get_json_info().c_str(), out);
|
|
|
|
fputs("\nActive compile time flags:\n\n",out);
|
|
if (has_gzip_support()) fputs("-DLAMMPS_GZIP\n",out);
|
|
if (has_png_support()) fputs("-DLAMMPS_PNG\n",out);
|
|
if (has_jpeg_support()) fputs("-DLAMMPS_JPEG\n",out);
|
|
if (has_ffmpeg_support()) fputs("-DLAMMPS_FFMPEG\n",out);
|
|
if (has_curl_support()) fputs("-DLAMMPS_CURL\n",out);
|
|
if (has_fft_single_support()) fputs("-DFFT_SINGLE\n",out);
|
|
|
|
#if defined(LAMMPS_BIGBIG)
|
|
fputs("-DLAMMPS_BIGBIG\n",out);
|
|
#elif defined(LAMMPS_SMALLBIG)
|
|
fputs("-DLAMMPS_SMALLBIG\n",out);
|
|
#endif
|
|
if (has_gzip_support()) utils::print(out,"\n{}\n",platform::compress_info());
|
|
|
|
int ncword, ncline = 0;
|
|
fputs("\nInstalled packages:\n\n",out);
|
|
for (const char **pkg = LAMMPS::installed_packages; *pkg != nullptr; ++pkg) {
|
|
ncword = strlen(*pkg);
|
|
if (ncline + ncword > 78) {
|
|
ncline = 0;
|
|
fputs("\n",out);
|
|
}
|
|
utils::print(out,"{} ",*pkg);
|
|
ncline += ncword + 1;
|
|
}
|
|
fputs("\n",out);
|
|
}
|
|
|
|
if (flags & ACCELERATOR) {
|
|
utils::print(out,"\nAccelerator configuration:\n\n{}",
|
|
get_accelerator_info());
|
|
if (Info::has_gpu_device())
|
|
utils::print(out,"\nAvailable GPU devices:\n{}\n",get_gpu_device_info());
|
|
}
|
|
|
|
if (flags & MEMORY) {
|
|
double meminfo[3];
|
|
|
|
get_memory_info(meminfo);
|
|
|
|
fputs("\nMemory allocation information (MPI rank 0):\n\n",out);
|
|
utils::print(out,"Total dynamically allocated memory: {:.4} Mbyte\n",
|
|
meminfo[0]);
|
|
|
|
#if defined(_WIN32)
|
|
utils::print(out,"Non-shared memory use: {:.4} Mbyte\n",meminfo[1]);
|
|
utils::print(out,"Maximum working set size: {:.4} Mbyte\n",meminfo[2]);
|
|
#else
|
|
#if defined(__linux__)
|
|
utils::print(out,"Current reserved memory pool size: {:.4} Mbyte\n",
|
|
meminfo[1]);
|
|
#endif
|
|
utils::print(out,"Maximum resident set size: {:.4} Mbyte\n",meminfo[2]);
|
|
#endif
|
|
}
|
|
|
|
if (flags & COMM) {
|
|
int major,minor;
|
|
std::string version = platform::mpi_info(major,minor);
|
|
|
|
utils::print(out,"\nCommunication information:\n"
|
|
"MPI library level: MPI v{}.{}\n"
|
|
"MPI version: {}\n",major,minor,version);
|
|
|
|
utils::print(out,"Comm style = {}, Comm layout = {}\n"
|
|
"Communicate velocities for ghost atoms = {}\n",
|
|
commstyles[comm->style], commlayout[comm->layout],
|
|
comm->ghost_velocity ? "yes" : "no");
|
|
|
|
if (domain->box_exist) {
|
|
if (comm->mode == 0)
|
|
utils::print(out,"Communication mode = single\n"
|
|
"Communication cutoff = {}\n",
|
|
comm->get_comm_cutoff());
|
|
|
|
if (comm->mode == 1) {
|
|
fputs("Communication mode = multi\n",out);
|
|
double cut;
|
|
for (int i=0; i < neighbor->ncollections; ++i) {
|
|
if (comm->cutusermulti) cut = comm->cutusermulti[i];
|
|
else cut = 0.0;
|
|
for (int j=0; j < neighbor->ncollections; ++j) {
|
|
cut = MAX(cut,sqrt(neighbor->cutcollectionsq[i][j]));
|
|
}
|
|
|
|
if (comm->cutusermulti) cut = MAX(cut,comm->cutusermulti[i]);
|
|
utils::print(out,"Communication cutoff for collection {} = {:.8}\n", i, cut);
|
|
}
|
|
}
|
|
|
|
if (comm->mode == 2) {
|
|
fputs("Communication mode = multi/old\n",out);
|
|
double cut;
|
|
for (int i=1; i <= atom->ntypes && neighbor->cuttype; ++i) {
|
|
cut = neighbor->cuttype[i];
|
|
if (comm->cutusermultiold) cut = MAX(cut,comm->cutusermultiold[i]);
|
|
utils::print(out,"Communication cutoff for type {} = {:.8}\n", i, cut);
|
|
}
|
|
}
|
|
}
|
|
utils::print(out,"Nprocs = {}, Nthreads = {}\n",comm->nprocs,comm->nthreads);
|
|
if (domain->box_exist)
|
|
utils::print(out,"Processor grid = {} x {} x {}\n",comm->procgrid[0],
|
|
comm->procgrid[1], comm->procgrid[2]);
|
|
}
|
|
|
|
if (flags & FFT) {
|
|
fputs("\nFFT information:\n",out);
|
|
fputs(get_fft_info().c_str(),out);
|
|
}
|
|
|
|
if (flags & SYSTEM) {
|
|
fputs("\nSystem information:\n",out);
|
|
utils::print(out,"Units = {}\n", update->unit_style);
|
|
utils::print(out,"Atom style = {}\n", atom->get_style());
|
|
utils::print(out,"Atom map = {}\n", mapstyles[atom->map_style]);
|
|
if (atom->molecular != Atom::ATOMIC) {
|
|
const char *msg;
|
|
msg = (atom->molecular == Atom::TEMPLATE) ? "template" : "standard";
|
|
utils::print(out,"Molecule type = {}\n",msg);
|
|
}
|
|
utils::print(out,"Atoms = {:12}, types = {:8d}, style = {}\n",
|
|
atom->natoms, atom->ntypes, force->pair_style);
|
|
|
|
if (atom->tag_enable) utils::print(out,"Atoms with atom IDs\n");
|
|
if (atom->molecule) utils::print(out,"Atoms with molecule IDs\n");
|
|
if (atom->mass) utils::print(out,"Atoms with per-type masses\n");
|
|
if (atom->rmass) utils::print(out,"Atoms with per-atom masses\n");
|
|
if (atom->q) utils::print(out,"Atoms with per-atom charges\n");
|
|
|
|
if (force->pair && utils::strmatch(force->pair_style,"^hybrid")) {
|
|
auto hybrid = dynamic_cast<PairHybrid *>(force->pair);
|
|
utils::print(out,"Hybrid sub-styles:");
|
|
for (int i=0; i < hybrid->nstyles; ++i)
|
|
utils::print(out," {}", hybrid->keywords[i]);
|
|
fputc('\n',out);
|
|
}
|
|
if (atom->molecular != Atom::ATOMIC) {
|
|
const char *msg;
|
|
msg = force->bond_style ? force->bond_style : "none";
|
|
utils::print(out,"Bonds = {:12}, types = {:8}, style = {}\n",
|
|
atom->nbonds, atom->nbondtypes, msg);
|
|
|
|
msg = force->angle_style ? force->angle_style : "none";
|
|
utils::print(out,"Angles = {:12}, types = {:8}, style = {}\n",
|
|
atom->nangles, atom->nangletypes, msg);
|
|
|
|
msg = force->dihedral_style ? force->dihedral_style : "none";
|
|
utils::print(out,"Dihedrals = {:12}, types = {:8}, style = {}\n",
|
|
atom->ndihedrals, atom->ndihedraltypes, msg);
|
|
|
|
msg = force->improper_style ? force->improper_style : "none";
|
|
utils::print(out,"Impropers = {:12}, types = {:8}, style = {}\n",
|
|
atom->nimpropers, atom->nimpropertypes, msg);
|
|
|
|
const double * const special_lj = force->special_lj;
|
|
const double * const special_coul = force->special_coul;
|
|
|
|
utils::print(out,"Special bond factors lj = {:<8} {:<8} {:<8}\n"
|
|
"Special bond factors coul = {:<8} {:<8} {:<8}\n",
|
|
special_lj[1],special_lj[2],special_lj[3],
|
|
special_coul[1],special_coul[2],special_coul[3]);
|
|
}
|
|
|
|
utils::print(out,"Kspace style = {}\n",
|
|
force->kspace ? force->kspace_style : "none");
|
|
|
|
if (domain->box_exist) {
|
|
utils::print(out,"\nDimensions = {}\n",domain->dimension);
|
|
utils::print(out,"{} box = {:.8} x {:.8} x {:.8}\n",
|
|
domain->triclinic ? "Triclinic" : "Orthogonal",
|
|
domain->xprd, domain->yprd, domain->zprd);
|
|
utils::print(out,"Boundaries = {},{} {},{} {},{}\n",
|
|
bstyles[domain->boundary[0][0]],bstyles[domain->boundary[0][1]],
|
|
bstyles[domain->boundary[1][0]],bstyles[domain->boundary[1][1]],
|
|
bstyles[domain->boundary[2][0]],bstyles[domain->boundary[2][1]]);
|
|
utils::print(out,"xlo, xhi = {:.8}, {:.8}\n", domain->boxlo[0], domain->boxhi[0]);
|
|
utils::print(out,"ylo, yhi = {:.8}, {:.8}\n", domain->boxlo[1], domain->boxhi[1]);
|
|
utils::print(out,"zlo, zhi = {:.8}, {:.8}\n", domain->boxlo[2], domain->boxhi[2]);
|
|
if (domain->triclinic)
|
|
utils::print(out,"Xy, xz, yz = {:.8}, {:.8}, {:.8}\n",
|
|
domain->xy, domain->xz, domain->yz);
|
|
} else {
|
|
fputs("\nBox has not yet been created\n",out);
|
|
}
|
|
utils::print(out,"\nCurrent timestep number = {}\n", update->ntimestep);
|
|
utils::print(out,"Current timestep size = {}\n", update->dt);
|
|
}
|
|
|
|
if (domain->box_exist && (flags & COEFFS)) {
|
|
Pair *pair=force->pair;
|
|
|
|
fputs("\nCoeff status information:\n",out);
|
|
if (pair) utils::print(out,"\nPair coeffs\n{}", get_pair_coeff_status(lmp));
|
|
if (force->bond) utils::print(out,"\nBond coeffs\n{}", get_bond_coeff_status(lmp));
|
|
if (force->angle) utils::print(out,"\nAngle coeffs\n{}", get_angle_coeff_status(lmp));
|
|
if (force->dihedral) utils::print(out,"\nDihedral coeffs\n{}", get_dihedral_coeff_status(lmp));
|
|
if (force->improper) utils::print(out,"\nImproper coeffs\n{}", get_improper_coeff_status(lmp));
|
|
}
|
|
|
|
if (flags & GROUPS) {
|
|
int ngroup = group->ngroup;
|
|
char **names = group->names;
|
|
int *dynamic = group->dynamic;
|
|
fputs("\nGroup information:\n",out);
|
|
for (int i=0; i < ngroup; ++i) {
|
|
if (names[i])
|
|
utils::print(out,"Group[{:2d}]: {:16} ({})\n",
|
|
i, names[i], dynamic[i] ? "dynamic" : "static");
|
|
}
|
|
}
|
|
|
|
if (flags & REGIONS) {
|
|
fputs("\nRegion information:\n",out);
|
|
int i=0;
|
|
for (auto ® : domain->get_region_list()) {
|
|
utils::print(out,"Region[{:3d}]: {:16} style = {:16} side = {}\n",
|
|
i, std::string(reg->id)+',', std::string(reg->style)+',',
|
|
reg->interior ? "in" : "out");
|
|
if (reg->bboxflag)
|
|
utils::print(out," Boundary: lo {:.8} {:.8} {:.8} hi {:.8} {:.8} {:.8}\n",
|
|
reg->extent_xlo, reg->extent_ylo,
|
|
reg->extent_zlo, reg->extent_xhi,
|
|
reg->extent_yhi, reg->extent_zhi);
|
|
else fputs(" No Boundary\n",out);
|
|
}
|
|
}
|
|
|
|
if (flags & COMPUTES) {
|
|
int i = 0;
|
|
char **names = group->names;
|
|
fputs("\nCompute information:\n",out);
|
|
for (const auto &compute : modify->get_compute_list())
|
|
utils::print(out,"Compute[{:3d}]: {:16} style = {:16} group = {}\n", i++,
|
|
std::string(compute->id)+',',std::string(compute->style)+',',
|
|
names[compute->igroup]);
|
|
}
|
|
|
|
if (flags & DUMPS) {
|
|
int ndump = output->ndump;
|
|
Dump **dump = output->dump;
|
|
int *nevery = output->every_dump; \
|
|
char **vnames = output->var_dump;
|
|
char **names = group->names;
|
|
fputs("\nDump information:\n",out);
|
|
for (int i=0; i < ndump; ++i) {
|
|
utils::print(out,"Dump[{:3d}]: {:16} file = {:16} style = {:16} group = {:16} ",
|
|
i, std::string(dump[i]->id)+',',std::string(dump[i]->filename)+',',
|
|
std::string(dump[i]->style)+',',std::string(names[dump[i]->igroup])+',');
|
|
if (nevery[i]) {
|
|
utils::print(out,"every = {}\n", nevery[i]);
|
|
} else {
|
|
utils::print(out,"every = {}\n", vnames[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (flags & FIXES) {
|
|
int i = 0;
|
|
char **names = group->names;
|
|
fputs("\nFix information:\n",out);
|
|
for (const auto &fix : modify->get_fix_list())
|
|
utils::print(out, "Fix[{:3d}]: {:16} style = {:16} group = {}\n",i++,
|
|
std::string(fix->id)+',',std::string(fix->style)+',',names[fix->igroup]);
|
|
}
|
|
|
|
if (flags & VARIABLES) {
|
|
int nvar = input->variable->nvar;
|
|
fputs("\nVariable information:\n",out);
|
|
for (int i=0; i < nvar; ++i) {
|
|
auto vinfo = get_variable_info(i);
|
|
utils::print(out, get_variable_info(i));
|
|
}
|
|
}
|
|
|
|
if (flags & TIME) {
|
|
double wallclock = platform::walltime() - lmp->initclock;
|
|
double cpuclock = platform::cputime();
|
|
|
|
int cpuh,cpum,cpus,wallh,wallm,walls;
|
|
cpus = fmod(cpuclock,60.0);
|
|
cpuclock = (cpuclock - cpus) / 60.0;
|
|
cpum = fmod(cpuclock,60.0);
|
|
cpuh = (cpuclock - cpum) / 60.0;
|
|
walls = fmod(wallclock,60.0);
|
|
wallclock = (wallclock - walls) / 60.0;
|
|
wallm = fmod(wallclock,60.0);
|
|
wallh = (wallclock - wallm) / 60.0;
|
|
utils::print(out,"\nTotal time information (MPI rank 0):\n"
|
|
" CPU time: {:4d}:{:02d}:{:02d}\n"
|
|
" Wall time: {:4d}:{:02d}:{:02d}\n",
|
|
cpuh,cpum,cpus,wallh,wallm,walls);
|
|
}
|
|
|
|
if (flags & STYLES) {
|
|
available_styles(out, flags);
|
|
}
|
|
|
|
fputs("\nInfo-Info-Info-Info-Info-Info-Info-Info-Info-Info-Info\n\n",out);
|
|
|
|
// close output file pointer if opened locally thus forcing a hard sync.
|
|
if ((out != screen) && (out != logfile))
|
|
fclose(out);
|
|
}
|
|
|
|
void Info::available_styles(FILE * out, int flags)
|
|
{
|
|
|
|
fputs("\nStyles information:\n",out);
|
|
|
|
if (flags & ATOM_STYLES) atom_styles(out);
|
|
if (flags & INTEGRATE_STYLES) integrate_styles(out);
|
|
if (flags & MINIMIZE_STYLES) minimize_styles(out);
|
|
if (flags & PAIR_STYLES) pair_styles(out);
|
|
if (flags & BOND_STYLES) bond_styles(out);
|
|
if (flags & ANGLE_STYLES) angle_styles(out);
|
|
if (flags & DIHEDRAL_STYLES) dihedral_styles(out);
|
|
if (flags & IMPROPER_STYLES) improper_styles(out);
|
|
if (flags & KSPACE_STYLES) kspace_styles(out);
|
|
if (flags & FIX_STYLES) fix_styles(out);
|
|
if (flags & COMPUTE_STYLES) compute_styles(out);
|
|
if (flags & REGION_STYLES) region_styles(out);
|
|
if (flags & DUMP_STYLES) dump_styles(out);
|
|
if (flags & COMMAND_STYLES) command_styles(out);
|
|
}
|
|
|
|
void Info::atom_styles(FILE *out)
|
|
{
|
|
fputs("\nAtom styles:\n",out);
|
|
print_columns(out, atom->avec_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::integrate_styles(FILE *out)
|
|
{
|
|
fputs("\nIntegrate styles:\n",out);
|
|
print_columns(out, update->integrate_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::minimize_styles(FILE *out)
|
|
{
|
|
fputs("\nMinimize styles:\n",out);
|
|
print_columns(out, update->minimize_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::pair_styles(FILE *out)
|
|
{
|
|
fputs("\nPair styles:\n",out);
|
|
print_columns(out, force->pair_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::bond_styles(FILE *out)
|
|
{
|
|
fputs("\nBond styles:\n",out);
|
|
print_columns(out, force->bond_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::angle_styles(FILE *out)
|
|
{
|
|
fputs("\nAngle styles:\n",out);
|
|
print_columns(out, force->angle_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::dihedral_styles(FILE *out)
|
|
{
|
|
fputs("\nDihedral styles:\n",out);
|
|
print_columns(out, force->dihedral_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::improper_styles(FILE *out)
|
|
{
|
|
fputs("\nImproper styles:\n",out);
|
|
print_columns(out, force->improper_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::kspace_styles(FILE *out)
|
|
{
|
|
fputs("\nKSpace styles:\n",out);
|
|
print_columns(out, force->kspace_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::fix_styles(FILE *out)
|
|
{
|
|
fputs("\nFix styles:\n",out);
|
|
print_columns(out, modify->fix_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::compute_styles(FILE *out)
|
|
{
|
|
fputs("\nCompute styles:\n",out);
|
|
print_columns(out, modify->compute_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::region_styles(FILE *out)
|
|
{
|
|
fputs("\nRegion styles:\n",out);
|
|
print_columns(out, domain->region_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::dump_styles(FILE *out)
|
|
{
|
|
fputs("\nDump styles:\n",out);
|
|
print_columns(out,output->dump_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
void Info::command_styles(FILE *out)
|
|
{
|
|
fputs("\nCommand styles (add-on input script commands):\n",out);
|
|
print_columns(out, input->command_map);
|
|
fputs("\n\n\n",out);
|
|
}
|
|
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
// the is_active() function returns true if the selected style or name
|
|
// in the selected category is currently in use.
|
|
|
|
bool Info::is_active(const char *category, const char *name)
|
|
{
|
|
if ((category == nullptr) || (name == nullptr)) return false;
|
|
const char *style = "none";
|
|
|
|
if (strcmp(category,"package") == 0) {
|
|
if (strcmp(name,"gpu") == 0) {
|
|
return modify->get_fix_by_id("package_gpu") != nullptr;
|
|
} else if (strcmp(name,"intel") == 0) {
|
|
return modify->get_fix_by_id("package_intel") != nullptr;
|
|
} else if (strcmp(name,"kokkos") == 0) {
|
|
return lmp->kokkos && lmp->kokkos->kokkos_exists;
|
|
} else if (strcmp(name,"omp") == 0) {
|
|
return modify->get_fix_by_id("package_omp") != nullptr;
|
|
} else error->all(FLERR,"Unknown name for info package category: {}", name);
|
|
|
|
} else if (strcmp(category,"newton") == 0) {
|
|
if (strcmp(name,"pair") == 0) return (force->newton_pair != 0);
|
|
else if (strcmp(name,"bond") == 0) return (force->newton_bond != 0);
|
|
else if (strcmp(name,"any") == 0) return (force->newton != 0);
|
|
else error->all(FLERR,"Unknown name for info newton category: {}", name);
|
|
|
|
} else if (strcmp(category,"pair") == 0) {
|
|
if (force->pair == nullptr) return false;
|
|
if (strcmp(name,"single") == 0) return (force->pair->single_enable != 0);
|
|
else if (strcmp(name,"respa") == 0) return (force->pair->respa_enable != 0);
|
|
else if (strcmp(name,"manybody") == 0) return (force->pair->manybody_flag != 0);
|
|
else if (strcmp(name,"tail") == 0) return (force->pair->tail_flag != 0);
|
|
else if (strcmp(name,"shift") == 0) return (force->pair->offset_flag != 0);
|
|
else error->all(FLERR,"Unknown name for info pair category: {}", name);
|
|
|
|
} else if (strcmp(category,"comm_style") == 0) {
|
|
style = commstyles[comm->style];
|
|
} else if (strcmp(category,"min_style") == 0) {
|
|
style = update->minimize_style;
|
|
} else if (strcmp(category,"run_style") == 0) {
|
|
style = update->integrate_style;
|
|
} else if (strcmp(category,"atom_style") == 0) {
|
|
style = atom->atom_style;
|
|
} else if (strcmp(category,"pair_style") == 0) {
|
|
style = force->pair_style;
|
|
} else if (strcmp(category,"bond_style") == 0) {
|
|
style = force->bond_style;
|
|
} else if (strcmp(category,"angle_style") == 0) {
|
|
style = force->angle_style;
|
|
} else if (strcmp(category,"dihedral_style") == 0) {
|
|
style = force->dihedral_style;
|
|
} else if (strcmp(category,"improper_style") == 0) {
|
|
style = force->improper_style;
|
|
} else if (strcmp(category,"kspace_style") == 0) {
|
|
style = force->kspace_style;
|
|
} else error->all(FLERR,"Unknown category for info is_active(): {}", category);
|
|
|
|
int match = 0;
|
|
if (strcmp(style,name) == 0) match = 1;
|
|
|
|
if (!match && lmp->suffix_enable) {
|
|
if (lmp->suffix) {
|
|
std::string name_w_suffix = name + std::string("/") + lmp->suffix;
|
|
if (name_w_suffix == style) match = 1;
|
|
}
|
|
if (!match && lmp->suffix2) {
|
|
std::string name_w_suffix = name + std::string("/") + lmp->suffix2;
|
|
if (name_w_suffix == style) match = 1;
|
|
}
|
|
}
|
|
return match != 0;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
// the is_available() function returns true if the selected style
|
|
// or name in the selected category is available for use (but need
|
|
// not be currently active).
|
|
|
|
bool Info::is_available(const char *category, const char *name)
|
|
{
|
|
if ((category == nullptr) || (name == nullptr)) return false;
|
|
|
|
if (has_style(category, name)) {
|
|
return true;
|
|
} else if (strcmp(category,"feature") == 0) {
|
|
if (strcmp(name,"gzip") == 0) {
|
|
return has_gzip_support();
|
|
} else if (strcmp(name,"png") == 0) {
|
|
return has_png_support();
|
|
} else if (strcmp(name,"jpeg") == 0) {
|
|
return has_jpeg_support();
|
|
} else if (strcmp(name,"ffmpeg") == 0) {
|
|
return has_ffmpeg_support();
|
|
} else if (strcmp(name,"curl") == 0) {
|
|
return has_curl_support();
|
|
} else if (strcmp(name,"fft_single") == 0) {
|
|
return has_fft_single_support();
|
|
} else if (strcmp(name,"exceptions") == 0) {
|
|
return has_exceptions();
|
|
}
|
|
} else error->all(FLERR,"Unknown category for info is_available(): {}", category);
|
|
|
|
return false;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
// the is_defined() function returns true if a particular ID of the
|
|
// selected category (e.g. fix ID, group ID, region ID etc.) has been
|
|
// defined and thus can be accessed. It does *NOT* check whether a
|
|
// particular ID has a particular style.
|
|
|
|
bool Info::is_defined(const char *category, const char *name)
|
|
{
|
|
if ((category == nullptr) || (name == nullptr)) return false;
|
|
|
|
if (strcmp(category,"compute") == 0) {
|
|
if (modify->get_compute_by_id(name)) return true;
|
|
} else if (strcmp(category,"dump") == 0) {
|
|
if (output->get_dump_by_id(name)) return true;
|
|
} else if (strcmp(category,"fix") == 0) {
|
|
if (modify->get_fix_by_id(name)) return true;
|
|
} else if (strcmp(category,"group") == 0) {
|
|
if (group->find(name) >= 0) return true;
|
|
} else if (strcmp(category,"region") == 0) {
|
|
if (domain->get_region_by_id(name)) return true;
|
|
} else if (strcmp(category,"variable") == 0) {
|
|
if (input->variable->find(name) >= 0) return true;
|
|
} else error->all(FLERR,"Unknown category for info is_defined(): {}", category);
|
|
|
|
return false;
|
|
}
|
|
|
|
bool Info::has_style(const std::string &category, const std::string &name)
|
|
{
|
|
if (category == "atom") {
|
|
return find_style(lmp, atom->avec_map, name, false);
|
|
} else if (category == "integrate") {
|
|
return find_style(lmp, update->integrate_map, name, true);
|
|
} else if (category == "minimize") {
|
|
return find_style(lmp, update->minimize_map, name, true);
|
|
} else if (category == "pair") {
|
|
return find_style(lmp, force->pair_map, name, true);
|
|
} else if (category == "bond") {
|
|
return find_style(lmp, force->bond_map, name, true);
|
|
} else if (category == "angle") {
|
|
return find_style(lmp, force->angle_map, name, true);
|
|
} else if (category == "dihedral") {
|
|
return find_style(lmp, force->dihedral_map, name, true);
|
|
} else if (category == "improper") {
|
|
return find_style(lmp, force->improper_map, name, true);
|
|
} else if (category == "kspace") {
|
|
return find_style(lmp, force->kspace_map, name, true);
|
|
} else if (category == "fix") {
|
|
return find_style(lmp, modify->fix_map, name, true);
|
|
} else if (category == "compute") {
|
|
return find_style(lmp, modify->compute_map, name, true);
|
|
} else if (category == "region") {
|
|
return find_style(lmp, domain->region_map, name, false);
|
|
} else if (category == "dump") {
|
|
return find_style(lmp, output->dump_map, name, false);
|
|
} else if (category == "command") {
|
|
return find_style(lmp, input->command_map, name, false);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::string> Info::get_available_styles(const std::string &category)
|
|
{
|
|
if (category == "atom") {
|
|
return get_style_names(atom->avec_map);
|
|
} else if (category == "integrate") {
|
|
return get_style_names(update->integrate_map);
|
|
} else if (category == "minimize") {
|
|
return get_style_names(update->minimize_map);
|
|
} else if (category == "pair") {
|
|
return get_style_names(force->pair_map);
|
|
} else if (category == "bond") {
|
|
return get_style_names(force->bond_map);
|
|
} else if (category == "angle") {
|
|
return get_style_names(force->angle_map);
|
|
} else if (category == "dihedral") {
|
|
return get_style_names(force->dihedral_map);
|
|
} else if (category == "improper") {
|
|
return get_style_names(force->improper_map);
|
|
} else if (category == "kspace") {
|
|
return get_style_names(force->kspace_map);
|
|
} else if (category == "fix") {
|
|
return get_style_names(modify->fix_map);
|
|
} else if (category == "compute") {
|
|
return get_style_names(modify->compute_map);
|
|
} else if (category == "region") {
|
|
return get_style_names(domain->region_map);
|
|
} else if (category == "dump") {
|
|
return get_style_names(output->dump_map);
|
|
} else if (category == "command") {
|
|
return get_style_names(input->command_map);
|
|
}
|
|
return {};
|
|
}
|
|
|
|
template<typename ValueType>
|
|
static std::vector<std::string> get_style_names(std::map<std::string, ValueType> *styles)
|
|
{
|
|
std::vector<std::string> names;
|
|
|
|
names.reserve(styles->size());
|
|
for (auto const &kv : *styles) {
|
|
// skip "secret" styles
|
|
if (isupper(kv.first[0])) continue;
|
|
names.push_back(kv.first);
|
|
}
|
|
|
|
return names;
|
|
}
|
|
|
|
template<typename ValueType>
|
|
static bool find_style(const LAMMPS *lmp, std::map<std::string, ValueType> *styles,
|
|
const std::string &name, bool suffix_check)
|
|
{
|
|
if (styles->find(name) != styles->end()) {
|
|
return true;
|
|
}
|
|
|
|
if (suffix_check && lmp->suffix_enable) {
|
|
if (lmp->suffix) {
|
|
std::string name_w_suffix = name + "/" + lmp->suffix;
|
|
if (find_style(lmp, styles, name_w_suffix, false)) {
|
|
return true;
|
|
}
|
|
}
|
|
if (lmp->suffix2) {
|
|
std::string name_w_suffix = name + "/" + lmp->suffix2;
|
|
if (find_style(lmp, styles, name_w_suffix, false)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename ValueType>
|
|
static void print_columns(FILE *fp, std::map<std::string, ValueType> *styles)
|
|
{
|
|
if (styles->empty()) {
|
|
fprintf(fp, "\nNone");
|
|
return;
|
|
}
|
|
|
|
// std::map keys are already sorted
|
|
int pos = 80;
|
|
for (auto it = styles->begin(); it != styles->end(); ++it) {
|
|
const std::string &style_name = it->first;
|
|
|
|
// skip "internal" styles
|
|
if (isupper(style_name[0]) || utils::strmatch(style_name,"/kk/host$")
|
|
|| utils::strmatch(style_name,"/kk/device$")) continue;
|
|
|
|
int len = style_name.length();
|
|
if (pos + len > 80) {
|
|
fprintf(fp,"\n");
|
|
pos = 0;
|
|
}
|
|
|
|
if (len < 16) {
|
|
fprintf(fp,"%-16s", style_name.c_str());
|
|
pos += 16;
|
|
} else if (len < 32) {
|
|
fprintf(fp,"%-32s", style_name.c_str());
|
|
pos += 32;
|
|
} else if (len < 48) {
|
|
fprintf(fp,"%-48s", style_name.c_str());
|
|
pos += 48;
|
|
} else if (len < 64) {
|
|
fprintf(fp,"%-64s", style_name.c_str());
|
|
pos += 64;
|
|
} else {
|
|
fprintf(fp,"%-80s", style_name.c_str());
|
|
pos += 80;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool Info::has_gzip_support() {
|
|
#ifdef LAMMPS_GZIP
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool Info::has_png_support() {
|
|
#ifdef LAMMPS_PNG
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool Info::has_jpeg_support() {
|
|
#ifdef LAMMPS_JPEG
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool Info::has_ffmpeg_support() {
|
|
#ifdef LAMMPS_FFMPEG
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool Info::has_curl_support() {
|
|
#ifdef LAMMPS_CURL
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool Info::has_fft_single_support() {
|
|
#ifdef FFT_SINGLE
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
bool Info::has_exceptions() {
|
|
return true;
|
|
}
|
|
|
|
bool Info::has_package(const std::string &package_name) {
|
|
for (int i = 0; LAMMPS::installed_packages[i] != nullptr; ++i) {
|
|
if (package_name == LAMMPS::installed_packages[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#if defined(LMP_GPU)
|
|
extern bool lmp_gpu_config(const std::string &, const std::string &);
|
|
extern bool lmp_has_compatible_gpu_device();
|
|
extern std::string lmp_gpu_device_info();
|
|
|
|
// we will only report compatible GPUs, i.e. when a GPU device is
|
|
// available *and* supports the required floating point precision
|
|
bool Info::has_gpu_device()
|
|
{
|
|
return lmp_has_compatible_gpu_device();
|
|
}
|
|
|
|
std::string Info::get_gpu_device_info()
|
|
{
|
|
return lmp_gpu_device_info();
|
|
}
|
|
#else
|
|
bool Info::has_gpu_device()
|
|
{
|
|
return false;
|
|
}
|
|
std::string Info::get_gpu_device_info()
|
|
{
|
|
return "";
|
|
}
|
|
#endif
|
|
|
|
#if defined(LMP_KOKKOS)
|
|
#include "Kokkos_Macros.hpp"
|
|
#endif
|
|
|
|
bool Info::has_accelerator_feature(const std::string &package,
|
|
const std::string &category,
|
|
const std::string &setting)
|
|
{
|
|
#if defined(LMP_KOKKOS)
|
|
if (package == "KOKKOS") {
|
|
if (category == "precision") {
|
|
return setting == "double";
|
|
}
|
|
if (category == "api") {
|
|
#if defined(KOKKOS_ENABLE_OPENMP)
|
|
if (setting == "openmp") return true;
|
|
#endif
|
|
#if defined(KOKKOS_ENABLE_SERIAL)
|
|
if (setting == "serial") return true;
|
|
#endif
|
|
#if defined(KOKKOS_ENABLE_THREADS)
|
|
if (setting == "pthreads") return true;
|
|
#endif
|
|
#if defined(KOKKOS_ENABLE_CUDA)
|
|
if (setting == "cuda") return true;
|
|
#endif
|
|
#if defined(KOKKOS_ENABLE_HIP)
|
|
if (setting == "hip") return true;
|
|
#endif
|
|
#if defined(KOKKOS_ENABLE_SYCL)
|
|
if (setting == "sycl") return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(LMP_GPU)
|
|
if (package == "GPU") {
|
|
return lmp_gpu_config(category,setting);
|
|
}
|
|
#endif
|
|
#if defined(LMP_OPENMP)
|
|
if (package == "OPENMP") {
|
|
if (category == "precision") {
|
|
return setting == "double";
|
|
}
|
|
if (category == "api") {
|
|
#if defined(_OPENMP)
|
|
return setting == "openmp";
|
|
#else
|
|
return setting == "serial";
|
|
#endif
|
|
}
|
|
}
|
|
#endif
|
|
#if defined(LMP_INTEL)
|
|
if (package == "INTEL") {
|
|
if (category == "precision") {
|
|
if (setting == "double") return true;
|
|
else if (setting == "mixed") return true;
|
|
else if (setting == "single") return true;
|
|
else return false;
|
|
}
|
|
if (category == "api") {
|
|
#if defined(LMP_INTEL_OFFLOAD)
|
|
if (setting == "phi") return true;
|
|
#elif defined(_OPENMP)
|
|
if (setting == "openmp") return true;
|
|
#else
|
|
if (setting == "serial") return true;
|
|
#endif
|
|
return false;
|
|
}
|
|
}
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
#if defined(LMP_INTEL)
|
|
#include "intel_preprocess.h"
|
|
#endif
|
|
|
|
std::string Info::get_accelerator_info(const std::string &package)
|
|
{
|
|
std::string mesg;
|
|
if ((package.empty() || (package == "GPU")) && has_package("GPU")) {
|
|
mesg += "GPU package API:";
|
|
if (has_accelerator_feature("GPU","api","cuda")) mesg += " CUDA";
|
|
if (has_accelerator_feature("GPU","api","hip")) mesg += " HIP";
|
|
if (has_accelerator_feature("GPU","api","opencl")) mesg += " OpenCL";
|
|
mesg += "\nGPU package precision:";
|
|
if (has_accelerator_feature("GPU","precision","single")) mesg += " single";
|
|
if (has_accelerator_feature("GPU","precision","mixed")) mesg += " mixed";
|
|
if (has_accelerator_feature("GPU","precision","double")) mesg += " double";
|
|
mesg += "\n";
|
|
}
|
|
if ((package.empty() || (package == "KOKKOS")) && has_package("KOKKOS")) {
|
|
mesg += "KOKKOS package API:";
|
|
if (has_accelerator_feature("KOKKOS","api","cuda")) mesg += " CUDA";
|
|
if (has_accelerator_feature("KOKKOS","api","hip")) mesg += " HIP";
|
|
if (has_accelerator_feature("KOKKOS","api","sycl")) mesg += " SYCL";
|
|
if (has_accelerator_feature("KOKKOS","api","openmp")) mesg += " OpenMP";
|
|
if (has_accelerator_feature("KOKKOS","api","serial")) mesg += " Serial";
|
|
if (has_accelerator_feature("KOKKOS","api","pthreads")) mesg += " Pthreads";
|
|
mesg += "\nKOKKOS package precision:";
|
|
if (has_accelerator_feature("KOKKOS","precision","single")) mesg += " single";
|
|
if (has_accelerator_feature("KOKKOS","precision","mixed")) mesg += " mixed";
|
|
if (has_accelerator_feature("KOKKOS","precision","double")) mesg += " double";
|
|
#if LMP_KOKKOS
|
|
mesg += fmt::format("\nKokkos library version: {}.{}.{}", KOKKOS_VERSION / 10000,
|
|
(KOKKOS_VERSION % 10000) / 100, KOKKOS_VERSION % 100);
|
|
#endif
|
|
mesg += "\n";
|
|
}
|
|
if ((package.empty() || (package == "OPENMP")) && has_package("OPENMP")) {
|
|
mesg += "OPENMP package API:";
|
|
if (has_accelerator_feature("OPENMP","api","openmp")) mesg += " OpenMP";
|
|
if (has_accelerator_feature("OPENMP","api","serial")) mesg += " Serial";
|
|
mesg += "\nOPENMP package precision:";
|
|
if (has_accelerator_feature("OPENMP","precision","single")) mesg += " single";
|
|
if (has_accelerator_feature("OPENMP","precision","mixed")) mesg += " mixed";
|
|
if (has_accelerator_feature("OPENMP","precision","double")) mesg += " double";
|
|
#if defined(_OPENMP)
|
|
mesg += "\nOpenMP standard: " + platform::openmp_standard();
|
|
#endif
|
|
mesg += "\n";
|
|
}
|
|
if ((package.empty() || (package == "INTEL")) && has_package("INTEL")) {
|
|
mesg += "INTEL package API:";
|
|
if (has_accelerator_feature("INTEL","api","phi")) mesg += " Phi";
|
|
if (has_accelerator_feature("INTEL","api","openmp")) mesg += " OpenMP";
|
|
mesg += "\nINTEL package precision:";
|
|
if (has_accelerator_feature("INTEL","precision","single")) mesg += " single";
|
|
if (has_accelerator_feature("INTEL","precision","mixed")) mesg += " mixed";
|
|
if (has_accelerator_feature("INTEL","precision","double")) mesg += " double";
|
|
#if defined(LMP_SIMD_COMPILER)
|
|
mesg += "\nINTEL package SIMD: enabled";
|
|
#else
|
|
mesg += "\nINTEL package SIMD: not enabled";
|
|
#endif
|
|
mesg += "\n";
|
|
}
|
|
return mesg;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_fft_info()
|
|
{
|
|
std::string fft_info;
|
|
#if defined(FFT_SINGLE)
|
|
fft_info = "FFT precision = single\n";
|
|
#else
|
|
fft_info = "FFT precision = double\n";
|
|
#endif
|
|
#if defined(FFT_HEFFTE)
|
|
fft_info += "FFT engine = HeFFTe\n";
|
|
#if defined(FFT_HEFFTE_MKL)
|
|
fft_info += "FFT library = MKL\n";
|
|
#elif defined(FFT_HEFFTE_FFTW)
|
|
fft_info += "FFT library = FFTW\n";
|
|
#else
|
|
fft_info += "FFT library = (builtin)\n";
|
|
#endif
|
|
#else
|
|
fft_info += "FFT engine = mpiFFT\n";
|
|
#if defined(FFT_MKL)
|
|
#if defined(FFT_MKL_THREADS)
|
|
fft_info += "FFT library = MKL with threads\n";
|
|
#else
|
|
fft_info += "FFT library = MKL\n";
|
|
#endif
|
|
#elif defined(FFT_MKL_GPU)
|
|
fft_info += "FFT library = MKL GPU\n";
|
|
#elif defined(FFT_NVPL)
|
|
fft_info += "FFT library = NVPL\n";
|
|
#elif defined(FFT_FFTW3)
|
|
#if defined(FFT_FFTW_THREADS)
|
|
fft_info += "FFT library = FFTW3 with threads\n";
|
|
#else
|
|
fft_info += "FFT library = FFTW3\n";
|
|
#endif
|
|
#else
|
|
fft_info += "FFT library = KISS\n";
|
|
#endif
|
|
#endif
|
|
#if defined(LMP_KOKKOS)
|
|
fft_info += "KOKKOS FFT engine = mpiFFT\n";
|
|
#if defined(FFT_KOKKOS_CUFFT)
|
|
fft_info += "KOKKOS FFT library = cuFFT\n";
|
|
#elif defined(FFT_KOKKOS_HIPFFT)
|
|
fft_info += "KOKKOS FFT library = hipFFT\n";
|
|
#elif defined(FFT_KOKKOS_FFTW3)
|
|
#if defined(FFT_KOKKOS_FFTW_THREADS)
|
|
fft_info += "KOKKOS FFT library = FFTW3 with threads\n";
|
|
#else
|
|
fft_info += "KOKKOS FFT library = FFTW3\n";
|
|
#endif
|
|
#elif defined(FFT_KOKKOS_NVPL)
|
|
fft_info += "KOKKOS FFT library = NVPL\n";
|
|
#elif defined(FFT_KOKKOS_MKL)
|
|
#if defined(FFT_KOKKOS_MKL_THREADS)
|
|
fft_info += "KOKKOS FFT library = MKL with threads\n";
|
|
#else
|
|
fft_info += "KOKKOS FFT library = MKL\n";
|
|
#endif
|
|
#elif defined(FFT_KOKKOS_MKL_GPU)
|
|
fft_info += "KOKKOS FFT library = MKL GPU\n";
|
|
#else
|
|
fft_info += "KOKKOS FFT library = KISS\n";
|
|
#endif
|
|
#endif
|
|
return fft_info;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
static constexpr int fmt_ver_major = FMT_VERSION / 10000;
|
|
static constexpr int fmt_ver_minor = (FMT_VERSION % 10000) / 100;
|
|
static constexpr int fmt_ver_patch = FMT_VERSION % 100;
|
|
|
|
std::string Info::get_fmt_info()
|
|
{
|
|
return fmt::format("Embedded fmt library version: {}.{}.{}\n",
|
|
fmt_ver_major, fmt_ver_minor, fmt_ver_patch);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_json_info()
|
|
{
|
|
return fmt::format("Embedded JSON class version: {}.{}.{}\n",
|
|
NLOHMANN_JSON_VERSION_MAJOR,
|
|
NLOHMANN_JSON_VERSION_MINOR,
|
|
NLOHMANN_JSON_VERSION_PATCH);
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
void Info::get_memory_info(double *meminfo)
|
|
{
|
|
double bytes = 0;
|
|
bytes += atom->memory_usage();
|
|
bytes += neighbor->memory_usage();
|
|
bytes += comm->memory_usage();
|
|
bytes += update->memory_usage();
|
|
bytes += force->memory_usage();
|
|
bytes += modify->memory_usage();
|
|
for (int i = 0; i < output->ndump; i++)
|
|
bytes += output->dump[i]->memory_usage();
|
|
meminfo[0] = bytes/1024.0/1024.0;
|
|
meminfo[1] = 0;
|
|
meminfo[2] = 0;
|
|
|
|
#if defined(_WIN32)
|
|
HANDLE phandle = GetCurrentProcess();
|
|
PROCESS_MEMORY_COUNTERS_EX pmc;
|
|
GetProcessMemoryInfo(phandle,(PROCESS_MEMORY_COUNTERS *)&pmc,sizeof(pmc));
|
|
meminfo[1] = (double)pmc.PrivateUsage/1048576.0;
|
|
meminfo[2] = (double)pmc.PeakWorkingSetSize/1048576.0;
|
|
#else
|
|
#if defined(__linux__)
|
|
// __GLIBC_MINOR__ is only defined on real glibc (i.e. not on musl)
|
|
#if defined(__GLIBC_MINOR__)
|
|
// newer glibc versions have mallinfo2
|
|
#if defined(__GLIBC__) && __GLIBC_PREREQ(2, 33)
|
|
struct mallinfo2 mi;
|
|
mi = mallinfo2();
|
|
#else
|
|
struct mallinfo mi;
|
|
mi = mallinfo();
|
|
#endif
|
|
meminfo[1] = (double)mi.uordblks/1048576.0+(double)mi.hblkhd/1048576.0;
|
|
#endif
|
|
// not glibc => may not have mallinfo/mallinfo2
|
|
#else
|
|
meminfo[1] = 0.0;
|
|
#endif
|
|
struct rusage ru;
|
|
if (getrusage(RUSAGE_SELF, &ru) == 0)
|
|
meminfo[2] = (double)ru.ru_maxrss/1024.0;
|
|
#endif
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
char **Info::get_variable_names(int &num) {
|
|
num = input->variable->nvar;
|
|
return input->variable->names;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_variable_info(int num) {
|
|
int *style = input->variable->style;
|
|
char **names = input->variable->names;
|
|
char ***data = input->variable->data;
|
|
std::string text;
|
|
int ndata = 1;
|
|
text = fmt::format("Variable[{:3d}]: {:16} style = {:16} def =", num,
|
|
std::string(names[num]) + ',', Variable::varstyles[style[num]] + ',');
|
|
if (style[num] == Variable::INTERNAL) {
|
|
text += fmt::format("{:.8}\n",input->variable->dvalue[num]);
|
|
return text;
|
|
}
|
|
|
|
if ((style[num] != Variable::LOOP) && (style[num] != Variable::ULOOP))
|
|
ndata = input->variable->num[num];
|
|
else
|
|
input->variable->retrieve(names[num]);
|
|
|
|
for (int j=0; j < ndata; ++j)
|
|
if (data[num][j]) text += fmt::format(" {}",data[num][j]);
|
|
text += "\n";
|
|
return text;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_pair_coeff_status(const LAMMPS *lmp) {
|
|
|
|
if (!lmp || !lmp->force || !lmp->force->pair || !lmp->force->pair->allocated)
|
|
return "Pair style not yet initialized\n";
|
|
|
|
const auto ntypes = lmp->atom->ntypes;
|
|
const auto setflag = lmp->force->pair->setflag;
|
|
std::string output = "";
|
|
for (int i=1; i <= ntypes; ++i) {
|
|
for (int j=i; j <= ntypes; ++j)
|
|
output += fmt::format("{:6d} {:6d}: is{}set\n", i, j, setflag[i][j] ? " " : " not ");
|
|
}
|
|
return output;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_bond_coeff_status(const LAMMPS *lmp) {
|
|
|
|
if (!lmp || !lmp->force || !lmp->force->bond || !lmp->force->bond->allocated)
|
|
return "Bond style not yet initialized\n";
|
|
|
|
const auto ntypes = lmp->atom->nbondtypes;
|
|
const auto setflag = lmp->force->bond->setflag;
|
|
std::string output = "";
|
|
for (int i=1; i <= ntypes; ++i)
|
|
output += fmt::format("{:6d}: is{}set\n", i, setflag[i] ? " " : " not ");
|
|
return output;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_angle_coeff_status(const LAMMPS *lmp) {
|
|
|
|
if (!lmp || !lmp->force || !lmp->force->angle || !lmp->force->angle->allocated)
|
|
return "Angle style not yet initialized\n";
|
|
|
|
const auto ntypes = lmp->atom->nangletypes;
|
|
const auto setflag = lmp->force->angle->setflag;
|
|
std::string output = "";
|
|
for (int i=1; i <= ntypes; ++i)
|
|
output += fmt::format("{:6d}: is{}set\n", i, setflag[i] ? " " : " not ");
|
|
return output;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_dihedral_coeff_status(const LAMMPS *lmp) {
|
|
|
|
if (!lmp || !lmp->force || !lmp->force->dihedral || !lmp->force->dihedral->allocated)
|
|
return "Dihedral style not yet initialized\n";
|
|
|
|
const auto ntypes = lmp->atom->ndihedraltypes;
|
|
const auto setflag = lmp->force->dihedral->setflag;
|
|
std::string output = "";
|
|
for (int i=1; i <= ntypes; ++i)
|
|
output += fmt::format("{:6d}: is{}set\n", i, setflag[i] ? " " : " not ");
|
|
return output;
|
|
}
|
|
|
|
/* ---------------------------------------------------------------------- */
|
|
|
|
std::string Info::get_improper_coeff_status(const LAMMPS *lmp) {
|
|
|
|
if (!lmp || !lmp->force || !lmp->force->improper || !lmp->force->improper->allocated)
|
|
return "Improper style not yet initialized\n";
|
|
|
|
const auto ntypes = lmp->atom->nimpropertypes;
|
|
const auto setflag = lmp->force->improper->setflag;
|
|
std::string output = "";
|
|
for (int i=1; i <= ntypes; ++i)
|
|
output += fmt::format("{:6d}: is{}set\n", i, setflag[i] ? " " : " not ");
|
|
return output;
|
|
}
|