modulation-da 0.0.1__py3-none-any.whl

modulation_da/main.py

@@ -0,0 +1,77 @@
+# main.py
+import sys
+import os
+import argparse
+from datetime import datetime
+
+# Add the current directory to system path for imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+from quantum_solver import QuantumPINNSolver
+from modulation_da import __version__
+
+def run_simulation(perturbation_type):
+    """
+    Launches the simulation with the given perturbation type.
+    """
+    print("=== QUANTUM PINN SIMULATOR ===")
+    
+    available_perturbations = ['gaussian', 'sinusoidal', 'rectangular', 
+                              'exponential', 'modulated_sinusoidal']
+    
+    if perturbation_type not in available_perturbations:
+        print(f"Invalid perturbation type: {perturbation_type}. Please choose from: {', '.join(available_perturbations)}")
+        return
+
+    # Create solver instance
+    solver = QuantumPINNSolver(perturbation_type=perturbation_type)
+    
+    print(f"\nStarting simulation with {perturbation_type} perturbation...")
+    print(f"Simulation ID: {solver.config.simulation_id}")
+    
+    try:
+        # LAUNCH COMPLETE SIMULATION
+        start_time = datetime.now()
+        solver.run_full_simulation()
+        end_time = datetime.now()
+        
+        print(f"\nSimulation time: {end_time - start_time}")
+        
+        # AUTOMATIC SAVING
+        solver.save_results()
+        
+        # PLOT GENERATION
+        solver.generate_plots()
+        
+        # DISPLAY SUMMARY
+        print(solver.get_simulation_summary())
+        
+    except KeyboardInterrupt:
+        print("\n⚠ Simulation interrupted by user")
+    except Exception as e:
+        print(f"\n❌ Simulation failed: {e}")
+        raise
+
+def main():
+    """
+    Main entry point for the CLI.
+    """
+    parser = argparse.ArgumentParser(description="Quantum PINN Simulator for donor-acceptor modulation.")
+    parser.add_argument('--version', action='version', version=f'%(prog)s {__version__}')
+    
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+
+    # 'run' command
+    run_parser = subparsers.add_parser('run', help='Run a simulation')
+    run_parser.add_argument('--perturbation-type', type=str, default='gaussian',
+                            help='Type of perturbation to apply (e.g., gaussian, sinusoidal)')
+
+    args = parser.parse_args()
+
+    if args.command == 'run':
+        run_simulation(args.perturbation_type)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

modulation_da/perturbations.py

@@ -0,0 +1,103 @@
+# perturbations.py
+import numpy as np
+
+class PerturbationManager:
+    """Management of all time-dependent perturbations"""
+    
+    def __init__(self, config):
+        self.config = config
+        self.setup_parameters()
+    
+    def setup_parameters(self):
+        """Perturbation parameters"""
+        self.cent = 15 * self.config.Power
+        self.he1, self.he2 = 0.500, 0.00
+        self.W0 = 5.0 * self.config.Power
+        self.W1 = 2 * self.config.molE / self.config.hbar
+        self.tau = 6 * self.config.Power
+        
+        # Normalization
+        self.cent_norm = self.cent / self.config.t_scale
+        self.he1_norm = self.he1 / self.config.E_scale
+        self.he2_norm = self.he2 / self.config.E_scale
+        self.W0_norm = self.W0 / self.config.t_scale
+        self.W1_norm = self.W1 * self.config.t_scale
+        self.tau_norm = self.tau / self.config.t_scale
+    
+    def gaussian_perturbation(self, t_norm):
+        """Gaussian perturbation"""
+        How = np.zeros((self.config.n, self.config.n), dtype=complex)
+        
+        term1 = (-self.he1_norm * np.cos(self.W1_norm * (t_norm - self.cent_norm)) *
+                np.exp(-((t_norm - self.cent_norm)**2) / (2 * self.W0_norm**2)))
+        
+        term2 = (-self.he2_norm * np.cos(self.W1_norm * (t_norm - self.cent_norm - self.tau_norm)) *
+                np.exp(-((t_norm - self.cent_norm - self.tau_norm)**2) / (2 * self.W0_norm**2)))
+        
+        valeur = term1 + term2
+        How[0, 1] = How[1, 0] = valeur
+        return How
+    
+    def sinusoidal_perturbation(self, t_norm):
+        """Continuous sinusoidal perturbation"""
+        How = np.zeros((self.config.n, self.config.n), dtype=complex)
+        amplitude = self.he1_norm
+        frequency = self.W1_norm
+        
+        # Simple sine wave
+        valeur = -amplitude * np.cos(frequency * t_norm)
+        How[0, 1] = How[1, 0] = valeur
+        return How
+    
+    def rectangular_perturbation(self, t_norm):
+        """Rectangular pulse"""
+        How = np.zeros((self.config.n, self.config.n), dtype=complex)
+        t_start, t_duration = 10, 20
+        
+        if t_start <= t_norm <= t_start + t_duration:
+            valeur = -self.he1_norm * np.cos(self.W1_norm * t_norm)
+            How[0, 1] = How[1, 0] = valeur
+        return How
+    
+    def exponential_perturbation(self, t_norm):
+        """Exponential perturbation"""
+        How = np.zeros((self.config.n, self.config.n), dtype=complex)
+        t_start = 10
+        
+        if t_norm >= t_start:
+            decay = np.exp(-(t_norm - t_start) / self.W0_norm)
+            valeur = -self.he1_norm * decay * np.cos(self.W1_norm * t_norm)
+            How[0, 1] = How[1, 0] = valeur
+        return How
+    
+    def modulated_sinusoidal(self, t_norm):
+        """Amplitude-modulated sine wave"""
+        How = np.zeros((self.config.n, self.config.n), dtype=complex)
+        
+        # Gaussian envelope
+        envelope = np.exp(-((t_norm - self.cent_norm)**2) / (2 * self.W0_norm**2))
+        carrier = np.cos(self.W1_norm * t_norm)
+        
+        valeur = -self.he1_norm * envelope * carrier
+        How[0, 1] = How[1, 0] = valeur
+        return How
+    
+    def get_perturbation(self, t_norm, perturbation_type='gaussian'):
+        """Perturbation selector"""
+        perturbations = {
+            'gaussian': self.gaussian_perturbation,
+            'sinusoidal': self.sinusoidal_perturbation,
+            'rectangular': self.rectangular_perturbation,
+            'exponential': self.exponential_perturbation,
+            'modulated_sinusoidal': self.modulated_sinusoidal
+        }
+        
+        return perturbations[perturbation_type](t_norm)
+    
+    def generate_pulse_profile(self, t_values, perturbation_type):
+        """Generates pulse profile for visualization"""
+        profile = []
+        for t in t_values:
+            H_pert = self.get_perturbation(t, perturbation_type)
+            profile.append(np.real(H_pert[0, 1]))
+        return np.array(profile)

modulation_da/pinn_model.py

@@ -0,0 +1,243 @@
+# pinn_model.py
+import tensorflow as tf
+import numpy as np
+from time import time
+import scipy.optimize
+
+class PINNModel:
+    """Complete management of PINN model and hybrid training"""    
+    def __init__(self, config):
+        self.config = config
+        self.N = 15000
+        self.N_0 = 2000
+        self.N_pred = 5000
+        self.N_train_adam = 90000
+        self.N_train_lbfgs = 3000
+        
+    def create_model(self, num_hidden=4, num_neurons=64):
+        """Creates the neural network"""
+        model = tf.keras.Sequential()
+        model.add(tf.keras.layers.InputLayer(input_shape=(1,)))
+        
+        for _ in range(num_hidden):
+            model.add(tf.keras.layers.Dense(num_neurons, activation='tanh',
+                                          kernel_initializer='glorot_normal'))
+        
+        model.add(tf.keras.layers.Dense(2 * self.config.n))
+        return model
+    
+    def physics_loss(self, model, t_colloc_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i):
+        """Calculates physics loss based on PDE with consistent units"""
+        with tf.GradientTape(persistent=True) as tape:
+            tape.watch(t_colloc_norm)
+            psi_pred = model(t_colloc_norm)
+            u = psi_pred[:, :self.config.n]
+            v = psi_pred[:, self.config.n:]
+
+        u_t = tape.batch_jacobian(u, t_colloc_norm)[:, :, 0]
+        v_t = tape.batch_jacobian(v, t_colloc_norm)[:, :, 0]
+        del tape
+        # Source term S(t) 
+        E_complex = tf.cast(E_norm, tf.complex64)
+        t_complex = tf.cast(tf.squeeze(t_colloc_norm), tf.complex64)
+        phase = tf.exp(-1j * E_complex * t_complex)
+        phase = tf.expand_dims(phase, axis=-1)  # [N, 1]
+
+        psi_st_broadcast = tf.transpose(psi_st_tensor)  # [1, n]
+        expo_term = phase * psi_st_broadcast  # [N, n] 
+        expo_term = tf.expand_dims(expo_term, axis=-1)  # [N, n, 1]
+
+        S_complex = tf.matmul(HP_tensor, expo_term)  # [N, n, n] @ [N, n, 1] = [N, n, 1]
+        S_complex = tf.squeeze(S_complex, axis=-1)  # [N, n]
+        S_r = tf.math.real(S_complex)
+        S_i = tf.math.imag(S_complex)
+
+        # Residual equations
+        u_exp = tf.expand_dims(u, axis=-1)  # [N, n, 1]
+        v_exp = tf.expand_dims(v, axis=-1)  # [N, n, 1]
+
+        # H_t_r et H_t_i are [N, n, n]
+        # u_exp et v_exp are [N, n, 1]
+        # Result matmul: [N, n, 1] -> squeeze -> [N, n]
+        r_u = u_t - tf.squeeze(tf.matmul(H_t_r, v_exp), axis=-1) - tf.squeeze(tf.matmul(H_t_i, u_exp), axis=-1) - S_i
+        r_v = -v_t - tf.squeeze(tf.matmul(H_t_r, u_exp), axis=-1) + tf.squeeze(tf.matmul(H_t_i, v_exp), axis=-1) - S_r
+
+        pde_loss = tf.reduce_mean(tf.square(r_u)) + tf.reduce_mean(tf.square(r_v))
+        return pde_loss
+    
+    def initial_conditions_loss(self, model, t_0_norm):
+        """Loss for initial conditions (zero)"""
+        psi_pred_0 = model(t_0_norm)
+        u_0 = psi_pred_0[:, :self.config.n]
+        v_0 = psi_pred_0[:, self.config.n:]
+        ic_loss = tf.reduce_mean(tf.square(u_0)) + tf.reduce_mean(tf.square(v_0))
+        return ic_loss
+    
+    def total_loss(self, model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i):
+        """Total loss combining physics and initial conditions"""
+        pde_loss = self.physics_loss(model, t_colloc_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i)
+        ic_loss = self.initial_conditions_loss(model, t_0_norm)
+
+        lambda_pde = 1.0
+        lambda_ic = 1.0
+
+        return lambda_pde * pde_loss + lambda_ic * ic_loss, pde_loss, ic_loss
+    
+    def get_weights(self, model):
+        """Extracts model weights as 1D vector"""
+        weights = []
+        for layer in model.layers:
+            if hasattr(layer, 'get_weights') and layer.get_weights():
+                for w in layer.get_weights():
+                    weights.append(w.flatten())
+        return np.concatenate(weights) if weights else np.array([])
+    
+    def set_weights(self, model, weights_1d):
+        """Restores model weights from 1D vector"""
+        idx = 0
+        for layer in model.layers:
+            if hasattr(layer, 'get_weights') and layer.get_weights():
+                layer_weights = []
+                for w in layer.get_weights():
+                    size = w.size
+                    new_w = weights_1d[idx:idx+size].reshape(w.shape)
+                    layer_weights.append(new_w)
+                    idx += size
+                layer.set_weights(layer_weights)
+    
+    def lbfgs_loss_func(self, weights_1d, model, t_colloc_norm, t_0_norm, E_norm,
+                       psi_st_tensor, HP_tensor, H_t_r, H_t_i):
+        """Loss function for L-BFGS"""
+        self.set_weights(model, weights_1d)
+
+        with tf.GradientTape() as tape:
+            loss, pde_loss, ic_loss = self.total_loss(
+                model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+            )
+
+        gradients = tape.gradient(loss, model.trainable_variables)
+        grad_1d = []
+        for grad in gradients:
+            if grad is not None:
+                grad_1d.append(grad.numpy().flatten())
+        grad_1d = np.concatenate(grad_1d) if grad_1d else np.array([])
+
+        return float(loss.numpy()), grad_1d.astype(np.float64)
+    
+    def train_hybrid(self, model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor,
+                    HP_tensor, H_t_r, H_t_i):
+        """Trains the model with Adam then L-BFGS"""
+
+        # Phase 1: Adam training
+        print("    Phase 1: Adam training...")
+
+        # Adam optimizer with adaptive learning rate
+        initial_lr = 1e-3
+        lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
+            initial_learning_rate=initial_lr,
+            decay_steps=30000,
+            decay_rate=0.9,
+            staircase=True
+        )
+        optimizer_adam = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
+
+        @tf.function
+        def adam_train_step():
+            with tf.GradientTape() as tape:
+                loss, pde_loss, ic_loss = self.total_loss(
+                    model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+                )
+            gradients = tape.gradient(loss, model.trainable_variables)
+            optimizer_adam.apply_gradients(zip(gradients, model.trainable_variables))
+            return loss, pde_loss, ic_loss
+
+        adam_history = {'total_loss': [], 'pde_loss': [], 'ic_loss': []}
+        t_start_adam = time()
+
+        for epoch in range(self.N_train_adam):
+            loss, pde_loss, ic_loss = adam_train_step()
+
+            if epoch % 1000 == 0:
+                print(f"      Adam Epoch {epoch:5d}: Total = {loss:.6e}, PDE = {pde_loss:.6e}, IC = {ic_loss:.6e}")
+
+            adam_history['total_loss'].append(float(loss))
+            adam_history['pde_loss'].append(float(pde_loss))
+            adam_history['ic_loss'].append(float(ic_loss))
+
+            # Early stopping criterion for Adam
+            if epoch > 1000 and loss < 1e-4:
+                print(f"      Early stopping at epoch {epoch}")
+                break
+
+        print(f"    Adam training time: {time() - t_start_adam:.2f}s")
+        print(f"    Final Adam loss: {loss:.6e}")
+
+        # Phase 2: L-BFGS refinement
+        print("    Phase 2: L-BFGS refinement...")
+
+        t_start_lbfgs = time()
+
+        # Initial weights for L-BFGS
+        initial_weights = self.get_weights(model)
+
+        # L-BFGS configuration
+        lbfgs_options = {
+            'maxiter': self.N_train_lbfgs,
+            'maxfun': self.N_train_lbfgs * 2,
+            'ftol': 1e-12,
+            'gtol': 1e-12,
+            'eps': 1e-8,
+            'disp': True
+        }
+
+        # Variables to track L-BFGS iterations
+        self.lbfgs_iter = 0
+        self.lbfgs_losses = []
+
+        def callback_func(xk):
+            self.lbfgs_iter += 1
+            if self.lbfgs_iter % 100 == 0:
+                self.set_weights(model, xk)
+                loss, pde_loss, ic_loss = self.total_loss(
+                    model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+                )
+                print(f"      L-BFGS Iter {self.lbfgs_iter:4d}: Total = {loss:.6e}, PDE = {pde_loss:.6e}, IC = {ic_loss:.6e}")
+                self.lbfgs_losses.append(float(loss))
+
+        # L-BFGS optimization
+        try:
+            result = scipy.optimize.minimize(
+                fun=lambda w: self.lbfgs_loss_func(w, model, t_colloc_norm, t_0_norm,
+                                                  E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i),
+                x0=initial_weights.astype(np.float64),
+                method='L-BFGS-B',
+                jac=True,
+                callback=callback_func,
+                options=lbfgs_options
+            )
+
+            self.set_weights(model, result.x)
+
+            print(f"    L-BFGS completed: {result.message}")
+            print(f"    L-BFGS iterations: {result.nit}")
+            print(f"    Final L-BFGS loss: {result.fun:.6e}")
+
+        except Exception as e:
+            print(f"    L-BFGS error: {e}")
+            print("    Using Adam weights as final solution")
+
+        print(f"    L-BFGS training time: {time() - t_start_lbfgs:.2f}s")
+
+        # Final Evaluation
+        final_loss, final_pde_loss, final_ic_loss = self.total_loss(
+            model, t_colloc_norm, t_0_norm, E_norm, psi_st_tensor, HP_tensor, H_t_r, H_t_i
+        )
+        print(f"    Final combined loss: {final_loss:.6e}")
+
+        return {
+            'adam_history': adam_history,
+            'lbfgs_losses': self.lbfgs_losses,
+            'final_loss': float(final_loss),
+            'final_pde_loss': float(final_pde_loss),
+            'final_ic_loss': float(final_ic_loss)
+        }

modulation_da/quantum_config.py

@@ -0,0 +1,50 @@
+# quantum_config.py
+import numpy as np
+from datetime import datetime
+
+class QuantumConfig:
+    """Configuration of physical parameters and normalization"""
+    
+    def __init__(self):
+        # Physical constants
+        self.e_charge = 1.602176634e-19
+        self.hbar = 6.582119514e-16
+        self.KB = 8.6173303e-5
+        self.pi = np.pi
+        
+         # System parameters
+        self.n = 3
+        self.Ne = 20
+        self.E_min, self.E_max = -2.5, 2.5
+        self.Ef, self.Temp = 0.0, 10
+        
+        # Hamiltonian
+        self.GammaL, self.GammaR = 0.05, 0.05
+        self.molE, self.tm = 0.7, 0.1
+        
+        # Time
+        self.Power = 1.0e-15
+        self.t_min, self.t_max = 0, 100 * self.Power
+        
+        self._setup_normalization()
+        self._record_simulation_time()
+    
+    def _setup_normalization(self):
+        """Normalization of physical units"""
+        self.E_scale = abs(self.molE)
+        self.t_scale = self.hbar / self.E_scale
+        self.current_scale = self.e_charge / self.t_scale
+        
+        # Normalized parameters
+        self.E_min_norm = self.E_min / self.E_scale
+        self.E_max_norm = self.E_max / self.E_scale
+        self.dE_norm = (self.E_max_norm - self.E_min_norm) / self.Ne
+        self.Ef_norm = self.Ef / self.E_scale
+        self.KBT_norm = (self.KB * self.Temp) / self.E_scale
+        self.t_min_norm = self.t_min / self.t_scale
+        self.t_max_norm = self.t_max / self.t_scale
+    
+    def _record_simulation_time(self):
+        """Records the simulation start time"""
+        self.start_time = datetime.now()
+        self.simulation_id = self.start_time.strftime("%Y%m%d_%H%M%S")