votca 2026-dev
Loading...
Searching...
No Matches
inactivescreening.cc
Go to the documentation of this file.
1/*
2 * Copyright 2009-2026 The VOTCA Development Team
3 * (http://www.votca.org)
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License")
6 *
7 * You may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 */
19
20// Standard includes
21#include <algorithm>
22#include <limits>
23#include <stdexcept>
24#include <string>
25#include <utility>
26#include <vector>
27
28// Local VOTCA includes
30#include "votca/xtp/aomatrix.h"
34
35namespace votca {
36namespace xtp {
37
39 const Eigen::MatrixXd& DB = full.getInactiveDensity();
40 if (DB.size() == 0) {
41 throw std::runtime_error(
42 "InactiveScreening: no inactive density; run the projection-based "
43 "embedding first");
44 }
45 const Index nocc = full.getNumberOfAlphaElectrons();
46 const Eigen::MatrixXd& C = full.MOs().eigenvectors();
47 const Eigen::VectorXd& e = full.MOs().eigenvalues();
48 if (DB.rows() != C.rows()) {
49 throw std::runtime_error(
50 "InactiveScreening: inactive density and MOs have different AO "
51 "dimensions (truncated basis is not supported)");
52 }
53
54 AOOverlap overlap;
55 overlap.Fill(full.getDftBasis());
56 const Eigen::MatrixXd SCocc = overlap.Matrix() * C.leftCols(nocc);
57
58 // Projector of the inactive density onto the occupied space; its
59 // eigenvalues are 1 for the inactive and 0 for the active orbitals.
60 const Eigen::MatrixXd Q = 0.5 * SCocc.transpose() * DB * SCocc;
62 const Index nB = (q.values.array() > 0.5).count();
63 const Eigen::MatrixXd UB = q.vectors.rightCols(nB);
64
65 InactiveSpace space;
66 space.idempotency_error = (Q * Q - Q).cwiseAbs().maxCoeff();
67
68 // semicanonical: diagonalize the Fock operator within the inactive space
69 const Eigen::MatrixXd FB = UB.transpose() * e.head(nocc).asDiagonal() * UB;
71 if (ncore < 0 || ncore > nB) {
72 throw std::runtime_error("InactiveScreening: " + std::to_string(ncore) +
73 " core levels requested, but the inactive "
74 "region has only " +
75 std::to_string(nB) + " occupied orbitals");
76 }
77 const Index nkeep = nB - ncore;
78 space.occupied = C.leftCols(nocc) * UB * f.vectors.rightCols(nkeep);
79 space.occupied_energies = f.values.tail(nkeep);
80 const Index nvirt = C.cols() - nocc;
81 space.virtuals = C.rightCols(nvirt);
82 space.virtual_energies = e.tail(nvirt);
83 return space;
84}
85
86std::vector<Eigen::MatrixXd> InactiveScreening::Responses(
87 const AOBasis& auxbasis, const AOBasis& dftbasis,
88 const Eigen::MatrixXd& occupied, const Eigen::VectorXd& occupied_energies,
89 const Eigen::MatrixXd& virtuals, const Eigen::VectorXd& virtual_energies,
90 double chunk_bytes, const std::vector<double>& imaginary_frequencies,
91 const Eigen::MatrixXd& inv_sqrt) {
92 const Index naux = auxbasis.AOBasisSize();
93 const Index nocc = occupied.cols();
94 const Index nvirt = virtuals.cols();
95 std::vector<Eigen::MatrixXd> X(imaginary_frequencies.size(),
96 Eigen::MatrixXd::Zero(naux, naux));
97 if (nocc == 0 || nvirt == 0) {
98 return X;
99 }
100 const double bytes_per_level = 8.0 * double(nvirt) * double(naux);
101 const Index chunk = std::clamp<Index>(
102 static_cast<Index>(chunk_bytes / bytes_per_level), 1, nocc);
103
104 // the metric of the auxiliary basis is the same for every chunk
105 Eigen::MatrixXd metric = inv_sqrt;
106 for (Index first = 0; first < nocc; first += chunk) {
107 const Index nc = std::min(chunk, nocc - first);
108 Eigen::MatrixXd orbitals(occupied.rows(), nc + nvirt);
109 orbitals << occupied.middleCols(first, nc), virtuals;
110 // one integral pass for all frequencies
111 TCMatrix_gwbse Mmn;
112 Mmn.Initialize(naux, 0, nc - 1, nc, nc + nvirt - 1);
113 if (metric.size() == 0) {
114 Mmn.Fill(auxbasis, dftbasis, orbitals);
115 metric = Mmn.InvSqrt();
116 } else {
117 Mmn.Fill(auxbasis, dftbasis, orbitals, metric);
118 }
119 for (std::size_t f = 0; f < imaginary_frequencies.size(); ++f) {
120 const double w2 = imaginary_frequencies[f] * imaginary_frequencies[f];
121 X[f] += WeightedGram::Compute(
122 nc, naux,
123 [&](Index m, Eigen::VectorXd& w) {
124 const Eigen::ArrayXd d =
125 virtual_energies.array() - occupied_energies(first + m);
126 w = 4.0 * d / (d.square() + w2);
127 },
128 [&](Index m, const WeightedGram::RowsVisitor& use) { use(Mmn[m]); });
129 }
130 }
131 return X;
132}
133
135 const AOBasis& auxbasis, const AOBasis& dftbasis,
136 const Eigen::MatrixXd& occupied, const Eigen::VectorXd& occupied_energies,
137 const Eigen::MatrixXd& virtuals, const Eigen::VectorXd& virtual_energies,
138 double chunk_bytes, double imaginary_frequency) {
139 return Responses(auxbasis, dftbasis, occupied, occupied_energies, virtuals,
140 virtual_energies, chunk_bytes, {imaginary_frequency})
141 .front();
142}
143
145 const std::string& name) {
146 if (name == "none") {
147 return Mode::None;
148 } else if (name == "block") {
149 return Mode::Block;
150 } else if (name == "exact") {
151 return Mode::Exact;
152 }
153 throw std::runtime_error("inactive_screening: unknown mode '" + name +
154 "' (none, block, exact)");
155}
156
158 switch (mode) {
159 case Mode::Block:
160 return "block";
161 case Mode::Exact:
162 return "exact";
163 default:
164 return "none";
165 }
166}
167
169 Index& n_far) {
170 const Eigen::MatrixXd& L = full.getLMOs();
171 const Index nocc = full.getNumberOfAlphaElectrons();
172 if (L.cols() != nocc || L.rows() != full.MOs().eigenvectors().rows()) {
173 throw std::runtime_error(
174 "inactive_screening_radius needs the localized occupied orbitals of "
175 "the full calculation (localize step)");
176 }
177 AOOverlap overlap;
178 overlap.Fill(full.getDftBasis());
179 const Eigen::MatrixXd& S = overlap.Matrix();
180 const Eigen::MatrixXd SL = S * L;
181 // inactive LMOs: weight ~1 in the inactive density
182 const Eigen::VectorXd q =
183 0.5 * (SL.transpose() * full.getInactiveDensity() * SL).diagonal();
184 // charge centroids from Mulliken atom populations
185 const QMMolecule& atoms = full.QMAtoms();
186 const Eigen::MatrixXd pop = ActiveRegion::AtomPopulations(full, L);
187 Eigen::MatrixXd R(3, atoms.size());
188 for (Index a = 0; a < atoms.size(); ++a) {
189 R.col(a) = atoms[a].getPos();
190 }
191 const Eigen::MatrixXd centroid =
192 R * pop * pop.colwise().sum().cwiseInverse().asDiagonal();
193 std::vector<Index> active;
194 std::vector<Index> inactive;
195 for (Index k = 0; k < nocc; ++k) {
196 (q(k) > 0.5 ? inactive : active).push_back(k);
197 }
198 std::vector<Index> near;
199 for (Index k : inactive) {
200 double dmin = std::numeric_limits<double>::max();
201 for (Index j : active) {
202 dmin = std::min(dmin, (centroid.col(k) - centroid.col(j)).norm());
203 }
204 if (dmin <= radius) {
205 near.push_back(k);
206 }
207 }
208 n_far = Index(inactive.size() - near.size());
209 Eigen::MatrixXd Ln(L.rows(), Index(near.size()));
210 for (Index i = 0; i < Index(near.size()); ++i) {
211 Ln.col(i) = L.col(near[std::size_t(i)]);
212 }
213 // semicanonical among the near ones: F = S C diag(e) C^T S
214 const Index n = full.MOs().eigenvectors().cols();
215 const Eigen::MatrixXd SC = S * full.MOs().eigenvectors();
216 const Eigen::MatrixXd CL = SC.leftCols(nocc).transpose() * Ln; // MO basis
217 const Eigen::MatrixXd FL =
218 CL.transpose() * full.MOs().eigenvalues().head(nocc).asDiagonal() * CL;
219 const SymmetricEigenSystem f = SymmetricEigen(0.5 * (FL + FL.transpose()));
220 InactiveSpace space;
221 space.occupied = Ln * f.vectors;
222 space.occupied_energies = f.values;
223 space.virtuals = full.MOs().eigenvectors().rightCols(n - nocc);
224 space.virtual_energies = full.MOs().eigenvalues().tail(n - nocc);
225 return space;
226}
227
229 const Orbitals& full, InactiveScreeningInput::Mode mode, bool complete_g,
230 double radius) {
232 input.mode = mode;
233 input.complete_g = complete_g && mode != InactiveScreeningInput::Mode::None;
235 return input;
236 }
237 if (full.getCalculationType() == "Truncated") {
238 throw std::runtime_error(
239 "inactive_screening is not implemented for truncated active "
240 "regions (dft_in_dft.truncate_basis).");
241 }
242 // the inactive space is built in both modes: its size and idempotency
243 // are the checks that the full MOs and the inactive density belong
244 // together
245 InactiveSpace space = BuildSpace(full);
246 input.n_inactive = space.size();
248 if (input.complete_g) {
249 input.inactive_occupied = space.occupied;
251 }
252 if (mode == InactiveScreeningInput::Mode::Block && radius > 0.0) {
253 InactiveSpace near = NearSpace(full, radius, input.n_far);
254 input.radius = radius;
255 input.occupied = std::move(near.occupied);
256 input.occupied_energies = std::move(near.occupied_energies);
257 } else if (mode == InactiveScreeningInput::Mode::Block) {
258 input.occupied = std::move(space.occupied);
259 input.occupied_energies = std::move(space.occupied_energies);
260 } else {
261 if (radius > 0.0) {
262 throw std::runtime_error(
263 "inactive_screening_radius is only available for "
264 "inactive_screening block");
265 }
266 const Index nocc = full.getNumberOfAlphaElectrons();
267 input.occupied = full.MOs().eigenvectors().leftCols(nocc);
268 input.occupied_energies = full.MOs().eigenvalues().head(nocc);
269 }
270 input.virtuals = std::move(space.virtuals);
271 input.virtual_energies = std::move(space.virtual_energies);
272 return input;
273}
274
276 const tools::EigenSystem& embedded, Index n_active_occupied,
277 const InactiveScreeningInput& input) {
278 const Index nB = input.inactive_occupied.cols();
279 const Index nvirt = input.virtuals.cols();
280 const Index nA = n_active_occupied;
281 if (nA + nvirt > embedded.eigenvectors().cols()) {
282 throw std::runtime_error(
283 "CompleteGOrbitals: the embedded MOs have fewer levels than the "
284 "active occupied plus virtual ones");
285 }
286 tools::EigenSystem result;
287 result.eigenvectors().resize(embedded.eigenvectors().rows(), nB + nA + nvirt);
288 result.eigenvectors() << input.inactive_occupied,
289 embedded.eigenvectors().leftCols(nA + nvirt);
290 result.eigenvalues().resize(nB + nA + nvirt);
291 result.eigenvalues() << input.inactive_energies,
292 embedded.eigenvalues().head(nA + nvirt);
293 return result;
294}
295
296Eigen::MatrixXd InactiveScreening::Kernel(const AOBasis& auxbasis,
297 const AOBasis& dftbasis,
298 const InactiveScreeningInput& input,
299 const tools::EigenSystem& embedded,
300 Index homo, double chunk_bytes,
301 double imaginary_frequency,
302 Index first_active) {
303 Eigen::MatrixXd Y = Response(
304 auxbasis, dftbasis, input.occupied, input.occupied_energies,
305 input.virtuals, input.virtual_energies, chunk_bytes, imaginary_frequency);
307 const Index nA = homo + 1 - first_active;
308 const Index nvirt = input.virtuals.cols();
309 if (homo + 1 + nvirt > embedded.eigenvectors().cols()) {
310 throw std::runtime_error(
311 "inactive_screening: the embedded MOs have fewer levels than the "
312 "full calculation's occupied and virtual ones");
313 }
314 Y -= Response(auxbasis, dftbasis,
315 embedded.eigenvectors().middleCols(first_active, nA),
316 embedded.eigenvalues().segment(first_active, nA),
317 embedded.eigenvectors().middleCols(homo + 1, nvirt),
318 embedded.eigenvalues().segment(homo + 1, nvirt), chunk_bytes,
319 imaginary_frequency);
320 }
321 return 0.5 * (Y + Y.transpose());
322}
323
324std::vector<Eigen::MatrixXd> InactiveScreening::Kernels(
325 const AOBasis& auxbasis, const AOBasis& dftbasis,
326 const InactiveScreeningInput& input, const TCMatrix_gwbse& active,
327 const Eigen::VectorXd& rpa_energies, Index homo, Index rpamin, Index rpamax,
328 double chunk_bytes, const std::vector<double>& imaginary_frequencies,
329 double virtual_cutoff) {
330 // the virtuals of the full calculation inside the RPA range; above them
331 // (no complete G) sit the inactive levels the projector shifted up,
332 // which are left out of both terms
333 Index nvirt = std::min(rpamax - homo, input.virtuals.cols());
334 if (virtual_cutoff > 0.0 && nvirt > 0) {
335 // only virtuals up to the cutoff above the LUMO, in both terms
336 const double top = input.virtual_energies(0) + virtual_cutoff;
337 nvirt = std::min(
338 nvirt,
339 Index((input.virtual_energies.head(nvirt).array() <= top).count()));
340 }
341 std::vector<Eigen::MatrixXd> Y = Responses(
342 auxbasis, dftbasis, input.occupied, input.occupied_energies,
343 input.virtuals.leftCols(nvirt), input.virtual_energies.head(nvirt),
344 chunk_bytes, imaginary_frequencies, active.InvSqrt());
346 // X_A from the integrals GW already holds (excluded holes, e.g. the
347 // inactive levels of complete G, are left out as in the RPA)
348 if (active.HasAdditionalResponse() || active.AdditionalPoleCount() > 0) {
349 throw std::runtime_error(
350 "inactive_screening: X_A must be built before the inactive "
351 "response is attached to the integrals");
352 }
353 const Index first = rpamin + active.ExcludedHoles();
354 const Index mmin = active.get_mmin();
355 const Index nmin = active.get_nmin();
356 for (std::size_t f = 0; f < Y.size(); ++f) {
357 const double w2 = imaginary_frequencies[f] * imaginary_frequencies[f];
358 Y[f] -= WeightedGram::Compute(
359 homo + 1 - first, active.auxsize(),
360 [&](Index m, Eigen::VectorXd& w) {
361 const Eigen::ArrayXd d =
362 rpa_energies.segment(homo + 1 - rpamin, nvirt).array() -
363 rpa_energies(first + m - rpamin);
364 w = 4.0 * d / (d.square() + w2);
365 },
366 [&](Index m, const WeightedGram::RowsVisitor& use) {
367 use(active[first + m - mmin].middleRows(homo + 1 - nmin, nvirt));
368 });
369 }
370 }
371 for (Eigen::MatrixXd& y : Y) {
372 y = 0.5 * (y + y.transpose());
373 }
374 return Y;
375}
376
378 const Eigen::MatrixXd& Y0, const Eigen::MatrixXd& Yi, double w_i,
379 double tolerance) {
380 PoleFit fit;
381 const SymmetricEigenSystem y = SymmetricEigen(0.5 * (Y0 + Y0.transpose()));
382 const double cut = tolerance * std::max(y.values.maxCoeff(), 0.0);
383 const Index keep = (y.values.array() > cut).count();
384 fit.dropped = y.values.size() - keep;
385 if (keep == 0) {
386 return fit;
387 }
388 // Y(0) = G G^T on its range, G = U s^1/2; P = U s^-1/2 = G^+T
389 const Eigen::VectorXd s = y.values.tail(keep);
390 const Eigen::MatrixXd U = y.vectors.rightCols(keep);
391 const Eigen::MatrixXd P = U * s.cwiseSqrt().cwiseInverse().asDiagonal();
392 const Eigen::MatrixXd Yp = P.transpose() * Yi * P;
393 const SymmetricEigenSystem q = SymmetricEigen(0.5 * (Yp + Yp.transpose()));
394 // l = W^2/(W^2 + w_i^2): W from 1e-3 Ha (l_min) to 1e3 Ha (l_max)
395 const double l_min = 1e-6 / (1e-6 + w_i * w_i);
396 const double l_max = 1e6 / (1e6 + w_i * w_i);
397 Eigen::VectorXd l = q.values;
398 for (Index k = 0; k < l.size(); ++k) {
399 if (l(k) <= 0.0 || l(k) >= 1.0) {
400 // no real pole: keep the mode's static response, as a pole far above
401 // every excitation (a spurious low-lying pole would be worse for
402 // the exact self-energy than a static contribution)
403 ++fit.clipped;
404 l(k) = l_max;
405 } else {
406 l(k) = std::clamp(l(k), l_min, l_max);
407 }
408 }
409 fit.energies = w_i * (l.array() / (1.0 - l.array())).sqrt();
410 const Eigen::MatrixXd G = U * s.cwiseSqrt().asDiagonal() * q.vectors;
411 fit.vectors = G * (0.25 * fit.energies.array()).sqrt().matrix().asDiagonal();
412 return fit;
413}
414
415Eigen::MatrixXd InactiveScreening::ReactionField(const Eigen::MatrixXd& Y,
416 const Eigen::MatrixXd& R_env) {
417 const Index n = Y.rows();
418 const Eigen::MatrixXd one = Eigen::MatrixXd::Identity(n, n);
419 Eigen::MatrixXd u_inv = one + Y;
420 if (R_env.size() > 0) {
421 if (R_env.rows() != n) {
422 throw std::runtime_error(
423 "InactiveScreening: environment reaction field and inactive "
424 "response have different auxiliary dimensions");
425 }
426 // (1 + R_env)^-1 + Y; 1 + R_env is positive definite (Check)
427 u_inv = InverseSPD(one + R_env) + Y;
428 }
429 Eigen::MatrixXd R = InverseSPD(u_inv) - one;
430 return 0.5 * (R + R.transpose());
431}
432
433} // namespace xtp
434} // namespace votca
const Eigen::VectorXd & eigenvalues() const
Definition eigensystem.h:30
const Eigen::MatrixXd & eigenvectors() const
Definition eigensystem.h:33
Container to hold Basisfunctions for all atoms.
Definition aobasis.h:42
Index AOBasisSize() const
Definition aobasis.h:46
void Fill(const AOBasis &aobasis) final
const Eigen::MatrixXd & Matrix() const
Definition aomatrix.h:52
static Eigen::MatrixXd AtomPopulations(const Orbitals &orb, const Eigen::MatrixXd &mos)
const Eigen::Vector3d & getPos() const
static Eigen::MatrixXd ReactionField(const Eigen::MatrixXd &Y, const Eigen::MatrixXd &R_env=Eigen::MatrixXd())
The reaction field R with 1 + R = ((1 + R_env)^-1 + Y)^-1; without an environment (R_env empty) R = (...
static PoleFit FitPoles(const Eigen::MatrixXd &Y0, const Eigen::MatrixXd &Yi, double w_i, double tolerance=1e-10)
static tools::EigenSystem CompleteGOrbitals(const tools::EigenSystem &embedded, Index n_active_occupied, const InactiveScreeningInput &input)
The MOs GW-BSE works with for complete G: the inactive occupied orbitals (semicanonical,...
static Eigen::MatrixXd Kernel(const AOBasis &auxbasis, const AOBasis &dftbasis, const InactiveScreeningInput &input, const tools::EigenSystem &embedded, Index homo, double chunk_bytes, double imaginary_frequency=0.0, Index first_active=0)
Y, the response of the inactive region: X_B (block) or X_full - X_A (exact), static or at an imaginar...
static std::vector< Eigen::MatrixXd > Kernels(const AOBasis &auxbasis, const AOBasis &dftbasis, const InactiveScreeningInput &input, const TCMatrix_gwbse &active, const Eigen::VectorXd &rpa_energies, Index homo, Index rpamin, Index rpamax, double chunk_bytes, const std::vector< double > &imaginary_frequencies, double virtual_cutoff=0.0)
Y at several imaginary frequencies, as GWBSE uses it: one integral pass for the full (exact) or inact...
static std::vector< Eigen::MatrixXd > Responses(const AOBasis &auxbasis, const AOBasis &dftbasis, const Eigen::MatrixXd &occupied, const Eigen::VectorXd &occupied_energies, const Eigen::MatrixXd &virtuals, const Eigen::VectorXd &virtual_energies, double chunk_bytes, const std::vector< double > &imaginary_frequencies, const Eigen::MatrixXd &inv_sqrt=Eigen::MatrixXd())
static InactiveSpace BuildSpace(const Orbitals &full, Index ncore=0)
The inactive space from the full reference orbitals and the inactive density stored by DFTEngine::Eva...
static Eigen::MatrixXd Response(const AOBasis &auxbasis, const AOBasis &dftbasis, const Eigen::MatrixXd &occupied, const Eigen::VectorXd &occupied_energies, const Eigen::MatrixXd &virtuals, const Eigen::VectorXd &virtual_energies, double chunk_bytes=4e9, double imaginary_frequency=0.0)
X = sum_ia 4/(e_a - e_i) M_ia M_ia^T over the given occupied and virtual orbitals,...
static InactiveScreeningInput Prepare(const Orbitals &full, InactiveScreeningInput::Mode mode, bool complete_g=false, double radius=0.0)
The input for GWBSE, from the full reference orbitals (before they are replaced by the embedded ones)...
static InactiveSpace NearSpace(const Orbitals &full, double radius, Index &n_far)
Block mode with a spatial cutoff: the inactive LMOs whose charge centroid lies within radius (bohr) o...
Container for molecular orbitals and derived one-particle data.
Definition orbitals.h:47
Index getNumberOfAlphaElectrons() const
Return the stored number of alpha electrons.
Definition orbitals.h:159
std::string getCalculationType() const
Return the stored calculation-type tag.
Definition orbitals.h:242
const Eigen::MatrixXd & getLMOs() const
Return localized molecular orbitals, if available.
Definition orbitals.h:719
const Eigen::MatrixXd & getInactiveDensity() const
Return the inactive-region density matrix used in embedding workflows.
Definition orbitals.h:744
const tools::EigenSystem & MOs() const
Return read-only access to alpha/restricted molecular orbitals.
Definition orbitals.h:192
const QMMolecule & QMAtoms() const
Return read-only access to the molecular geometry.
Definition orbitals.h:262
const AOBasis & getDftBasis() const
Return the DFT AO basis, throwing if it has not been initialized.
Definition orbitals.h:372
void Fill(const AOBasis &auxbasis, const AOBasis &dftbasis, const Eigen::MatrixXd &dft_orbitals)
Index AdditionalPoleCount() const
void Initialize(Index basissize, Index mmin, Index mmax, Index nmin, Index nmax)
bool HasAdditionalResponse() const
const Eigen::MatrixXd & InvSqrt() const
std::function< void(const Eigen::Ref< const Eigen::MatrixXd > &)> RowsVisitor
Calls use(R_m); R_m may be a block of stored data or a temporary.
static Eigen::MatrixXd Compute(Index nblocks, Index ncols, const WeightsFn &weights, const RowsFn &rows)
Charge transport classes.
Definition ERIs.h:28
SymmetricEigenSystem SymmetricEigen(const Eigen::MatrixXd &A, bool vectors=true)
With vectors = false only the eigenvalues are computed.
Eigen::MatrixXd InverseSPD(const Eigen::MatrixXd &A)
Provides a means for comparing floating point numbers.
Definition basebead.h:33
Eigen::Index Index
Definition types.h:26
What GWBSE needs to add the static screening of the inactive region: the mode and the orbitals of the...
static Mode Parse(const std::string &name)
static std::string Name(Mode mode)
Poles in the form of transitions that reproduce a response at zero and at one imaginary frequency: Y(...
Occupied orbitals of the inactive region of a projection-based embedding, with the virtual space they...
Eigen::VectorXd occupied_energies