geff.utility.mode

A module defining equations used to define a GEFF.mbm.ModeSolver.

View Source

  1"""
  2A module defining equations used to define a `GEFF.mbm.ModeSolver`.
  3"""
  4import numpy as np
  5from typing import Callable
  6
  7
  8def bd_classic(t: float, k : float) -> np.ndarray:
  9    r"""
 10    Returns gauge-field modes in Bunch&ndash;Davies vacuum:
 11
 12    $$A_\lambda(k,t) \sim \frac{1}{\sqrt{2k}}exp{(-i \eta(t) k)}\, , \qquad -\eta(t) k \gg 1 \, .$$
 13
 14    Parameters
 15    ----------
 16    t : float
 17        time of initialisation $t_{\rm init}$
 18    k : float
 19        comoving momentum $k$
 20
 21    Returns
 22    -------
 23    y : NDArray
 24         $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$ in Bunch&ndash;Davies
 25
 26    """
 27    return np.array([1., 0, 0, -1., 1, 0, 0, -1.])
 28
 29def mode_equation_classic(t: float, y : np.ndarray, k : float, a : Callable,
 30                    xi : Callable, H : Callable) -> np.ndarray:
 31    r"""
 32    Mode equation for pure axion inflation:
 33
 34    $$\ddot{A}_\lambda(t,k) + H \dot{A}_\lambda(t,k) + \left[\left(\frac{k}{a}\right)^2  - 2\lambda \left(\frac{k}{a}\right) \xi H \right]A_\lambda(t,k) = 0 \, .$$
 35
 36    Parameters
 37    ----------
 38    t : float
 39        cosmic time $t$
 40    y : NDArray
 41        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
 42    k : float
 43        comoving momentum $k$
 44    a : Callable
 45        scale factor as function of time, $a(t)$
 46    xi : Callable
 47        instability parameter as function of time, $\xi(t)$
 48    H : Callable
 49        Hubble rate as function of time, $H(t)$
 50        
 51    Returns
 52    -------
 53    dydt : array
 54        an array of time derivatives of y
 55    """
 56    
 57    dydt = np.zeros_like(y)
 58    
 59    dis1 = k / a(t)
 60    dis2 = 2*H(t)*xi(t)
 61
 62    #positive helicity
 63    lam = 1.
 64    #Real Part
 65    dydt[0] = y[1]*dis1
 66    dydt[1] = -(dis1  - lam * dis2) * y[0]
 67    
 68    #Imaginary Part
 69    dydt[2] = y[3]*dis1
 70    dydt[3] = -(dis1  - lam * dis2) * y[2]
 71    
 72    #negative helicity
 73    lam = -1.
 74    #Real Part
 75    dydt[4] = y[5]*dis1
 76    dydt[5] = -(dis1  - lam * dis2) * y[4]
 77    
 78    #Imaginary Part
 79    dydt[6] = y[7]*dis1
 80    dydt[7] = -(dis1  - lam * dis2) * y[6]
 81    
 82    return dydt
 83
 84def damped_bd(t : float, k : float, a : Callable, delta : Callable,
 85              sigmaE : Callable) -> np.ndarray:
 86    r"""
 87    Returns gauge-field modes in damped Bunch&ndash;Davies vaccum:
 88
 89    $$A_\lambda(k,t) \sim \sqrt{\frac{\Delta(t)}{2k}}exp{(-i \eta(t) k)}\, , \qquad -\eta(t) k \gg 1 \, .$$
 90
 91    Parameters
 92    ----------
 93    t : float
 94        time of initialisation $t_{\rm init}$
 95    k : float
 96        comoving momentum $k$
 97    a : Callable
 98        scale factor as function of time, $a(t)$
 99    sigmaE : Callable
100        electric damping, $\sigma_{\rm E}(t)$
101    delta : Callable
102        cumulative electric damping $\Delta(t) = \exp{\left(-\int \sigma_{\rm E}(t) {\rm d}t\right)}$
103
104    Returns
105    -------
106    y : NDArray
107        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$ in Bunch&ndash;Davies
108
109    """
110    yini = np.array([1., -1/2*sigmaE(t)*a(t)/k, 0, -1.,
111                     1., -1/2*sigmaE(t)*a(t)/k, 0, -1.])*np.sqrt( delta(t) )
112    return yini
113
114
115def mode_equation_SE_no_scale(t: float, y : np.ndarray, k : float,
116                    a : Callable, xieff : Callable, H : Callable,
117                    sigmaE : Callable) -> np.ndarray:
118    r"""
119    Mode equation for scale-dependent fermionic axion inflation:
120
121    $$\ddot{A}_\lambda(t, k)  + \big( H + \sigma_{\rm E} \big) \dot{A}_\lambda(t, k) + \left[ \left(\frac{k}{a}\right)^2 - \lambda \frac{k}{a} \big( 2 \xi H + \sigma_{\rm B} \big) \right] A_\lambda(t, k) = 0\, .$$
122
123    Parameters
124    ----------
125    t : float
126        cosmic time $t$
127    y : NDArray
128        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
129    k : float
130        comoving momentum $k$
131    a : Callable
132        scale factor as function of time, $a(t)$
133    xieff : Callable
134        effective instability parameter as function of time, $\xi_{\rm eff}(t)$
135    H : Callable
136        Hubble rate as function of time, $H(t)$
137    sigmaE : Callable
138        electric damping, $\sigma_{\rm E}(t)$
139        
140    Returns
141    -------
142    dydt : array
143        an array of time derivatives of y
144    """
145    
146    dydt = np.zeros_like(y)
147    
148    drag = sigmaE(t)
149    dis1 = k / a(t)
150    dis2 = 2*H(t)*xieff(t)
151
152    #positive helicity
153    lam = 1.
154    #Real Part
155    dydt[0] = y[1]*dis1
156    dydt[1] = - drag * y[1] - (dis1  - lam * dis2) * y[0]
157    
158    #Imaginary Part
159    dydt[2] = y[3]*dis1
160    dydt[3] = - drag * y[3] - (dis1  - lam * dis2) * y[2]
161    
162    #negative helicity
163    lam = -1.
164    #Real Part
165    dydt[4] = y[5]*dis1
166    dydt[5] = - drag * y[5] - (dis1  - lam * dis2) * y[4]
167    
168    #Imaginary Part
169    dydt[6] = y[7]*dis1
170    dydt[7] = - drag * y[7] - (dis1  - lam * dis2) * y[6]
171    
172    return dydt
173
174def mode_equation_SE_scale(t: float, y : np.ndarray, k : float,
175                    a : Callable, xi : Callable, H : Callable,
176                    sigmaE : Callable, sigmaB : Callable,
177                      kS : Callable) -> np.ndarray:
178    r"""
179    Mode equation for scale-independent fermionic axion inflation:
180
181    $$\ddot{A}_\lambda(t, k)  + \big( H + \sigma_{\rm E} \Theta(t, k) \big) \dot{A}_\lambda(t, k) + \left[ \left(\frac{k}{a}\right)^2 - \lambda \frac{k}{a} \big( 2 \xi H + \sigma_{\rm B}\Theta(t, k) \big) \right] A_\lambda(t, k) = 0\, .$$
182
183    Parameters
184    ----------
185    t : float
186        cosmic time $t$
187    y : NDArray
188        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
189    k : float
190        comoving momentum $k$
191    a : Callable
192        scale factor as function of time, $a(t)$
193    xi : Callable
194        einstability parameter as function of time, $\xi(t)$
195    H : Callable
196        Hubble rate as function of time, $H(t)$
197    sigmaE : Callable
198        electric damping, $\sigma_{\rm E}(t)$
199    sigmaB : Callable
200        magnetic damping, $\sigma_{\rm B}(t)$
201    kS : Callable
202        no damping for $k > k_{\rm S}(t)$ from $\Theta(t, k)$
203        
204    Returns
205    -------
206    dydt : array
207        an array of time derivatives of y
208    """
209
210    dydt = np.zeros_like(y)
211    cut = max(a(t)*H(t), kS(t))
212    theta = np.heaviside(cut - k, 0.5)
213    
214    drag = theta*sigmaE(t)
215    dis1 = k / a(t)
216    dis2 = 2*H(t)*xi(t) + theta*sigmaB(t)
217
218    #positive helicity
219    lam = 1.
220    #Real Part
221    dydt[0] = y[1]*dis1
222    dydt[1] = - drag * y[1] - (dis1  - lam * dis2) * y[0]
223    
224    #Imaginary Part
225    dydt[2] = y[3]*dis1
226    dydt[3] = - drag * y[3] - (dis1  - lam * dis2) * y[2]
227    
228    #negative helicity
229    lam = -1.
230    #Real Part
231    dydt[4] = y[5]*dis1
232    dydt[5] = - drag * y[5] - (dis1  - lam * dis2) * y[4]
233    
234    #Imaginary Part
235    dydt[6] = y[7]*dis1
236    dydt[7] = - drag * y[7] - (dis1  - lam * dis2) * y[6]
237    
238    return dydt

def bd_classic(t: float, k: float) -> numpy.ndarray: View Source

 9def bd_classic(t: float, k : float) -> np.ndarray:
10    r"""
11    Returns gauge-field modes in Bunch&ndash;Davies vacuum:
12
13    $$A_\lambda(k,t) \sim \frac{1}{\sqrt{2k}}exp{(-i \eta(t) k)}\, , \qquad -\eta(t) k \gg 1 \, .$$
14
15    Parameters
16    ----------
17    t : float
18        time of initialisation $t_{\rm init}$
19    k : float
20        comoving momentum $k$
21
22    Returns
23    -------
24    y : NDArray
25         $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$ in Bunch&ndash;Davies
26
27    """
28    return np.array([1., 0, 0, -1., 1, 0, 0, -1.])

Returns gauge-field modes in Bunch–Davies vacuum:

$$A_\lambda(k,t) \sim \frac{1}{\sqrt{2k}}exp{(-i \eta(t) k)}\, , \qquad -\eta(t) k \gg 1 \, .$$

Parameters

t (float): time of initialisation $t_{\rm init}$
k (float): comoving momentum $k$

Returns

y (NDArray): $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$ in Bunch–Davies

def mode_equation_classic( t: float, y: numpy.ndarray, k: float, a: Callable, xi: Callable, H: Callable) -> numpy.ndarray: View Source

30def mode_equation_classic(t: float, y : np.ndarray, k : float, a : Callable,
31                    xi : Callable, H : Callable) -> np.ndarray:
32    r"""
33    Mode equation for pure axion inflation:
34
35    $$\ddot{A}_\lambda(t,k) + H \dot{A}_\lambda(t,k) + \left[\left(\frac{k}{a}\right)^2  - 2\lambda \left(\frac{k}{a}\right) \xi H \right]A_\lambda(t,k) = 0 \, .$$
36
37    Parameters
38    ----------
39    t : float
40        cosmic time $t$
41    y : NDArray
42        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
43    k : float
44        comoving momentum $k$
45    a : Callable
46        scale factor as function of time, $a(t)$
47    xi : Callable
48        instability parameter as function of time, $\xi(t)$
49    H : Callable
50        Hubble rate as function of time, $H(t)$
51        
52    Returns
53    -------
54    dydt : array
55        an array of time derivatives of y
56    """
57    
58    dydt = np.zeros_like(y)
59    
60    dis1 = k / a(t)
61    dis2 = 2*H(t)*xi(t)
62
63    #positive helicity
64    lam = 1.
65    #Real Part
66    dydt[0] = y[1]*dis1
67    dydt[1] = -(dis1  - lam * dis2) * y[0]
68    
69    #Imaginary Part
70    dydt[2] = y[3]*dis1
71    dydt[3] = -(dis1  - lam * dis2) * y[2]
72    
73    #negative helicity
74    lam = -1.
75    #Real Part
76    dydt[4] = y[5]*dis1
77    dydt[5] = -(dis1  - lam * dis2) * y[4]
78    
79    #Imaginary Part
80    dydt[6] = y[7]*dis1
81    dydt[7] = -(dis1  - lam * dis2) * y[6]
82    
83    return dydt

Mode equation for pure axion inflation:

$$\ddot{A}_\lambda(t,k) + H \dot{A}_\lambda(t,k) + \left[\left(\frac{k}{a}\right)^2 - 2\lambda \left(\frac{k}{a}\right) \xi H \right]A_\lambda(t,k) = 0 \, .$$

Parameters

t (float): cosmic time $t$
y (NDArray): $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
k (float): comoving momentum $k$
a (Callable): scale factor as function of time, $a(t)$
xi (Callable): instability parameter as function of time, $\xi(t)$
H (Callable): Hubble rate as function of time, $H(t)$

Returns

dydt (array): an array of time derivatives of y

def damped_bd( t: float, k: float, a: Callable, delta: Callable, sigmaE: Callable) -> numpy.ndarray: View Source

 85def damped_bd(t : float, k : float, a : Callable, delta : Callable,
 86              sigmaE : Callable) -> np.ndarray:
 87    r"""
 88    Returns gauge-field modes in damped Bunch&ndash;Davies vaccum:
 89
 90    $$A_\lambda(k,t) \sim \sqrt{\frac{\Delta(t)}{2k}}exp{(-i \eta(t) k)}\, , \qquad -\eta(t) k \gg 1 \, .$$
 91
 92    Parameters
 93    ----------
 94    t : float
 95        time of initialisation $t_{\rm init}$
 96    k : float
 97        comoving momentum $k$
 98    a : Callable
 99        scale factor as function of time, $a(t)$
100    sigmaE : Callable
101        electric damping, $\sigma_{\rm E}(t)$
102    delta : Callable
103        cumulative electric damping $\Delta(t) = \exp{\left(-\int \sigma_{\rm E}(t) {\rm d}t\right)}$
104
105    Returns
106    -------
107    y : NDArray
108        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$ in Bunch&ndash;Davies
109
110    """
111    yini = np.array([1., -1/2*sigmaE(t)*a(t)/k, 0, -1.,
112                     1., -1/2*sigmaE(t)*a(t)/k, 0, -1.])*np.sqrt( delta(t) )
113    return yini

Returns gauge-field modes in damped Bunch–Davies vaccum:

$$A_\lambda(k,t) \sim \sqrt{\frac{\Delta(t)}{2k}}exp{(-i \eta(t) k)}\, , \qquad -\eta(t) k \gg 1 \, .$$

Parameters

t (float): time of initialisation $t_{\rm init}$
k (float): comoving momentum $k$
a (Callable): scale factor as function of time, $a(t)$
sigmaE (Callable): electric damping, $\sigma_{\rm E}(t)$
delta (Callable): cumulative electric damping $\Delta(t) = \exp{\left(-\int \sigma_{\rm E}(t) {\rm d}t\right)}$

Returns

y (NDArray): $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$ in Bunch–Davies

def mode_equation_SE_no_scale( t: float, y: numpy.ndarray, k: float, a: Callable, xieff: Callable, H: Callable, sigmaE: Callable) -> numpy.ndarray: View Source

116def mode_equation_SE_no_scale(t: float, y : np.ndarray, k : float,
117                    a : Callable, xieff : Callable, H : Callable,
118                    sigmaE : Callable) -> np.ndarray:
119    r"""
120    Mode equation for scale-dependent fermionic axion inflation:
121
122    $$\ddot{A}_\lambda(t, k)  + \big( H + \sigma_{\rm E} \big) \dot{A}_\lambda(t, k) + \left[ \left(\frac{k}{a}\right)^2 - \lambda \frac{k}{a} \big( 2 \xi H + \sigma_{\rm B} \big) \right] A_\lambda(t, k) = 0\, .$$
123
124    Parameters
125    ----------
126    t : float
127        cosmic time $t$
128    y : NDArray
129        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
130    k : float
131        comoving momentum $k$
132    a : Callable
133        scale factor as function of time, $a(t)$
134    xieff : Callable
135        effective instability parameter as function of time, $\xi_{\rm eff}(t)$
136    H : Callable
137        Hubble rate as function of time, $H(t)$
138    sigmaE : Callable
139        electric damping, $\sigma_{\rm E}(t)$
140        
141    Returns
142    -------
143    dydt : array
144        an array of time derivatives of y
145    """
146    
147    dydt = np.zeros_like(y)
148    
149    drag = sigmaE(t)
150    dis1 = k / a(t)
151    dis2 = 2*H(t)*xieff(t)
152
153    #positive helicity
154    lam = 1.
155    #Real Part
156    dydt[0] = y[1]*dis1
157    dydt[1] = - drag * y[1] - (dis1  - lam * dis2) * y[0]
158    
159    #Imaginary Part
160    dydt[2] = y[3]*dis1
161    dydt[3] = - drag * y[3] - (dis1  - lam * dis2) * y[2]
162    
163    #negative helicity
164    lam = -1.
165    #Real Part
166    dydt[4] = y[5]*dis1
167    dydt[5] = - drag * y[5] - (dis1  - lam * dis2) * y[4]
168    
169    #Imaginary Part
170    dydt[6] = y[7]*dis1
171    dydt[7] = - drag * y[7] - (dis1  - lam * dis2) * y[6]
172    
173    return dydt

Mode equation for scale-dependent fermionic axion inflation:

$$\ddot{A}_\lambda(t, k) + \big( H + \sigma_{\rm E} \big) \dot{A}_\lambda(t, k) + \left[ \left(\frac{k}{a}\right)^2 - \lambda \frac{k}{a} \big( 2 \xi H + \sigma_{\rm B} \big) \right] A_\lambda(t, k) = 0\, .$$

Parameters

t (float): cosmic time $t$
y (NDArray): $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
k (float): comoving momentum $k$
a (Callable): scale factor as function of time, $a(t)$
xieff (Callable): effective instability parameter as function of time, $\xi_{\rm eff}(t)$
H (Callable): Hubble rate as function of time, $H(t)$
sigmaE (Callable): electric damping, $\sigma_{\rm E}(t)$

Returns

dydt (array): an array of time derivatives of y

def mode_equation_SE_scale( t: float, y: numpy.ndarray, k: float, a: Callable, xi: Callable, H: Callable, sigmaE: Callable, sigmaB: Callable, kS: Callable) -> numpy.ndarray: View Source

175def mode_equation_SE_scale(t: float, y : np.ndarray, k : float,
176                    a : Callable, xi : Callable, H : Callable,
177                    sigmaE : Callable, sigmaB : Callable,
178                      kS : Callable) -> np.ndarray:
179    r"""
180    Mode equation for scale-independent fermionic axion inflation:
181
182    $$\ddot{A}_\lambda(t, k)  + \big( H + \sigma_{\rm E} \Theta(t, k) \big) \dot{A}_\lambda(t, k) + \left[ \left(\frac{k}{a}\right)^2 - \lambda \frac{k}{a} \big( 2 \xi H + \sigma_{\rm B}\Theta(t, k) \big) \right] A_\lambda(t, k) = 0\, .$$
183
184    Parameters
185    ----------
186    t : float
187        cosmic time $t$
188    y : NDArray
189        $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
190    k : float
191        comoving momentum $k$
192    a : Callable
193        scale factor as function of time, $a(t)$
194    xi : Callable
195        einstability parameter as function of time, $\xi(t)$
196    H : Callable
197        Hubble rate as function of time, $H(t)$
198    sigmaE : Callable
199        electric damping, $\sigma_{\rm E}(t)$
200    sigmaB : Callable
201        magnetic damping, $\sigma_{\rm B}(t)$
202    kS : Callable
203        no damping for $k > k_{\rm S}(t)$ from $\Theta(t, k)$
204        
205    Returns
206    -------
207    dydt : array
208        an array of time derivatives of y
209    """
210
211    dydt = np.zeros_like(y)
212    cut = max(a(t)*H(t), kS(t))
213    theta = np.heaviside(cut - k, 0.5)
214    
215    drag = theta*sigmaE(t)
216    dis1 = k / a(t)
217    dis2 = 2*H(t)*xi(t) + theta*sigmaB(t)
218
219    #positive helicity
220    lam = 1.
221    #Real Part
222    dydt[0] = y[1]*dis1
223    dydt[1] = - drag * y[1] - (dis1  - lam * dis2) * y[0]
224    
225    #Imaginary Part
226    dydt[2] = y[3]*dis1
227    dydt[3] = - drag * y[3] - (dis1  - lam * dis2) * y[2]
228    
229    #negative helicity
230    lam = -1.
231    #Real Part
232    dydt[4] = y[5]*dis1
233    dydt[5] = - drag * y[5] - (dis1  - lam * dis2) * y[4]
234    
235    #Imaginary Part
236    dydt[6] = y[7]*dis1
237    dydt[7] = - drag * y[7] - (dis1  - lam * dis2) * y[6]
238    
239    return dydt

Mode equation for scale-independent fermionic axion inflation:

$$\ddot{A}_\lambda(t, k) + \big( H + \sigma_{\rm E} \Theta(t, k) \big) \dot{A}_\lambda(t, k) + \left[ \left(\frac{k}{a}\right)^2 - \lambda \frac{k}{a} \big( 2 \xi H + \sigma_{\rm B}\Theta(t, k) \big) \right] A_\lambda(t, k) = 0\, .$$

Parameters

t (float): cosmic time $t$
y (NDArray): $\sqrt{2k} A_\lambda(t_{\rm init},k)$ and $a\sqrt{2/k} \dot{A}_\lambda(t_{\rm init},k)$
k (float): comoving momentum $k$
a (Callable): scale factor as function of time, $a(t)$
xi (Callable): einstability parameter as function of time, $\xi(t)$
H (Callable): Hubble rate as function of time, $H(t)$
sigmaE (Callable): electric damping, $\sigma_{\rm E}(t)$
sigmaB (Callable): magnetic damping, $\sigma_{\rm B}(t)$
kS (Callable): no damping for $k > k_{\rm S}(t)$ from $\Theta(t, k)$

Returns

dydt (array): an array of time derivatives of y