**BandStructureComputeProjections**
*Section*: Output
*Type*: logical
*Default*: false

Determines if projections of wavefunctions on the atomic orbitals
are computed or not for obtaining the orbital resolved band-structure.

**CurrentThroughPlane**
*Section*: Output
*Type*: block

The code can calculate current
traversing a user-defined portion of a plane, as specified by this block.
A small plain-text file `current-flow` will be written containing this information.
Only available for 1D, 2D, or 3D.
In the format below, `origin` is a point in the plane.
`u` and `v` are the (dimensionless) vectors defining the plane;
they will be normalized. `spacing` is the fineness of the mesh
on the plane. Integers `nu` and `mu` are the length and
width of the portion of the plane, in units of `spacing`.
Thus, the grid points included in the plane are
`x_ij = origin + i*spacing*u + j*spacing*v`,
for `nu <= i <= mu` and `nv <= j <= mv`.
Analogously, in the 2D case, the current flow is calculated through a line;
in the 1D case, the current flow is calculated through a point. Note that the spacing
can differ from the one used in the main calculation; an interpolation will be performed.

Example (3D):

`%CurrentThroughPlane
0.0 | 0.0 | 0.0 # origin
0.0 | 1.0 | 0.0 # u
0.0 | 0.0 | 1.0 # v
0.2 # spacing
0 | 50 # nu | mu
-50 | 50 # nv | mv
%`

Example (2D):

0.0 | 0.0 # origin

1.0 | 0.0 # u

0.2 # spacing

0 | 50 # nu | mu

%

Example (1D):

0.0 # origin

%

**DOSComputePDOS**
*Section*: Output
*Type*: logical
*Default*: false

Determines if projected dos are computed or not.

**DOSEnergyMax**
*Section*: Output
*Type*: float

Upper bound for the energy mesh of the DOS.
The default is the highest eigenvalue, plus a quarter of the total range of eigenvalues.

**DOSEnergyMin**
*Section*: Output
*Type*: float

Lower bound for the energy mesh of the DOS.
The default is the lowest eigenvalue, minus a quarter of the total range of eigenvalues.

**DOSEnergyPoints**
*Section*: Output
*Type*: integer
*Default*: 500

Determines how many energy points `Octopus` should use for
the DOS energy grid.

**DOSGamma**
*Section*: Output
*Type*: float
*Default*: 0.008 Ha

Determines the width of the Lorentzian which is used for the DOS sum.

**ELFWithCurrentTerm**
*Section*: Output
*Type*: logical
*Default*: true

The ELF, when calculated for complex wavefunctions, should contain
a term dependent on the current. This term is properly calculated by
default; however, for research purposes it may be useful not to add it.
If this feature proves to be useless, this option should go away.

**LocalMagneticMomentsSphereRadius**
*Section*: Output
*Type*: float

The local magnetic moments are calculated by integrating the
magnetization density in spheres centered around each atom.
This variable controls the radius of the spheres.
The default is half the minimum distance between two atoms
in the input coordinates, or 100 a.u. if there is only one atom (for isolated systems).

**MomentumTransfer**
*Section*: Output
*Type*: block

Momentum-transfer vector \(\vec{q}\) to be used when calculating matrix elements
\(\left< f \left| e^{i \vec{q} \cdot \vec{r}} \right| i \right>\).
This enables the calculation of the dynamical structure factor,
which is closely related to generalized oscillator strengths.
If the vector is not given, but TPA output is requested (`Output = TPA`),
only the oscillator strengths are written in the output file.
For example, to use \(\vec{q}\) = (0.1, 0.2, 0.3), set

`%MomentumTransfer
0.1 | 0.2 | 0.3
%`

**Output**
*Section*: Output
*Type*: flag
*Default*: none

Specifies what to print. The output files are written at the end of the run into the output directory for the
relevant kind of run (*e.g.* `static` for `CalculationMode = gs`).
Time-dependent simulations print only per iteration, including always the last. The frequency of output per iteration
(available for `CalculationMode` = `gs`, `unocc`, `td`, and `opt_control`)
is set by `OutputInterval` and the directory is set by `OutputIterDir`.
For linear-response run modes, the derivatives of many quantities can be printed, as listed in
the options below. Indices in the filename are labelled as follows:
`sp` = spin (or spinor component), `k` = *k*-point, `st` = state/band.
There is no tag for directions, given as a letter. The perturbation direction is always
the last direction for linear-response quantities, and a following +/- indicates the sign of the frequency.
Example: `density + potential`
*Options*:

**potential**: Outputs Kohn-Sham potential, separated by parts. File names are`v0`for the local part of the ionic potential,`vc`for the classical potential (if it exists),`vh`for the Hartree potential,`vks`for the local part of the Kohn-Sham potential, and`vxc-`for the exchange-correlation potentials. For`vks`and`vxc`, a suffix for spin is added in the spin-polarized case.**density**: Outputs density. The output file is called`density-`, or`lr_density-`in linear response.**el_pressure**: Outputs electronic pressure. See Tao, Vignale, and Tokatly,*Phys Rev Lett***100**, 206405 (2008).**matrix_elements**: Outputs a series of matrix elements of the Kohn-Sham states. What is output can be controlled by the`OutputMatrixElements`variable.**pol_density**: Outputs dipole-moment density`dipole_density-`, or polarizability density`alpha_density-`in linear response. If`ResponseMethod = finite_differences`, the hyperpolarizability density`beta_density-`is also printed.**mesh_r**: Outputs values of the coordinates over the grid. Files will be called`mesh_r-`followed by the direction.**kinetic_energy_density**: Outputs kinetic-energy density, defined as:

\(\tau_\sigma(\vec{r}) = \sum_{i=1}^{N_\sigma} \left| \vec{\nabla} \phi_{i\sigma}(\vec{r}) \right|^2\,. \)

The index \(\sigma\) is the spin index for the spin-polarized case, or if you are using spinors. For spin-unpolarized calculations, you get the total kinetic-energy density. The previous expression assumes full or null occupations. If fractional occupation numbers, each term in the sum is weighted by the occupation. Also, if we are working with an infinite system, all*k*-points are summed up, with their corresponding weights. The files will be called`tau-sp1`and`tau-sp2`, if the spin-resolved kinetic energy density is produced (runs in spin-polarized and spinors mode), or only`tau`if the run is in spin-unpolarized mode.**dos**: Outputs density of states. See`DOSEnergyMax`,`DOSEnergyMin`,`DOSEnergyPoints`, and`DOSGamma`.**tpa**: Outputs transition-potential approximation (TPA) matrix elements, using \(\vec{q}\)-vector specified by`MomentumTransfer`.**forces**: Outputs file`forces.xsf`containing structure and forces on the atoms as a vector associated with each atom, which can be visualized with XCrySDen.**wfs_fourier**: (Experimental) Outputs wavefunctions in Fourier space. This is only implemented for the ETSF file format output. The file will be called`wfs-pw-etsf.nc`.**wfs**: Outputs wavefunctions. Which wavefunctions are to be printed is specified by the variable`OutputWfsNumber`-- see below. The output file is called`wf-`, or`lr_wf-`in linear response.**xc_density**: Outputs the XC density, which is the charge density that generates the XC potential. (This is \(-1/4\pi\) times the Laplacian of the XC potential). The files are called`nxc`.**PES_wfs**: Outputs the photoelectron wavefunctions. The file name is`pes_wfs-`plus the orbital number.**PES_density**: Outputs the photolectron density. Output file is`pes_dens-`plus spin species if spin-polarized calculation is performed.**PES**: Outputs the time-dependent photoelectron spectrum.**BerkeleyGW**: Output for a run with BerkeleyGW. See`Output::BerkeleyGW`for further specification.**delta_perturbation**: Outputs the "kick", or time-delta perturbation applied to compute optical response in real time.**external_td_potential**: Outputs the (scalar) time-dependent potential.**mmb_wfs**: Triggers the ModelMB wavefunctions to be output for each state.**mmb_den**: Triggers the ModelMB density matrix to be output for each state, and the particles specified by the`DensitytoCalc`block. Calculates, and outputs, the reduced density matrix. For the moment the trace is made over the second dimension, and the code is limited to 2D. The idea is to model*N*particles in 1D as an*N*-dimensional non-interacting problem, then to trace out*N*-1 coordinates.**wfs_sqmod**: Outputs modulus squared of the wavefunctions. The output file is called`sqm-wf-`. For linear response, the filename is`sqm_lr_wf-`.**potential_gradient**: Prints the gradient of the potential.**energy_density**: Outputs the total energy density to a file called`energy_density`.**heat_current**: Outputs the total heat current density. The output file is called`heat_current-`.**geometry**: Outputs file containing the coordinates of the atoms treated within quantum mechanics. If`OutputFormat = xyz`, the file is called`geometry.xyz`; a file`crystal.xyz`is written with a supercell geometry if the system is periodic; if point charges were defined in the PDB file (see`PDBCoordinates`), they will be output in the file`geometry_classical.xyz`. If`OutputFormat = xcrysden`, a file called`geometry.xsf`is written.**current**: Outputs the total current density. The output file is called`current-`. For linear response, the filename is`lr_current-`.**ELF**: Outputs electron localization function (ELF). The output file is called`elf-`, or`lr_elf-`in linear response, in which case the associated function D is also written, as`lr_elf_D-`. Only in 2D and 3D.**ELF_basins**: Outputs basins of attraction of the ELF. The output file is called`elf_rs_basins.info`. Only in 2D and 3D.**Bader**: Outputs Laplacian of the density which shows lone pairs, bonded charge concentrations and regions subject to electrophilic or nucleophilic attack. See RF Bader,*Atoms in Molecules: A Quantum Theory*(Oxford Univ. Press, Oxford, 1990).

**OutputDuringSCF**
*Section*: Output
*Type*: logical
*Default*: no

During `gs` and `unocc` runs, if this variable is set to yes,
output will be written after every `OutputInterval` iterations.

**OutputFormat**
*Section*: Output
*Type*: flag
*Default*: 0

Describes the format of the output files (see `Output`).
Example: `axis_x + plane_x + dx`
*Options*:

**axis_x**: The values of the function on the*x*axis are printed. The string`.y=0,z=0`is appended to previous file names.**axis_y**: The values of the function on the*y*axis are printed. The string`.x=0,z=0`is appended to previous file names.**matlab**: In combination with`plane_x`,`plane_y`and`plane_z`, this option produces output files which are suitable for 2D Matlab functions like`mesh()`,`surf()`, or`waterfall()`. To load these files into Matlab you can use,*e.g.*`>> density = load('static/density-1.x=0.matlab.abs'); >> mesh(density);`**meshgrid**: Outputs in Matlab mode the internal mesh in a format similar to`>> [x,y] = meshgrid(-2:.2:2,-1:.15:1)`The*x*meshgrid is contained in a file`*.meshgrid.x`and the*y*-grid can be found in`*.meshgrid.y`.**boundary_points**: This option includes the output of the mesh enlargement. Default is without. Supported only by`binary`,`axis`,`plane`,`mesh_index`, and`matlab`formats. Not all types of`Output`will have this information available. Not supported when parallel in domains.**binary**: Plain binary, new format.**etsf**: ETSF file format. Requires the ETSF_IO library. Applies only to`Output = density`,`geometry`,`wfs`, and/or`wfs_fourier`.**xyz**: Geometry will be output in XYZ format. Does not affect other outputs.**cube**: Generates output in the cube file format. Available only in 3D. Only writes the real part of complex functions.**bild**: Generates output in BILD format.**axis_z**: The values of the function on the*z*axis are printed. The string`.x=0,y=0`is appended to previous file names.**vtk**: Generates output in VTK legacy format.**integrate_xy**: Integrates the function in the x-y plane and the result on the*z*axis is printed.**integrate_xz**: Integrates the function in the x-z plane and the result on the*y*axis is printed**integrate_yz**: Integrates the function in the y-z plane and the result on the*x*axis is printed**plane_x**: A plane slice at*x*= 0 is printed. The string`.x=0`is appended to previous file names.**plane_y**: A plane slice at*y*= 0 is printed. The string`.y=0`is appended to previous file names.**plane_z**: A plane slice at*z*= 0 is printed. The string`.z=0`is appended to previous file names.**dx**: For printing three-dimensional information, the open-source program visualization tool OpenDX can be used. The string`.dx`is appended to previous file names. Available only in 3D.**netcdf**: Outputs in NetCDF format. This file can then be read, for example, by OpenDX. The string`.ncdf`is appended to previous file names. Requires the NetCDF library. Only writes the real part of complex functions.**mesh_index**: Generates output files of a given quantity (density, wavefunctions, ...) which include the internal numbering of mesh points. Since this mode produces large datafiles this is only useful for small meshes and debugging purposes. The output can also be used to display the mesh directly. A Gnuplot script for mesh visualization can be found under`PREFIX/share/octopus/util/display_mesh_index.gp`.**xcrysden**: A format for printing structures and three-dimensional information, which can be visualized by the free open-source program XCrySDen and others. The string`.xsf`is appended to previous file names. Note that lattice vectors and coordinates are as specified by`UnitsOutput`. Available in 2D and 3D.

**OutputInterval**
*Section*: Output
*Type*: integer
*Default*: 50

The output requested by variable `Output` is written
to the directory `OutputIterDir`
when the iteration number is a multiple of the `OutputInterval` variable.
Subdirectories are named Y.X, where Y is `td`, `scf`, or `unocc`, and
X is the iteration number. To use the working directory, specify `"."`
(Output of restart files is instead controlled by `RestartWriteInterval`.)
Must be >= 0. If it is 0, then no output is written. For `gs` and `unocc`
calculations, `OutputDuringSCF` must be set too for this output to be produced.

**OutputIterDir**
*Section*: Output
*Type*: string
*Default*: "output_iter"

The name of the directory where `Octopus` stores information
such as the density, forces, etc. requested by variable `Output`
in the format specified by `OutputFormat`.
This information is written while iterating `CalculationMode = gs`, `unocc`, or `td`,
according to `OutputInterval`, and has nothing to do with the restart information.

**OutputLDA_U**
*Section*: Output
*Type*: flag
*Default*: none

Specifies what to print, related to LDA+U.
The output files are written at the end of the run into the output directory for the
relevant kind of run (*e.g.* `static` for `CalculationMode = gs`).
Time-dependent simulations print only per iteration, including always the last. The frequency of output per iteration
(available for `CalculationMode` = `gs`, `unocc`, `td`, and `opt_control`)
is set by `OutputInterval` and the directory is set by `OutputIterDir/effectiveU`.
For linear-response run modes, the derivatives of many quantities can be printed, as listed in
the options below. Indices in the filename are labelled as follows:
`sp` = spin (or spinor component), `k` = *k*-point, `st` = state/band.
There is no tag for directions, given as a letter. The perturbation direction is always
the last direction for linear-response quantities, and a following +/- indicates the sign of the frequency.
Example: `occ_matrices + effectiveU`
*Options*:

**occ_matrices**: Outputs the occupation matrices of LDA+U**effectiveU**: Outputs the value of the effectiveU for each atoms**magnetization**: Outputs file containing structure and magnetization of the localized subspace on the atoms as a vector associated with each atom, which can be visualized. For the moment, it only works if a +U is added on one type of orbital per atom.**local_orbitals**: Outputs the localized orbitals that form the correlated subspace**kanamoriU**: Outputs the Kanamori interaction parameters U, U`, and J. These parameters are not determined self-consistently, but are taken from the occupation matrices and Coulomb integrals comming from a standard +U calculation.

**OutputMEMultipoles**
*Section*: Output
*Type*: integer
*Default*: 1

This variable decides which multipole moments are printed out for
`OutputMatrixElements = ks_multipoles`:

In 3D, if, for example, `OutputMEMultipoles = 1`, then the program will print three
files, `ks_me_multipoles.x` (`x`=1,2,3), containing
respectively the (1,-1), (1,0) and (1,1) multipole matrix elements
between Kohn-Sham states.

In 2D, this variable is ignored: it will always print two files,
`ks_me_multipoles.i` (`i`=1,2), containing the \(x\) and
\(y\) dipole matrix elements.

In 1D, if, for example, `OutputMEMultipoles = 2`, the program will print two files, containing the
\(x\) and \(x^2\) matrix elements between Kohn-Sham states.

**OutputMatrixElements**
*Section*: Output
*Type*: flag
*Default*: none

Specifies what matrix elements to print.
Enabled only if `Output` includes `matrix_elements`.
The output files go into the `static` directory, except when
running a time-dependent simulation, when the directory `td.XXXXXXX` is used.
Example: "momentum + ks_multipoles"
*Options*:

**ks_multipoles**: See`OutputMEMultipoles`. Not available with states parallelization.**momentum**: Momentum. Filename:`ks_me_momentum`.**ang_momentum**: Dimensionless angular momentum \(\vec{r} \times \vec{k}\). Filename:`ks_me_angular_momentum`.**one_body**: \(\left< i \left| \hat{T} + V_{ext} \right| j \right>\). Not available with states parallelization.**two_body**: \(\left< ij \left| \frac{1}{\left|\vec{r}_1-\vec{r}_2\right|} \right| kl \right>\). Not available with states parallelization.

**OutputWfsNumber**
*Section*: Output
*Type*: string
*Default*: all states

Which wavefunctions to print, in list form: *i.e.*, "1-5" to print the first
five states, "2,3" to print the second and the third state, etc.
If more states are specified than available, extra ones will be ignored.

**Output_KPT**
*Section*: Output
*Type*: flag
*Default*: none

Specifies what to print. The output files are written at the end of the run into the output directory for the
relevant kind of run (*e.g.* `static` for `CalculationMode = gs`).
Time-dependent simulations print only per iteration, including always the last. The frequency of output per iteration
(available for `CalculationMode` = `gs`, `unocc`, `td`, and `opt_control`)
is set by `OutputInterval` and the directory is set by `OutputIterDir`.
For linear-response run modes, the derivatives of many quantities can be printed, as listed in
the options below. Indices in the filename are labelled as follows:
`sp` = spin (or spinor component), `k` = *k*-point, `st` = state/band.
There is no tag for directions, given as a letter. The perturbation direction is always
the last direction for linear-response quantities, and a following +/- indicates the sign of the frequency.
Example: `current_kpt`
*Options*:

**current_kpt**: Outputs the current density resolved in momentum space. The output file is called`current_kpt-`.**density_kpt**: Outputs the electronic density resolved in momentum space.

**BerkeleyGW_CalcDipoleMtxels**
*Section*: Output::BerkeleyGW
*Type*: logical
*Default*: false

Whether to calculate dipole matrix elements, to be written in `vmtxel`.
This should be done when calculating `WFN_fi` for Bethe-Salpeter calculations
with light polarization in a finite direction. In that case, a shifted grid
`WFNq_fi` cannot be calculated, but we can instead use matrix elements of
\(r\) in a more exact scheme. In `absorption.inp`, set `read_vmtxel`
and `use_momentum`. Specify the number of conduction and valence bands you will
use in BSE here with `BerkeleyGW_VmtxelNumCondBands` and `BerkeleyGW_VmtxelNumValBands`.

**BerkeleyGW_CalcExchange**
*Section*: Output::BerkeleyGW
*Type*: logical
*Default*: false

Whether to calculate exchange matrix elements, to be written in `x.dat`.
These will be calculated anyway by BerkeleyGW `Sigma`, so this is useful
mainly for comparison and testing.

**BerkeleyGW_NumberBands**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: all states

Wavefunctions for bands up to this number will be output. Must be between <= number of states.
If < 1, no wavefunction file will be output.

**BerkeleyGW_VmtxelNumCondBands**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: 0

Number of conduction bands for which to calculate `vmtxel`, if you have set
`BerkeleyGW_CalcDipoleMtxels = yes`. This should be equal to the number to be
used in BSE.

**BerkeleyGW_VmtxelNumValBands**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: 0

Number of valence bands for which to calculate `vmtxel`, if you have set
`BerkeleyGW_CalcDipoleMtxels = yes`. This should be equal to the number to be
used in BSE.

**BerkeleyGW_VmtxelPolarization**
*Section*: Output::BerkeleyGW
*Type*: block
*Default*: (1, 0, 0)

Polarization, *i.e.* direction vector, for which to calculate `vmtxel`, if you have set
`BerkeleyGW_CalcDipoleMtxels = yes`. May not have any component in a periodic direction.
The vector will be normalized.

**BerkeleyGW_Vxc_diag_nmax**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: nst

Highest band for which to write diagonal exchange-correlation matrix elements. Must be between <= number of states.
If < 1, diagonals will be skipped.

**BerkeleyGW_Vxc_diag_nmin**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: 1

Lowest band for which to write diagonal exchange-correlation matrix elements. Must be <= number of states.
If < 1, diagonals will be skipped.

**BerkeleyGW_Vxc_offdiag_nmax**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: nst

Highest band for which to write off-diagonal exchange-correlation matrix elements. Must be <= number of states.
If < 1, off-diagonals will be skipped.

**BerkeleyGW_Vxc_offdiag_nmin**
*Section*: Output::BerkeleyGW
*Type*: integer
*Default*: 1

Lowest band for which to write off-diagonal exchange-correlation matrix elements. Must be <= number of states.
If < 1, off-diagonals will be skipped.

**BerkeleyGW_WFN_filename**
*Section*: Output::BerkeleyGW
*Type*: string
*Default*: WFN

Filename for the wavefunctions.