spintronics 0.3.0

Pure Rust library for simulating spin dynamics, spin current generation, and conversion phenomena in magnetic and topological materials
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//! Python bindings for spin-charge conversion effects

use pyo3::prelude::*;

use super::vector::PyVector3;
use crate::effect::InverseSpinHall;

/// Inverse Spin Hall Effect converter
///
/// Converts spin current to charge current via spin-orbit coupling.
/// The electric field E is generated perpendicular to both the
/// spin current direction and spin polarization:
///
/// E = rho * theta_SH * (j_s x sigma)
///
/// ## Example
/// ```python
/// pt = InverseSpinHall.platinum()
/// js_flow = Vector3(0.0, 0.0, 1.0)  # Spin current flow direction
/// js_pol = Vector3(1e8, 0.0, 0.0)   # Spin polarization (A/m^2)
///
/// e_field = pt.convert(js_flow, js_pol)
/// print(f"Electric field: {e_field} V/m")
/// ```
#[pyclass(name = "InverseSpinHall")]
#[derive(Clone)]
pub struct PyInverseSpinHall {
    inner: InverseSpinHall,
}

#[pymethods]
impl PyInverseSpinHall {
    /// Create a new ISHE converter
    ///
    /// Args:
    ///     theta_sh: Spin Hall angle (dimensionless)
    ///     rho: Electrical resistivity (Ohm*m)
    #[new]
    pub fn new(theta_sh: f64, rho: f64) -> Self {
        Self {
            inner: InverseSpinHall { theta_sh, rho },
        }
    }

    /// Spin Hall angle (dimensionless)
    #[getter]
    pub fn theta_sh(&self) -> f64 {
        self.inner.theta_sh
    }

    /// Electrical resistivity (Ohm*m)
    #[getter]
    pub fn rho(&self) -> f64 {
        self.inner.rho
    }

    /// Convert spin current to electric field
    ///
    /// Args:
    ///     js_flow: Spin current flow direction (Vector3)
    ///     js_polarization: Spin polarization direction with magnitude (Vector3, A/m^2)
    ///
    /// Returns:
    ///     Electric field vector (V/m)
    pub fn convert(&self, js_flow: &PyVector3, js_polarization: &PyVector3) -> PyVector3 {
        let e_field = self.inner.convert(js_flow.inner(), js_polarization.inner());
        PyVector3::from_inner(e_field)
    }

    /// Calculate voltage across a strip of given width
    ///
    /// Args:
    ///     js_flow: Spin current flow direction (Vector3)
    ///     js_polarization: Spin polarization direction with magnitude (Vector3, A/m^2)
    ///     strip_width: Width of the conducting strip (m)
    ///
    /// Returns:
    ///     Voltage (V)
    pub fn voltage(
        &self,
        js_flow: &PyVector3,
        js_polarization: &PyVector3,
        strip_width: f64,
    ) -> f64 {
        self.inner
            .voltage(js_flow.inner(), js_polarization.inner(), strip_width)
    }

    /// Calculate conversion efficiency (V/W ratio)
    pub fn efficiency(&self) -> f64 {
        self.inner.efficiency()
    }

    /// Create Platinum (Pt) ISHE converter
    ///
    /// Platinum has a large positive spin Hall angle (~0.08)
    /// and is the most commonly used material for ISHE detection.
    #[staticmethod]
    pub fn platinum() -> Self {
        Self {
            inner: InverseSpinHall::platinum(),
        }
    }

    /// Create Tantalum (Ta) ISHE converter
    ///
    /// Tantalum has a large positive spin Hall angle (~0.12).
    #[staticmethod]
    pub fn tantalum() -> Self {
        Self {
            inner: InverseSpinHall::tantalum(),
        }
    }

    /// Create Tungsten (W) ISHE converter
    ///
    /// Tungsten has the largest known spin Hall angle (~-0.30, negative).
    #[staticmethod]
    pub fn tungsten() -> Self {
        Self {
            inner: InverseSpinHall::tungsten(),
        }
    }

    /// String representation
    pub fn __repr__(&self) -> String {
        format!(
            "InverseSpinHall(theta_sh={:.3}, rho={:.2e})",
            self.inner.theta_sh, self.inner.rho
        )
    }
}

impl PyInverseSpinHall {
    /// Get the inner InverseSpinHall
    #[allow(dead_code)]
    pub fn inner(&self) -> &InverseSpinHall {
        &self.inner
    }
}