Local interactions from constrained RPA#
task = crpa computes bare, partially screened and fully screened onsite
interaction tensors on the native positive imaginary-frequency grid. The two
Green-function branches use the same original KS states with binary or
fractional endpoint weights to form Pd; the screened interaction uses Pr = P0 - Pd. KS energies, occupations
and the frequency grid are unchanged.
Orbital analysis before screening#
By default, crpa_output_analysis = true evaluates Mulliken and symmetric
Lowdin AO weights from the loaded scalar or two-component spinor KS
coefficients and supplied S(k).
Here (C) contains the already exported KS eigenvectors in the atomic-orbital
basis, with (C_{\mu n}) the coefficient of AO (\mu) in band (n).
For scalar states each column (c_n) obeys (Hc_n=\varepsilon_n Sc_n).
For spinor states the overlap metric is (I_{\rm spinor}\otimes S), and
(\sum_s c_{ns}^\dagger Sc_{ns}=1); k and stored-channel indices are
suppressed here.
No Hamiltonian is read and no physical KS eigenproblem is solved. S alone is
diagonalized to evaluate its positive square root. The weight definitions are
The existing basis_wfc_out shell metadata and explicit basis convention
identify atom/l groups. All radial functions are summed, with d split into
global-axis eg and t2g channels. No pbands.xml, Orbital or PDOS.dat
reference file is required. This AO character diagnostic is independent of
the first-radial projected local frame used for the interaction tensors.
The driver writes the following before screening:
crpa_orbital_groups.dat: zero-based group/atom indices, species, l and channel.crpa_orbital_weights.dat: each spin/k/band/group weight in both conventions, absolute and relative energy, occupation, k weight and original S norm.crpa_pdos.dat: both Gaussian PDOS conventions on one energy grid, with separate stored spin channels, in states/(eV cell stored-spin-channel).crpa_orbital_analysis.txt: definitions, energy reference, Gaussian sigma, normalization and overlap-square-root diagnostics.
For a two-component input, weights sum both components of the same KS state
and are written in one stored spin channel (spin = 0). This index does not
identify a conserved spin projection. Scalar collinear inputs retain their
separate spin-up and spin-down channels. No spin-projected vector or spin
texture is computed by this orbital-character analysis.
PDOS uses the loaded normalized k weights, all loaded bands and no occupation
or additional spin-degeneracy factor. Mulliken weights can be negative; they
are not clipped. The default grid is -10 to 14 eV in steps of 0.02 eV, relative
to the highest occupied KS energy (crpa_pdos_reference = vbm), with Gaussian
standard deviation crpa_pdos_sigma_ev = 0.15. Set the reference to fermi
for a Fermi-level zero, and control the range with crpa_pdos_min_ev,
crpa_pdos_max_ev and crpa_pdos_step_ev. A finite grid covers only that
energy range; it is not a complete-spectrum normalization integral.
Energy conversion uses the configured LibRPA constants. A producer’s printed
eV column can use a slightly different Hartree/eV constant; comparisons must
match this convention as well as poles, k weights and Gaussian sigma.
For a first pass that helps select A/B windows, use:
task = crpa
input_preset = abacus
input_dir = ./input/
fn_stru = stru_out
fn_eigocc_scf = band_out
crpa_species_labels = Ni O
crpa_overlap_file = srs1_nao.csr
crpa_residual_tol = 1e-8
crpa_analysis_only = true
use_spinor_wfc = false
use_kpara_scf_eigvec = false
use_symmetry_rpa = false
This mode reads structure/k metadata, the split wave-function basis, energies,
coefficients and S; it skips auxiliary-basis, RI and Coulomb inputs entirely.
For SOC or a noncollinear spinor input, change use_spinor_wfc to true.
Either a spatial S(R) export or a validated interleaved SOC export can be
used. Optical velocity inputs are also skipped in analysis-only mode.
No correlated species or A/B selections are required. After inspecting the
analysis, supply the normal cRPA selections and set crpa_analysis_only = false
to run screening. These diagnostic AO weights never select windows automatically
or enter Pd. The separate orbital-weight response mode below uses the actual
interaction frame. crpa_output_analysis = false skips the additional diagnostic
analysis during an interaction run, without disabling the response weights.
Response selection and local frames#
With the default crpa_response_mode = bands, the binary response subspace
A and orbital-construction band space B are independent. Each can be selected by inclusive absolute-Hartree intervals (lower/upper pairs)
or by an explicit zero-based KS band list shared by all spin/k points. PDOS and
KS-band inspection determine the material-specific selection.
For each spin, atomic trials are projected into B and orthonormalized using
the AO overlap. crpa_parent_orbitals selects s, p, sp, d, dp, eg or t2g trials;
crpa_output_orbitals selects a subset of the resulting common frame. Thus
d|dp and eg|dp retain columns of the jointly normalized d+p frame. The
first radial shell is used; eg and t2g refer to the global Cartesian axes.
sp combines s, pz, px, py on each correlated atom in one output site, retaining
the cross-shell direct and exchange interactions in its four-index tensor. In
contrast, dp combines correlated-atom d orbitals with distinct ligand-atom p
orbitals. Selecting s or p from an sp parent retains columns of that same
jointly normalized frame, rather than constructing separate local frames.
An explicit ligand species prevents spectator atoms such as Li or Sr from
being interpreted as oxygen.
An example using the existing AFM NiO d|dp windows is:
task = crpa
input_preset = abacus
parallel_routing = libri
use_symmetry_rpa = false
use_kpara_scf_eigvec = false
use_fullcoul_eps = true
use_fullcoul_wc = true
replace_w_head = false
option_dielect_func = 0
n_bands_chi0 = -1
tfgrids_type = minimax
nfreq = 24
crpa_overlap_file = srs1_nao.csr
crpa_species_labels = Ni O
crpa_correlated_species = Ni
crpa_ligand_species = O
crpa_parent_orbitals = dp
crpa_output_orbitals = d
crpa_response_windows_ha = 0.422538107206142 0.6066522113061734
crpa_orbital_windows_ha = 0.231441631892736 0.6066522113061734
crpa_residual_tol = 1e-8
If a group is isolated at each k but overlaps other bands in its global energy
range, specify crpa_response_bands = 20 21 22 and/or
crpa_orbital_bands = 20 21 22. Omit the respective _windows_ha input when
using a band list. This selects the original KS indices directly; no orbital
character weighting or modified eigenvalues enter the response.
Fractional orbital-projector response#
Set crpa_response_mode = orbital_weights to define the excluded response from
the actual output frame, rather than a binary A window. Supply only B
(crpa_orbital_windows_ha or crpa_orbital_bands) and the parent/output orbitals;
omit both crpa_response_windows_ha and crpa_response_bands. The NAO trials
are still projected into B and jointly Lowdin normalized. No Wannier
localization or new physical eigenproblem is introduced.
For each physical spin and k, the output frame obeys (\Phi^\dagger S\Phi=I). Its endpoint probabilities are
The denominator handles the accepted finite-precision normalization of input C. For SOC, S denotes the lifted spinor metric. Both Green-function branches are weighted, giving the original KS transition ((n\mathbf k,m\mathbf{k+q})) a factor (w_{n\mathbf k}w_{m\mathbf{k+q}}) in Pd. Pr therefore uses (1-w_{n\mathbf k}w_{m\mathbf{k+q}}). The same retained factor enters analytic optical head and wings. KS poles, physical occupations, density vertices and the full GW response are unchanged. Small positive probabilities are retained continuously; there is no character threshold or filling of band-index holes. Validated roundoff above one alone is clipped to one.
For NiO d|dp, for example:
crpa_response_mode = orbital_weights
crpa_parent_orbitals = dp
crpa_output_orbitals = d
crpa_orbital_bands = 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
These band indices are illustrative, not a transferable NiO prescription. B must span all requested trials without a rank defect at every spin/k. The d|dp response uses d output columns from the joint dp frame; dp|dp uses all dp output columns. A d|d frame generally defines a different projector. This weighted construction is a distinct screening model from binary energy-window exclusion, even when its windows are numerically identical. Collinear magnetic and full SOC states are supported within the existing even-frequency response scope. Explicit q-star symmetry can be used when the chosen weighted target preserves that group, as described below. By default QSGW rebuilds atomic-trial frames from current C when cRPA is requested. B retains its supplied window/list rule.
For iteration with an explicitly reviewed, sufficiently wide candidate B, enable
crpa_track_orbitals = true
crpa_tracking_min_capture = 0.99
The first frame uses the declared atomic trials. Subsequent frames transport the
complete previous parent, including ligand columns, through the current KS B:
X = C_B C_B^dagger S Phi_previous, followed by metric polar normalization.
The orbital dimension and labels stay fixed while KS band character may reorder.
Every previous parent direction must retain at least the stated probability,
measured by the smallest eigenvalue of X^dagger S X. Original Gram/metric
rank and condition gates remain in force. A loss requires a wider reviewed B;
the code does not silently change B, remove orbitals or lower rank thresholds.
Full rank alone does not establish a stable model: compare frames and U under
candidate-window enlargement.
QSGW performs this inexpensive model-only transport after every eigenstate update,
independently of crpa_interval; no response, W or self-energy is computed by
transport. The C API librpa_prepare_crpa_model and the C++ handler expose the
same operation. Response probabilities always use the actual current C and Phi.
Tracking writes crpa_tracking.dat with each output state and a .crpa companion
to the QSGW checkpoint. Keep that companion for continuation: the model definition,
parent dimensions, iteration and complete checkpoint eigenvalues are checked.
Restarting a tracked trajectory without its parent record is rejected.
Species labels follow the numeric species order in the structure input.
crpa_overlap_file is a native S(R) CSR file, relative to input_dir.
Spatial exports and interleaved SOC exports are accepted; SOC exports must
have identical diagonal spin blocks and zero off-diagonal blocks.
Scalar or two-component spinor wavefunctions, the full k/q mesh and LIBRI routing are required. A
compressed auxiliary basis additionally requires use_shrink_abfs = true,
use_shrink_chi = true and the corresponding native transformation inputs.
Outputs under output_dir are:
crpa_tensors.dat: complete ordered onsite v/U/W tensors for every output spin pair and positive imaginary frequency, in eV.crpa_summary.dat: intraorbital, distinct-orbital direct and exchange averages, with explicit atom/spin indices. Exchange averages are not Slater J.crpa_windows.dat: actual selected KS indices for binary A and for B; weighted mode has no binary A list.crpa_response_weights.dat: the actual endpoint probability for every spin/k/band in either response mode.crpa_orbitals.dat: atom, local column and atomic-trial label.crpa_metadata.txt: orbital conventions, input selections and units.
The response calculation has no direct zero-frequency node. By default the driver additionally estimates U(0) using the internal continuation API described below. The first minimax node must not be identified with U(0).
Native model output and continuation#
crpa_output_model = true and crpa_output_static = true are defaults. Each
calculated electronic state writes crpa_model.npz, a standard uncompressed
NumPy/ZIP64 archive, alongside the existing text tensors. Geometry, k points,
weights, AO conventions and shell layout are stored once in
output_dir/crpa_static.npz; the state archive contains its relative path.
Move that file together with the state directories when copying the model.
Set crpa_output_format = dat to write the same model as readable text instead
of NumPy archives. This option changes driver output only; the response and
orbital-selection rules are unchanged. crpa_model_info.dat records dimensions,
units, spin frames and state identity; crpa_structure.dat and
crpa_kpoints.dat retain geometry and sampling. crpa_bands.dat contains
energies, physical occupations and the actual A endpoint probabilities;
crpa_projectors.dat contains parent/output P; crpa_model_k.dat contains
H(k) and density. parent=1 identifies the joint construction frame and
parent=0 the actual output frame. The orbital/site mapping is in
crpa_model_orbitals.dat. Energies and interactions in DAT output use eV,
lengths use Bohr, and all indices are zero based.
The existing crpa_tensors.dat retains every imaginary-node tensor entry;
crpa_continued_tensors.dat additionally retains every requested static/real
entry with its numerical status and subset spread. The metadata and orbital
analysis notes use .dat extensions in this mode. Optional raw export writes
crpa_coefficients.dat, crpa_overlap.dat and crpa_local_orbitals.dat.
QSGW uses the same files inside each crpa/state_NNNN directory.
The state archive contains physical occupations, absolute-Hartree Bloch
energies, the parent/output projectors P, projected H(k) and density matrices,
weighted onsite H and density blocks, the actual A/B band selections and A_weights (empty A lists in weighted mode), orbital
labels, site offsets, and the full ordered v/U tensors on original positive
imaginary nodes. Standalone results also contain the full-RPA local W tensors.
QSGW metadata identifies the entering or final electronic state. These are the
static state’s eigenvalues, distinct from diagonal QP roots in qsgw_qp.csv.
The numerical library constructs P = Phi-dagger S C and H = P diag(E)
P-dagger once using the actual frame that formed the U vertices. No additional
KS eigenproblem is solved. crpa_local_model.dat reports onsite H in eV and
physical density matrices, without subtracting a DMFT double-counting term.
Use Bloch E and P for projection-based DMFT: replacing the Bloch Hamiltonian
by a smaller projected H can discard its coupling to omitted bands.
The compact default does not retain or write full C/S/Phi. Set
crpa_output_raw = true to include them for rebuilding orbital projectors.
The corresponding C API input is retain_raw_model = LIBRPA_SWITCH_ON;
otherwise raw model-view pointers are null. This avoids duplicating every
wavefunction and metric on each MPI rank just to write the compact model.
Retaining C/S alone does not permit an arbitrary new U projection: that also
requires the matching constrained kernel and RI data. A full auxiliary-space
Wr/RI cache is not included in this archive.
Static extraction uses the selected anacon_method (default Padé) on Delta U = U-v with source
arguments z=inu, evaluates at z=0, then restores v. It uses the original imaginary-frequency grid
and no electronic Fermi/Hedin shift. This is an extrapolation, not a direct
static response calculation. crpa_continuation_summary.dat and the archive
retain per-entry status, subset spread and source/holdout residuals. The
default absolute diagnostic tolerance is crpa_fit_tol_ev = 0.01 eV.
Nonfinite or unstable estimates are flagged; they do not replace the original
U(inu). Numerical fit checks do not certify passivity, causality or material
convergence. Set crpa_output_static = false to omit the static estimate.
Real-axis continuation uses the same internal function and is requested by an explicit frequency list, for example:
crpa_real_frequencies_ev = 0 1 3
crpa_eta_ev = 0.05
The real frequencies are bosonic energies measured from zero. Evaluation is
at omega+i*eta; no real-axis grid is produced when the list is empty. The
archive’s continued_z gives the actual complex queries in Hartree and
continued_U_*, continued_status_*, continued_spread_* contain all entries.
When static output is enabled the first query is exactly zero; subsequent
queries correspond to the requested real frequencies.
Library callers use librpa_crpa_model_info, librpa_crpa_model_k,
librpa_crpa_model_local and librpa_crpa_model_hopping to retrieve the owned
state and one-body model. librpa_crpa_project_orbitals and
librpa_crpa_project_one_body also operate on explicit numerical arrays.
librpa_crpa_rotate_projector and librpa_crpa_rotate_tensor apply matched
isometries to a fixed local model. Changing the excluded response requires
new screening. librpa_crpa_tensor_to_fermion converts density U_ab,cd to
V_ijkl=U_ik,jl for a (1/2) c_i-dagger c_j-dagger c_l c_k Hamiltonian; it does
not impose a Kanamori or Slater approximation. librpa_crpa_tensor_averages
returns the complex ordered-column means U_mm,mm, U_mm,nn and U_mn,nm;
the two off-diagonal means are zero for a one-orbital frame. The continuation API
librpa_continue_crpa returns an owned result for arbitrary upper-half-plane
queries, including zero. These numerical operations are noncollective.
For an iterative library calculation, create and prepare a public QSGW task
before supplying the full-grid cRPA overlap. Initialize
LibrpaQsgwCrpaControls with librpa_init_qsgw_crpa_controls, then attach it
with librpa_set_qsgw_crpa; the task supplies its owning numerical state internally.
The task copies the numerical input and controls. Core cRPA code evaluates
the resident entering-state response, transports the parent after every
completed update, restores its checkpoint companion, and builds the final
response-only state. Its output sink runs on every rank and receives borrowed
cRPA and optional orbital-analysis views. The sink may query these views and
write output, but must not delete them or recursively invoke the handler/task.
Keep the sink’s user data alive until the task returns. Ordinary input reading
and DAT/NPZ output remain in the driver.
utilities/export_crpa_dmft.py performs only unit/layout conversion into a
TRIQS HDFArchive (requires TRIQS’s Python h5 module):
python3 utilities/export_crpa_dmft.py output/crpa/state_0000/crpa_model.npz nio.h5
It preserves all output sites as separate impurity shells and both AFM spin
blocks, writes the band-basis Hamiltonian and complex projectors, and retains
full native interaction tensors with their conventions. The interaction group
also stores the original positive imaginary-frequency nodes as nu, converted
to eV with the same factor as U; frequency_unit is eV. It does not choose
a double-counting functional, impose AFM equivalence, or initialize an impurity
solver. Mixed-angular-momentum sp sites require a custom DMFT shell definition.
For SOC, set use_spinor_wfc = true. Each spatial trial is lifted to both
spin components, projected into the original full-spinor B states, and jointly
normalized in the metric I_spinor tensor S. A p site therefore has six columns,
a d site ten, and an sp site eight. Within each site, up trials precede down
trials; these labels identify the trial orientation and are not conserved spin
quantum numbers. The response has one channel of occupied spinor states with
occupation at most one, without an additional factor of two. It retains all
four Green-function spin-block products.
SOC emits one complete spinor four-index tensor per site/frequency. Its
spin_left = spin_right = 0 denotes that one channel; spinor information is
carried by a,b,c,d. The density vertex sums same-component products before
screening. The complete-spinor summary exchange average includes opposite
trial-spin columns and is not a scalar-shell Hund parameter. Inspect resolved
entries using the emitted orbital labels. Keep entire degenerate groups when
choosing A or B.
For a gapped three-dimensional input, replace_w_head = true with
option_dielect_func = 3 uses analytic head and wings from the current
one-particle eigenpairs and their velocity matrices. The driver preset
option_dielect_func = 6 selects the same full head/wing calculation and
computes velocity from native H(R), S(R) and r(R), using the existing
g0w0_fn_hr, g0w0_fn_sr, g0w0_fn_rr and unit parameters. With option 3,
select either that native source or the existing velocity_matrix file. Full
screening uses every physical transition; constrained screening omits a pair
only when both original endpoints belong to A. The RI optical charge vertex
sums equal spinor components. Only the angular Gamma-cell weights are
normalized; the regular dielectric body is unchanged. Optical sums retain all
original full-BZ KS states and velocities even when q-star screening is enabled.
Distributed KS inputs and the two-dimensional optical route remain excluded.
With replace_w_head = false and option_dielect_func = 0, an uncorrected
periodic result remains a finite-mesh diagnostic until the Gamma contribution
is bounded. Using a full-response optical head unchanged for nonzero Pd would
screen with the wrong response. Small-case optical tests do not establish
material mesh or basis convergence.
Library callers use LibrpaCrpaInput and its initializer from librpa_input.h,
and the QSGW companion controls and initializer from librpa_options.h.
Numerical result views, accessors, continuation and task attachment are declared
in librpa_compute.h; librpa_handler.h declares the indexed result handles.
Supply S(k) and the window/species data, call librpa_compute_crpa_window collectively,
then inspect the owned result and release it with librpa_delete_crpa_result.
The standalone computation accepts numerical data and returns an owned snapshot.
The separate tracking-checkpoint function writes library state; the iterative
companion restores and saves its checkpoint at the QSGW completed-state boundary.
The orbital-analysis functions in librpa_compute.h compute an owned
result through librpa_analyze_orbitals, expose spatial AO/group weights and
state metadata including the number of spinor components, and evaluate
Gaussian PDOS in Hartree units. C++ callers can use Handler::analyze_orbitals,
which returns an owning result. Neither path modifies the handler, KS states,
response masks or local output frames. Orbital analysis uses the original full
k-grid states even when cRPA screening applies q-star symmetry reduction.
Every participating rank must supply identical numerical options, species, selections and S(k) arrays. Input buffers remain owned by the caller and must stay valid until the collective call returns. Each rank receives its own result and releases it locally. Accessor arrays and strings remain valid until that owned result is deleted. QSGW output callbacks instead receive borrowed result handles and views that must not be deleted or retained after the callback returns. The driver supplies this replicated input by reading the same native source on every rank. KS orthogonality and frame checks validate the supplied data; they do not reorthogonalize or repair the KS eigenvectors.
The scalar nspin=1 response retains the native spin-degeneracy convention. For nspin=2, screening includes both physical spin channels, while output vertices use their respective spin-resolved local frames. The reported left and right spin indices identify those frames, not two independently screened U’s. Finite-temperature or metallic static-limit accuracy requires separate response and convergence controls; selecting positive minimax nodes alone does not establish it.
With use_symmetry_rpa = true, the first symmetry route retains full original
k-grid Green functions and reduces only response q sampling and dense screening.
Every screened kernel is restored through the supplied unitary/antiunitary
operation table before contraction with the full-grid local spinor vertices.
The bare term also uses all original q points. Multiplying one representative
orbital tensor by star multiplicity would not preserve its individual components.
The actual diagonal endpoint-weight operator must transform covariantly with
E/C/f. The implementation obtains the band sewing matrix from the supplied
complete KS frames and checks E_t M = M E_s, f_t M = M f_s and p_t M = M p_s,
including operations in each little group. Complex phases, band permutations
and degenerate mixing that preserves p are allowed; weights are not averaged
or replaced by a binary envelope. Violations fail collectively. In particular,
arbitrary mixing of degenerate states with unequal p is incompatible with this
diagonal-weight approximation and cannot use q reduction.
The driver accepts an explicit spin_symmetry structure tail; library callers
use librpa_set_symmetry_spin_operations. SOC symmetry rejects a legacy spatial-only
declaration. A grey-group declaration appends time reversal only when the supplied
state has that symmetry. Current-HR QSGW can expand paired IBZ source E/C/f and
Vxc into its internal full-grid frame before coupled cRPA; standalone library
cRPA continues to require complete replicated KS frames. Auxiliary compression
maps use separate full/compressed shell actions, with conjugation on antiunitary
routes, and existing full-q maps are checked rather than averaged. Bare and
screened kernels are restored before contraction. This does not extend the
native even-frequency response to arbitrary magnetic odd-frequency components.
Compose or reuse numerical stages#
The internal C++ stage declarations are in src/core/crpa_workflow.h, with
their implementations together in src/core/crpa_workflow.cpp. The public
standalone API prepares the model through these stages, and compute_crpa_onsite
is the composition that retains the existing complete v/U/W calculation.
The driver continues to own native-file reading and output writing.
Stage |
Result |
|---|---|
|
Owning B, binary A or fractional weights, and scalar/spinor local frames |
|
RI density vertices and retained bare interaction |
|
Owning P0 on the current state and actual grid |
|
Owning Pd with both endpoint probabilities |
|
Owning Pr = P0 - Pd |
|
Native correlation-only Wc from an owning response |
|
Local bare + Wc tensors, without changing Wc |
For a caller that already holds P0, the combination
evaluate_crpa_onsite_from_response(context, selection, frames, p0) computes
only bare and U. It builds Pd and screens Pr; it does not build P0 or screen
the full response. Its returned CrpaResult has empty W vectors. The caller
can use the projection/contraction stages separately for an already computed
full Wc when a local fully screened comparison is wanted.
The borrowed P0, resident Chi0 response map and incoming band selector are
preserved, including when P0 aliases context.chi0.get_chi0_q(). Response
stages return owning maps; screening consumes its map by value/move. Temporary
Green-function workspaces may rebuild. The numerical stages do not update
the mean field or reinitialize the Dataset, frequency grid or descriptors.
Reuse requires the same current E/C/f, native frequency nodes, response q view,
active auxiliary space, MPI atom-pair layout and Coulomb/optical conventions.
Call before the GW backend releases its P0. The public collective
librpa_build_g0w0_sigma_crpa combines the ordinary GW build with U-only
constrained screening immediately after its P0 is available. The corresponding
C++ method is Handler::build_g0w0_sigma_crpa. It returns an owned cRPA result
while retaining the usual GW EXX and self-energy objects. The public
librpa_compute_crpa_u_window / Handler::compute_crpa_u_window builds a
current-state P0 and U without an additional full-W or self-energy calculation.
The standalone librpa_compute_crpa_window / Handler::compute_crpa_window
returns complete v/U/W. The C++ wrapper owns the result through CrpaResult
and releases it automatically; accessor views borrow that result’s storage.
Compute U during G0W0 or QSGW#
For a single G0W0 calculation, enable the shared cRPA workflow with:
task = g0w0
option_dielect_func = 6
crpa_enabled = true
crpa_model_file = crpa-model.in
The calculation reuses G0W0’s P0 and the original PBE eigenpairs for U, while
retaining the usual GW screened interaction and quasiparticle calculation.
It writes the cRPA tensors, orbital weights and PDOS to
output_dir/crpa/state_0000. The metadata records the unchanged reference
state (state_index = 0, gw_update = 0) as final. The interval option
applies to QSGW iteration; G0W0 evaluates U once.
Add the following to a working QSGW input using the native full head/wing preset:
task = qsgw
option_dielect_func = 6
crpa_enabled = true
crpa_model_file = crpa-model.in
The model file contains only the cRPA choices already used by a standalone
calculation: species labels, correlated/ligand species, overlap, parent/output
orbitals and the A/B selectors. An existing standalone cRPA input can itself
be the model file. Its shared GW settings are not imported. The model-file
path is relative to the main input file; native data paths are relative to the
main input_dir. Main-input cRPA assignments override the imported model;
selecting bands replaces an inherited energy-window selection and conversely.
Do not explicitly specify both selector forms for the same A or B.
crpa_interval = 1 evaluates every entering electronic state. To sample every
second state, set crpa_interval = 2. The final state is always evaluated,
including when it does not fall on the interval. Ordinary QSGW supplies its
current E, C and occupations; each selected calculation rebuilds the model
frame and Pd from that state. The overlap, atomic trial definition and input
selection rule remain fixed. An energy-window rule may select different bands
as energies move; explicit band indices retain the stated indices.
Outputs are written below output_dir/crpa/state_0000, state_0001, etc.
State 0 is the initial reference; update 1 produces state 1. Metadata records
the electronic state, GW update and whether this is the final state. A selected
entering state borrows the GW P0 before full screening. After the last QSGW
update, a response-only call evaluates the final U with the final eigenpairs
and current-HR velocity. That call does not perform another self-energy update.
A checkpoint restart keeps the saved state index and the same interval rule.
These outputs contain bare and partially screened tensors and their direct/
exchange summaries. The U-only route omits W columns. Orbital weights and PDOS
are enabled by the existing crpa_output_analysis default and use the same
current eigenvectors; no extra physical KS solve is required.
The coupled path currently requires replicated full-BZ states, native minimax
frequencies and the LibRI response path. Explicit magnetic q reduction is
supported for compatible live states and targets. The QSGW task can expand
paired IBZ inputs internally; the direct coupled API requires full-grid KS
frames. G0W0 with crpa_enabled = true also requires complete replicated KS
inputs; its IBZ-only head/wing reconstruction does not expand the cRPA KS frame.
It rejects read_sigc_mat_rf, which bypasses P0. Use full head/wing option 3 (or driver
preset 6) for a corrected three-dimensional calculation. Head-only option 4
does not provide the constrained optical wings required by this implementation.
Driver preset 6 is normalized to option 3 before the library call.
The cRPA kernel uses the dataset’s full Coulomb interaction for its own bare term and constrained screening. GW retains its separately selected full/cut Coulomb treatment. P0 reuse requires the same response, not an identical final screened interaction. cRPA normalizes the angular Gamma-cell weights in its onsite kernel; the GW optical convention remains the one selected by the ordinary GW calculation. Consequently a cRPA fully screened local comparison and GW W should be compared only with explicitly matched optical conventions.
Method selection is shared with GW/QSGW; see analytic continuation.
The original C API librpa_continue_crpa now uses default Pade settings with
its requested coefficient count. Use librpa_continue_crpa_with_options for
explicit Padé/AAA/ridge selection and penalties. C++ has the corresponding
continue_crpa overload taking Options. The bosonic variable remains z=i*nu,
without a fermionic energy shift or change to the original response tensors.