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")