Same as compute(matter, dir) but with an explicit mobile atom list (intersected with free flags).
Eigenvector rows outside the list are 0.
98 {
101
102 std::unique_ptr<Matter> probe = std::move(
probe_);
103 long probeCalls = 0;
104 lowestEv.resize(matter->numberOfAtoms(), 3);
106
108 const int size = 3 * static_cast<int>(mobile.size());
109 if (size == 0) {
111 return;
112 }
113
114 const long maxIters = std::max(1L,
params.lanczos_options().max_iterations);
115 MatrixXd T(size, maxIters), Q(size, maxIters);
116 T.setZero();
118
119 double alpha, beta = r.norm();
122 return;
123 }
124 double ew = 0, ewOld = 0, ewAbsRelErr;
125 const double dr =
params.main_options().finiteDifference;
127
128
131 VectorXd evEst, evT, evOldEst;
132
133 auto tmpMatter = std::make_unique<Matter>(*matter);
134 const long forceCallsStart = tmpMatter->getForceCalls();
135 const AtomMatrix pos0 = matter->getPositions();
136 const VectorXd force0 =
mobileForces(tmpMatter.get(), mobile);
137
138 auto applyH = [&](const VectorXd &v) -> VectorXd {
139 auto at = [&](double scale) -> VectorXd {
142 pos);
143 tmpMatter->setPositions(pos);
144
145
146 if (probe && !probe->needsForceUpdate() &&
147 probe->getPositions() == tmpMatter->getPositions()) {
149 probe.reset();
150 probeCalls++;
151 return f;
152 }
153 probe.reset();
155 };
157 };
158
159 for (int i = 0; i < size; i++) {
161 Q.col(i) = r / beta;
162
163 u = applyH(Q.col(i));
164
165 if (i == 0) {
166 r = u;
167 } else {
168 r = u - beta * Q.col(i - 1);
169 }
170 alpha = Q.col(i).dot(r);
171 r = r - alpha * Q.col(i);
172
173 T(i, i) = alpha;
174 if (i > 0) {
175 T(i - 1, i) = beta;
176 T(i, i - 1) = beta;
177 }
178
179 beta = r.norm();
180
181
182 const bool krylovClosed = beta <= 1e-10 * std::fabs(alpha);
183
184 if (i >= 1) {
185 Eigen::SelfAdjointEigenSolver<MatrixXd> es(T.block(0, 0, i + 1, i + 1));
186 ew = es.eigenvalues()(0);
187 evT = es.eigenvectors().col(0);
189 std::fabs(ewOld), 1.0);
190 ewOld = ew;
191
192 evEst = Q.block(0, 0, size, i + 1) * evT;
193 eonc::safemath::safe_normalize_inplace(evEst);
197 evOldEst = evEst;
199 "[ILanczos] {:9s} {:9s} {:10s} {:14s} {:9.4f} "
200 "{:10.6f} {:7.3f} {:5} n_mobile={}",
201 "----", "----", "----", "----", ew, ewAbsRelErr,
203 if (krylovClosed) {
204 QUILL_LOG_ERROR(
log,
"[ILanczos] ERROR: linear dependence");
205 break;
206 }
207 if (ewAbsRelErr <
params.lanczos_options().tolerance) {
208 QUILL_LOG_INFO(
log,
"[ILanczos] Tolerance reached: {}",
209 params.lanczos_options().tolerance);
210 break;
211 }
212 } else {
213 ew = alpha;
214 ewOld = ew;
215 evEst = Q.col(0);
216 evOldEst = Q.col(0);
217 if (krylovClosed) {
218 QUILL_LOG_ERROR(
log,
"[ILanczos] ERROR: linear dependence");
219 break;
220 }
223 double Cnew = u.dot(Q.col(i));
225 std::fabs(Cprev), 1.0);
226 if (ewAbsRelErr <=
params.lanczos_options().tolerance) {
229 QUILL_LOG_INFO(
log,
"[ILanczos] Tolerance reached: {}",
230 params.lanczos_options().tolerance);
231 break;
232 }
233 }
234 }
235
236 if (i >=
params.lanczos_options().max_iterations - 1) {
237 QUILL_LOG_ERROR(
log,
"[ILanczos] Max iterations");
238 break;
239 }
240 }
241
243 totalForceCalls = tmpMatter->getForceCalls() - forceCallsStart + probeCalls;
244
246 if (evEst.size() == size) {
248 }
249}
Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, eOnStorageOrder > MatrixXd
Eigen::Matrix< double, Eigen::Dynamic, 3, eOnStorageOrder > AtomMatrix
std::unique_ptr< Matter > probe_
constexpr double safe_div(double num, double denom, double fallback=0.0)
double safe_acos(double x)
FdScheme
Real finite-difference scheme for the assembled Hessian and for Lanczos/Davidson Hessian-vector produ...
VectorXd fdHessianVector(FdScheme scheme, double dr, const VectorXd &force0, Eval &&eval)
Energy Hessian-vector product -dF.
void unpackMobileRows(const VectorXd &packed, const VectorXi &mobile, AtomMatrix &full)
Write a 3*n_mobile vector into full AtomMatrix rows (other rows unchanged).
FdScheme parseFdScheme(std::string_view scheme)
VectorXd packMobileRows(const AtomMatrix &full, const VectorXi &mobile)
Pack full (n_atoms,3) rows of mobile atoms into a 3*n_mobile vector.
VectorXd mobileForces(Matter *matter, const VectorXi &mobile)
Force components on mobile atoms after Matter has a valid force cache (calls getForces under the hood...