Device

Configuration for the simulated device.

construct_from_unit_cell#

construct_from_unit_cell: bool = False

Whether to construct a device from its unit cell geometry and electronic structure.

If this is set to True, the Hamiltonian read from the input file is assumed to be the tight-binding-like Hamiltonian of a single unit cell. The simulated device structure is then constructed by repeating the unit cell along the transport direction, as specified by num_transport_cells, and including the neighboring cells as configured by neighbor_cell_cutoff.

geometry#

geometry: GeometryConfig

The geometry configuration of the device.

This contains a defintion of all regions in the device, such as doping, material constants and gates.

neighbor_cell_cutoff#

neighbor_cell_cutoff: tuple[NonNegativeInt, NonNegativeInt, NonNegativeInt] | None = None

The number of neighbor cells to consider along each lattice direction.

If set to None, all neighbor cells present in the Hamiltonian input file are considered. A neighbor_cell_cutoff of zero means that only the unit cell itself is considered.

Along the transport direction, at least one neighboring cell must be included if construct_from_unit_cell is True. If construct_from_unit_cell is False, including neighboring cells in transport direction is not allowed, since the device should already be upscaled in that case.

If more neighbor cells are requested than present in the input Hamiltonian, a ValueError is raised.

num_transport_cells#

num_transport_cells: PositiveInt = 1

The number of transport cells to include in the simulation.

transport_direction#

transport_direction: Literal['x', 'y', 'z']

The direction along which the transport occurs.

block_size#

block_size: PositiveInt | list[PositiveInt] | None = None

The block size to use for the device Hamiltonian.

This block size is used in NEGF calculations, where it determines the block-tridiagonal tiling of all quantities.

If a single integer is given, a constant block size is assumed. Alternatively, a list of block sizes can be given to specify the size of each block along transport direction.

The block_size parameter cannot be used in conjunction with construct_from_unit_cell = True since the block sizes are determined from the unit cell and the neighbor_cell_cutoff in that case.

If construct_from_unit_cell = False in NEGF simulations, the block size must be given.

contacts#

contacts: list[ContactConfig]

The contacts of the device.

num_orbitals_per_atom#

num_orbitals_per_atom: dict[str, int] = {'X': 1}

The number of orbitals per atom type.

This mapping is used to connect the atomistic geometry with the corresponding operator matrix elements.

Currently, this is primarily used when configuring contacts via their real-space extents in QTBM calculations. It is also used to map a given potential vector to the corresponding orbitals in the Hamiltonian.

The keys can be any string, that matches the atom types in the structure file. The default is a single atom type "X" with one orbital per atom, which is useful when dealing with Wannier orbitals that are not atom-centered.

kpoint_grid#

kpoint_grid: tuple[PositiveInt, PositiveInt, PositiveInt] = (1, 1, 1)

The kpoint grid on which to compute transport quantities.

This is a Monkhorst-Pack grid, which is used to sample the Brillouin zone transverse to the transport direction. The k-point grid is specified as a tuple of three integers, which correspond to the number of k-points along the x, y, and z directions, respectively. The k-point grid must be 1 along the transport direction, since the periodicity along that direction is broken.

kpoint_shift#

kpoint_shift: tuple[float, float, float] = (0.0, 0.0, 0.0)

The kpoint shift to apply to the Monkhorst-Pack grid.