

quantized.hopping_matrix Module

Classes

---

OccupancyProbabilites

OccupancyProbabilites(s)

Fields

s (TimeEvolvingObservable)

Properties

initial

Static Methods

from_1d_state

OccupancyProbabilites.from_1d_state(
    state: quantized.time_evolution.TimeEvolvingState,
    borders: Tuple[float, ...]
) -> OccupancyProbabilites

Dunder Methods

__call__

OccupancyProbabilites.__call__(self, t: float) -> <built-in function array>

Call self as a function.

__getitem__

OccupancyProbabilites.__getitem__(self, item) -> typing.Callable

__iter__

OccupancyProbabilites.__iter__(self) -> <class 'inspect._empty'>

---

HoppingMatrix

HoppingMatrix(occ_probs: quantized.hopping_matrix.OccupancyProbabilites)

Fields

occ_probs (OccupancyProbabilites)

Methods

at_time

HoppingMatrix.at_time(self, t: float, delta_t: float) -> <built-in function array>

Properties

N = 3

Dunder Methods

__call__

HoppingMatrix.__call__(
    self,
    t: Union[float, numpy.ndarray],
    delta_t: float
) -> <class 'inspect._empty'>

Call self as a function.

---

Pnot

Pnot(
    acceptor: int,
    hopping_matrix: quantized.hopping_matrix.HoppingMatrix,
    times: List[float],
    values: List[float],
    delta_t: float
)

Fields

acceptor (int)

hopping_matrix (HoppingMatrix)

times (float)

values (float)

delta_t (float)

Methods

time_when_equal_to

Properties

acceptor_occ_prob

final_value

initial_value

max_time

min_time

tau90

Static Methods

converged_with_timestep

Pnot.converged_with_timestep(
    a: quantized.hopping_matrix.HoppingMatrix,
    acceptor: int,
    until_equals: float,
    tolerance: float,
    max_dt: float = 1.0,
    min_dt: float = 0.0001
) -> Pnot

gen

Pnot.gen(
    delta_t: float,
    hopping_matrix: quantized.hopping_matrix.HoppingMatrix,
    acceptor: int
) -> typing.Generator[typing.Tuple, NoneType, NoneType]

gen_until_prob

Pnot.gen_until_prob(
    p: float,
    delta_t: float,
    hopping_matrix: quantized.hopping_matrix.HoppingMatrix,
    acceptor: int
) -> typing.Iterator[typing.Tuple[float, float]]

gen_until_time

Pnot.gen_until_time(
    t: float,
    delta_t: float,
    hopping_matrix: quantized.hopping_matrix.HoppingMatrix,
    acceptor: int
) -> typing.Iterator[typing.Tuple[float, float]]

Dunder Methods

__call__

Pnot.__call__(self, t: float) -> <class 'float'>

Call self as a function.