eOn 3.2.0
Long-timescale dynamics: aKMC, NEB, parallel replica
☾
Toggle main menu visibility
Loading...
Searching...
No Matches
DerivativeRbfModel.h
Go to the documentation of this file.
1
/*
2
** This file is part of eOn.
3
** SPDX-License-Identifier: BSD-3-Clause
4
** Copyright (c) 2010--present, eOn Development Team
5
*/
6
#pragma once
7
#include <Eigen/Dense>
8
#include <cmath>
9
#include <nlohmann/json.hpp>
10
#include <stdexcept>
11
#include <vector>
12
13
namespace
eonc::tunneling
{
14
15
struct
RbfEvaluation
{
16
Eigen::VectorXd
value
;
17
Eigen::MatrixXd
jacobian
;
18
std::vector<Eigen::MatrixXd>
hessians
;
19
};
20
23
class
DerivativeRbfModel
{
24
public
:
25
static
DerivativeRbfModel
fromJson
(
const
nlohmann::json &data) {
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
}
80
81
Eigen::Index
dimension
()
const
{
return
scales_
.size(); }
82
Eigen::Index
outputs
()
const
{
return
constant_
.size(); }
83
84
RbfEvaluation
evaluate
(
const
Eigen::VectorXd &q,
85
double
scalarValueShift = 0.0)
const
{
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
}
122
123
private
:
125
struct
Sum
{
126
long
double
value
= 0,
correction
= 0;
127
void
add
(
long
double
term) {
128
const
long
double
next =
value
+ term;
129
correction
+= std::abs(
value
) >= std::abs(term) ? (
value
- next) + term
130
: (term - next) +
value
;
131
value
= next;
132
}
133
long
double
total
()
const
{
return
value
+
correction
; }
134
};
135
136
RbfEvaluation
evaluateScalar
(
const
Eigen::VectorXd &q,
double
shift)
const
{
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
}
182
183
long
double
scalarKernel
(
const
Eigen::VectorXd &q, Eigen::Index site,
184
const
std::vector<int> &inputOrder)
const
{
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
}
204
205
static
Eigen::VectorXd
vector
(
const
nlohmann::json &data) {
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
}
215
static
Eigen::MatrixXd
matrix
(
const
nlohmann::json &data,
216
Eigen::Index columns) {
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
}
230
template
<
class
Scalar>
static
Scalar
hermite
(
int
n, Scalar z) {
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
}
243
double
kernel
(
const
Eigen::VectorXd &q, Eigen::Index site,
244
const
std::vector<int> &inputOrder)
const
{
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
}
258
Eigen::VectorXd
scales_
,
constant_
;
259
Eigen::MatrixXd
sites_
,
weights_
,
linear_
;
260
std::vector<std::vector<int>>
orders_
;
261
std::vector<Eigen::MatrixXd>
quadratic_
;
262
};
263
}
// namespace eonc::tunneling
eonc::tunneling::DerivativeRbfModel
Gaussian derivative interpolant with an explicit quadratic baseline.
Definition
DerivativeRbfModel.h:23
eonc::tunneling::DerivativeRbfModel::dimension
Eigen::Index dimension() const
Definition
DerivativeRbfModel.h:81
eonc::tunneling::DerivativeRbfModel::evaluateScalar
RbfEvaluation evaluateScalar(const Eigen::VectorXd &q, double shift) const
Definition
DerivativeRbfModel.h:136
eonc::tunneling::DerivativeRbfModel::hermite
static Scalar hermite(int n, Scalar z)
Definition
DerivativeRbfModel.h:230
eonc::tunneling::DerivativeRbfModel::linear_
Eigen::MatrixXd linear_
Definition
DerivativeRbfModel.h:259
eonc::tunneling::DerivativeRbfModel::vector
static Eigen::VectorXd vector(const nlohmann::json &data)
Definition
DerivativeRbfModel.h:205
eonc::tunneling::DerivativeRbfModel::orders_
std::vector< std::vector< int > > orders_
Definition
DerivativeRbfModel.h:260
eonc::tunneling::DerivativeRbfModel::kernel
double kernel(const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const
Definition
DerivativeRbfModel.h:243
eonc::tunneling::DerivativeRbfModel::fromJson
static DerivativeRbfModel fromJson(const nlohmann::json &data)
Definition
DerivativeRbfModel.h:25
eonc::tunneling::DerivativeRbfModel::scalarKernel
long double scalarKernel(const Eigen::VectorXd &q, Eigen::Index site, const std::vector< int > &inputOrder) const
Definition
DerivativeRbfModel.h:183
eonc::tunneling::DerivativeRbfModel::evaluate
RbfEvaluation evaluate(const Eigen::VectorXd &q, double scalarValueShift=0.0) const
Definition
DerivativeRbfModel.h:84
eonc::tunneling::DerivativeRbfModel::sites_
Eigen::MatrixXd sites_
Definition
DerivativeRbfModel.h:259
eonc::tunneling::DerivativeRbfModel::matrix
static Eigen::MatrixXd matrix(const nlohmann::json &data, Eigen::Index columns)
Definition
DerivativeRbfModel.h:215
eonc::tunneling::DerivativeRbfModel::constant_
Eigen::VectorXd constant_
Definition
DerivativeRbfModel.h:258
eonc::tunneling::DerivativeRbfModel::outputs
Eigen::Index outputs() const
Definition
DerivativeRbfModel.h:82
eonc::tunneling::DerivativeRbfModel::quadratic_
std::vector< Eigen::MatrixXd > quadratic_
Definition
DerivativeRbfModel.h:261
eonc::tunneling::DerivativeRbfModel::scales_
Eigen::VectorXd scales_
Definition
DerivativeRbfModel.h:258
eonc::tunneling::DerivativeRbfModel::weights_
Eigen::MatrixXd weights_
Definition
DerivativeRbfModel.h:259
eonc::tunneling
Definition
Tunneling.cpp:41
eonc::tunneling::DerivativeRbfModel::Sum
Compensated accumulation retains small terms beside cancelling weights.
Definition
DerivativeRbfModel.h:125
eonc::tunneling::DerivativeRbfModel::Sum::add
void add(long double term)
Definition
DerivativeRbfModel.h:127
eonc::tunneling::DerivativeRbfModel::Sum::total
long double total() const
Definition
DerivativeRbfModel.h:133
eonc::tunneling::DerivativeRbfModel::Sum::value
long double value
Definition
DerivativeRbfModel.h:126
eonc::tunneling::DerivativeRbfModel::Sum::correction
long double correction
Definition
DerivativeRbfModel.h:126
eonc::tunneling::RbfEvaluation
Definition
DerivativeRbfModel.h:15
eonc::tunneling::RbfEvaluation::value
Eigen::VectorXd value
Definition
DerivativeRbfModel.h:16
eonc::tunneling::RbfEvaluation::jacobian
Eigen::MatrixXd jacobian
Definition
DerivativeRbfModel.h:17
eonc::tunneling::RbfEvaluation::hessians
std::vector< Eigen::MatrixXd > hessians
Definition
DerivativeRbfModel.h:18
include
eon
DerivativeRbfModel.h
Generated by
1.17.0
Generated by
Doxygen 1.17.0
Analytics by
Antics
provided by
TurtleTech ehf