Struct Floquet 

pub struct Floquet { /* private fields */ }

One period of a piecewise-constant drive.

Implementations

impl Floquet

pub fn new(steps: impl IntoIterator<Item = DriveStep>) -> Result<Self>

Construct one period from ordered piecewise-constant drive steps.

pub fn from_callable( steps: impl IntoIterator<Item = CallableDriveStep>, ) -> Result<Self>

Construct one period from ordered callable drive steps.

pub fn with_evolution_options(self, options: EvolutionOptions) -> Self

Replace the Krylov controls used to apply each drive step.

pub fn with_period(self, period: f64) -> Result<Self>

Override the physical Floquet period used for quasienergies and the effective Hamiltonian without changing the step durations.

This supports kicked protocols whose explicit evolution intervals do not add up to the declared drive period.

pub fn apply_period( &self, input: &[Complex64], output: &mut [Complex64], ) -> Result<()>

Apply one ordered drive period without materializing the full unitary.

pub fn apply_adjoint_period( &self, input: &[Complex64], output: &mut [Complex64], ) -> Result<()>

Apply the adjoint one-period propagator without materializing it.

The reverse-time action is exact for the static piecewise-constant protocol represented by DriveStep. Callable drives currently fail explicitly because their adjoint requires reverse-time evaluation of the original time-dependent generator.

pub fn period(&self) -> f64

Return the declared analysis period or the sum of step durations.

pub fn protocol_duration(&self) -> f64

Sum of the explicit piecewise evolution intervals.

pub fn full_unitary(&self, format: MatrixFormat) -> Result<Operator>

Materialize the complete period propagator in the requested format.

This operation scales quadratically in memory and is intended for workflows that explicitly require the full Floquet unitary.

pub fn eigensystem(&self) -> Result<FloquetEigensystem>

Compute sorted quasienergies, unit-circle eigenvalues, vectors, and residuals.

pub fn selected_eigensystem( &self, options: FloquetSpectrumOptions, ) -> Result<FloquetEigensystem>

Compute selected Floquet eigenpairs near one target quasienergy without materializing the complete period propagator.

The method solves the Hermitian phase filter Re(exp(-i*target_phase) U) with the ordinary matrix-free eigensolver, then diagonalizes U inside the converged candidate subspace. The second step separates phase branches that share one cosine-filter value.

pub fn effective_hamiltonian(&self, format: MatrixFormat) -> Result<Operator>

Construct the principal-branch effective Hamiltonian.

pub fn spectrum(&self, format: MatrixFormat) -> Result<FloquetSpectrum>

Materialize one period once and compute its complete dense spectrum.

The returned object owns both products, so callers that need unitarity and quasienergy checks never need to rebuild the propagator or bring a second dense eigensolver into the workflow.

pub fn analyze(&self, format: MatrixFormat) -> Result<FloquetAnalysis>

Compute the period propagator and all spectral products while materializing the propagator only once.

Trait Implementations

impl LinearOperator for Floquet

fn shape(&self) -> (usize, usize)

Return (rows, columns).

fn format(&self) -> MatrixFormat

Report the public materialization format.

fn apply(&self, input: &[Complex64], output: &mut [Complex64]) -> Result<()>

Compute output = A * input.

fn is_real(&self) -> bool

Whether this operator preserves real vectors exactly.

fn apply_real(&self, input: &[f64], output: &mut [f64]) -> Result<()>

Apply this operator to a real vector.

fn apply_transpose( &self, input: &[Complex64], output: &mut [Complex64], ) -> Result<()>

Apply the algebraic transpose without conjugating either operand.

fn apply_adjoint( &self, input: &[Complex64], output: &mut [Complex64], ) -> Result<()>

Apply the conjugate transpose.

fn stored_triplets(&self) -> Result<Option<Vec<(usize, usize, Complex64)>>>

Return canonical stored nonzeros when the representation already owns them.

fn shifted_solver( &self, _shift: f64, ) -> Result<Option<Box<dyn ShiftedLinearSolver>>>

Prepare a reusable solver for (A - shift I) x = b, when supported.