Skip to main content

shivya_turing/
morphogen.rs

1pub struct MorphogenSystem {
2    pub max_nodes: usize,
3    pub active: Vec<bool>,
4    
5    // Activator and inhibitor concentrations
6    pub u: Vec<f64>,
7    pub v: Vec<f64>,
8    
9    // Adjacency matrix for topology weights
10    pub adj: Vec<Vec<f64>>,
11    
12    // Constants
13    pub d_u: f64, // Activator diffusion rate
14    pub d_v: f64, // Inhibitor diffusion rate
15    
16    // Gierer-Meinhardt parameter constants
17    pub a: f64,
18    pub b: f64,
19    pub c: f64,
20    pub d: f64,
21}
22
23impl MorphogenSystem {
24    pub fn new(max_nodes: usize, d_u: f64, d_v: f64) -> Self {
25        Self {
26            max_nodes,
27            active: vec![false; max_nodes],
28            u: vec![0.0; max_nodes],
29            v: vec![0.0; max_nodes],
30            adj: vec![vec![0.0; max_nodes]; max_nodes],
31            d_u,
32            d_v,
33            a: 0.1,
34            b: 1.0,
35            c: 1.0,
36            d: 1.0,
37        }
38    }
39
40    pub fn activate_node(&mut self, idx: usize, u_init: f64, v_init: f64) {
41        if idx < self.max_nodes {
42            self.active[idx] = true;
43            self.u[idx] = u_init;
44            self.v[idx] = v_init;
45        }
46    }
47
48    pub fn set_edge(&mut self, u_idx: usize, v_idx: usize, weight: f64) {
49        if u_idx < self.max_nodes && v_idx < self.max_nodes {
50            self.adj[u_idx][v_idx] = weight;
51            self.adj[v_idx][u_idx] = weight; // Symmetric undirected connections
52        }
53    }
54
55    // Calculates maximum node degree to dynamically clamp dt via CFL guard
56    pub fn get_cfl_dt(&self, requested_dt: f64) -> f64 {
57        let mut max_deg = 0.0;
58        for i in 0..self.max_nodes {
59            if self.active[i] {
60                let mut deg = 0.0;
61                for j in 0..self.max_nodes {
62                    if self.active[j] {
63                        deg += self.adj[i][j];
64                    }
65                }
66                if deg > max_deg {
67                    max_deg = deg;
68                }
69            }
70        }
71        
72        let max_diffusion = self.d_u.max(self.d_v);
73        // CFL requirement: dt < 0.5 / (max_diffusion * max_degree)
74        let safety_limit = 0.45 / (max_diffusion * max_deg.max(1.0));
75        requested_dt.min(safety_limit)
76    }
77
78    // Computes Derivatives du/dt and dv/dt
79    pub fn compute_derivatives(&self, u_state: &[f64], v_state: &[f64], du: &mut [f64], dv: &mut [f64]) {
80        for i in 0..self.max_nodes {
81            if !self.active[i] {
82                du[i] = 0.0;
83                dv[i] = 0.0;
84                continue;
85            }
86
87            // 1. Calculate discrete Laplacian for node i
88            let mut lap_u = 0.0;
89            let mut lap_v = 0.0;
90            for j in 0..self.max_nodes {
91                if self.active[j] && self.adj[i][j] > 0.0 {
92                    let weight = self.adj[i][j];
93                    lap_u += weight * (u_state[j] - u_state[i]);
94                    lap_v += weight * (v_state[j] - v_state[i]);
95                }
96            }
97
98            // 2. Reaction kinetics (Gierer-Meinhardt) with division safeguard
99            let ui = u_state[i];
100            let vi = v_state[i].max(1e-5); // Prevent div by zero
101
102            let react_u = self.a - self.b * ui + (ui * ui) / vi;
103            let react_v = self.c * ui * ui - self.d * vi;
104
105            du[i] = self.d_u * lap_u + react_u;
106            dv[i] = self.d_v * lap_v + react_v;
107        }
108    }
109
110    // Runge-Kutta 4th Order step
111    pub fn step_rk4(&mut self, requested_dt: f64) {
112        let dt = self.get_cfl_dt(requested_dt);
113        let n = self.max_nodes;
114
115        let mut k1_u = vec![0.0; n];
116        let mut k1_v = vec![0.0; n];
117        self.compute_derivatives(&self.u, &self.v, &mut k1_u, &mut k1_v);
118
119        let mut tmp_u = vec![0.0; n];
120        let mut tmp_v = vec![0.0; n];
121        for i in 0..n {
122            tmp_u[i] = self.u[i] + 0.5 * dt * k1_u[i];
123            tmp_v[i] = self.v[i] + 0.5 * dt * k1_v[i];
124        }
125
126        let mut k2_u = vec![0.0; n];
127        let mut k2_v = vec![0.0; n];
128        self.compute_derivatives(&tmp_u, &tmp_v, &mut k2_u, &mut k2_v);
129
130        for i in 0..n {
131            tmp_u[i] = self.u[i] + 0.5 * dt * k2_u[i];
132            tmp_v[i] = self.v[i] + 0.5 * dt * k2_v[i];
133        }
134
135        let mut k3_u = vec![0.0; n];
136        let mut k3_v = vec![0.0; n];
137        self.compute_derivatives(&tmp_u, &tmp_v, &mut k3_u, &mut k3_v);
138
139        for i in 0..n {
140            tmp_u[i] = self.u[i] + dt * k3_u[i];
141            tmp_v[i] = self.v[i] + dt * k3_v[i];
142        }
143
144        let mut k4_u = vec![0.0; n];
145        let mut k4_v = vec![0.0; n];
146        self.compute_derivatives(&tmp_u, &tmp_v, &mut k4_u, &mut k4_v);
147
148        // Update concentrations using weighted average of stages
149        for i in 0..n {
150            if self.active[i] {
151                self.u[i] += (dt / 6.0) * (k1_u[i] + 2.0 * k2_u[i] + 2.0 * k3_u[i] + k4_u[i]);
152                self.v[i] += (dt / 6.0) * (k1_v[i] + 2.0 * k2_v[i] + 2.0 * k3_v[i] + k4_v[i]);
153            }
154        }
155    }
156}