modulation-da 0.0.1__py3-none-any.whl

modulation_da/__init__.py

@@ -0,0 +1,7 @@
+# modulation_donneur_accepteur_uniquement/__init__.py
+
+"""
+A scientific computing package for simulating donor-acceptor modulation.
+"""
+
+__version__ = "0.0.1"

modulation_da/current_calculator.py

@@ -0,0 +1,71 @@
+# current_calculator.py
+import tensorflow as tf
+import numpy as np
+
+class CurrentCalculator:
+    """Complete calculation of quantum currents"""
+    
+    def __init__(self, config, system):
+        self.config = config
+        self.system = system
+    
+    def compute_current_contribution(self, model, i_energy, j_mode, perturbation_manager, perturbation_type):
+        """Calculates current contribution for a specific mode/energy"""
+        E_norm = self.config.E_min_norm + i_energy * self.config.dE_norm
+        psi_st = self.system.stock_psi[i_energy, j_mode, :].reshape((-1, 1))
+        psi_st_tensor = tf.convert_to_tensor(psi_st, dtype=tf.complex64)
+        
+        # Prédiction
+        t_pred, psi_total, HT_pred = self.predict_wavefunction(model, E_norm, psi_st_tensor, perturbation_manager, perturbation_type)
+        
+         # Current calculation
+        fermi_factor = self.system.fermi_dirac(E_norm)
+        current_mode = self._compute_mode_current(psi_total, HT_pred, fermi_factor)
+        
+        return current_mode, t_pred
+    
+    def predict_wavefunction(self, model, E_norm, psi_st_tensor, perturbation_manager, perturbation_type):
+        """Predicts the complete wavefunction"""
+        t_pred_norm_vals = np.linspace(self.config.t_min_norm, self.config.t_max_norm, 5000)
+        t_pred_norm = tf.convert_to_tensor(t_pred_norm_vals.reshape(-1, 1), dtype=tf.float32)
+        
+        # Hamiltonians for prediction
+        HP_pred_list = []
+        for s in range(len(t_pred_norm_vals)):
+            t_s_norm = t_pred_norm_vals[s]
+            HP_s = perturbation_manager.get_perturbation(t_s_norm, perturbation_type)
+            HP_pred_list.append(HP_s)
+        
+        HP_pred = tf.convert_to_tensor(np.stack(HP_pred_list), dtype=tf.complex64)
+        
+        # Network prediction
+        psi_pred = model(t_pred_norm)
+        u_pred = psi_pred[:, :self.config.n]
+        v_pred = psi_pred[:, self.config.n:]
+        psi_p = tf.complex(u_pred, v_pred)
+        
+        # Add stationary state
+        phase = tf.exp(-1j * tf.cast(E_norm, tf.complex64) * 
+                      tf.cast(t_pred_norm_vals, tf.complex64))
+        phase = tf.expand_dims(phase, axis=-1)
+        
+        psi_st_broadcast = tf.transpose(psi_st_tensor)
+        psi_total = psi_p + phase * psi_st_broadcast
+        
+        # Total Hamiltonian
+        H_0_tensor = tf.convert_to_tensor(self.system.H_0, dtype=tf.complex64)
+        SELF_tensor = tf.convert_to_tensor(self.system.SELF, dtype=tf.complex64)
+        
+        H_0_pred = tf.repeat(tf.expand_dims(H_0_tensor, axis=0), len(t_pred_norm_vals), axis=0)
+        SELF_pred = tf.repeat(tf.expand_dims(SELF_tensor, axis=0), len(t_pred_norm_vals), axis=0)
+        HT_pred = HP_pred + H_0_pred + SELF_pred
+        
+        return t_pred_norm_vals, psi_total, HT_pred
+    
+    def _compute_mode_current(self, psi_total, HT_pred, fermi_factor):
+        """Calculates current for a specific mode"""
+        psi1_conj = tf.math.conj(psi_total[:, 1])
+        H12 = HT_pred[:, 1, 2]
+        psi2 = psi_total[:, 2]
+        
+        return fermi_factor * psi1_conj * H12 * psi2