Units and Settings

def get_units() -> str:
    """
    Get current system-wide frequency units.
    
    Returns:
    - str: Current units ('GHz', 'MHz', 'kHz', or 'Hz')
    """

def set_units(units: str) -> str:
    """
    Set system-wide frequency units.
    
    Parameters:
    - units (str): Target units ('GHz', 'MHz', 'kHz', or 'Hz')
    
    Returns:
    - str: The units that were set
    """

def show_supported_units() -> None:
    """Display all supported frequency units and their conversion factors."""

def to_standard_units(value: float) -> float:
    """
    Convert value from current units to Hz.
    
    Parameters:
    - value (float): Value in current system units
    
    Returns:
    - float: Value converted to Hz
    """

def from_standard_units(value: float) -> float:
    """
    Convert value from Hz to current system units.
    
    Parameters:
    - value (float): Value in Hz
    
    Returns:
    - float: Value in current system units
    """

def get_units_time_label() -> str:
    """
    Get appropriate time unit label based on current frequency units.
    
    Returns:
    - str: Time unit label (e.g., 'ns' for GHz, 'μs' for MHz)
    """

# Computation Settings
AUTORUN_SWEEP: bool = True
"""Automatically run parameter sweeps when created."""

NUM_CPUS: int = None  
"""Number of CPU cores for parallel processing (None = auto-detect)."""

MULTIPROC: str = 'multiprocessing'
"""Multiprocessing library choice ('multiprocessing', 'pathos')."""

# Event System
DISPATCH_ENABLED: bool = True
"""Enable/disable central dispatch event system."""

# File I/O
FILE_TYPES: list = ['.h5', '.hdf5', '.csv']
"""Supported file formats for data persistence."""

# Visualization  
MODE_FUNC_DICT: dict = {
    'abs_sqr': lambda psi: np.abs(psi)**2,
    'abs': np.abs, 
    'real': np.real,
    'imag': np.imag,
    'phase': np.angle
}
"""Available modes for wavefunction visualization."""

# Diagonalization
DEFAULT_DIAG_METHOD: str = 'esys_scipy_sparse'
"""Default eigenvalue solver method."""

def configure_settings(**kwargs) -> None:
    """
    Configure multiple settings simultaneously.
    
    Parameters:
    - **kwargs: Setting name-value pairs to update
    """

def get_setting(setting_name: str):
    """
    Get current value of a setting.
    
    Parameters:
    - setting_name (str): Name of setting to query
    
    Returns:
    - Current value of the setting
    """

def reset_settings() -> None:
    """Reset all settings to their default values."""

def show_settings() -> None:
    """Display current values of all settings."""

DIAG_METHODS: dict = {
    'evals_scipy_dense': 'Dense matrix eigenvalues (scipy.linalg.eigh)',
    'esys_scipy_dense': 'Dense matrix eigensystem (scipy.linalg.eigh)',
    'evals_scipy_sparse': 'Sparse matrix eigenvalues (scipy.sparse.linalg.eigsh)',
    'esys_scipy_sparse': 'Sparse matrix eigensystem (scipy.sparse.linalg.eigsh)',
    'evals_scipy_sparse_SM': 'Sparse eigenvalues - smallest magnitude',
    'esys_scipy_sparse_SM': 'Sparse eigensystem - smallest magnitude',
    'evals_qutip': 'QuTiP eigenvalues (qutip.groundstate)',
    'esys_qutip': 'QuTiP eigensystem (qutip.groundstate)'
}
"""Dictionary of available diagonalization methods."""

def set_diag_method(method_name: str) -> None:
    """
    Set default diagonalization method.
    
    Parameters:
    - method_name (str): Method name from DIAG_METHODS keys
    """

import scqubits as scq

# Check current units
current_units = scq.units.get_units()
print(f"Current units: {current_units}")

# Show all supported units
scq.units.show_supported_units()

# Create transmon with GHz units (default)
transmon = scq.Transmon(EJ=25.0, EC=0.2, ng=0.0, ncut=30)
energies_GHz = transmon.eigenvals(evals_count=4)
print("Energies in GHz:", energies_GHz)

# Switch to MHz units
scq.units.set_units('MHz')
energies_MHz = transmon.eigenvals(evals_count=4)  
print("Energies in MHz:", energies_MHz)

# Verify conversion
print("Conversion factor:", energies_MHz[0] / energies_GHz[0])

# Convert specific values
value_in_GHz = 5.0
value_in_Hz = scq.units.to_standard_units(value_in_GHz)
print(f"{value_in_GHz} GHz = {value_in_Hz} Hz")

# Switch back to GHz
scq.units.set_units('GHz')

# Configure parallel processing
scq.settings.NUM_CPUS = 4
scq.settings.MULTIPROC = 'multiprocessing'

# Check available CPU cores
import multiprocessing
print(f"Available CPU cores: {multiprocessing.cpu_count()}")
print(f"Using {scq.settings.NUM_CPUS} cores")

# Large parameter sweep with parallel processing
transmon = scq.Transmon(EJ=25.0, EC=0.2, ng=0.0, ncut=30)
ng_vals = np.linspace(-2, 2, 201)  # Large sweep

sweep = scq.ParameterSweep(
    hilbert_space=scq.HilbertSpace([transmon]),
    paramvals_by_name={'ng': ng_vals},
    evals_count=6,
    num_cpus=scq.settings.NUM_CPUS
)

import time
start_time = time.time()
sweep.run()
end_time = time.time()
print(f"Sweep completed in {end_time - start_time:.2f} seconds")

# Show available diagonalization methods
print("Available diagonalization methods:")
for method, description in scq.DIAG_METHODS.items():
    print(f"  {method}: {description}")

# Test different methods for performance
transmon = scq.Transmon(EJ=25.0, EC=0.2, ng=0.0, ncut=50)  # Large basis

methods_to_test = ['esys_scipy_sparse', 'esys_scipy_dense']
results = {}

for method in methods_to_test:
    # Set diagonalization method
    scq.set_diag_method(method)
    
    # Time the calculation
    start_time = time.time()
    evals, evecs = transmon.eigensys(evals_count=6)
    end_time = time.time()
    
    results[method] = {
        'time': end_time - start_time,
        'energies': evals[:3]
    }

# Compare results
print("\nDiagonalization method comparison:")
for method, result in results.items():
    print(f"{method}:")
    print(f"  Time: {result['time']:.4f} seconds")
    print(f"  Energies: {result['energies']}")

# Display current settings
print("Current settings:")
scq.show_settings()

# Configure multiple settings at once
scq.configure_settings(
    NUM_CPUS=2,
    AUTORUN_SWEEP=False,
    DISPATCH_ENABLED=True
)

# Check specific setting
autorun = scq.get_setting('AUTORUN_SWEEP')
print(f"AUTORUN_SWEEP is set to: {autorun}")

# Create parameter sweep (won't auto-run due to AUTORUN_SWEEP=False)
sweep = scq.ParameterSweep(
    hilbert_space=scq.HilbertSpace([transmon]),
    paramvals_by_name={'ng': np.linspace(-1, 1, 21)},
    evals_count=4
)

# Manually run sweep since auto-run is disabled
print("Running sweep manually...")
sweep.run()

# Reset to defaults
scq.reset_settings()
print("Settings reset to defaults")

# Demonstrate units consistency across calculations
scq.units.set_units('GHz')

# Create system with GHz parameters
transmon = scq.Transmon(EJ=25.0, EC=0.2, ng=0.0, ncut=30)
cavity = scq.Oscillator(E_osc=6.0, truncated_dim=4)

system = scq.HilbertSpace([transmon, cavity])
system.add_interaction(
    g_strength=0.1,  # 100 MHz coupling in GHz units
    op1=transmon.n_operator,
    op2=cavity.creation_operator + cavity.annihilation_operator
)

# Calculate in GHz
spectrum_GHz = system.eigenvals(evals_count=8)
print("Spectrum in GHz:", spectrum_GHz[:4])

# Switch to MHz and recalculate
scq.units.set_units('MHz')
spectrum_MHz = system.eigenvals(evals_count=8)
print("Spectrum in MHz:", spectrum_MHz[:4])

# Verify unit conversion
conversion_factor = spectrum_MHz[0] / spectrum_GHz[0]
print(f"MHz/GHz ratio: {conversion_factor}")

# Use appropriate time units based on frequency units
scq.units.set_units('GHz')
time_label = scq.units.get_units_time_label()
print(f"Frequency units: GHz, Time units: {time_label}")

# Calculate coherence times
T1 = 50.0  # microseconds
T2 = 25.0  # microseconds

# Convert to appropriate time units
if time_label == 'ns':
    T1_converted = T1 * 1000  # μs to ns
    T2_converted = T2 * 1000
elif time_label == 'μs':
    T1_converted = T1
    T2_converted = T2
    
print(f"T1 = {T1_converted} {time_label}")
print(f"T2 = {T2_converted} {time_label}")

# Calculate corresponding frequencies
gamma1 = 1 / (2 * np.pi * T1_converted * 1e-9)  # Convert to Hz, then to current units
gamma2 = 1 / (2 * np.pi * T2_converted * 1e-9)

gamma1_current = scq.units.from_standard_units(gamma1)
gamma2_current = scq.units.from_standard_units(gamma2)

print(f"Γ1 = {gamma1_current:.6f} {scq.units.get_units()}")
print(f"Γ2 = {gamma2_current:.6f} {scq.units.get_units()}")