Loading...
Searching...
No Matches
eonc::tunneling::DerivativeRbfModel Class Reference

Gaussian derivative interpolant with an explicit quadratic baseline. More...

#include <DerivativeRbfModel.h>

Classes

struct  Sum
 Compensated accumulation retains small terms beside cancelling weights. More...

Public Member Functions

Eigen::Index dimension () const
Eigen::Index outputs () const
RbfEvaluation evaluate (const Eigen::VectorXd &q, double scalarValueShift=0.0) const

Static Public Member Functions

static DerivativeRbfModel fromJson (const nlohmann::json &data)

Private Member Functions

RbfEvaluation evaluateScalar (const Eigen::VectorXd &q, double shift) const
long double scalarKernel (const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const
double kernel (const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const

Static Private Member Functions

static Eigen::VectorXd vector (const nlohmann::json &data)
static Eigen::MatrixXd matrix (const nlohmann::json &data, Eigen::Index columns)
template<class Scalar>
static Scalar hermite (int n, Scalar z)

Private Attributes

Eigen::VectorXd scales_
Eigen::VectorXd constant_
Eigen::MatrixXd sites_
Eigen::MatrixXd weights_
Eigen::MatrixXd linear_
std::vector< std::vector< int > > orders_
std::vector< Eigen::MatrixXd > quadratic_

Detailed Description

Gaussian derivative interpolant with an explicit quadratic baseline.

Orders differentiate the site's argument; returned derivatives act on q.

Definition at line 23 of file DerivativeRbfModel.h.

Member Function Documentation

◆ dimension()

Eigen::Index eonc::tunneling::DerivativeRbfModel::dimension ( ) const
inline

Definition at line 81 of file DerivativeRbfModel.h.

81{ return scales_.size(); }

◆ evaluate()

RbfEvaluation eonc::tunneling::DerivativeRbfModel::evaluate ( const Eigen::VectorXd & q,
double scalarValueShift = 0.0 ) const
inline

Definition at line 84 of file DerivativeRbfModel.h.

85 {
86 if (q.size() != dimension() || !q.allFinite())
87 throw std::invalid_argument(
88 "interpolant coordinate dimension or finiteness differs");
89 if (!std::isfinite(scalarValueShift) ||
90 (outputs() != 1 && scalarValueShift != 0.0))
91 throw std::invalid_argument(
92 "interpolant energy shift requires a scalar output and finite value");
93 if (outputs() == 1)
94 return evaluateScalar(q, scalarValueShift);
95 RbfEvaluation result{constant_ + linear_ * q, linear_, quadratic_};
96 for (Eigen::Index k = 0; k < outputs(); ++k) {
97 result.value[k] += .5 * q.dot(quadratic_[static_cast<size_t>(k)] * q);
98 result.jacobian.row(k) +=
99 (quadratic_[static_cast<size_t>(k)] * q).transpose();
100 }
101 std::vector<int> derivative(static_cast<size_t>(dimension()), 0);
102 for (Eigen::Index site = 0; site < sites_.rows(); ++site) {
103 result.value.noalias() +=
104 kernel(q, site, derivative) * weights_.row(site).transpose();
105 for (Eigen::Index i = 0; i < dimension(); ++i) {
106 derivative[static_cast<size_t>(i)]++;
107 result.jacobian.col(i).noalias() +=
108 kernel(q, site, derivative) * weights_.row(site).transpose();
109 for (Eigen::Index j = 0; j < dimension(); ++j) {
110 derivative[static_cast<size_t>(j)]++;
111 const double value = kernel(q, site, derivative);
112 for (Eigen::Index output = 0; output < outputs(); ++output)
113 result.hessians[static_cast<size_t>(output)](i, j) +=
114 value * weights_(site, output);
115 derivative[static_cast<size_t>(j)]--;
116 }
117 derivative[static_cast<size_t>(i)]--;
118 }
119 }
120 return result;
121 }
RbfEvaluation evaluateScalar(const Eigen::VectorXd &q, double shift) const
double kernel(const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const
std::vector< Eigen::MatrixXd > quadratic_
constexpr long derivative

◆ evaluateScalar()

RbfEvaluation eonc::tunneling::DerivativeRbfModel::evaluateScalar ( const Eigen::VectorXd & q,
double shift ) const
inlineprivate

Definition at line 136 of file DerivativeRbfModel.h.

136 {
137 const Eigen::Index d = dimension();
138 std::vector<Sum> jet(static_cast<size_t>(1 + d + d * d));
139 // Shift the constant before accumulating kernels, preserving relative
140 // energies.
141 jet[0].add(static_cast<long double>(constant_[0]) -
142 static_cast<long double>(shift));
143 for (Eigen::Index i = 0; i < d; ++i) {
144 jet[0].add(static_cast<long double>(linear_(0, i)) * q[i]);
145 jet[static_cast<size_t>(1 + i)].add(linear_(0, i));
146 for (Eigen::Index j = 0; j < d; ++j) {
147 const long double h = quadratic_[0](i, j);
148 jet[0].add(0.5L * q[i] * h * q[j]);
149 jet[static_cast<size_t>(1 + i)].add(h * q[j]);
150 jet[static_cast<size_t>(1 + d + i * d + j)].add(h);
151 }
152 }
153 std::vector<int> derivative(static_cast<size_t>(d), 0);
154 for (Eigen::Index site = 0; site < sites_.rows(); ++site) {
155 const long double weight = weights_(site, 0);
156 jet[0].add(weight * scalarKernel(q, site, derivative));
157 for (Eigen::Index i = 0; i < d; ++i) {
158 derivative[static_cast<size_t>(i)]++;
159 jet[static_cast<size_t>(1 + i)].add(weight *
160 scalarKernel(q, site, derivative));
161 for (Eigen::Index j = 0; j < d; ++j) {
162 derivative[static_cast<size_t>(j)]++;
163 jet[static_cast<size_t>(1 + d + i * d + j)].add(
164 weight * scalarKernel(q, site, derivative));
165 derivative[static_cast<size_t>(j)]--;
166 }
167 derivative[static_cast<size_t>(i)]--;
168 }
169 }
170 RbfEvaluation result{
171 Eigen::VectorXd(1), Eigen::MatrixXd(1, d), {Eigen::MatrixXd(d, d)}};
172 result.value[0] = static_cast<double>(jet[0].total());
173 for (Eigen::Index i = 0; i < d; ++i) {
174 result.jacobian(0, i) =
175 static_cast<double>(jet[static_cast<size_t>(1 + i)].total());
176 for (Eigen::Index j = 0; j < d; ++j)
177 result.hessians[0](i, j) = static_cast<double>(
178 jet[static_cast<size_t>(1 + d + i * d + j)].total());
179 }
180 return result;
181 }
long double scalarKernel(const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const

◆ fromJson()

DerivativeRbfModel eonc::tunneling::DerivativeRbfModel::fromJson ( const nlohmann::json & data)
inlinestatic

Definition at line 25 of file DerivativeRbfModel.h.

25 {
26 if (data.at("kind").get<std::string>() != "derivative_rbf")
27 throw std::invalid_argument("unsupported reduced interpolant kind");
28 DerivativeRbfModel model;
29 model.scales_ = vector(data.at("length_scales"));
30 model.constant_ = vector(data.at("constant"));
31 const Eigen::Index d = model.scales_.size(),
32 outputs = model.constant_.size();
33 if (d < 1 || outputs < 1 || !(model.scales_.array() > 0).all())
34 throw std::invalid_argument(
35 "interpolant dimensions and scales must be positive");
36 model.sites_ = matrix(data.at("sites"), d);
37 model.weights_ = matrix(data.at("weights"), outputs);
38 model.linear_ = data.contains("linear") ? matrix(data.at("linear"), d)
39 : Eigen::MatrixXd::Zero(outputs, d);
40 if (model.weights_.rows() != model.sites_.rows() ||
41 model.linear_.rows() != outputs)
42 throw std::invalid_argument("interpolant coefficient dimensions differ");
43 const auto &orders = data.at("derivative_orders");
44 if (orders.size() != static_cast<size_t>(model.sites_.rows()))
45 throw std::invalid_argument("interpolant derivative count differs");
46 for (const auto &row : orders) {
47 if (row.size() != static_cast<size_t>(d))
48 throw std::invalid_argument("interpolant derivative dimension differs");
49 std::vector<int> values;
50 int total = 0;
51 for (const auto &entry : row) {
52 const int order = entry.get<int>();
53 if (order < 0 || order > 2)
54 throw std::invalid_argument(
55 "interpolant site derivative order must be 0, 1 or 2");
56 values.push_back(order);
57 total += order;
58 }
59 if (total > 2)
60 throw std::invalid_argument(
61 "interpolant site derivative total exceeds two");
62 model.orders_.push_back(std::move(values));
63 }
64 model.quadratic_.assign(static_cast<size_t>(outputs),
65 Eigen::MatrixXd::Zero(d, d));
66 if (data.contains("quadratic")) {
67 if (data.at("quadratic").size() != static_cast<size_t>(outputs))
68 throw std::invalid_argument(
69 "interpolant quadratic output dimension differs");
70 for (Eigen::Index i = 0; i < outputs; ++i) {
71 auto h = matrix(data.at("quadratic").at(i), d);
72 if (h.rows() != d || !h.isApprox(h.transpose(), 1e-12))
73 throw std::invalid_argument(
74 "interpolant quadratic baseline must be symmetric");
75 model.quadratic_[static_cast<size_t>(i)] = std::move(h);
76 }
77 }
78 return model;
79 }
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, eOnStorageOrder > MatrixXd
Definition Eigen.h:33
static Eigen::VectorXd vector(const nlohmann::json &data)
static Eigen::MatrixXd matrix(const nlohmann::json &data, Eigen::Index columns)

◆ hermite()

template<class Scalar>
Scalar eonc::tunneling::DerivativeRbfModel::hermite ( int n,
Scalar z )
inlinestaticprivate

Definition at line 230 of file DerivativeRbfModel.h.

230 {
231 if (n == 0)
232 return 1.;
233 if (n == 1)
234 return z;
235 Scalar previous = 1., current = z;
236 for (int k = 1; k < n; ++k) {
237 const Scalar next = z * current - k * previous;
238 previous = current;
239 current = next;
240 }
241 return current;
242 }

◆ kernel()

double eonc::tunneling::DerivativeRbfModel::kernel ( const Eigen::VectorXd & q,
Eigen::Index site,
const std::vector< int > & inputOrder ) const
inlineprivate

Definition at line 243 of file DerivativeRbfModel.h.

244 {
245 const Eigen::VectorXd z =
246 (q - sites_.row(site).transpose()).array() / scales_.array();
247 double value = std::exp(-.5 * z.squaredNorm());
248 for (Eigen::Index j = 0; j < dimension(); ++j) {
249 const int input = inputOrder[static_cast<size_t>(j)];
250 const int total =
251 input + orders_[static_cast<size_t>(site)][static_cast<size_t>(j)];
252 value *= hermite(total, z[j]) / std::pow(scales_[j], total);
253 if (input % 2)
254 value = -value;
255 }
256 return value;
257 }
static Scalar hermite(int n, Scalar z)
std::vector< std::vector< int > > orders_

◆ matrix()

Eigen::MatrixXd eonc::tunneling::DerivativeRbfModel::matrix ( const nlohmann::json & data,
Eigen::Index columns )
inlinestaticprivate

Definition at line 215 of file DerivativeRbfModel.h.

216 {
217 if (!data.is_array())
218 throw std::invalid_argument("interpolant matrix must be an array");
219 Eigen::MatrixXd out(data.size(), columns);
220 for (Eigen::Index i = 0; i < out.rows(); ++i) {
221 if (data.at(i).size() != static_cast<size_t>(columns))
222 throw std::invalid_argument("interpolant matrix column count differs");
223 for (Eigen::Index j = 0; j < columns; ++j)
224 out(i, j) = data.at(i).at(j).get<double>();
225 }
226 if (!out.allFinite())
227 throw std::invalid_argument("non-finite interpolant matrix");
228 return out;
229 }

◆ outputs()

Eigen::Index eonc::tunneling::DerivativeRbfModel::outputs ( ) const
inline

Definition at line 82 of file DerivativeRbfModel.h.

82{ return constant_.size(); }

◆ scalarKernel()

long double eonc::tunneling::DerivativeRbfModel::scalarKernel ( const Eigen::VectorXd & q,
Eigen::Index site,
const std::vector< int > & inputOrder ) const
inlineprivate

Definition at line 183 of file DerivativeRbfModel.h.

184 {
185 std::vector<long double> z(static_cast<size_t>(dimension()));
186 long double squared = 0;
187 for (Eigen::Index j = 0; j < dimension(); ++j) {
188 z[static_cast<size_t>(j)] =
189 (static_cast<long double>(q[j]) - sites_(site, j)) / scales_[j];
190 squared += z[static_cast<size_t>(j)] * z[static_cast<size_t>(j)];
191 }
192 long double value = std::exp(-0.5L * squared);
193 for (Eigen::Index j = 0; j < dimension(); ++j) {
194 const int input = inputOrder[static_cast<size_t>(j)];
195 const int total =
196 input + orders_[static_cast<size_t>(site)][static_cast<size_t>(j)];
197 value *= hermite(total, z[static_cast<size_t>(j)]) /
198 std::pow(static_cast<long double>(scales_[j]), total);
199 if (input % 2)
200 value = -value;
201 }
202 return value;
203 }

◆ vector()

Eigen::VectorXd eonc::tunneling::DerivativeRbfModel::vector ( const nlohmann::json & data)
inlinestaticprivate

Definition at line 205 of file DerivativeRbfModel.h.

205 {
206 if (!data.is_array())
207 throw std::invalid_argument("interpolant vector must be an array");
208 Eigen::VectorXd out(data.size());
209 for (Eigen::Index i = 0; i < out.size(); ++i)
210 out[i] = data.at(i).get<double>();
211 if (!out.allFinite())
212 throw std::invalid_argument("non-finite interpolant vector");
213 return out;
214 }

Member Data Documentation

◆ constant_

Eigen::VectorXd eonc::tunneling::DerivativeRbfModel::constant_
private

Definition at line 258 of file DerivativeRbfModel.h.

◆ linear_

Eigen::MatrixXd eonc::tunneling::DerivativeRbfModel::linear_
private

Definition at line 259 of file DerivativeRbfModel.h.

◆ orders_

std::vector<std::vector<int> > eonc::tunneling::DerivativeRbfModel::orders_
private

Definition at line 260 of file DerivativeRbfModel.h.

◆ quadratic_

std::vector<Eigen::MatrixXd> eonc::tunneling::DerivativeRbfModel::quadratic_
private

Definition at line 261 of file DerivativeRbfModel.h.

◆ scales_

Eigen::VectorXd eonc::tunneling::DerivativeRbfModel::scales_
private

Definition at line 258 of file DerivativeRbfModel.h.

◆ sites_

Eigen::MatrixXd eonc::tunneling::DerivativeRbfModel::sites_
private

Definition at line 259 of file DerivativeRbfModel.h.

◆ weights_

Eigen::MatrixXd eonc::tunneling::DerivativeRbfModel::weights_
private

Definition at line 259 of file DerivativeRbfModel.h.


The documentation for this class was generated from the following file: