From aadd4f1a2895afc32ee75f80884e75b677aa16b6 Mon Sep 17 00:00:00 2001 From: GardevoirX Date: Tue, 10 Mar 2026 20:32:35 +0100 Subject: [PATCH 1/6] A (at least) compilable versiron of `compute metatomic` Temp2 A (at least) compilable versiron of `compute metatomic` --- src/ML-METATOMIC/compute_metatomic.cpp | 635 +++++++++++++++++++++++++ src/ML-METATOMIC/compute_metatomic.h | 109 +++++ src/ML-METATOMIC/metatomic_system.cpp | 15 +- src/ML-METATOMIC/metatomic_system.h | 3 +- src/ML-METATOMIC/metatomic_types.h | 6 + 5 files changed, 766 insertions(+), 2 deletions(-) create mode 100644 src/ML-METATOMIC/compute_metatomic.cpp create mode 100644 src/ML-METATOMIC/compute_metatomic.h diff --git a/src/ML-METATOMIC/compute_metatomic.cpp b/src/ML-METATOMIC/compute_metatomic.cpp new file mode 100644 index 00000000000..7590502578d --- /dev/null +++ b/src/ML-METATOMIC/compute_metatomic.cpp @@ -0,0 +1,635 @@ +/* ---------------------------------------------------------------------- + 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. +------------------------------------------------------------------------- */ + +#include "metatomic_types.h" +#include "metatomic_system.h" + +#include "compute_metatomic.h" + +#include "atom.h" +#include "memory.h" +#include "modify.h" +#include "error.h" +#include "group.h" +#include "force.h" +#include "update.h" +#include "neighbor.h" +#include "neigh_list.h" +#include "neigh_request.h" +#include "comm.h" + +#include +#include + +#include +#include + +using namespace LAMMPS_NS; + +/* ---------------------------------------------------------------------- */ + +ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(lmp, narg, arg) { + scalar_flag = 1; + vector_flag = 1; + size_vector_variable = 1; + size_array_rows_variable = 1; + peratom_flag = 1; + + std::string length_unit; + if (strcmp(update->unit_style, "metal") != 0) { + error->all(FLERR, "compute metatomic currently only supports 'metal' units"); + } + length_unit = "angstrom"; + + if (narg < 5) { + error->all(FLERR, + "Illegal compute metatomic command: expected at least 5 arguments " + "(compute ID group-ID metatomic model_path output_name ...); got %d", narg + ); + } + + std::string output_name; + this->mta_data = new ComputeMetatomicData(std::move(length_unit)); + this->model_path = arg[3]; + this->requested_device = std::nullopt; + this->extensions_directory = std::nullopt; + this->output_name = arg[4]; + + int iarg = 5; + + bool quantity_is_set = false; + bool unit_is_set = false; + bool per_atom_is_set = false; + bool types_are_set = false; + std::string quantity; + std::string unit; + bool per_atom; + std::vector parsed_types; + + while (iarg < narg) { + if (strcmp(arg[iarg], "quantity") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'quantity' in compute metatomic, got nothing"); + } else { + quantity = std::string(arg[iarg]); + quantity_is_set = true; + iarg += 1; + } + } else if (strcmp(arg[iarg], "unit") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'unit' in compute metatomic, got nothing"); + } else { + unit = std::string(arg[iarg]); + unit_is_set = true; + iarg += 1; + } + } else if (strcmp(arg[iarg], "per_atom") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'per_atom' in compute metatomic, got nothing"); + } else if (strcmp(arg[iarg], "on") == 0) { + per_atom = true; + per_atom_is_set = true; + iarg += 1; + } else if (strcmp(arg[iarg], "off") == 0) { + per_atom = false; + per_atom_is_set = true; + iarg += 1; + } else { + error->one(FLERR, "expected after 'per_atom' in compute metatomic, got '{}'", arg[iarg]); + } + } else if (strcmp(arg[iarg], "device") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "Illegal compute metatomic command: 'device' expects an argument " + "specifying the device (e.g. cpu, cuda, mps)"); + } + this->requested_device = std::string(arg[iarg]); + iarg += 1; + } else if (strcmp(arg[iarg], "check_consistency") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'check_consistency' in compute metatomic, got nothing"); + } else if (strcmp(arg[iarg], "on") == 0) { + mta_data->check_consistency = true; + iarg += 1; + } else if (strcmp(arg[iarg], "off") == 0) { + mta_data->check_consistency = false; + iarg += 1; + } else { + error->one(FLERR, "expected after 'check_consistency' in compute metatomic, got '{}'", arg[iarg]); + } + } else if (strcmp(arg[iarg], "extensions_directory") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'extensions_directory' in compute metatomic, got nothing"); + } else { + this->extensions_directory = std::string(arg[iarg]); + iarg += 1; + } + } else if (strcmp(arg[iarg], "types") == 0) { + iarg += 1; + types_are_set = true; + // Require exactly atom->ntypes integer values after the "types" keyword. + if (iarg + atom->ntypes > narg) { + error->all(FLERR, + "Illegal compute metatomic command: expected {} type values " + "after 'types'", atom->ntypes + ); + } + for (int ti = 0; ti < atom->ntypes; ++ti) { + int type = -1; + const char *argstr = arg[iarg + ti]; + try { + type = std::stoi(argstr); + } catch (const std::invalid_argument &) { + error->all(FLERR, + "Illegal compute metatomic command: expected integer for type {}, " + "got '{}'", ti + 1, argstr + ); + } catch (const std::out_of_range &) { + error->all(FLERR, + "Illegal compute metatomic command: type value out of range " + "for argument '%s'", argstr + ); + } + if (type <= 0) { + error->all(FLERR, "Illegal compute metatomic command: type {} should be > 0", type); + } + parsed_types.push_back(type); + } + iarg += atom->ntypes; + } else { + error->all(FLERR, + "Illegal compute metatomic command: unrecognized keyword '{}' (expected 'quantity', 'unit', 'per_atom', 'device', 'check_consistency', or 'types' )", arg[iarg]); + } + } + + if (!quantity_is_set) { + error->all(FLERR, "Illegal compute metatomic command: 'quantity' keyword is required"); + } + if (!unit_is_set) { + error->all(FLERR, "Illegal compute metatomic command: 'unit' keyword is required"); + } + if (!per_atom_is_set) { + error->all(FLERR, "Illegal compute metatomic command: 'per_atom' keyword is required"); + } + if (!types_are_set) { + error->all(FLERR, "Illegal compute metatomic command: no types specified"); + } + + // Allocate and fill the type-mapping (1-based indexing) + type_mapping = memory->create(type_mapping, atom->ntypes + 1, "compute_metatomic:type_mapping"); + for (int i = 1; i <= atom->ntypes; i++) { + type_mapping[i] = parsed_types[i - 1]; + } + + this->mta_data->requested_output = torch::make_intrusive( + /*quantity=*/quantity, + /*unit=*/unit, + /*per_atom=*/per_atom, + /*explicit_gradients=*/std::vector{}, + /*description=*/"" + ); + this->mta_data->evaluation_options->outputs.insert(this->output_name, this->mta_data->requested_output); +} + +ComputeMetatomic::~ComputeMetatomic() { + memory->destroy(type_mapping); + delete mta_data; + if (result_kind == RESULT_GLOBAL_VECTOR) { + memory->destroy(vector); + } else if (result_kind == RESULT_PERATOM_VECTOR) { + memory->destroy(vector_atom); + } else if (result_kind == RESULT_PERATOM_ARRAY) { + memory->destroy(array_atom); + } else if (result_kind == RESULT_SCALAR || result_kind == RESULT_NONE) { + // nothing to destroy + } else { + error->all(FLERR, "compute metatomic internal error: unknown result kind in destructor"); + } +} + +void ComputeMetatomic::init() { + if (!type_mapping) { + error->all(FLERR, "compute metatomic internal error: type_mapping not initialized"); + } + mta_data->load_model( + this->lmp, + this->model_path.c_str(), + this->extensions_directory ? this->extensions_directory->c_str() : nullptr + ); + + // Select the device to use based on the model's preference, the user choice + // and what's available. + this->pick_device( + mta_data->device, + this->requested_device ? this->requested_device->c_str() : nullptr + ); + + // move all data to the correct device + mta_data->model->to(mta_data->device); + mta_data->selected_atoms_values = mta_data->selected_atoms_values.to(mta_data->device); + + auto message = "Computing " + this->output_name + " on " + mta_data->device.str() + " device with " + mta_data->capabilities->dtype() + " data"; + if (screen) { + fprintf(screen, "%s\n", message.c_str()); + } + if (logfile) { + fprintf(logfile,"%s\n", message.c_str()); + } + + // get the model's interaction range + auto range = mta_data->capabilities->engine_interaction_range(mta_data->evaluation_options->length_unit()); + if (range < 0) { + error->all(FLERR, "interaction_range is negative for this model"); + } else if (!std::isfinite(range)) { + if (comm->nprocs > 1) { + error->all(FLERR, + "interaction_range is infinite for this model, " + "using multiple MPI domains is not supported" + ); + } + + // determine the maximal cutoff in the NL + auto requested_nl = mta_data->model->run_method("requested_neighbor_lists"); + for (const auto& ivalue: requested_nl.toList()) { + auto options = ivalue.get().toCustomClass(); + auto cutoff = options->engine_cutoff(mta_data->evaluation_options->length_unit()); + + mta_data->max_cutoff = std::max(mta_data->max_cutoff, cutoff); + } + } else { + mta_data->max_cutoff = range; + } + + // Initialize metatensor system object + auto options = MetatomicSystemOptions{ + this->type_mapping, + mta_data->max_cutoff, + mta_data->check_consistency, + /* requires_grad */ false, + }; + this->system_adaptor = std::make_unique(lmp, options); + + // We ask LAMMPS for a full neighbor lists because we need to know about + // ALL pairs, even if options->full_list() is false. We will then filter + // the pairs to only include each pair once where needed. + auto request = neighbor->add_request(this, NeighConst::REQ_FULL | NeighConst::REQ_GHOST); + request->set_cutoff(mta_data->max_cutoff); + + auto mincut = mta_data->max_cutoff + neighbor->skin; + if (comm->get_comm_cutoff() < mincut) { + if (comm->me == 0) { + error->warning(FLERR, + "Increasing communication cutoff to {:.8} for compute metatomic", + mincut + ); + } + comm->cutghostuser = mincut; + } + + // Translate from the metatomic neighbor lists requests to LAMMPS neighbor + // lists requests. + auto requested_nl = mta_data->model->run_method("requested_neighbor_lists"); + for (const auto& ivalue: requested_nl.toList()) { + auto options = ivalue.get().toCustomClass(); + auto cutoff = options->engine_cutoff(mta_data->evaluation_options->length_unit()); + assert(cutoff <= mta_data->max_cutoff); + + this->system_adaptor->add_nl_request(cutoff, options); + } + + // HACK: Explicitly set the binsize for the neighbor list if there is no + // pair_style that would set it instead. + // + // Otherwise, the default binsize of box[0] is used, which crashes kokkos + // for large-ish boxes (~40A), and slow down the simulation for non-kokkos. + if (strcmp(force->pair_style, "none") == 0) { + neighbor->binsize_user = 0.5 * mta_data->max_cutoff; + neighbor->binsizeflag = 1; + } + // END HACK +} + +void ComputeMetatomic::pick_device(c10::Device& device, const char* requested) { + torch::optional requested_string; + torch::DeviceType device_type; + + if (requested != nullptr) { + requested_string = std::string(requested); + } else { + requested_string = torch::nullopt; + } + + try { + device_type = metatomic_torch::pick_device( + this->mta_data->capabilities->supported_devices, + requested_string + ); + } catch (const c10::Error& e) { + error->one(FLERR, "compute metatomic: {}", e.what()); + } + + if (device_type == torch::DeviceType::CUDA) { + // distribute GPUs between multiple MPI processes on the same node + + // (1) get a MPI communicator for all processes on the current node + MPI_Comm local; + MPI_Comm_split_type(world, MPI_COMM_TYPE_SHARED, 0, MPI_INFO_NULL, &local); + // (2) get the rank of this MPI process on the current node + int local_rank; + MPI_Comm_rank(local, &local_rank); + + int size; + MPI_Comm_size(local, &size); + if (size < torch::cuda::device_count()) { + if (comm->me == 0) { + error->warning(FLERR, + "found {} CUDA-capable GPUs, but only {} MPI processes on the current node; the remaining GPUs will not be used", + torch::cuda::device_count(), size + ); + } + } + + // (3) split GPUs between node-local processes using round-robin allocation + auto device_index = local_rank % torch::cuda::device_count(); + device = torch::Device(device_type, static_cast(device_index)); + } else { + device = torch::Device(device_type); + } +} + +void ComputeMetatomic::init_list(int id, NeighList *ptr) { + mta_list = ptr; +} + +void ComputeMetatomic::compute() { + if (update->ntimestep == last_eval_step) { + // already computed the model output for the current configuration, no need to do it again + return; + } + clear_cache(); + int nlocal = atom->nlocal; + int *mask = atom->mask; + + // Determine the dtype of the system based on the model's capabilities + auto dtype = torch::kFloat64; + if (mta_data->capabilities->dtype() == "float64") { + dtype = torch::kFloat64; + } else if (mta_data->capabilities->dtype() == "float32") { + dtype = torch::kFloat32; + } else { + error->all(FLERR, "the model requested an unsupported dtype '{}'", mta_data->capabilities->dtype()); + } + + // add the required additional inputs + auto requested_inputs = mta_data->model->run_method("requested_inputs").toList(); + std::vector input_holders; + for (const auto& ivalue: requested_inputs) { + auto options = ivalue.get().toCustomClass(); + input_holders.push_back(options); + } + + auto system = this->system_adaptor->system_from_lmp( + mta_list, + false, + dtype, + mta_data->device, + input_holders + ); + + // Configure selected atoms for evaluation + // Only run the calculation for atoms in the current group + mta_data->selected_atoms_values.resize_({group->count(igroup), 2}); + mta_data->selected_atoms_values.index_put_({torch::indexing::Slice(), 0}, 0); + int64_t idx = 0; + for (int i = 0; i < nlocal; i++) { + if (mask[i] & groupbit) { + mta_data->selected_atoms_values.index_put_({idx, 1}, i); + idx++; + } + } + + auto selected_atoms = torch::make_intrusive( + std::vector{"system", "atom"}, mta_data->selected_atoms_values + ); + mta_data->evaluation_options->set_selected_atoms(selected_atoms); + + // Call the ML model to predict the requested output + torch::IValue result_ivalue; + try { + result_ivalue = mta_data->model->forward({ + std::vector{system}, + mta_data->evaluation_options, + mta_data->check_consistency + }); + } catch (const std::exception& e) { + error->all(FLERR, "error evaluating the torch model: {}", e.what()); + } + + // Extract results from the model output + auto result = result_ivalue.toGenericDict(); + + // Extract requested output + auto output_map = result.at(this->output_name).toCustomClass(); + auto output_block = metatensor_torch::TensorMapHolder::block_by_id(output_map, 0); + auto output = output_block->values().to(torch::kCPU).to(torch::kFloat64).contiguous(); + + auto output_samples = output_block->samples(); + auto output_samples_values = output_samples->values().to(torch::kCPU); + auto output_samples_accessor = output_samples_values.accessor(); + auto output_components = output_block->components(); + ResultKind kind = RESULT_NONE; + n_samples = output.size(0); + n_components = output.size(1); + if (output.dim() == 3) { + n_properties = output.size(2); + } else { + n_properties = 1; + } + if (n_properties != 1) { + error->all(FLERR, "compute metatomic currently only supports outputs with a single property dimension, got {}", n_properties); + } + + if (output_samples->size() == 1) { + assert (output_samples->names()[0] == "system"); + if (output_components.size() == 1) { + // a system-level output, having components means it's a vector quantity (e.g. heat flux) + kind = RESULT_GLOBAL_VECTOR; + vector_cache_ = std::vector(output.data_ptr(), output.data_ptr() + output.numel()); + } else if (output_components.size() == 0) { + // a system-level output with no components is a scalar quantity (e.g. potential energy) + kind = RESULT_SCALAR; + scalar_cache_ = output.squeeze().item(); + } else { + error->all(FLERR, "compute metatomic: expected at most 1 component label for global outputs, got {}", output_components.size()); + } + } else if (output_samples->size() == 2) { + assert (output_samples->names()[0] == "system"); + assert (output_samples->names()[1] == "atom"); + // map from metatomic atom indices to local LAMMPS atom indices + const auto& mta_to_lmp = this->system_adaptor->mta_to_lmp; + local_indices_cache_ = {}; + for (int i = 0; i < n_samples; i++) { + assert(output_samples_accessor[i][0] == 0); + // handle potentially out of order samples in + // the per-atom energy tensor + auto atom_i = mta_to_lmp[output_samples_accessor[i][1]]; + local_indices_cache_.push_back(atom_i); + } + if (output_components.size() == 1) { + // a per-atom vector quantity (e.g. forces) + kind = RESULT_PERATOM_ARRAY; + peratom_array_cache_ = std::vector(output.data_ptr(), output.data_ptr() + output.numel()); + } else if (output_components.size() == 0) { + // a per-atom scalar quantity (e.g. atomic energy) + kind = RESULT_PERATOM_VECTOR; + peratom_cache_ = std::vector(output.data_ptr(), output.data_ptr() + output.numel()); + } else { + error->all(FLERR, "compute metatomic: expected at most 1 component label for per-atom outputs, got {}", output_components.size()); + } + } else { + error->all(FLERR, "compute metatomic: expected output samples to have either 1 or 2 labels, got {}", output_samples->size()); + } + + check_or_init_layout(kind, n_components, n_components != 1 ? n_components : 0); + last_eval_step = update->ntimestep; +} + +double ComputeMetatomic::compute_scalar() { + invoked_scalar = update->ntimestep; + this->compute(); + if (result_kind != RESULT_SCALAR) { + error->all(FLERR, "compute metatomic: compute_scalar called but the output is not a scalar"); + } + scalar = scalar_cache_; + return scalar; +} + +void ComputeMetatomic::compute_vector() { + invoked_vector = update->ntimestep; + this->compute(); + if (result_kind != RESULT_GLOBAL_VECTOR) { + error->all(FLERR, "compute metatomic: compute_vector called but the output is not a vector"); + } + if (vector_cache_.size() != n_components) { + error->all(FLERR, "compute metatomic: expected vector output of size {}, got {}", n_components, vector_cache_.size()); + } + for (int i = 0; i < n_components; i++) { + vector[i] = vector_cache_[i]; + } +} + +void ComputeMetatomic::compute_peratom() { + invoked_peratom = update->ntimestep; + this->compute(); + if (result_kind == RESULT_PERATOM_VECTOR) { + if (peratom_cache_.size() != n_samples) { + error->all(FLERR, "compute metatomic: expected per-atom output of size {}, got {}", n_samples, peratom_cache_.size()); + } + for (int i = 0; i < n_max_atoms; i++) { + vector_atom[i] = 0.0; + } + for (int i = 0; i < n_samples; i++) { + vector_atom[local_indices_cache_[i]] = peratom_cache_[i]; + } + } else if (result_kind == RESULT_PERATOM_ARRAY) { + if (peratom_array_cache_.size() != n_samples * n_components) { + error->all(FLERR, "compute metatomic: expected per-atom array output of size {}, got {}", n_samples * n_components, peratom_array_cache_.size()); + } + for (int i = 0; i < n_max_atoms; i++) { + for (int j = 0; j < n_components; j++) { + array_atom[i][j] = 0.0; + } + } + for (int i = 0; i < n_samples; i++) { + for (int j = 0; j < n_components; j++) { + array_atom[local_indices_cache_[i]][j] = peratom_array_cache_[i * n_components + j]; + } + } + } else { + error->all(FLERR, "compute metatomic: compute_peratom called but the output is not per-atom"); + } +} + + +void ComputeMetatomic::check_or_init_layout(ResultKind kind, int size, int peratom_cols) { + if (!layout_initialized) { + layout_initialized = true; + result_kind = kind; + size_vector = size; + size_peratom_cols = peratom_cols; + n_max_atoms = atom->nmax; + if (result_kind == RESULT_GLOBAL_VECTOR) { + memory->create(vector, size_vector, "compute_metatomic:vector"); + } + if (result_kind == RESULT_PERATOM_VECTOR) { + if (size_peratom_cols != 0) { + error->all(FLERR, "compute metatomic: expected per-atom vector output to have no component, got {}", size_peratom_cols); + } + memory->create(vector_atom, n_max_atoms, "compute_metatomic:vector_atom"); + } + if (result_kind == RESULT_PERATOM_ARRAY) { + if (size_peratom_cols <= 0) { + error->all(FLERR, "compute metatomic: expected per-atom array output to have at least 1 component, got {}", size_peratom_cols); + } + memory->create(array_atom, n_max_atoms, size_peratom_cols, "compute_metatomic:array_atom"); + } + } else { + if (result_kind != kind) { + error->all(FLERR, "compute metatomic: expected output of kind {}, got {}", result_kind_name(result_kind), result_kind_name(kind)); + } + if (size_vector != size) { + error->all(FLERR, "compute metatomic: expected output vector of size {}, got {}", size_vector, size); + } + if (size_peratom_cols != peratom_cols) { + error->all(FLERR, "compute metatomic: expected per-atom array output with {} columns, got {}", size_peratom_cols, peratom_cols); + } + if (n_max_atoms < atom->nmax) { + n_max_atoms = atom->nmax; + if (result_kind == RESULT_PERATOM_VECTOR) { + memory->destroy(vector_atom); + memory->create(vector_atom, n_max_atoms, "compute_metatomic:vector_atom"); + } + if (result_kind == RESULT_PERATOM_ARRAY) { + memory->destroy(array_atom); + memory->create(array_atom, n_max_atoms, size_peratom_cols, "compute_metatomic:array_atom"); + } + } + } +} + +const char *ComputeMetatomic::result_kind_name(ResultKind kind) +{ + switch (kind) { + case RESULT_NONE: return "none"; + case RESULT_SCALAR: return "scalar"; + case RESULT_GLOBAL_VECTOR: return "global_vector"; + case RESULT_PERATOM_VECTOR: return "peratom_vector"; + case RESULT_PERATOM_ARRAY: return "peratom_array"; + case RESULT_GLOBAL_ARRAY: return "global_array"; + } + return "unknown"; +} + +void ComputeMetatomic::clear_cache() { + scalar_cache_ = 0.0; + vector_cache_.clear(); + peratom_cache_.clear(); + peratom_array_cache_.clear(); + local_indices_cache_.clear(); + n_samples = 0; +}; \ No newline at end of file diff --git a/src/ML-METATOMIC/compute_metatomic.h b/src/ML-METATOMIC/compute_metatomic.h new file mode 100644 index 00000000000..4de92a1fe2e --- /dev/null +++ b/src/ML-METATOMIC/compute_metatomic.h @@ -0,0 +1,109 @@ +/* -*- c++ -*- ---------------------------------------------------------- + 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. +------------------------------------------------------------------------- */ +#ifdef COMPUTE_CLASS +// clang-format off +ComputeStyle(metatomic, ComputeMetatomic); + +// additional versions of compute_style metatomic, to be used with compute_style +// hybrid when combining multiple metatomic potentials together +ComputeStyle(metatomic_1, ComputeMetatomic); +ComputeStyle(metatomic_2, ComputeMetatomic); +ComputeStyle(metatomic_3, ComputeMetatomic); +ComputeStyle(metatomic_4, ComputeMetatomic); +ComputeStyle(metatomic_5, ComputeMetatomic); +ComputeStyle(metatomic_6, ComputeMetatomic); +ComputeStyle(metatomic_7, ComputeMetatomic); +ComputeStyle(metatomic_8, ComputeMetatomic); +ComputeStyle(metatomic_9, ComputeMetatomic); +// clang-format on +#else + +#ifndef LMP_COMPUTE_METATOMIC_H +#define LMP_COMPUTE_METATOMIC_H + +#include "compute.h" + +#include + +namespace c10 { + class Device; + enum class DeviceType: int8_t; +} + +namespace at { + class Tensor; +} + +namespace LAMMPS_NS { +class MetatomicSystemAdaptor; +struct ComputeMetatomicData; + +class ComputeMetatomic : public Compute { +public: + ComputeMetatomic(class LAMMPS *, int, char **); + ~ComputeMetatomic(); + void init() override; + void init_list(int id, NeighList *ptr) override; + double compute_scalar() override; + void compute_vector() override; + void compute_peratom() override; + +protected: + virtual void pick_device(c10::Device& device, const char* requested); + std::string model_path; + std::optional requested_device; + std::optional extensions_directory; + std::string output_name; + + // Metatomic model data + ComputeMetatomicData* mta_data; + NeighList *mta_list; + + // Mapping from LAMMPS atom types to metatomic model types + int32_t *type_mapping; + + // Helper class to convert between LAMMPS and metatomic representations + std::unique_ptr system_adaptor; + +private: + // Cache the output of the most recent model evaluation + void compute(); + enum ResultKind { + RESULT_NONE, + RESULT_SCALAR, + RESULT_GLOBAL_VECTOR, + RESULT_PERATOM_VECTOR, + RESULT_PERATOM_ARRAY, + RESULT_GLOBAL_ARRAY + }; + bool layout_initialized = false; + ResultKind result_kind = RESULT_NONE; + bigint last_eval_step = -1; + std::vector local_indices_cache_; + double scalar_cache_ = 0.0; + std::vector vector_cache_; + std::vector peratom_cache_; + std::vector peratom_array_cache_; + int n_max_atoms = 0; + int n_samples = 0; + int n_components = 0; + int n_properties = 0; + void check_or_init_layout(ResultKind kind, int size, int peratom_cols); + void clear_cache(); + const char *result_kind_name(ResultKind kind); +}; + +} // namespace LAMMPS_NS + +#endif +#endif diff --git a/src/ML-METATOMIC/metatomic_system.cpp b/src/ML-METATOMIC/metatomic_system.cpp index 4652449d3b9..e234c94b59a 100644 --- a/src/ML-METATOMIC/metatomic_system.cpp +++ b/src/ML-METATOMIC/metatomic_system.cpp @@ -520,7 +520,8 @@ metatomic_torch::System MetatomicSystemAdaptor::system_from_lmp( NeighList* list, bool do_virial, torch::ScalarType dtype, - torch::Device device + torch::Device device, + const std::vector>& inputs ) { auto _ = MetatomicTimer("creating System from LAMMPS data"); @@ -589,6 +590,18 @@ metatomic_torch::System MetatomicSystemAdaptor::system_from_lmp( this->setup_neighbors(system, list); + for (const auto& input: inputs) { + const auto& quantity = input->quantity().c_str(); + const auto& unit = input->unit().c_str(); + if (strcmp(quantity, "mass") == 0) { + add_masses(system, metatomic_torch::unit_conversion_factor(quantity, "u", unit)); + } else if (strcmp(quantity, "momentum") == 0) { + add_momenta(system, metatomic_torch::unit_conversion_factor(quantity, "u*A/ps", unit)); + } else { + error->all(FLERR, "compute metatomic: the model requested an unsupported additional input of quantity '{}'", quantity); + } + } + return system; } diff --git a/src/ML-METATOMIC/metatomic_system.h b/src/ML-METATOMIC/metatomic_system.h index 38fa9ed62d8..79ed4c74e05 100644 --- a/src/ML-METATOMIC/metatomic_system.h +++ b/src/ML-METATOMIC/metatomic_system.h @@ -72,7 +72,8 @@ class MetatomicSystemAdaptor : public Pointers { NeighList* list, bool do_virial, torch::ScalarType dtype, - torch::Device device + torch::Device device, + const std::vector>& inputs = {} ); // Add masses as extra data to this system, only for atoms which are not diff --git a/src/ML-METATOMIC/metatomic_types.h b/src/ML-METATOMIC/metatomic_types.h index 9565e76a35a..91ebe4a44cd 100644 --- a/src/ML-METATOMIC/metatomic_types.h +++ b/src/ML-METATOMIC/metatomic_types.h @@ -86,6 +86,12 @@ struct FixMetatomicData: public CommonMetatomicData { FixMetatomicData(std::string length_unit): CommonMetatomicData(std::move(length_unit)) {} }; +struct ComputeMetatomicData: public CommonMetatomicData { + ComputeMetatomicData(std::string length_unit): CommonMetatomicData(std::move(length_unit)) {} + // the output we'll request from a model + metatomic_torch::ModelOutput requested_output; +}; + } // namespace LAMMPS_NS #endif From e282187c5ba9307bcf23e9b842ccc97e3fdb06c1 Mon Sep 17 00:00:00 2001 From: GardevoirX Date: Fri, 27 Mar 2026 11:24:45 +0100 Subject: [PATCH 2/6] A version tested with global scalar, atomic scalar, and atomic vector --- src/ML-METATOMIC/compute_metatomic.cpp | 193 +++++++++++++++++++++---- 1 file changed, 165 insertions(+), 28 deletions(-) diff --git a/src/ML-METATOMIC/compute_metatomic.cpp b/src/ML-METATOMIC/compute_metatomic.cpp index 7590502578d..2238249752b 100644 --- a/src/ML-METATOMIC/compute_metatomic.cpp +++ b/src/ML-METATOMIC/compute_metatomic.cpp @@ -30,6 +30,7 @@ #include #include +#include #include #include @@ -38,12 +39,44 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ +metatensor_torch::TensorBlock add_dummy_neighbors( + torch::TensorOptions options +) { + auto neighbor_component = torch::make_intrusive( + "xyz", + torch::tensor({0, 1, 2}, options.dtype(torch::kI32)).reshape({3, 1}) + ); + auto neighbor_properties = torch::make_intrusive( + "distance", torch::zeros({1, 1}, options.dtype(torch::kI32)) + ); + + auto n_pairs = 0; + + auto pair_vectors = torch::empty({n_pairs, 3, 1}, options.device(torch::kCPU)); + + auto pair_samples_values = torch::empty({n_pairs, 5}, options.device(torch::kCPU).dtype(torch::kI32)); + + auto neighbor_samples = torch::make_intrusive( + std::vector{"first_atom", "second_atom", "cell_shift_a", "cell_shift_b", "cell_shift_c"}, + pair_samples_values.to(options.device()) + ); + + auto neighbors = torch::make_intrusive( + pair_vectors.to(options.dtype()).to(options.device()), + neighbor_samples, + std::vector{neighbor_component}, + neighbor_properties + ); + + return neighbors; +} + ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(lmp, narg, arg) { - scalar_flag = 1; - vector_flag = 1; - size_vector_variable = 1; - size_array_rows_variable = 1; - peratom_flag = 1; + scalar_flag = 0; + vector_flag = 0; + peratom_flag = 0; + size_vector_variable = 0; + extscalar = 1; // for now, we need to improve this in the future std::string length_unit; if (strcmp(update->unit_style, "metal") != 0) { @@ -61,6 +94,7 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l std::string output_name; this->mta_data = new ComputeMetatomicData(std::move(length_unit)); this->model_path = arg[3]; + std::cout << "Initializing compute metatomic with model path: " << this->model_path << std::endl; this->requested_device = std::nullopt; this->extensions_directory = std::nullopt; this->output_name = arg[4]; @@ -204,25 +238,7 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l /*description=*/"" ); this->mta_data->evaluation_options->outputs.insert(this->output_name, this->mta_data->requested_output); -} -ComputeMetatomic::~ComputeMetatomic() { - memory->destroy(type_mapping); - delete mta_data; - if (result_kind == RESULT_GLOBAL_VECTOR) { - memory->destroy(vector); - } else if (result_kind == RESULT_PERATOM_VECTOR) { - memory->destroy(vector_atom); - } else if (result_kind == RESULT_PERATOM_ARRAY) { - memory->destroy(array_atom); - } else if (result_kind == RESULT_SCALAR || result_kind == RESULT_NONE) { - // nothing to destroy - } else { - error->all(FLERR, "compute metatomic internal error: unknown result kind in destructor"); - } -} - -void ComputeMetatomic::init() { if (!type_mapping) { error->all(FLERR, "compute metatomic internal error: type_mapping not initialized"); } @@ -232,6 +248,18 @@ void ComputeMetatomic::init() { this->extensions_directory ? this->extensions_directory->c_str() : nullptr ); + auto capabilities = mta_data->model->run_method("capabilities").toCustomClass(); + c10::ScalarType dtype; + if (capabilities->dtype() == "float64") { + dtype = torch::kFloat64; + } else if (capabilities->dtype() == "float32") { + dtype = torch::kFloat32; + } else { + error->all(FLERR, + "the model requested an unsupported dtype '" + capabilities->dtype() + "'" + ); + } + // Select the device to use based on the model's preference, the user choice // and what's available. this->pick_device( @@ -243,6 +271,109 @@ void ComputeMetatomic::init() { mta_data->model->to(mta_data->device); mta_data->selected_atoms_values = mta_data->selected_atoms_values.to(mta_data->device); + + // determine the type of the requested property by running the + // model once on a dummy system + auto tensor_options = torch::TensorOptions().dtype(dtype).device(mta_data->device); + auto dummy_system = torch::make_intrusive( + /*types = */ torch::full({0}, 0, tensor_options.dtype(torch::kInt32)), + /*positions = */ torch::full({0, 3}, 0, tensor_options), + /*cell = */ torch::zeros({3, 3}, tensor_options), + /*pbc = */ torch::zeros({3}, tensor_options.dtype(torch::kBool)) + ); + auto dummy_nl = add_dummy_neighbors(tensor_options); + for (auto request: mta_data->model->run_method("requested_neighbor_lists").toList()) { + metatomic_torch::register_autograd_neighbors(dummy_system, dummy_nl, mta_data->check_consistency); + dummy_system->add_neighbor_list(request.get().toCustomClass(), dummy_nl); + } + + // Call the ML model to predict the requested output + torch::IValue result_ivalue; + try { + result_ivalue = mta_data->model->forward({ + std::vector{dummy_system}, + mta_data->evaluation_options, + mta_data->check_consistency + }); + } catch (const std::exception& e) { + error->all(FLERR, "error evaluating the torch model: {}", e.what()); + } + + // Extract results from the model output + auto result = result_ivalue.toGenericDict(); + + // Extract requested output + auto output_map = result.at(this->output_name).toCustomClass(); + auto output_block = metatensor_torch::TensorMapHolder::block_by_id(output_map, 0); + auto output = output_block->values().to(torch::kCPU).to(torch::kFloat64).contiguous(); + + auto output_samples = output_block->samples(); + auto output_samples_values = output_samples->values().to(torch::kCPU); + auto output_samples_accessor = output_samples_values.accessor(); + auto output_components = output_block->components(); + ResultKind kind = RESULT_NONE; + n_samples = output.size(0); + n_components = output.size(1); + if (output.dim() == 3) { + n_properties = output.size(2); + } else { + n_properties = 1; + } + if (n_properties != 1) { + error->all(FLERR, "compute metatomic currently only supports outputs with a single property dimension, got {}", n_properties); + } + + if (output_samples->size() == 1) { + assert (output_samples->names()[0] == "system"); + if (output_components.size() == 1) { + // a system-level output, having components means it's a vector quantity (e.g. heat flux) + kind = RESULT_GLOBAL_VECTOR; + vector_flag = 1; + size_vector = n_components; + } else if (output_components.size() == 0) { + // a system-level output with no components is a scalar quantity (e.g. potential energy) + kind = RESULT_SCALAR; + scalar_flag = 1; + } else { + error->all(FLERR, "compute metatomic: expected at most 1 component label for global outputs, got {}", output_components.size()); + } + } else if (output_samples->size() == 2) { + assert (output_samples->names()[0] == "system"); + assert (output_samples->names()[1] == "atom"); + peratom_flag = 1; + if (output_components.size() == 1) { + // a per-atom vector quantity (e.g. forces) + kind = RESULT_PERATOM_ARRAY; + size_peratom_cols = n_components; + } else if (output_components.size() == 0) { + // a per-atom scalar quantity (e.g. atomic energy) + kind = RESULT_PERATOM_VECTOR; + size_peratom_cols = 0; + } else { + error->all(FLERR, "compute metatomic: expected at most 1 component label for per-atom outputs, got {}", output_components.size()); + } + } else { + error->all(FLERR, "compute metatomic: expected output samples to have either 1 or 2 labels, got {}", output_samples->size()); + } +} + +ComputeMetatomic::~ComputeMetatomic() { + memory->destroy(type_mapping); + delete mta_data; + if (result_kind == RESULT_GLOBAL_VECTOR) { + memory->destroy(vector); + } else if (result_kind == RESULT_PERATOM_VECTOR) { + memory->destroy(vector_atom); + } else if (result_kind == RESULT_PERATOM_ARRAY) { + memory->destroy(array_atom); + } else if (result_kind == RESULT_SCALAR || result_kind == RESULT_NONE) { + // nothing to destroy + } else { + error->all(FLERR, "compute metatomic internal error: unknown result kind in destructor"); + } +} + +void ComputeMetatomic::init() { auto message = "Computing " + this->output_name + " on " + mta_data->device.str() + " device with " + mta_data->capabilities->dtype() + " data"; if (screen) { fprintf(screen, "%s\n", message.c_str()); @@ -268,7 +399,6 @@ void ComputeMetatomic::init() { for (const auto& ivalue: requested_nl.toList()) { auto options = ivalue.get().toCustomClass(); auto cutoff = options->engine_cutoff(mta_data->evaluation_options->length_unit()); - mta_data->max_cutoff = std::max(mta_data->max_cutoff, cutoff); } } else { @@ -396,11 +526,14 @@ void ComputeMetatomic::compute() { } // add the required additional inputs - auto requested_inputs = mta_data->model->run_method("requested_inputs").toList(); - std::vector input_holders; + auto requested_inputs = mta_data->model->run_method("requested_inputs").toGenericDict(); + std::vector requested_input_properties = {}; + std::vector input_holders = {}; for (const auto& ivalue: requested_inputs) { - auto options = ivalue.get().toCustomClass(); - input_holders.push_back(options); + auto key = ivalue.key().toStringRef(); + auto value = ivalue.value().toCustomClass(); + requested_input_properties.push_back(key); + input_holders.push_back(value); } auto system = this->system_adaptor->system_from_lmp( @@ -510,6 +643,7 @@ void ComputeMetatomic::compute() { } double ComputeMetatomic::compute_scalar() { + std::cout << "Computing scalar output for compute metatomic" << std::endl; invoked_scalar = update->ntimestep; this->compute(); if (result_kind != RESULT_SCALAR) { @@ -520,6 +654,8 @@ double ComputeMetatomic::compute_scalar() { } void ComputeMetatomic::compute_vector() { + std::cout << "Computing vector output for compute metatomic" << std::endl; + invoked_vector = update->ntimestep; this->compute(); if (result_kind != RESULT_GLOBAL_VECTOR) { @@ -534,6 +670,7 @@ void ComputeMetatomic::compute_vector() { } void ComputeMetatomic::compute_peratom() { + std::cout << "Computing per-atom output for compute metatomic" << std::endl; invoked_peratom = update->ntimestep; this->compute(); if (result_kind == RESULT_PERATOM_VECTOR) { From 4272d3f55e62b356979171cb4a453b306b73b44a Mon Sep 17 00:00:00 2001 From: GardevoirX Date: Fri, 27 Mar 2026 23:24:36 +0100 Subject: [PATCH 3/6] Reuse the shared code of `add_masses` and `add_momenta` --- src/ML-METATOMIC/metatomic_system.cpp | 75 ++++++++++++++------------- src/ML-METATOMIC/metatomic_system.h | 9 ++++ 2 files changed, 47 insertions(+), 37 deletions(-) diff --git a/src/ML-METATOMIC/metatomic_system.cpp b/src/ML-METATOMIC/metatomic_system.cpp index e234c94b59a..0011f8332b9 100644 --- a/src/ML-METATOMIC/metatomic_system.cpp +++ b/src/ML-METATOMIC/metatomic_system.cpp @@ -641,29 +641,7 @@ void MetatomicSystemAdaptor::add_masses(metatomic_torch::System& system, double masses = masses.index_select(0, mta_to_lmp_tensor); masses = masses * unit_conversion; - - auto keys = metatensor_torch::LabelsHolder::single()->to(device); - auto label_tensor_options = torch::TensorOptions().dtype(torch::kInt32).device(device); - auto samples_values = torch::column_stack({ - torch::zeros(system->size(), label_tensor_options).unsqueeze(1), - torch::arange(system->size(), label_tensor_options).unsqueeze(1) - }); - auto samples = torch::make_intrusive( - std::vector{"system","atom"}, - samples_values, - metatensor::assume_unique{} - ); - auto properties = metatensor_torch::LabelsHolder::single()->to(device); - auto block = torch::make_intrusive( - masses.to(dtype).to(device).unsqueeze(-1), // add property dimension - samples, - std::vector{}, - properties - ); - auto tensor = torch::make_intrusive( - keys, - std::vector{block} - ); + auto tensor = make_per_atom_tensormap(masses, dtype, device); system->add_data("masses", tensor, /*override=*/true); } @@ -698,37 +676,60 @@ void MetatomicSystemAdaptor::add_momenta(metatomic_torch::System& system, double momenta = momenta.index_select(0, mta_to_lmp_tensor); momenta = momenta * unit_conversion; + auto tensor = make_per_atom_tensormap(momenta, dtype, device, {"xyz"}); - auto keys = metatensor_torch::LabelsHolder::single()->to(device); + system->add_data("momenta", tensor, /*override=*/true); +} +metatensor_torch::TensorMap MetatomicSystemAdaptor::make_per_atom_tensormap( + const torch::Tensor& values, + torch::ScalarType dtype, + const torch::Device& device, + const std::vector& component_names +) { + if (values.dim() != static_cast(component_names.size() + 1)) { + error->all( + FLERR, + "metatomic per-atom TensorMap helper expected rank {} tensor, got rank {}", + component_names.size() + 1, + values.dim() + ); + } + + auto n_atoms = values.size(0); auto label_tensor_options = torch::TensorOptions().dtype(torch::kInt32).device(device); + + auto keys = metatensor_torch::LabelsHolder::single()->to(device); auto samples_values = torch::column_stack({ - torch::zeros(system->size(), label_tensor_options).unsqueeze(1), - torch::arange(system->size(), label_tensor_options).unsqueeze(1) + torch::zeros(n_atoms, label_tensor_options).unsqueeze(1), + torch::arange(n_atoms, label_tensor_options).unsqueeze(1) }); auto samples = torch::make_intrusive( - std::vector{"system","atom"}, + std::vector{"system", "atom"}, samples_values, metatensor::assume_unique{} ); - auto component_values = torch::arange(3, label_tensor_options).unsqueeze(1); - auto component = torch::make_intrusive( - std::vector{"xyz"}, component_values - ); + auto components = std::vector{}; + for (size_t axis = 0; axis < component_names.size(); axis++) { + auto component_values = torch::arange(values.size(axis + 1), label_tensor_options).unsqueeze(1); + auto component = torch::make_intrusive( + std::vector{component_names[axis]}, + component_values + ); + components.push_back(component); + } auto properties = metatensor_torch::LabelsHolder::single()->to(device); - auto block = torch::make_intrusive( - momenta.to(dtype).to(device).unsqueeze(-1), + values.to(dtype).to(device).unsqueeze(-1), samples, - std::vector{component}, + components, properties ); - auto tensor = torch::make_intrusive( + + return torch::make_intrusive( keys, std::vector{block} ); - - system->add_data("momenta", tensor, /*override=*/true); } diff --git a/src/ML-METATOMIC/metatomic_system.h b/src/ML-METATOMIC/metatomic_system.h index 79ed4c74e05..98919c3b17e 100644 --- a/src/ML-METATOMIC/metatomic_system.h +++ b/src/ML-METATOMIC/metatomic_system.h @@ -16,6 +16,7 @@ #include #include +#include #include "pointers.h" #include "pair.h" @@ -82,6 +83,14 @@ class MetatomicSystemAdaptor : public Pointers { // Add momenta as extra data to this system, only for atoms which are not // periodic images of other atoms virtual void add_momenta(metatomic_torch::System& system, double unit_conversion); + // Build a per-atom TensorMap from values shaped as [atoms, components...]. + // A property dimension is appended automatically. + virtual metatensor_torch::TensorMap make_per_atom_tensormap( + const torch::Tensor& values, + torch::ScalarType dtype, + const torch::Device& device, + const std::vector& component_names = {} + ); // Explicit strain for virial calculations. This uses the same dtype/device // as LAMMPS data (positions, …) From a1e085ba2889bd1ab8e50d6849b711b17f092df1 Mon Sep 17 00:00:00 2001 From: GardevoirX Date: Sat, 28 Mar 2026 20:14:54 +0100 Subject: [PATCH 4/6] Give names to the property label of the requested input's tensormap --- src/ML-METATOMIC/metatomic_system.cpp | 121 ++++++++++++++++---------- src/ML-METATOMIC/metatomic_system.h | 21 +++-- 2 files changed, 88 insertions(+), 54 deletions(-) diff --git a/src/ML-METATOMIC/metatomic_system.cpp b/src/ML-METATOMIC/metatomic_system.cpp index 0011f8332b9..25652d5df50 100644 --- a/src/ML-METATOMIC/metatomic_system.cpp +++ b/src/ML-METATOMIC/metatomic_system.cpp @@ -206,6 +206,56 @@ static std::array cell_shifts( return {shift_a, shift_b, shift_c}; } +metatensor_torch::TensorMap LAMMPS_NS::make_per_atom_tensormap( + const torch::Tensor& values, + const torch::ScalarType& dtype, + const torch::Device& device, + const std::string& property_name, + const std::vector& component_names +) { + assert (values.dim() == static_cast(component_names.size() + 1)); + + auto n_atoms = values.size(0); + auto label_tensor_options = torch::TensorOptions().dtype(torch::kInt32).device(device); + + auto keys = metatensor_torch::LabelsHolder::single()->to(device); + auto samples_values = torch::column_stack({ + torch::zeros(n_atoms, label_tensor_options).unsqueeze(1), + torch::arange(n_atoms, label_tensor_options).unsqueeze(1) + }); + auto samples = torch::make_intrusive( + std::vector{"system", "atom"}, + samples_values, + metatensor::assume_unique{} + ); + + auto components = std::vector{}; + for (size_t axis = 0; axis < component_names.size(); axis++) { + auto component_values = torch::arange(values.size(axis + 1), label_tensor_options).unsqueeze(1); + auto component = torch::make_intrusive( + std::vector{component_names[axis]}, + component_values + ); + components.push_back(component); + } + + auto properties = torch::make_intrusive( + std::vector{property_name}, + torch::tensor({{0}}, label_tensor_options) + ); + auto block = torch::make_intrusive( + values.to(dtype).to(device).unsqueeze(-1), + samples, + components, + properties + ); + + return torch::make_intrusive( + keys, + std::vector{block} + ); +} + void MetatomicSystemAdaptor::guess_periodic_ghosts() { auto _ = MetatomicTimer("identifying periodic ghosts"); auto total_n_atoms = atom->nlocal + atom->nghost; @@ -597,6 +647,8 @@ metatomic_torch::System MetatomicSystemAdaptor::system_from_lmp( add_masses(system, metatomic_torch::unit_conversion_factor(quantity, "u", unit)); } else if (strcmp(quantity, "momentum") == 0) { add_momenta(system, metatomic_torch::unit_conversion_factor(quantity, "u*A/ps", unit)); + } else if (strcmp(quantity, "velocity") == 0) { + add_velocities(system, metatomic_torch::unit_conversion_factor(quantity, "A/ps", unit)); } else { error->all(FLERR, "compute metatomic: the model requested an unsupported additional input of quantity '{}'", quantity); } @@ -641,7 +693,7 @@ void MetatomicSystemAdaptor::add_masses(metatomic_torch::System& system, double masses = masses.index_select(0, mta_to_lmp_tensor); masses = masses * unit_conversion; - auto tensor = make_per_atom_tensormap(masses, dtype, device); + auto tensor = make_per_atom_tensormap(masses, dtype, device, "mass"); system->add_data("masses", tensor, /*override=*/true); } @@ -676,60 +728,37 @@ void MetatomicSystemAdaptor::add_momenta(metatomic_torch::System& system, double momenta = momenta.index_select(0, mta_to_lmp_tensor); momenta = momenta * unit_conversion; - auto tensor = make_per_atom_tensormap(momenta, dtype, device, {"xyz"}); + auto tensor = make_per_atom_tensormap(momenta, dtype, device, "momentum", {"xyz"}); system->add_data("momenta", tensor, /*override=*/true); } -metatensor_torch::TensorMap MetatomicSystemAdaptor::make_per_atom_tensormap( - const torch::Tensor& values, - torch::ScalarType dtype, - const torch::Device& device, - const std::vector& component_names -) { - if (values.dim() != static_cast(component_names.size() + 1)) { - error->all( - FLERR, - "metatomic per-atom TensorMap helper expected rank {} tensor, got rank {}", - component_names.size() + 1, - values.dim() - ); - } +void MetatomicSystemAdaptor::add_velocities(metatomic_torch::System& system, double unit_conversion) { + double** v = atom->v; - auto n_atoms = values.size(0); - auto label_tensor_options = torch::TensorOptions().dtype(torch::kInt32).device(device); + auto total_n_atoms = atom->nlocal + atom->nghost; - auto keys = metatensor_torch::LabelsHolder::single()->to(device); - auto samples_values = torch::column_stack({ - torch::zeros(n_atoms, label_tensor_options).unsqueeze(1), - torch::arange(n_atoms, label_tensor_options).unsqueeze(1) - }); - auto samples = torch::make_intrusive( - std::vector{"system", "atom"}, - samples_values, - metatensor::assume_unique{} + auto device = system->device(); + auto dtype = system->scalar_type(); + + auto mta_to_lmp_tensor = torch::from_blob( + mta_to_lmp.data(), + {static_cast(mta_to_lmp.size())}, + torch::TensorOptions().dtype(torch::kInt).device(torch::kCPU) ); - auto components = std::vector{}; - for (size_t axis = 0; axis < component_names.size(); axis++) { - auto component_values = torch::arange(values.size(axis + 1), label_tensor_options).unsqueeze(1); - auto component = torch::make_intrusive( - std::vector{component_names[axis]}, - component_values - ); - components.push_back(component); + // gather momenta (per-atom) in a tensor and ship to device + torch::Tensor velocities = torch::zeros({total_n_atoms, 3}, torch::TensorOptions().dtype(torch::kFloat64).device(torch::kCPU)); + auto velocities_accessor = velocities.accessor(); + for (int i=0; ito(device); - auto block = torch::make_intrusive( - values.to(dtype).to(device).unsqueeze(-1), - samples, - components, - properties - ); + velocities = velocities.index_select(0, mta_to_lmp_tensor); + velocities = velocities * unit_conversion; + auto tensor = make_per_atom_tensormap(velocities, dtype, device, "velocity", {"xyz"}); - return torch::make_intrusive( - keys, - std::vector{block} - ); + system->add_data("velocities", tensor, /*override=*/true); } diff --git a/src/ML-METATOMIC/metatomic_system.h b/src/ML-METATOMIC/metatomic_system.h index 98919c3b17e..d0ec0dff583 100644 --- a/src/ML-METATOMIC/metatomic_system.h +++ b/src/ML-METATOMIC/metatomic_system.h @@ -58,6 +58,16 @@ struct MetatomicNeighborsData { std::vector> distances_f32; }; +// Build a per-atom TensorMap from values shaped as [atoms, components...]. +// A property dimension is appended automatically. +metatensor_torch::TensorMap make_per_atom_tensormap( + const torch::Tensor& values, + const torch::ScalarType& dtype, + const torch::Device& device, + const std::string& property_name, + const std::vector& component_names = {} +); + class MetatomicSystemAdaptor : public Pointers { public: MetatomicSystemAdaptor(LAMMPS *lmp, MetatomicSystemOptions options); @@ -83,14 +93,9 @@ class MetatomicSystemAdaptor : public Pointers { // Add momenta as extra data to this system, only for atoms which are not // periodic images of other atoms virtual void add_momenta(metatomic_torch::System& system, double unit_conversion); - // Build a per-atom TensorMap from values shaped as [atoms, components...]. - // A property dimension is appended automatically. - virtual metatensor_torch::TensorMap make_per_atom_tensormap( - const torch::Tensor& values, - torch::ScalarType dtype, - const torch::Device& device, - const std::vector& component_names = {} - ); + // Add velocities as extra data to this system, only for atoms which are not + // periodic images of other atoms + virtual void add_velocities(metatomic_torch::System& system, double unit_conversion); // Explicit strain for virial calculations. This uses the same dtype/device // as LAMMPS data (positions, …) From ce8ab311a618b1a70e9d5db65ee34eab85c002c5 Mon Sep 17 00:00:00 2001 From: GardevoirX Date: Sat, 28 Mar 2026 20:15:34 +0100 Subject: [PATCH 5/6] Update the lj potential and wrapped with heat flux calculation --- .../PACKAGES/metatomic/nickel-lj-heat-flux.pt | Bin 0 -> 83057 bytes examples/PACKAGES/metatomic/nickel-lj.pt | Bin 70667 -> 57599 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 examples/PACKAGES/metatomic/nickel-lj-heat-flux.pt diff --git a/examples/PACKAGES/metatomic/nickel-lj-heat-flux.pt b/examples/PACKAGES/metatomic/nickel-lj-heat-flux.pt new file mode 100644 index 0000000000000000000000000000000000000000..55ed12509a5baf71b4fe2391b8a58e3cda55ca1b GIT binary patch literal 83057 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

_{DVGY* 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 literal 0 HcmV?d00001 diff --git a/examples/PACKAGES/metatomic/nickel-lj.pt b/examples/PACKAGES/metatomic/nickel-lj.pt index 4a9dcbc6a202a0f11b777f4aa7b502ade8ce4697..a129de2bc068120a1add0b1f51087f6dce1e498b 100644 GIT binary patch delta 39258 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

mGsw*_YW+Q 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%0A&PB)&xRET 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 Date: Sat, 28 Mar 2026 20:23:22 +0100 Subject: [PATCH 6/6] A version able to output global and atomic scalars and vectors --- .../PACKAGES/metatomic/in.compute_metatomic | 38 +++ src/ML-METATOMIC/compute_metatomic.cpp | 236 +++++++----------- src/ML-METATOMIC/compute_metatomic.h | 7 +- 3 files changed, 127 insertions(+), 154 deletions(-) create mode 100644 examples/PACKAGES/metatomic/in.compute_metatomic diff --git a/examples/PACKAGES/metatomic/in.compute_metatomic b/examples/PACKAGES/metatomic/in.compute_metatomic new file mode 100644 index 00000000000..d69c09427c1 --- /dev/null +++ b/examples/PACKAGES/metatomic/in.compute_metatomic @@ -0,0 +1,38 @@ +units metal +boundary p p p + +atom_style atomic +lattice fcc 3.6 +region box block 0 2 0 2 0 2 +create_box 1 box +create_atoms 1 box + +mass 1 58.693 + +velocity all create 123 42 + +pair_style metatomic nickel-lj.pt uncertainty_threshold off +# pair_style metatomic nickel-lj-extensions.pt extensions collected-extensions/ +pair_coeff * * 28 + +# pair_style hybrid/scaled 0.5 metatomic_1 nickel-lj.pt 0.5 metatomic_2 nickel-lj.pt +# pair_coeff * * metatomic_1 28 +# pair_coeff * * metatomic_2 28 + +timestep 0.001 +fix 1 all npt temp 123 123 $(100 * dt) iso 0 0 $(1000 * dt) drag 1.0 + +compute energy all metatomic nickel-lj.pt energy quantity energy unit eV per_atom off device cuda check_consistency on shape scalar types 28 + +compute heat_flux all metatomic nickel-lj-heat-flux.pt heat_flux quantity heat_flux unit eV*A/ps per_atom off device cuda check_consistency on extensions_directory pet-heat_flux_extensions shape vector 3 types 28 + +compute atomic_energies all metatomic nickel-lj.pt energy quantity energy unit eV per_atom on device cuda check_consistency on shape scalar types 28 + +compute forces all metatomic nickel-lj.pt non_conservative_forces quantity force unit eV/Angstrom per_atom on device cuda check_consistency on shape vector 3 types 28 + +thermo 10 +thermo_style custom step temp pe etotal press vol c_energy c_heat_flux[1] c_heat_flux[2] c_heat_flux[3] + +dump 1 all custom 10 dump.energy id type x y z c_atomic_energies c_forces[1] c_forces[2] c_forces[3] + +run 30 diff --git a/src/ML-METATOMIC/compute_metatomic.cpp b/src/ML-METATOMIC/compute_metatomic.cpp index 2238249752b..a7e32b289ed 100644 --- a/src/ML-METATOMIC/compute_metatomic.cpp +++ b/src/ML-METATOMIC/compute_metatomic.cpp @@ -38,45 +38,13 @@ using namespace LAMMPS_NS; /* ---------------------------------------------------------------------- */ - -metatensor_torch::TensorBlock add_dummy_neighbors( - torch::TensorOptions options -) { - auto neighbor_component = torch::make_intrusive( - "xyz", - torch::tensor({0, 1, 2}, options.dtype(torch::kI32)).reshape({3, 1}) - ); - auto neighbor_properties = torch::make_intrusive( - "distance", torch::zeros({1, 1}, options.dtype(torch::kI32)) - ); - - auto n_pairs = 0; - - auto pair_vectors = torch::empty({n_pairs, 3, 1}, options.device(torch::kCPU)); - - auto pair_samples_values = torch::empty({n_pairs, 5}, options.device(torch::kCPU).dtype(torch::kI32)); - - auto neighbor_samples = torch::make_intrusive( - std::vector{"first_atom", "second_atom", "cell_shift_a", "cell_shift_b", "cell_shift_c"}, - pair_samples_values.to(options.device()) - ); - - auto neighbors = torch::make_intrusive( - pair_vectors.to(options.dtype()).to(options.device()), - neighbor_samples, - std::vector{neighbor_component}, - neighbor_properties - ); - - return neighbors; -} - ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(lmp, narg, arg) { scalar_flag = 0; vector_flag = 0; peratom_flag = 0; size_vector_variable = 0; extscalar = 1; // for now, we need to improve this in the future + extvector = 1; std::string length_unit; if (strcmp(update->unit_style, "metal") != 0) { @@ -94,7 +62,6 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l std::string output_name; this->mta_data = new ComputeMetatomicData(std::move(length_unit)); this->model_path = arg[3]; - std::cout << "Initializing compute metatomic with model path: " << this->model_path << std::endl; this->requested_device = std::nullopt; this->extensions_directory = std::nullopt; this->output_name = arg[4]; @@ -104,10 +71,14 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l bool quantity_is_set = false; bool unit_is_set = false; bool per_atom_is_set = false; + bool shape_is_set = false; + bool output_size_is_set = false; bool types_are_set = false; std::string quantity; std::string unit; bool per_atom; + std::string shape; + int output_size = 0; std::vector parsed_types; while (iarg < narg) { @@ -173,6 +144,27 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l this->extensions_directory = std::string(arg[iarg]); iarg += 1; } + } else if (strcmp(arg[iarg], "shape") == 0) { + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'shape' in compute metatomic, got nothing"); + } else if (strcmp(arg[iarg], "scalar") == 0) { + shape = arg[iarg]; + shape_is_set = true; + iarg += 1; + } else if (strcmp(arg[iarg], "vector") == 0) { + shape = arg[iarg]; + shape_is_set = true; + iarg += 1; + if (iarg == narg) { + error->one(FLERR, "expected after 'vector' in compute metatomic, got nothing"); + } + output_size = std::stoi(arg[iarg]); + output_size_is_set = true; + iarg += 1; + } else { + error->one(FLERR, "expected after 'shape' in compute metatomic, got '{}'", arg[iarg]); + } } else if (strcmp(arg[iarg], "types") == 0) { iarg += 1; types_are_set = true; @@ -207,7 +199,7 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l iarg += atom->ntypes; } else { error->all(FLERR, - "Illegal compute metatomic command: unrecognized keyword '{}' (expected 'quantity', 'unit', 'per_atom', 'device', 'check_consistency', or 'types' )", arg[iarg]); + "Illegal compute metatomic command: unrecognized keyword '{}' (expected 'quantity', 'unit', 'per_atom', 'device', 'check_consistency', 'shape', or 'types' )", arg[iarg]); } } @@ -223,6 +215,37 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l if (!types_are_set) { error->all(FLERR, "Illegal compute metatomic command: no types specified"); } + if (!shape_is_set) { + error->all(FLERR, "Illegal compute metatomic command: 'shape' keyword is required"); + } + if (strcmp(shape.c_str(), "vector") == 0 && !output_size_is_set) { + error->all(FLERR, "Illegal compute metatomic command: 'size' keyword is required when 'shape' is 'vector'"); + } + + // Initialize the output layout + if (per_atom) { + peratom_flag = 1; + if (strcmp(shape.c_str(), "scalar") == 0) { + result_kind = RESULT_PERATOM_SCALAR; + size_peratom_cols = 0; + } else if (strcmp(shape.c_str(), "vector") == 0) { + result_kind = RESULT_PERATOM_VECTOR; + size_peratom_cols = output_size; + } else { + error->all(FLERR, "Illegal compute metatomic command: 'shape' must be 'scalar' or 'vector'"); + } + } else { + if (strcmp(shape.c_str(), "scalar") == 0) { + result_kind = RESULT_GLOBAL_SCALAR; + scalar_flag = 1; + } else if (strcmp(shape.c_str(), "vector") == 0) { + result_kind = RESULT_GLOBAL_VECTOR; + vector_flag = 1; + size_vector = output_size; + } else { + error->all(FLERR, "Illegal compute metatomic command: 'shape' must be 'scalar' or 'vector'"); + } + } // Allocate and fill the type-mapping (1-based indexing) type_mapping = memory->create(type_mapping, atom->ntypes + 1, "compute_metatomic:type_mapping"); @@ -270,91 +293,6 @@ ComputeMetatomic::ComputeMetatomic(LAMMPS *lmp, int narg, char **arg): Compute(l // move all data to the correct device mta_data->model->to(mta_data->device); mta_data->selected_atoms_values = mta_data->selected_atoms_values.to(mta_data->device); - - - // determine the type of the requested property by running the - // model once on a dummy system - auto tensor_options = torch::TensorOptions().dtype(dtype).device(mta_data->device); - auto dummy_system = torch::make_intrusive( - /*types = */ torch::full({0}, 0, tensor_options.dtype(torch::kInt32)), - /*positions = */ torch::full({0, 3}, 0, tensor_options), - /*cell = */ torch::zeros({3, 3}, tensor_options), - /*pbc = */ torch::zeros({3}, tensor_options.dtype(torch::kBool)) - ); - auto dummy_nl = add_dummy_neighbors(tensor_options); - for (auto request: mta_data->model->run_method("requested_neighbor_lists").toList()) { - metatomic_torch::register_autograd_neighbors(dummy_system, dummy_nl, mta_data->check_consistency); - dummy_system->add_neighbor_list(request.get().toCustomClass(), dummy_nl); - } - - // Call the ML model to predict the requested output - torch::IValue result_ivalue; - try { - result_ivalue = mta_data->model->forward({ - std::vector{dummy_system}, - mta_data->evaluation_options, - mta_data->check_consistency - }); - } catch (const std::exception& e) { - error->all(FLERR, "error evaluating the torch model: {}", e.what()); - } - - // Extract results from the model output - auto result = result_ivalue.toGenericDict(); - - // Extract requested output - auto output_map = result.at(this->output_name).toCustomClass(); - auto output_block = metatensor_torch::TensorMapHolder::block_by_id(output_map, 0); - auto output = output_block->values().to(torch::kCPU).to(torch::kFloat64).contiguous(); - - auto output_samples = output_block->samples(); - auto output_samples_values = output_samples->values().to(torch::kCPU); - auto output_samples_accessor = output_samples_values.accessor(); - auto output_components = output_block->components(); - ResultKind kind = RESULT_NONE; - n_samples = output.size(0); - n_components = output.size(1); - if (output.dim() == 3) { - n_properties = output.size(2); - } else { - n_properties = 1; - } - if (n_properties != 1) { - error->all(FLERR, "compute metatomic currently only supports outputs with a single property dimension, got {}", n_properties); - } - - if (output_samples->size() == 1) { - assert (output_samples->names()[0] == "system"); - if (output_components.size() == 1) { - // a system-level output, having components means it's a vector quantity (e.g. heat flux) - kind = RESULT_GLOBAL_VECTOR; - vector_flag = 1; - size_vector = n_components; - } else if (output_components.size() == 0) { - // a system-level output with no components is a scalar quantity (e.g. potential energy) - kind = RESULT_SCALAR; - scalar_flag = 1; - } else { - error->all(FLERR, "compute metatomic: expected at most 1 component label for global outputs, got {}", output_components.size()); - } - } else if (output_samples->size() == 2) { - assert (output_samples->names()[0] == "system"); - assert (output_samples->names()[1] == "atom"); - peratom_flag = 1; - if (output_components.size() == 1) { - // a per-atom vector quantity (e.g. forces) - kind = RESULT_PERATOM_ARRAY; - size_peratom_cols = n_components; - } else if (output_components.size() == 0) { - // a per-atom scalar quantity (e.g. atomic energy) - kind = RESULT_PERATOM_VECTOR; - size_peratom_cols = 0; - } else { - error->all(FLERR, "compute metatomic: expected at most 1 component label for per-atom outputs, got {}", output_components.size()); - } - } else { - error->all(FLERR, "compute metatomic: expected output samples to have either 1 or 2 labels, got {}", output_samples->size()); - } } ComputeMetatomic::~ComputeMetatomic() { @@ -362,11 +300,11 @@ ComputeMetatomic::~ComputeMetatomic() { delete mta_data; if (result_kind == RESULT_GLOBAL_VECTOR) { memory->destroy(vector); - } else if (result_kind == RESULT_PERATOM_VECTOR) { + } else if (result_kind == RESULT_PERATOM_SCALAR) { memory->destroy(vector_atom); - } else if (result_kind == RESULT_PERATOM_ARRAY) { + } else if (result_kind == RESULT_PERATOM_VECTOR) { memory->destroy(array_atom); - } else if (result_kind == RESULT_SCALAR || result_kind == RESULT_NONE) { + } else if (result_kind == RESULT_GLOBAL_SCALAR || result_kind == RESULT_NONE) { // nothing to destroy } else { error->all(FLERR, "compute metatomic internal error: unknown result kind in destructor"); @@ -605,7 +543,7 @@ void ComputeMetatomic::compute() { vector_cache_ = std::vector(output.data_ptr(), output.data_ptr() + output.numel()); } else if (output_components.size() == 0) { // a system-level output with no components is a scalar quantity (e.g. potential energy) - kind = RESULT_SCALAR; + kind = RESULT_GLOBAL_SCALAR; scalar_cache_ = output.squeeze().item(); } else { error->all(FLERR, "compute metatomic: expected at most 1 component label for global outputs, got {}", output_components.size()); @@ -625,11 +563,11 @@ void ComputeMetatomic::compute() { } if (output_components.size() == 1) { // a per-atom vector quantity (e.g. forces) - kind = RESULT_PERATOM_ARRAY; + kind = RESULT_PERATOM_VECTOR; peratom_array_cache_ = std::vector(output.data_ptr(), output.data_ptr() + output.numel()); } else if (output_components.size() == 0) { // a per-atom scalar quantity (e.g. atomic energy) - kind = RESULT_PERATOM_VECTOR; + kind = RESULT_PERATOM_SCALAR; peratom_cache_ = std::vector(output.data_ptr(), output.data_ptr() + output.numel()); } else { error->all(FLERR, "compute metatomic: expected at most 1 component label for per-atom outputs, got {}", output_components.size()); @@ -643,10 +581,9 @@ void ComputeMetatomic::compute() { } double ComputeMetatomic::compute_scalar() { - std::cout << "Computing scalar output for compute metatomic" << std::endl; invoked_scalar = update->ntimestep; this->compute(); - if (result_kind != RESULT_SCALAR) { + if (result_kind != RESULT_GLOBAL_SCALAR) { error->all(FLERR, "compute metatomic: compute_scalar called but the output is not a scalar"); } scalar = scalar_cache_; @@ -654,8 +591,6 @@ double ComputeMetatomic::compute_scalar() { } void ComputeMetatomic::compute_vector() { - std::cout << "Computing vector output for compute metatomic" << std::endl; - invoked_vector = update->ntimestep; this->compute(); if (result_kind != RESULT_GLOBAL_VECTOR) { @@ -670,10 +605,9 @@ void ComputeMetatomic::compute_vector() { } void ComputeMetatomic::compute_peratom() { - std::cout << "Computing per-atom output for compute metatomic" << std::endl; invoked_peratom = update->ntimestep; this->compute(); - if (result_kind == RESULT_PERATOM_VECTOR) { + if (result_kind == RESULT_PERATOM_SCALAR) { if (peratom_cache_.size() != n_samples) { error->all(FLERR, "compute metatomic: expected per-atom output of size {}, got {}", n_samples, peratom_cache_.size()); } @@ -683,7 +617,7 @@ void ComputeMetatomic::compute_peratom() { for (int i = 0; i < n_samples; i++) { vector_atom[local_indices_cache_[i]] = peratom_cache_[i]; } - } else if (result_kind == RESULT_PERATOM_ARRAY) { + } else if (result_kind == RESULT_PERATOM_VECTOR) { if (peratom_array_cache_.size() != n_samples * n_components) { error->all(FLERR, "compute metatomic: expected per-atom array output of size {}, got {}", n_samples * n_components, peratom_array_cache_.size()); } @@ -706,22 +640,25 @@ void ComputeMetatomic::compute_peratom() { void ComputeMetatomic::check_or_init_layout(ResultKind kind, int size, int peratom_cols) { if (!layout_initialized) { layout_initialized = true; - result_kind = kind; - size_vector = size; - size_peratom_cols = peratom_cols; n_max_atoms = atom->nmax; + if (result_kind != kind) { + error->all(FLERR, "compute metatomic: expected user-specified output kind {}, got {} from model", result_kind_name(kind), result_kind_name(result_kind)); + } if (result_kind == RESULT_GLOBAL_VECTOR) { + if (size_vector != size) { + error->all(FLERR, "compute metatomic: expected user-specified output of size {}, got {}", size_vector, size); + } memory->create(vector, size_vector, "compute_metatomic:vector"); } - if (result_kind == RESULT_PERATOM_VECTOR) { - if (size_peratom_cols != 0) { - error->all(FLERR, "compute metatomic: expected per-atom vector output to have no component, got {}", size_peratom_cols); + if (result_kind == RESULT_PERATOM_SCALAR) { + if (size_peratom_cols != peratom_cols) { + error->all(FLERR, "compute metatomic: expected per-atom scalar output, got a non-scalar output with {} components", size_peratom_cols, peratom_cols); } memory->create(vector_atom, n_max_atoms, "compute_metatomic:vector_atom"); } - if (result_kind == RESULT_PERATOM_ARRAY) { - if (size_peratom_cols <= 0) { - error->all(FLERR, "compute metatomic: expected per-atom array output to have at least 1 component, got {}", size_peratom_cols); + if (result_kind == RESULT_PERATOM_VECTOR) { + if (size_peratom_cols != peratom_cols) { + error->all(FLERR, "compute metatomic: expected per-atom vector output with {} columns, got {}", size_peratom_cols, peratom_cols); } memory->create(array_atom, n_max_atoms, size_peratom_cols, "compute_metatomic:array_atom"); } @@ -729,19 +666,19 @@ void ComputeMetatomic::check_or_init_layout(ResultKind kind, int size, int perat if (result_kind != kind) { error->all(FLERR, "compute metatomic: expected output of kind {}, got {}", result_kind_name(result_kind), result_kind_name(kind)); } - if (size_vector != size) { + if (result_kind == RESULT_GLOBAL_VECTOR && size_vector != size) { error->all(FLERR, "compute metatomic: expected output vector of size {}, got {}", size_vector, size); } - if (size_peratom_cols != peratom_cols) { + if ((result_kind == RESULT_PERATOM_SCALAR || result_kind == RESULT_PERATOM_VECTOR) && size_peratom_cols != peratom_cols) { error->all(FLERR, "compute metatomic: expected per-atom array output with {} columns, got {}", size_peratom_cols, peratom_cols); } if (n_max_atoms < atom->nmax) { n_max_atoms = atom->nmax; - if (result_kind == RESULT_PERATOM_VECTOR) { + if (result_kind == RESULT_PERATOM_SCALAR) { memory->destroy(vector_atom); memory->create(vector_atom, n_max_atoms, "compute_metatomic:vector_atom"); } - if (result_kind == RESULT_PERATOM_ARRAY) { + if (result_kind == RESULT_PERATOM_VECTOR) { memory->destroy(array_atom); memory->create(array_atom, n_max_atoms, size_peratom_cols, "compute_metatomic:array_atom"); } @@ -753,11 +690,10 @@ const char *ComputeMetatomic::result_kind_name(ResultKind kind) { switch (kind) { case RESULT_NONE: return "none"; - case RESULT_SCALAR: return "scalar"; + case RESULT_GLOBAL_SCALAR: return "scalar"; case RESULT_GLOBAL_VECTOR: return "global_vector"; - case RESULT_PERATOM_VECTOR: return "peratom_vector"; - case RESULT_PERATOM_ARRAY: return "peratom_array"; - case RESULT_GLOBAL_ARRAY: return "global_array"; + case RESULT_PERATOM_SCALAR: return "peratom_vector"; + case RESULT_PERATOM_VECTOR: return "peratom_array"; } return "unknown"; } diff --git a/src/ML-METATOMIC/compute_metatomic.h b/src/ML-METATOMIC/compute_metatomic.h index 4de92a1fe2e..4ac0b969a90 100644 --- a/src/ML-METATOMIC/compute_metatomic.h +++ b/src/ML-METATOMIC/compute_metatomic.h @@ -80,11 +80,10 @@ class ComputeMetatomic : public Compute { void compute(); enum ResultKind { RESULT_NONE, - RESULT_SCALAR, + RESULT_GLOBAL_SCALAR, RESULT_GLOBAL_VECTOR, - RESULT_PERATOM_VECTOR, - RESULT_PERATOM_ARRAY, - RESULT_GLOBAL_ARRAY + RESULT_PERATOM_SCALAR, + RESULT_PERATOM_VECTOR }; bool layout_initialized = false; ResultKind result_kind = RESULT_NONE;