def __init__(
self,
name: str,
orbital_list: Union[List[int], numpy.ndarray],
N: int,
L: int,
initial_filling: Union[List[float], numpy.ndarray],
):
self.logger = get_logger(__name__ + ".CreateSQRBosonicWaveFunction")
self.name = name
self.number_of_particles = N
self.number_of_sites = L
if isinstance(initial_filling, numpy.ndarray):
self.initial_filling = initial_filling.tolist()
else:
self.initial_filling = initial_filling
if isinstance(orbital_list, numpy.ndarray):
self.orbital_list = orbital_list.astype(numpy.int64)
else:
self.orbital_list = orbital_list
self.path = Path(name)
self.path_pickle = Path(name + ".pickle")
def __init__(self, name: Path, working_dir: Optional[Path] = None):
self.name = name
self.working_dir = (Path(name)
if working_dir is None else working_dir).resolve()
self.tasks_run = []
self.tasks_clean = []
self.tasks_dry_run = []
self.logger = get_logger(__name__ + ".Simulation")
def __init__(self, parameters: Parameters, grid: DVRSpecification):
self.parameters = parameters
self.grid = grid
self.logger = get_logger(__name__ + ".MBOperatorSpecification")
if grid.is_fft():
self.grid_1b = grid.get_expdvr()
else:
self.grid_1b = self.grid
def __init__(self, wave_function: Union[str, Path], operator: Union[str, Path]):
self.logger = get_logger(__name__ + ".ComputeExpectationValueStatic")
# compute required paths
self.operator = make_path(operator)
self.wave_function = make_path(wave_function)
self.expval = self.wave_function.with_name(
self.wave_function.stem + "_" + self.operator.stem,
).with_suffix(".exp.h5")
self.name = str(self.expval.with_suffix(""))
def __init__(
self,
name: str,
func: Callable[[Parameters], Simulation],
combinations: List[Parameters],
working_dir: Union[str, Path] = None,
):
super().__init__(name, [], working_dir)
self.func = func
self.logger = get_logger(__name__ + ".ParameterScan")
self.simulations = [] # type: List[Simulation]
self.combinations = combinations
def __init__(
self,
name: str,
simulations: List[Simulation],
working_dir: Union[str, Path] = None,
):
self.name = name
self.simulations = simulations
self.working_dir = (Path(name).resolve()
if working_dir is None else make_path(working_dir))
self.logger = get_logger(__name__ + ".SimulationSet")
def __init__(
self,
name: str,
wfn_path: Path,
prototype: Parameters,
func: Callable[[Parameters], Simulation],
working_dir: str = None,
):
self.logger = get_logger(__name__ + ".WaveFunctionDB")
self.prototype = prototype
self.stored_wave_functions = [] # type: List[Parameters]
self.missing_wave_functions = [] # type: List[Parameters]
self.wfn_path = wfn_path
super().__init__(name, func, [], working_dir)
self.logger = get_logger(__name__ + ".WaveFunctionDB")
self.argparser_tui = self.subparsers.add_parser("tui")
self.argparser_tui.set_defaults(subcommand=self.cmd_tui)
self.argparser_remove = self.subparsers.add_parser("remove")
self.argparser_remove.set_defaults(subcommand=self.cmd_remove)
self.argparser_remove.add_argument("selection", type=str)
self.load_missing_wave_functions()
self.load_stored_wave_functions()
self.combinations = self.stored_wave_functions + self.missing_wave_functions
# TODO: it would be better to collect missing wave functions and remove them in one go
# this would require some additional methods
for parameter in self.stored_wave_functions:
path = self.get_path(parameter)
if not path:
self.store_missing_wave_function(parameter)
self.remove_wave_function(parameter)
continue
if not path.exists():
self.store_missing_wave_function(parameter)
self.remove_wave_function(parameter)
def __init__(
self,
parameters: Parameters,
grid: DVRSpecification,
):
self.parameters = parameters
self.grid = grid
self.logger = get_logger(__name__ + ".BoseBoseSystem")
if grid.is_fft():
self.grid_1b = grid.get_expdvr()
else:
self.grid_1b = self.grid
def __init__(self, name: str, *args, **kwargs):
self.name = name
self.logger = get_logger(__name__ + ".CreateMBOperator")
if "specification" in kwargs:
self.specification = kwargs["specification"]
else:
if isinstance(args[0], MBOperatorSpecification):
self.specification = args[0]
else:
self.specification = MBOperatorSpecification(*args, **kwargs)
self.path = Path(self.name)
self.path_pickle = Path(self.name + ".pickle")
def __init__(self, wave_function: Union[str, Path],
basis: Union[str, Path], **kwargs):
self.logger = get_logger(__name__ + ".NumberStateAnalysisStatic")
self.wave_function = make_path(wave_function)
self.basis = make_path(basis)
self.result = make_path(
kwargs.get(
"name",
self.wave_function.with_name(
self.wave_function.stem + "_" + self.basis.stem, ),
), ).with_suffix(".fixed_ns.h5")
self.name = str(self.result.with_suffix(""))
def __init__(
self,
name: str,
wave_function: Union[str, Path],
hamiltonian: Union[str, Path],
**kwargs,
):
kwargs["relax"] = True
kwargs["tfinal"] = kwargs.get("tfinal", 1000.0)
kwargs["stat_energ_tol"] = kwargs.get("stat_energ_tol", 1e-8)
kwargs["stat_npop_tol"] = kwargs.get("stat_npop_tol", 1e-6)
super().__init__(name, wave_function, hamiltonian, **kwargs)
self.logger = get_logger(__name__ + ".Relax")
def __init__(
self,
name: str,
wave_function: Union[str, Path],
hamiltonian: Union[str, Path],
**kwargs,
):
self.name = name
self.wave_function = wave_function
self.hamiltonian = hamiltonian
self.logger = get_logger(__name__ + ".Propagate")
self.diag_gauge_oper: Optional[str] = kwargs.get(
"diag_gauge_oper", None)
self.flags, self.flag_list = create_flags(**kwargs)
self.flag_list += ["-rst", "restart", "-opr", "hamiltonian"]
if self.flags.get("gauge", "standard") == "diagonalization":
self.flag_list += ["-diag_gauge_oper", "gauge_oper"]
if self.flags["relax"]:
self.basename = "relaxation"
elif self.flags["improved_relax"]:
self.basename = "improved_relaxation"
elif self.flags["exact_diag"]:
self.basename = "exact_diagonalization"
else:
self.basename = "propagation"
# compute required paths
self.path_name = Path(self.name)
self.path_pickle = Path(self.name + ".prop_pickle")
self.path_wave_function = make_path(wave_function)
self.path_hamiltonian = make_path(hamiltonian)
self.path_diag_gauge_oper: Optional[Path] = (Path(
self.diag_gauge_oper) if self.diag_gauge_oper else None)
self.path_hdf5 = self.path_name / (
"exact_diag.h5" if self.flags["exact_diag"] else "propagate.h5")
if self.flags["exact_diag"]:
self.qdtk_files: List[str] = ["eigenenergies", "eigenvectors"]
else:
self.qdtk_files = ["final.wfn"]
if self.flags["psi"]:
self.qdtk_files.append("psi")
self.qdtk_files += kwargs.get("extra_files", [])
def __init__(
self,
name: str,
orbital_list: list[int] | NDArray,
L: int,
spfs: list[NDArray],
):
self.logger = get_logger(__name__ + ".CreateSpinHalfWaveFunction")
self.name = name
self.number_of_sites = L
self.spfs = spfs
self.orbital_list = orbital_list
self.path = Path(name)
self.path_pickle = Path(name + ".pickle")
def __init__(
self,
psi: Union[str, Path],
index: int,
path: Union[Path, str] = None,
):
self.logger = get_logger(__name__ + ".FrameFromPsi")
self.psi = make_path(psi)
self.index = index
if path is None:
self.path = self.psi.stem + f"_{self.index}.wfn"
else:
self.path = make_path(path)
self.pickle_path = Path(str(self.path) + ".pickle")
def __init__(
self,
name: str,
wave_function: Union[str, Path],
hamiltonian: Union[str, Path],
number_of_states: int,
**kwargs,
):
kwargs["exact_diag"] = True
kwargs["eig_tot"] = number_of_states
kwargs["arpack_max_iter"] = kwargs.get("arpack_max_iter", 10000)
kwargs["arpack_tolerance"] = kwargs.get("arpack_max_tolerance", 1e-13)
super().__init__(name, wave_function, hamiltonian, **kwargs)
self.logger = get_logger(__name__ + ".Diagonalize")
def __init__(
self,
dofs: Iterable[int],
grids: Iterable[DVRSpecification],
coefficients: List[Any],
terms: List[Any],
table: Union[str, List[str]],
):
self.dofs = dofs
self.grids = grids
self.coefficients = coefficients
self.terms = terms
self.logger = get_logger(__name__ + ".MBOperatorSpecification")
if isinstance(table, str):
self.table = [table]
else:
self.table = table
def __init__(
self,
name: str,
psi: os.PathLike,
func: Callable[..., OperatorSpecification],
indices: NDArray[numpy.int64],
**kwargs,
):
self.logger = get_logger(__name__ + ".ComputePointFunction")
self.name = name
self.psi = Path(psi)
self.func = func
self.indices = indices
self.output = (self.psi.parent / name).with_suffix(".h5")
self.pickle = (self.psi.parent / name).with_suffix(".pickle")
self.wave_function = Path(
kwargs.get("wave_function",
self.psi.parent / "final"), ).with_suffix(".wfn")
def __init__(
self,
name: str,
wave_function: Union[str, Path],
hamiltonian: Union[str, Path],
eig_index: int,
**kwargs,
):
kwargs["improved_relax"] = True
kwargs["tfinal"] = kwargs.get("tfinal", 1000.0)
kwargs["stat_energ_tol"] = kwargs.get("stat_energ_tol", 1e-8)
kwargs["stat_npop_tol"] = kwargs.get("stat_npop_tol", 1e-6)
kwargs["nstep_diag"] = kwargs.get("nstep_diag", 50)
kwargs["statsteps"] = kwargs.get("stat_steps", 80)
kwargs["eig_index"] = eig_index
kwargs["arpack_max_iter"] = kwargs.get("arpack_max_iter", 10000)
kwargs["arpack_tolerance"] = kwargs.get("arpack_max_tolerance", 1e-13)
super().__init__(name, wave_function, hamiltonian, **kwargs)
self.logger = get_logger(__name__ + ".ImprovedRelax")
def __init__(
self,
name: str,
hamiltonian_1b: str,
num_particles: int,
threshold: float,
above_threshold: bool = False,
max_number: int = 0,
):
self.logger = get_logger(__name__ +
".MCTDHBCreateWaveFunctionEnergyThreshold")
self.name = name
self.number_of_particles = num_particles
self.threshold = threshold
self.above_threshold = above_threshold
self.max_number = max_number
self.hamiltonian_1b = hamiltonian_1b
self.path = Path(name)
self.path_pickle = Path(name + ".pickle")
self.path_basis = Path(name + "_basis.h5")
self.path_matrix = Path(self.hamiltonian_1b + "_mat.h5")
def __init__(self, psi: Union[str, Path], operator: Union[str, Path], **kwargs):
self.logger = get_logger(__name__ + ".ComputeExpectationValue")
self.unique_name = kwargs.get("unique_name", False)
# compute required paths
self.operator = make_path(operator)
self.psi = make_path(psi)
if self.unique_name:
self.expval = self.psi.with_name(
self.psi.stem + "_" + self.operator.stem,
).with_suffix(".exp.h5")
else:
self.expval = (self.psi.parent / self.operator.stem).with_suffix(".exp.h5")
if "wave_function" in kwargs:
self.wave_function = make_path(kwargs["wave_function"])
else:
self.wave_function = make_path(
kwargs.get("wave_function", self.psi.parent / "final"),
).with_suffix(".wfn")
self.name = str(self.expval.with_suffix(""))
def __init__(
self,
name: str,
tape: list[int],
spfs: list[NDArray],
shake: dict[str, Any] | None = None,
):
self.logger = get_logger(__name__ + ".CreateMLMCTDHWaveFunction")
self.name = name
self.tape = tape
self.spfs = spfs
self.shake = None
if shake is not None:
self.shake = {
"strength": shake.get("strength", 0.1),
"primitive": shake.get("primitive", False),
"onlytop": shake.get("onlytop", False),
"cmplx": shake.get("cmplx", False),
"seed": shake.get("seed", 0),
}
self.path = Path(name)
self.path_pickle = Path(name + ".pickle")
def __init__(self, path: Union[str, Path]):
self.logger = get_logger(__name__ + ".TemporaryDir")
self.complete = False
self.path = make_path(path).resolve()
self.already_present = self.path.exists()
from typing import List, Optional, Tuple
import numpy
import QDTK.Tools.Mathematics
import QDTK.Wavefunction
import scipy.linalg
from mlxtk import log
LOGGER = log.get_logger(__name__)
def diagonalize_1b_operator(
matrix: numpy.ndarray,
number_eigenfunctions: Optional[int] = None,
) -> Tuple[numpy.ndarray, List[numpy.ndarray]]:
"""Diagonalize the supplied one-dimensional one-body hamiltonian
Args:
hamiltonian (QDTK.Operator): operator to diagonalize
number_eigenfunctions (int): number of eigenvalues/eigenvectors to
compute (-1 to compute all)
Returns:
A tuple with the list of eigenvalues as the first element followed by
the eigenvectors
"""
eigenvalues, eigenvectors = scipy.linalg.eig(matrix)
eigenvalues = numpy.real(eigenvalues)
QDTK.Tools.Mathematics.sortEigValsVecs(eigenvalues, eigenvectors)
import matplotlib
import matplotlib.figure
import matplotlib.pyplot
from matplotlib.backend_bases import LocationEvent
from matplotlib.figure import Figure
from mlxtk.log import get_logger
from mlxtk.plot import cursor
from mlxtk.plot.energy import plot_energy, plot_energy_diff
from mlxtk.plot.entropy import plot_entropy, plot_entropy_diff
from mlxtk.plot.expval import plot_expval
from mlxtk.plot.gpop import create_gpop_model, plot_gpop
from mlxtk.plot.natpop import plot_depletion, plot_natpop
from mlxtk.util import make_path
LOGGER = get_logger(__name__)
def make_headless():
matplotlib.use("agg")
def save(
figure: matplotlib.figure.Figure,
path: Union[str, Path],
crop: bool = False,
optimize: bool = False,
):
path = make_path(path)
if path.suffix == ".pdf":
def __init__(self, parameters: Parameters):
self.logger = get_logger(__name__ + ".IsingLR1D")
self.parameters = parameters
self.grid = dvr.add_spin_half_dvr()
def __init__(self, parameters: Parameters):
super().__init__(parameters)
self.logger = get_logger(__name__ + ".AnyonHubbardSQR")
def __init__(self, parameters: Parameters):
self.logger = get_logger(__name__ + ".BosonicSQR")
self.parameters = parameters
self.grid = dvr.add_sqr_dvr_bosonic(parameters.N)
def __init__(self, parameters: Parameters):
self.logger = get_logger(__name__ + ".DisorderedXYSpinGlass")
self.parameters = parameters
self.grid = dvr.add_spin_half_dvr()
def __init__(self, parameters: Parameters, dof_map: Mapping[int, int]):
self.logger = get_logger(__name__ + ".Vitagliano2010")
self.parameters = parameters
self.grid = dvr.add_spin_half_dvr()
self.dof_map = dof_map
def __init__(self, parameters: Parameters):
self.parameters = parameters
self.grid = dvr.add_sinedvr(parameters.sites, 0, parameters.sites - 1)
self.logger = get_logger(__name__ + ".BoseHubbard")
