Procedures

Addition overload for hex type

Dot overload for hex type

Equality overload for hex type

polymorphic equality overload for xy_lattice type

tolerance equality for xy class [absolute tol hard-coded to 1d-12] -> probably to improve...

Get the lattice for a hexagon-shaped flake

Get the lattice for a hexagon-shaped flake

Extract sublattice, given a lattice and a label ("A" or "B")

Get the lattice for a honeycomb supercell

Get the lattice for a triangle-shaped flake

constructor override

Convert hex coordinates to real 2D space [returning the xy coordinates of the hexagon center] Actual real-space layout has to be specified by passing a (scalar) unit_cell object.

Convert hex coordinates to real 2D space [returning the xy coordinates for the hexagon corners, as appropriatiely wrapped in the "xy_lattice" type] Actual real-space layout has to be specified by passing a (scalar) unit_cell object.

Generate a type(xy_lattice) object from any given hex array, provided a suitable layout (unit-cell)

Convert hex coordinates to real 2D lattice sites [returning the xy coordinates for the unique unit-cell, sites "A" and "B": this of course does not account for border effects, so would be suitable only for simple, periodized, systems, which for now are out of scope.] Actual real-space layout has to be specified by passing a (scalar) unit_cell object.

Build a armchair-on-top honeycomb stripe/ribbon CONVERSION TO XY SITES REQUIRES ARMCHAIR LAYOUT

Return a direction in pseudo-3D hex space, given a (signed) integer label

Taxicab distance of hex coordinates

Build a hexagon-shaped honeycomb flake

Return the nearest neighbor of H, by hopping in the i-th direction. You can feed any i ∈ ℤ, but you'd get only 6 inequivalent neighbors

Utility to grow type(hex) arrays, it is a poor man implementation of a dynamic array insertion, a là std::vector (but with no preallocation and smart doubling...)

Draw a line between A and B, in hex space

Return the vector of all nearest hex_neighbors of hex H

Taxicab norm from hex coordinates

Simple plotter for arrays of type(hex). It features two backends, giving access to either matplotlib(pyplot) or gnuplot internal machinery. Either library needs to be installed in your system for hex_plot to work. You can specify a figure_name to save the plot to disk. If not specified the plot would be just displayed in a popup window (or the terminal with suitable configuration of the gnuplot backend) and a corresponding script saved, aiming at fast reproduction (the script will all contain data). The script has a default name (hex_plot.{py,gp}), but you can optionally give your own custom string, do not forget the appropriate file extension. Regarding output formats instead, the two backends have slightly different behavior: pyplot would infer the format from the given file extension in figure_name, whilst gnuplot does need a proper "output terminal" to be set. You can do that by passing the optional set_parameter variable. Refer to original gnuplot documentation for the list of available terminals and how they should be chosen. For convenience we report that you can get the list of (system dependent) available terminals in your console by executing the gnuplot -e "set terminal" command in your shell. Furthermore all systems should be compatible with the "dumb" terminal option, which would direct the plot to the terminal itself, in the form of ASCII art. This can be very useful for HPC workflows.

Pretty print of hex coordinates

Round a triplet of reals to a proper hex object

Build a honeycomb supercell (parallelogram)

Build a triangle-shaped honeycomb flake

Build a zigzag-on-top honeycomb stripe/ribbon CONVERSION TO XY SITES REQUIRES ZIGZAG LAYOUT

Compute the offset vector connecting a site with label "A", to its i-th neighbor, returning a (scalar) xy coordinate. It takes any i ∈ ℤ, but there will only be 3 inequivalent output vectors, pointing to the three nearest neighbors.

Compute the offset vector connecting a site with label "B", to its i-th neighbor, returning a (scalar) xy coordinate. It takes any i ∈ ℤ, but there will only be 3 inequivalent output vectors, pointing to the three nearest neighbors.

Compute the i-th offset vector connecting the hexagon center to its corners, returning a (scalar) xy coordinate

Left scale overload for hex type

Linear interpolation from a to b, with step t a + (b - a) * t = a * (1-t) + b * t for better floating-point precision

Inequality overload for hex type

polymorphic inequality overload for xy_lattice type

tolerance inequality for xy class [absolute tol hard-coded to 1d-12] -> probably to improve...

Axial cubic constructor for the hex type [s would be computed internally]

Safe cubic constructor for the hex type featuring an assertion on input coordinates before the initialization of the object

product overload

addition overload

subtraction overload

inequality overload

equality overload

Overload of == operator for hex_orientation type

Pretty print of hex coordinates

Poor man implementation of a dynamic array, a là std::vector (but without preallocation and smart doubling...)

Right scale overload for hex type

Subtraction overload for hex type

Pretty print of xy coordinates in static arrays

Polymorphic euclidean distance for xy class

Pretty print of xy coordinates in dynamic arrays

Build a mask for the nearest neighbors of a given lattice. It is a NxN matrix, with N the number of sites in the lattice, stocking .true. values only for the pairs of sites linked by a "NN-bond". It calls internally xy_shells, for all inter-site distances, so if you need more than NNs consider calling xy_shells directly. Note that we provide a similar subroutine for next-nearest-neighbors, which optionally gives also the NNs, so if just two shells are needed you should call that.

Build a mask for the next-nearest neighbors of a given lattice. It is a NxN matrix, with N the number of sites in the lattice, storing .true. values only for the pairs of sites linked by a "NNN-bond". Optionally builds a nearest-neighbors mask, too. It calls internally xy_shells, for all inter-site distances, so if you need more than NNNs consider calling xy_shells directly. Note that we provide a similar subroutine for nearest-neighbors only, so if you just need NNs consider calling it.

Return the nearest neighbor of a lattice site, by hopping in the i-th direction. You can feed any i ∈ ℤ, but you can get only 3 inequivalent neighbors, depending on the label of the given site: "A" and "B" activate two different suitable sets of hopping directions. A lattice layout is required to build the concrete hopping vectors.

Return the i-th next-nearest neighbor of a lattice site, by taking two xy_nn_hops in the suitable direction. You can feed any i ∈ ℤ, but you can get only 6 inequivalent neighbors, depending on the label of the given site: "A" and "B" activate two different suitable sets of NN hops, A lattice layout is required to build the concrete hoppings.

polymorphic euclidean norm for xy class

An ordered-keys set union for xy_lattices. It compares the lattice sites, looking at their x and y coordinates only: equal x,y entries are inserted in C just once, so to make it a set. A and B must be sets too. The sublattice labels are preserved in the process, assuming that two sites with the same x,y pertain to the same sublattice. For A the keys are assumed to be 1:size(A), and preserved as such (with an assertion). The keys of B are instead discarded, so to be replaced by size(A):size(C), which thus amounts to have result C uniquely indexed as 1, 2, ... , size(A) + size(B). This allows building consistently indexed matrices to act on the lattice array, such as real-space tight-binding hamiltonians. The keys would then be used to index other real space quantities, such as LDOS, Chern marker, local magnetization, and so on.

CURRENTLY GNUPLOT DOES NOT SUPPORT NN AND NNN LINKS, HELP IS WELCOME! Simple plotter for class(xy_lattice) objects. If optional argument nn_mask is passed it draws the nearest-neighbor bonds too. Similarly, if optional argument nnn_mask is passed a dashed link to next-nearest neighbors would be drawed. Otherwise only lallice sites. It features two backends, giving access to either matplotlib(pyplot) or gnuplot internal machinery. Either library needs to be installed in your system for hex_plot to work. You can specify a figure_name to save the plot to disk. If not specified the plot would be just displayed in a popup window (or the terminal with suitable configuration of the gnuplot backend) and a corresponding script saved, aiming at fast reproduction (the script will all contain data). The script has a default name (hex_plot.{py,gp}), but you can optionally give your own custom string, do not forget the appropriate file extension. Regarding output formats instead, the two backends have slightly different behavior: pyplot would infer the format from the given file extension in figure_name, whilst gnuplot does need a proper "output terminal" to be set. You can do that by passing the optional set_parameter variable. Refer to original gnuplot documentation for the list of available terminals and how they should be chosen. For convenience we report that you can get the list of (system dependent) available terminals in your console by executing the gnuplot -e "set terminal" command in your shell. Furthermore all systems should be compatible with the "dumb" terminal option, which would direct the plot to the terminal itself, in the form of ASCII art. This can be very useful for HPC workflows.

Build a /ordered/ set of all inter-atomic distances in a given xy_lattice and a table storing distances among all sites. Searching this matrix for the n-th set entry gives a mask of all pairs of atomic sites that are n-th order neigbors. E.g. shell_table == distance_set(1) would provide a mask for nearest neighbors, from which we can build the tight-binding hopping term of the corresponding lattice hamiltonian.