RgpotAdapter.h

Go to the documentation of this file.

/*
** This file is part of eOn.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** Adapter over rgpot potential kernels. Migrated pair potentials live in
** librgpot (github.com/OmniPotentRPC/rgpot); eOn's config surface,
** PotRegistry, force counters, and caching stay on this side.
*/
#pragma once
 
#include <memory>
#include <vector>
 
#include "eon/Potential.h"
 
#include "rgpot/ForceStructs.hpp"
#include "rgpot/pot_caps.hpp"

template <class RPot> class RgpotAdapter final : public Potential {
public:
  template <class Cfg>
  RgpotAdapter(PotType ptype, const Parameters &params, const Cfg &cfg)
      : Potential(ptype, params),
        pot_(cfg) {}

  RgpotAdapter(PotType ptype, const Parameters &params)
      : Potential(ptype, params),
        pot_() {}
 
  void force(long N, const double *R, const int *atomicNrs, double *F,
             double *U, double *variance, const double *box) override {
    rgpot::ForceInput in{static_cast<size_t>(N), R, atomicNrs, box};
    rgpot::ForceOut out{F, 0.0, 0.0};
    pot_.forceImpl(in, &out);
    *U = out.energy;
    if (variance != nullptr) {
      *variance = out.variance;
    }
  }

  [[nodiscard]] bool supportsBatchEvaluation() const noexcept override {
    return pot_.caps().batched;
  }

  void forceBatch(long nSystems, long nAtoms, const double *const *positions,
                  const int *const *atomicNrs, double *const *forces,
                  double *energies, double *variances,
                  const double *const *boxes) override {
    const auto n = static_cast<size_t>(nSystems);
    std::vector<rgpot::ForceInput> in;
    std::vector<rgpot::ForceOut> out;
    in.reserve(n);
    out.reserve(n);
    for (size_t i = 0; i < n; ++i) {
      in.push_back(rgpot::ForceInput{static_cast<size_t>(nAtoms), positions[i],
                                     atomicNrs[i], boxes[i]});
      out.push_back(rgpot::ForceOut{forces[i], 0.0, 0.0});
    }
 
    pot_.forceBatchImpl(
        rgpot::ForceBatch{.nSystems = n, .in = in.data(), .out = out.data()});
 
    for (size_t i = 0; i < n; ++i) {
      energies[i] = out[i].energy;
      if (variances != nullptr) {
        variances[i] = out[i].variance;
      }
      forceCallCounter++;
      PotRegistry::get().on_force_call(ptype);
    }
  }
 
  [[nodiscard]] bool isThreadSafe() const noexcept override {
    return pot_.caps().reentrancy == rgpot::Reentrancy::SharedInstance;
  }
 
  [[nodiscard]] bool needsPerImageInstance() const noexcept override {
    const auto caps = pot_.caps();
    return caps.perImageInstances ||
           caps.reentrancy == rgpot::Reentrancy::PerInstance;
  }
 
  [[nodiscard]] const RPot &kernel() const noexcept { return pot_; }
 
private:
  RPot pot_;
};

template <class RPot>
std::shared_ptr<Potential> makeRgpotDefault(PotType ptype,
                                            const Parameters &params) {
  return std::make_shared<RgpotAdapter<RPot>>(ptype, params);
}

template <class RPot, class Cfg>
std::shared_ptr<Potential> makeRgpot(PotType ptype, const Parameters &params,
                                     const Cfg &cfg) {
  return std::make_shared<RgpotAdapter<RPot>>(ptype, params, cfg);
}