CosmoWAP 0.0.2__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,291 @@
1
+ import numpy as np
2
+ import scipy
3
+
4
+ class PBBias:
5
+ def __init__(self,cosmo_functions,survey_attr="survey"):
6
+ """
7
+ Gets non-gaussian biases from PBs approach - assumes HMF (Tinker 2010) and HOD (yankelevich and porciani 2018)
8
+ """
9
+ #get which survey out of cosmo_funcs class
10
+ cosmo_func_survey = getattr(cosmo_functions, survey_attr)
11
+
12
+ def sigma_R_n(R, n,zz=0,cosmo=cosmo, K_MIN = 5e-4,K_MAX=1e+2,steps=int(1e+3)):
13
+ """
14
+ compute sigma^2 for a given radius and n i.e does interal over k
15
+
16
+ Uses differential equation approach for the yinit
17
+ """
18
+ k = np.logspace(np.log10(K_MIN), np.log10(K_MAX), num=steps)
19
+ pk_L = cosmo_functions.Pk(k)
20
+
21
+ def deriv_sigma(x,y,k,Pk,R,n): # from Pylians
22
+ Pkp=np.interp((x),(k),(Pk))
23
+ kR=x*R
24
+ W=3.0*(np.sin(kR)-kR*np.cos(kR))/kR**3
25
+ return [x**(2+n)*Pkp*W**2]
26
+
27
+ #this function computes sigma(R)
28
+ def sigma_sq(k,Pk,R,n):
29
+ k_limits=[k[0],k[-1]]; yinit=[0.0]
30
+
31
+ I=scipy.integrate.solve_ivp(deriv_sigma,k_limits,yinit,args=(k,Pk,R,n),method='RK45')
32
+
33
+ return I.y[0][-1]#get last value
34
+
35
+ sigma_squared = np.zeros((len(R)))
36
+ for i,_ in enumerate(R):
37
+ sigma_squared[i] = sigma_sq(k,pk_L,R[i],n)/(2.0*np.pi**2)
38
+
39
+ return sigma_squared
40
+
41
+ delta_c = 1.686 #from spherical collapse
42
+
43
+ #so several parameters are 2 dimensional - dependent on R and z
44
+ #therefore we interpolate over redshift here for convenience later where we call things as a fuction of z
45
+
46
+ #define R range
47
+ self.R = np.logspace(-3,3,300,dtype=np.float32) #upper limit - causes errors for large R
48
+
49
+ # M is the mass enclosed within the radius which also redshift dependent
50
+ self.M_func = lambda xx: ((4*np.pi*cosmo_functions.rho_m(xx)*self.R**3)/3) #so M is in units of solar Mass
51
+
52
+ #precompute
53
+ sigmaR0 = sigma_R_n(self.R,0)
54
+ sigmaR1 = sigma_R_n(self.R,-1)
55
+ sigmaR2 = sigma_R_n(self.R,-2)
56
+
57
+ #for sigma
58
+ sig_R = {}
59
+
60
+ sig_R['0'] = lambda xx: sigmaR0* cosmo_functions.D_intp(xx)# (z,R)
61
+ sig_R['1'] = lambda xx: sigmaR1* cosmo_functions.D_intp(xx)
62
+ sig_R['2'] = lambda xx: sigmaR2* cosmo_functions.D_intp(xx)
63
+
64
+ self.sig_R = sig_R
65
+
66
+ #peak height (z,R)
67
+ self.nu_func = lambda xx: delta_c/np.sqrt(sig_R['0'](xx))# interpolate along z
68
+
69
+ #also used in HOD - compute before
70
+ dSdM = CubicSpline(self.M_func(0),np.sqrt(self.sig_R['0'](0))).derivative()(self.M_func(0))
71
+
72
+
73
+ #define initial free paremeters from Tinker 2010 table 4, Delta=200
74
+ alpha = 0.368
75
+ beta = 0.589
76
+ gamma = 0.864
77
+ eta = -0.243
78
+ psi = -0.729
79
+ free_args0 = alpha,beta,gamma,eta,psi
80
+
81
+ def halo_bias_params(zz):#tinker 2010
82
+ alpha,beta0,gamma0,eta0,psi0 = free_args0
83
+ beta = beta0*(1+zz)**(0.2)
84
+ gamma = gamma0*(1+zz)**(-0.01)
85
+ eta = eta0*(1+zz)**(0.27)
86
+ psi = psi0*(1+zz)**(-0.08)
87
+ return alpha,beta,gamma,eta,psi
88
+
89
+ ######################################################## funcs
90
+
91
+ #define n_h mean number of halos and N(M,z) mean number of galaxies per halo
92
+ #@njit
93
+ def HOD(zz, M0, NHO):
94
+ #define HoD from Yankalevich and poricani 2018
95
+ M = self.M_func(zz)
96
+
97
+ theta_HoD = 1 + scipy.special.erf(2*np.log10(M/M0))
98
+ N_c = np.exp(-10*(np.log10(M/M0))**2)+0.05*theta_HoD #central galaxies
99
+ N_s = 0.003*(M/M0)*theta_HoD
100
+
101
+ return NHO*(N_c+N_s)
102
+
103
+ def multiplicity(zz): # from Tinker 2008,2010
104
+ alpha,beta,gamma,eta,psi = halo_bias_params(zz)
105
+ nu = self.nu_func(zz)
106
+ return alpha*(1+(beta*nu)**(-2*psi))*nu**(2*eta)*np.exp(-gamma*nu**2 /2)
107
+
108
+ def n_h(zz,free_args=free_args0): #dn/dm
109
+ """
110
+ define halo mass function - number density of halos per unit mass- Tinker2010
111
+ """
112
+ #derivate of sigma wrt to M
113
+ dSdM = CubicSpline(self.M_func(zz),np.sqrt(self.sig_R['0'](zz))).derivative()(self.M_func(zz))
114
+
115
+ return (cosmo_functions.rho_m(zz)/self.M_func(zz))*multiplicity(zz)*self.nu_func(zz)*np.abs(dSdM)/np.sqrt(self.sig_R['0'](zz))
116
+
117
+ self.multiplicity = multiplicity
118
+ self.HMF = n_h
119
+ self.HOD = HOD
120
+
121
+ #########################################################
122
+
123
+ # get halo biases these will be arrays with repsect to M - for integration
124
+ def dy_ov_dx(dy,dx):
125
+ """
126
+ Compute the derivative using spline derivatives.
127
+ """
128
+ # Fit cubic splines and caclulate their derivatives for each R coord
129
+ dum1 = CubicSpline(self.R, dy).derivative()(self.R)
130
+ dum2 = CubicSpline(self.R, dx).derivative()(self.R)
131
+
132
+ return dum1 / dum2 # Compute the ratio of the derivatives
133
+
134
+ #get langrangian and then eulerian biases
135
+ #see Appendix C ....
136
+ class LagBias:
137
+ """
138
+ define lagrangian biases in terms of z,M and the halo bias params - these are all arrays in (z,M)
139
+ """
140
+ def b1(self,zz):
141
+ alpha,beta,gamma,eta,psi = halo_bias_params(zz)
142
+ nu = self.nu_func(zz)
143
+ return (2*psi)/(delta_c*((beta*nu)**(2*psi)+1)) + (gamma*nu**2-2*eta-1)/delta_c
144
+
145
+ def b2(self,zz):
146
+ alpha,beta,gamma,eta,psi = halo_bias_params(zz)
147
+ nu = self.nu_func(zz)
148
+ return (2*psi*(2*gamma*nu**2-4*eta+2*psi-1))/(delta_c**2 *((beta*nu)**(2*psi)+1)) + (gamma**2 *nu**4-4*gamma*eta*nu**2-3*gamma*nu**2+4*eta**2+2*eta)/delta_c**2
149
+
150
+ class EulBias:
151
+ """
152
+ define Eulerian biases in terms of lagrangian biases
153
+ """
154
+ def b1(zz,A=1,alpha=0):
155
+ return 1 + LagBias.b1(self,zz)
156
+
157
+ def b2(zz,A=1,alpha=0):
158
+ return LagBias.b2(self,zz) - (8/21)*LagBias.b1(self,zz)
159
+
160
+ def b_psi(zz,A=1,alpha=0):
161
+ return A*fNL*(2*delta_c*LagBias.b1(self,zz)+4*(dy_ov_dx(np.log(self.sig_R[str(alpha)](zz)),np.log(self.sig_R['0'](zz)))-1))*(self.sig_R[str(alpha)](zz)/self.sig_R['0'](zz))
162
+
163
+ def b_psi_delta(zz,A=1,alpha=0):
164
+ return A*fNL*(delta_c*(EulBias.b2(zz)+(13/21)*(EulBias.b1(zz)-1))+EulBias.b1(zz)*(2*dy_ov_dx(np.log(self.sig_R[str(alpha)](zz)),np.log(self.sig_R['0'](zz)))-3)+1)*(self.sig_R[str(alpha)](zz)/self.sig_R['0'](zz))
165
+
166
+ self.EulBias = EulBias
167
+ self.LagBias = LagBias
168
+
169
+ #########################################################################################
170
+
171
+ def number_density(zz,M0,NO):
172
+ """
173
+ return number density for given z
174
+ """
175
+
176
+ return np.trapz(HOD(zz,M0,NO)*n_h(zz), (self.M_func(zz)))
177
+
178
+ # so implement Eq.
179
+ def general_galaxy_bias(b_h,zz,M0,NO,A=1,alpha=0):
180
+ """
181
+ return bias for given z
182
+ """
183
+
184
+ # Integrate over M for each value of z
185
+ integral_values = np.trapz(b_h(zz, A, alpha)*n_h(zz)*HOD(zz,M0,NO), (self.M_func(zz)))
186
+
187
+ return integral_values
188
+ ############################################################################################
189
+ #fit NO and M0 to given n_g and b_1
190
+ def fit_M0(z_arr):
191
+ """
192
+ fit M0 from linear bias (b_1 is independent of NO)
193
+ """
194
+ def objective(M0,zz,NO=1):
195
+ """
196
+ diff between linear bias from PBS and survey specifications
197
+ """
198
+ return general_galaxy_bias(EulBias.b1,zz,M0,NO)/number_density(zz,M0,NO) - cosmo_func_survey.b_1(zz)
199
+
200
+ M0_range = (1e+12,1e+14)# should build little tester for this ADD
201
+ #print([objective(M0_range[0],1),objective(M0_range[1],1)])
202
+ M0_arr = np.array([scipy.optimize.brentq(objective, M0_range[0], M0_range[1], args=(z),xtol=1e-4) for i,z in enumerate(z_arr)])
203
+
204
+ return CubicSpline(z_arr,M0_arr) # now returns M0 as function of redshift
205
+
206
+ #now can find NO from n_g
207
+ def fit_NO(z_arr):
208
+ """
209
+ fit NO from number density
210
+ """
211
+ def objective(NO,zz,M0):
212
+ """
213
+ diff between number density from PBS and survey specifications
214
+ """
215
+ return number_density(zz,M0,NO) - cosmo_func_survey.n_g(zz)
216
+
217
+ NO_range = (0,3)# should build little tester for this ADD
218
+ #print([objective(NO_range[0],1,self.M0_func(1)),objective(NO_range[1],1,self.M0_func(1))])
219
+ NO_arr = np.array([scipy.optimize.brentq(objective, NO_range[0], NO_range[1], args=(z,self.M0_func(z)),xtol=1e-4) for i,z in enumerate(z_arr)])
220
+
221
+ return CubicSpline(z_arr,NO_arr) # now returns M0 as function of redshift
222
+
223
+ # so get fittted values of NO and M0
224
+ z_arr = np.linspace(cosmo_functions.z_survey[0],cosmo_functions.z_survey[-1],10)
225
+ self.M0_func = fit_M0(z_arr)
226
+ self.NO_func = fit_NO(z_arr)
227
+
228
+ ###############################################################################################
229
+ def get_galaxy_bias(b_h,A=1,alpha=0):
230
+ """
231
+ set z_range and fit cubic spline for a given bias function
232
+ """
233
+ z_samps = np.linspace(cosmo_functions.z_survey[0],cosmo_functions.z_survey[-1],int(40))
234
+
235
+ bias_arr = np.ones_like(z_samps)
236
+ for i,zz in enumerate(z_samps):
237
+
238
+ bias_arr[i] = general_galaxy_bias(b_h,zz,self.M0_func(zz),self.NO_func(zz),A,alpha)/cosmo_func_survey.n_g(zz)
239
+
240
+ return CubicSpline(z_samps,bias_arr)
241
+
242
+ def get_number_density():
243
+ """
244
+ set z_range and fit cubic spline for a given bias function
245
+ """
246
+ z_samps = np.linspace(cosmo_functions.z_survey[0],cosmo_functions.z_survey[-1],int(40))
247
+
248
+ n_g = np.ones_like(z_samps)
249
+ for i,zz in enumerate(z_samps):
250
+
251
+ n_g[i] = number_density(zz,self.M0_func(zz),self.NO_func(zz))
252
+
253
+ return CubicSpline(z_samps,n_g)
254
+
255
+ self.get_galaxy_bias = get_galaxy_bias
256
+
257
+ #################################################################################################
258
+ # so save all required params
259
+
260
+ self.n_g = get_number_density()
261
+ self.b_1 = get_galaxy_bias(EulBias.b1)
262
+ self.b_2 = get_galaxy_bias(EulBias.b2)
263
+ self.g_2 = lambda xx: -(4/7)*(self.b_1-1)#tidal bias - e.g. baldauf
264
+
265
+ #get PNG biases for each type
266
+ self.loc = self.Loc(self)
267
+ self.equil = self.Equil(self)
268
+ self.orth = self.Orth(self)
269
+
270
+ #for the 3 different types of PNG
271
+ class Loc:
272
+ def __init__(self,parent):
273
+ self.A = 1
274
+ self.alpha = 0
275
+ self.b_psi = parent.get_galaxy_bias(parent.EulBias.b_psi,A=self.A,alpha=self.alpha)
276
+ self.b_psi_delta = parent.get_galaxy_bias(parent.EulBias.b_psi_delta,A=self.A,alpha=self.alpha)
277
+
278
+ class Equil:
279
+ def __init__(self,parent):
280
+ self.A = 3
281
+ self.alpha = 2
282
+ self.b_psi = parent.get_galaxy_bias(parent.EulBias.b_psi,A=self.A,alpha=self.alpha)
283
+ self.b_psi_delta = parent.get_galaxy_bias(parent.EulBias.b_psi_delta,A=self.A,alpha=self.alpha)
284
+
285
+ class Orth:
286
+ def __init__(self,parent):
287
+ self.A = -3
288
+ self.alpha = 1
289
+ self.b_psi = parent.get_galaxy_bias(parent.EulBias.b_psi,A=self.A,alpha=self.alpha)
290
+ self.b_psi_delta = parent.get_galaxy_bias(parent.EulBias.b_psi_delta,A=self.A,alpha=self.alpha)
291
+
cosmo_wap/pk/Pk_0.py ADDED
@@ -0,0 +1,109 @@
1
+ import numpy as np
2
+ import scipy
3
+
4
+ #1st order terms
5
+ class Pk0:
6
+ def l0(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
7
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
8
+
9
+ b1 = cosmo_functions.survey.b_1(zz)
10
+ xb1 = cosmo_functions.survey1.b_1(zz)
11
+
12
+ expr = D1**2*Pk*(5*b1*(f + 3*xb1) + f*(3*f + 5*xb1))/15
13
+
14
+ Erf = scipy.special.erf
15
+ if sigma != 0:
16
+ expr = D1**2*Pk*(-2*f*sigma*(f*(sigma**2 + 3) + sigma**2*(b1 + xb1))*np.exp(-sigma**2/2) + np.sqrt(2)*np.sqrt(np.pi)*(b1*sigma**4*xb1 + 3*f**2 + f*sigma**2*(b1 + xb1))*Erf(np.sqrt(2)*sigma/2))/(2*sigma**5)
17
+
18
+ return expr
19
+
20
+ def l2(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
21
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
22
+
23
+ b1 = cosmo_functions.survey.b_1(zz)
24
+ xb1 = cosmo_functions.survey1.b_1(zz)
25
+
26
+ expr = 2*D1**2*Pk*f*(7*b1 + 6*f + 7*xb1)/21
27
+
28
+ Erf = scipy.special.erf
29
+ if sigma != 0:
30
+ expr = -5*D1**2*Pk*(2*sigma*(3*b1*sigma**4*xb1 + f**2*(2*sigma**4 + 12*sigma**2 + 45) + f*sigma**2*(b1 + xb1)*(2*sigma**2 + 9)) + np.sqrt(2)*np.sqrt(np.pi)*(b1*sigma**4*xb1*(sigma**2 - 3) + 3*f**2*(sigma**2 - 15) + f*sigma**2*(b1 + xb1)*(sigma**2 - 9))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(4*sigma**7)
31
+
32
+ return expr
33
+
34
+
35
+ #1st order terms
36
+ class GR1:
37
+ def l1(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
38
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
39
+
40
+ b1 = cosmo_functions.survey.b_1(zz)
41
+ xb1 = cosmo_functions.survey1.b_1(zz)
42
+
43
+ gr1,gr2,grd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey)
44
+ xgr1,xgr2,xgrd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey1)
45
+
46
+ expr = 1j*D1**2*Pk*(-5*b1*xgr1 + 3*f*(gr1 - xgr1) + 5*gr1*xb1)/(5*k1)
47
+
48
+ Erf = scipy.special.erf
49
+ if sigma != 0:
50
+ expr = 3*1j*D1**2*Pk*(-2*f*sigma*(gr1 - xgr1)*(sigma**2 + 3) + 2*sigma**3*(b1*xgr1 - gr1*xb1) + np.sqrt(2)*np.sqrt(np.pi)*(3*f*(gr1 - xgr1) + sigma**2*(-b1*xgr1 + gr1*xb1))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*k1*sigma**5)
51
+
52
+ return expr
53
+
54
+ def l3(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
55
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
56
+
57
+ b1 = cosmo_functions.survey.b_1(zz)
58
+ xb1 = cosmo_functions.survey1.b_1(zz)
59
+
60
+ gr1,gr2,grd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey)
61
+ xgr1,xgr2,xgrd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey1)
62
+
63
+ expr = 2*1j*D1**2*Pk*f*(gr1 - xgr1)/(5*k1)
64
+
65
+ Erf = scipy.special.erf
66
+ if sigma != 0:
67
+ expr = 3*1j*D1**2*Pk*(-2*f*sigma*(gr1 - xgr1)*(sigma**2 + 3) + 2*sigma**3*(b1*xgr1 - gr1*xb1) + np.sqrt(2)*np.sqrt(np.pi)*(3*f*(gr1 - xgr1) + sigma**2*(-b1*xgr1 + gr1*xb1))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*k1*sigma**5)
68
+
69
+ return expr
70
+
71
+
72
+ #2nd order terms
73
+ class GR2:
74
+ def l0(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
75
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
76
+
77
+ b1 = cosmo_functions.survey.b_1(zz)
78
+ xb1 = cosmo_functions.survey1.b_1(zz)
79
+
80
+ gr1,gr2,grd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey)
81
+ xgr1,xgr2,xgrd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey1)
82
+
83
+ expr = D1**2*Pk*(3*b1*xgr2 + f*(gr2 + xgr2) - gr1*xgr1 + 3*gr2*xb1)/(3*k1**2)
84
+
85
+ Erf = scipy.special.erf
86
+ if sigma != 0:
87
+ expr = D1**2*Pk*(-2*sigma*(f*(gr2 + xgr2) + gr1*xgr1) + np.sqrt(2)*np.sqrt(np.pi)*(b1*sigma**2*xgr2 + f*(gr2 + xgr2) + gr1*xgr1 + gr2*sigma**2*xb1)*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*k1**2*sigma**3)
88
+
89
+ return expr
90
+
91
+ def l2(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
92
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
93
+
94
+ b1 = cosmo_functions.survey.b_1(zz)
95
+ xb1 = cosmo_functions.survey1.b_1(zz)
96
+
97
+ gr1,gr2,grd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey)
98
+ xgr1,xgr2,xgrd1,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_ = cosmo_functions.get_beta_funcs(zz,tracer = cosmo_functions.survey1)
99
+
100
+ expr = 2*D1**2*Pk*(f*(gr2 + xgr2) + gr1*xgr1)/(3*k1**2)
101
+
102
+ Erf = scipy.special.erf
103
+ if sigma != 0:
104
+ expr = -5*D1**2*Pk*(2*sigma*(3*b1*sigma**2*xgr2 + f*(gr2 + xgr2)*(2*sigma**2 + 9) + 2*gr1*sigma**2*xgr1 + 9*gr1*xgr1 + 3*gr2*sigma**2*xb1) + np.sqrt(2)*np.sqrt(np.pi)*(b1*sigma**4*xgr2 - 3*b1*sigma**2*xgr2 + f*(gr2 + xgr2)*(sigma**2 - 9) + gr1*sigma**2*xgr1 - 9*gr1*xgr1 + gr2*sigma**2*xb1*(sigma**2 - 3))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(4*k1**2*sigma**5)
105
+
106
+ return expr
107
+
108
+
109
+
cosmo_wap/pk/Pk_WS.py ADDED
@@ -0,0 +1,172 @@
1
+ import numpy as np
2
+ import scipy
3
+
4
+
5
+ #1st order terms
6
+ class WA1:
7
+ def l1(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
8
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
9
+
10
+ b1 = cosmo_functions.survey.b_1(zz)
11
+ xb1 = cosmo_functions.survey1.b_1(zz)
12
+
13
+ expr = 4*1j*D1**2*f*(3*Pk + Pkd*k1)*(7*b1*(t - 1) + f*(6*t - 3) + 7*t*xb1)/(35*d*k1)
14
+
15
+ Erf = scipy.special.erf
16
+ if sigma != 0:
17
+ expr = 3*1j*D1**2*f*(-2*f*sigma*(2*t - 1)*(2*Pk*(sigma**4 + 7*sigma**2 + 30) - Pkd*k1*(2*sigma**2 + 15)) - 2*sigma**3*(2*Pk*(sigma**2 + 3) - 3*Pkd*k1)*(b1*(t - 1) + t*xb1) + np.sqrt(2)*np.sqrt(np.pi)*(-3*f*(2*t - 1)*(2*Pk*(sigma**2 - 10) - Pkd*k1*(sigma**2 - 5)) + sigma**2*(6*Pk + Pkd*k1*(sigma**2 - 3))*(b1*(t - 1) + t*xb1))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(d*k1*sigma**7)
18
+
19
+ return expr
20
+
21
+ def l3(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
22
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
23
+
24
+ b1 = cosmo_functions.survey.b_1(zz)
25
+ xb1 = cosmo_functions.survey1.b_1(zz)
26
+
27
+ expr = 4*1j*D1**2*f*(9*b1*(2*Pk - Pkd*k1)*(t - 1) + f*(22*Pk - Pkd*k1)*(2*t - 1) + 9*t*xb1*(2*Pk - Pkd*k1))/(45*d*k1)
28
+
29
+ Erf = scipy.special.erf
30
+ if sigma != 0:
31
+ expr = -7*1j*D1**2*f*(2*f*sigma*(2*t - 1)*(Pk*(4*sigma**6 + 48*sigma**4 + 370*sigma**2 + 2100) - Pkd*k1*(4*sigma**4 + 55*sigma**2 + 525)) + 2*sigma**3*(2*Pk*(2*sigma**4 + 16*sigma**2 + 75) - Pkd*k1*(sigma**2 + 75))*(b1*(t - 1) + t*xb1) - 3*np.sqrt(2)*np.sqrt(np.pi)*(f*(2*t - 1)*(2*Pk*(3*sigma**4 - 55*sigma**2 + 350) + Pkd*k1*(-3*sigma**4 + 40*sigma**2 - 175)) - sigma**2*(Pk*(6*sigma**2 - 50) + Pkd*k1*(sigma**4 - 8*sigma**2 + 25))*(b1*(t - 1) + t*xb1))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*d*k1*sigma**9)
32
+
33
+ return expr
34
+
35
+
36
+ #1st order terms
37
+ class RR1:
38
+ def l1(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
39
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
40
+
41
+ fd,Dd,_,_,bd1,fdd,Ddd,_,_,bdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey)
42
+ fd,Dd,_,_,xbd1,fdd,Ddd,_,_,xbdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey1)
43
+
44
+ b1 = cosmo_functions.survey.b_1(zz)
45
+ xb1 = cosmo_functions.survey1.b_1(zz)
46
+
47
+ expr = 1j*D1*(D1*(3*f*fd*(8*Pk + 5*Pkd*k1)*(2*t - 1) + 7*f*(4*Pk + 3*Pkd*k1)*(bd1*t + xbd1*(t - 1)) + 7*t*xb1*(4*Pk*fd + 5*Pkd*bd1*k1 + 3*Pkd*fd*k1)) + Dd*f*(2*t - 1)*(3*f*(8*Pk + 5*Pkd*k1) + 7*xb1*(4*Pk + 3*Pkd*k1)) + 7*b1*(D1*(t - 1)*(4*Pk*fd + 3*Pkd*fd*k1 + 5*Pkd*k1*xbd1) + Dd*(2*t - 1)*(4*Pk*f + 3*Pkd*f*k1 + 5*Pkd*k1*xb1)))/(35*d*k1)
48
+
49
+ Erf = scipy.special.erf
50
+ if sigma != 0:
51
+ expr = 3*1j*D1*(-2*D1*sigma*(f*(-fd*(2*t - 1)*(Pk*(8*sigma**2 + 60) - Pkd*k1*(sigma**4 + 5*sigma**2 + 15)) + sigma**2*(-6*Pk + Pkd*k1*(sigma**2 + 3))*(bd1*t + xbd1*(t - 1))) + sigma**2*(-b1*(t - 1)*(6*Pk*fd - Pkd*fd*k1*(sigma**2 + 3) - Pkd*k1*sigma**2*xbd1) + t*xb1*(-6*Pk*fd + Pkd*bd1*k1*sigma**2 + Pkd*fd*k1*(sigma**2 + 3)))) + 2*Dd*sigma*(2*t - 1)*(-Pkd*b1*k1*sigma**4*xb1 + f**2*(Pk*(8*sigma**2 + 60) - Pkd*k1*(sigma**4 + 5*sigma**2 + 15)) + f*sigma**2*(6*Pk - Pkd*k1*(sigma**2 + 3))*(b1 + xb1)) + np.sqrt(2)*np.sqrt(np.pi)*(D1*(f*(3*fd*(2*t - 1)*(4*Pk*(sigma**2 - 5) + 5*Pkd*k1) + sigma**2*(2*Pk*(sigma**2 - 3) + 3*Pkd*k1)*(bd1*t + xbd1*(t - 1))) + sigma**2*(b1*(t - 1)*(2*Pk*fd*(sigma**2 - 3) + 3*Pkd*fd*k1 + Pkd*k1*sigma**2*xbd1) + t*xb1*(2*Pk*fd*(sigma**2 - 3) + Pkd*bd1*k1*sigma**2 + 3*Pkd*fd*k1))) + Dd*(2*t - 1)*(Pkd*b1*k1*sigma**4*xb1 + 3*f**2*(4*Pk*(sigma**2 - 5) + 5*Pkd*k1) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**2 - 3) + 3*Pkd*k1)))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*d*k1*sigma**7)
52
+
53
+ return expr
54
+
55
+ def l3(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
56
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
57
+
58
+ b1 = cosmo_functions.survey.b_1(zz)
59
+ xb1 = cosmo_functions.survey1.b_1(zz)
60
+
61
+ expr = 2*1j*D1*(D1*(-2*f*fd*(2*Pk - 5*Pkd*k1)*(2*t - 1) - 9*f*(2*Pk - Pkd*k1)*(bd1*t + xbd1*(t - 1)) + 9*fd*t*xb1*(-2*Pk + Pkd*k1)) - Dd*f*(2*t - 1)*(4*Pk*f + 18*Pk*xb1 - 10*Pkd*f*k1 - 9*Pkd*k1*xb1) - 9*b1*(2*Pk - Pkd*k1)*(D1*fd*(t - 1) + Dd*f*(2*t - 1)))/(45*d*k1)
62
+
63
+ Erf = scipy.special.erf
64
+ if sigma != 0:
65
+ expr = -7*1j*D1*(2*sigma*(D1*(f*(-fd*(2*t - 1)*(4*Pk*(4*sigma**4 + 55*sigma**2 + 525) - Pkd*k1*(2*sigma**6 + 20*sigma**4 + 130*sigma**2 + 525)) + sigma**2*(-2*Pk*(sigma**2 + 75) + Pkd*k1*(2*sigma**4 + 16*sigma**2 + 75))*(bd1*t + xbd1*(t - 1))) + sigma**2*(-b1*(t - 1)*(2*Pk*fd*(sigma**2 + 75) - Pkd*fd*k1*(2*sigma**4 + 16*sigma**2 + 75) - Pkd*k1*sigma**2*xbd1*(2*sigma**2 + 15)) + t*xb1*(-2*Pk*fd*(sigma**2 + 75) + Pkd*bd1*k1*sigma**2*(2*sigma**2 + 15) + Pkd*fd*k1*(2*sigma**4 + 16*sigma**2 + 75)))) - Dd*(2*t - 1)*(-Pkd*b1*k1*sigma**4*xb1*(2*sigma**2 + 15) + f**2*(4*Pk*(4*sigma**4 + 55*sigma**2 + 525) - Pkd*k1*(2*sigma**6 + 20*sigma**4 + 130*sigma**2 + 525)) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**2 + 75) - Pkd*k1*(2*sigma**4 + 16*sigma**2 + 75)))) + 3*np.sqrt(2)*np.sqrt(np.pi)*(D1*(f*(fd*(2*t - 1)*(4*Pk*(3*sigma**4 - 40*sigma**2 + 175) + 5*Pkd*k1*(3*sigma**2 - 35)) + sigma**2*(2*Pk*(sigma**4 - 8*sigma**2 + 25) + Pkd*k1*(3*sigma**2 - 25))*(bd1*t + xbd1*(t - 1))) + sigma**2*(b1*(t - 1)*(2*Pk*fd*(sigma**4 - 8*sigma**2 + 25) + Pkd*fd*k1*(3*sigma**2 - 25) + Pkd*k1*sigma**2*xbd1*(sigma**2 - 5)) + t*xb1*(2*Pk*fd*(sigma**4 - 8*sigma**2 + 25) + Pkd*bd1*k1*sigma**2*(sigma**2 - 5) + Pkd*fd*k1*(3*sigma**2 - 25)))) + Dd*(2*t - 1)*(Pkd*b1*k1*sigma**4*xb1*(sigma**2 - 5) + f**2*(4*Pk*(3*sigma**4 - 40*sigma**2 + 175) + 5*Pkd*k1*(3*sigma**2 - 35)) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**4 - 8*sigma**2 + 25) + Pkd*k1*(3*sigma**2 - 25))))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(4*d*k1*sigma**9)
66
+
67
+ return expr
68
+
69
+
70
+ #########################################################################################################
71
+
72
+ #2nd order terms
73
+ class WA2:
74
+ def l0(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
75
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
76
+
77
+ b1 = cosmo_functions.survey.b_1(zz)
78
+ xb1 = cosmo_functions.survey1.b_1(zz)
79
+
80
+ expr = -2*D1**2*f*(7*b1*(3*Pk + k1*(5*Pkd + Pkdd*k1))*(t - 1)**2 + f*(Pk*(18*t**2 - 18*t - 1) + k1*(Pkd*(30*t**2 - 30*t - 11) + Pkdd*k1*(6*t**2 - 6*t - 5))) + 7*t**2*xb1*(3*Pk + k1*(5*Pkd + Pkdd*k1)))/(105*d**2*k1**2)
81
+
82
+ Erf = scipy.special.erf
83
+ if sigma != 0:
84
+ expr = D1**2*f*(2*f*sigma*(6*Pk*(sigma**4*(10*t**2 - 10*t + 3) + 2*sigma**2*(54*t**2 - 54*t + 17) + 720*t**2 - 720*t + 240) + k1*(-6*Pkd*(sigma**4*(2*t**2 - 2*t + 1) + sigma**2*(30*t**2 - 30*t + 11) + 270*t**2 - 270*t + 90) + Pkdd*k1*(sigma**2*(6*t**2 - 6*t + 5) + 180*t**2 - 180*t + 60))) + 2*sigma**3*(2*Pk*(7*sigma**2 + 48) - k1*(6*Pkd*(sigma**2 + 10) + Pkdd*k1*(sigma**2 - 12)))*(b1*(t - 1)**2 + t**2*xb1) - np.sqrt(2)*np.sqrt(np.pi)*(f*(2*Pk*(sigma**4*(18*t**2 - 18*t + 7) - 6*sigma**2*(66*t**2 - 66*t + 23) + 2160*t**2 - 2160*t + 720) + k1*(-2*Pkd*(4*sigma**4*(3*t**2 - 3*t + 1) - 3*sigma**2*(60*t**2 - 60*t + 19) + 810*t**2 - 810*t + 270) + Pkdd*k1*(sigma**4*(6*t**2 - 6*t + 1) - 3*sigma**2*(18*t**2 - 18*t + 5) + 180*t**2 - 180*t + 60))) + sigma**2*(Pk*(96 - 18*sigma**2) + k1*(2*Pkd*(7*sigma**2 - 30) + Pkdd*k1*(sigma**4 - 5*sigma**2 + 12)))*(b1*(t - 1)**2 + t**2*xb1))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*d**2*k1**2*sigma**7)
85
+
86
+ return expr
87
+
88
+ def l2(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
89
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
90
+
91
+ b1 = cosmo_functions.survey.b_1(zz)
92
+ xb1 = cosmo_functions.survey1.b_1(zz)
93
+
94
+ expr = 2*D1**2*f*(-11*b1*(6*Pk - k1*(2*Pkd + Pkdd*k1))*(t - 1)**2 + f*(-2*Pk*(54*t**2 - 54*t + 13) + k1*(Pkd*(-12*t**2 + 12*t + 8) + 3*Pkdd*k1*(2*t**2 - 2*t + 1))) + 11*t**2*xb1*(-6*Pk + k1*(2*Pkd + Pkdd*k1)))/(21*d**2*k1**2)
95
+
96
+ Erf = scipy.special.erf
97
+ if sigma != 0:
98
+ expr = 5*D1**2*f*(2*f*sigma*(6*Pk*(sigma**6*(20*t**2 - 20*t + 6) + 3*sigma**4*(98*t**2 - 98*t + 31) + 30*sigma**2*(78*t**2 - 78*t + 25) + 15120*t**2 - 15120*t + 5040) + k1*(-6*Pkd*(sigma**6*(4*t**2 - 4*t + 2) + 4*sigma**4*(21*t**2 - 21*t + 8) + 15*sigma**2*(48*t**2 - 48*t + 17) + 5670*t**2 - 5670*t + 1890) + Pkdd*k1*(sigma**4*(30*t**2 - 30*t + 13) + 135*sigma**2*(2*t**2 - 2*t + 1) + 3780*t**2 - 3780*t + 1260))) + 2*sigma**3*(2*Pk*(14*sigma**4 + 111*sigma**2 + 720) + k1*(-6*Pkd*(2*sigma**4 + 19*sigma**2 + 150) + Pkdd*k1*(sigma**4 + 3*sigma**2 + 180)))*(b1*(t - 1)**2 + t**2*xb1) + np.sqrt(2)*np.sqrt(np.pi)*(f*(2*Pk*(sigma**6*(18*t**2 - 18*t + 7) - 3*sigma**4*(186*t**2 - 186*t + 67) + 90*sigma**2*(90*t**2 - 90*t + 31) - 45360*t**2 + 45360*t - 15120) + k1*(-2*Pkd*(4*sigma**6*(3*t**2 - 3*t + 1) - 3*sigma**4*(96*t**2 - 96*t + 31) + 45*sigma**2*(78*t**2 - 78*t + 25) - 17010*t**2 + 17010*t - 5670) + Pkdd*k1*(sigma**6*(6*t**2 - 6*t + 1) - 12*sigma**4*(9*t**2 - 9*t + 2) + 15*sigma**2*(66*t**2 - 66*t + 19) - 3780*t**2 + 3780*t - 1260))) + sigma**2*(-6*Pk*(3*sigma**4 - 43*sigma**2 + 240) + k1*(2*Pkd*(7*sigma**4 - 93*sigma**2 + 450) + Pkdd*k1*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180)))*(b1*(t - 1)**2 + t**2*xb1))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(4*d**2*k1**2*sigma**9)
99
+
100
+ return expr
101
+
102
+
103
+ class WARR:
104
+ def l0(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
105
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
106
+
107
+ b1 = cosmo_functions.survey.b_1(zz)
108
+ xb1 = cosmo_functions.survey1.b_1(zz)
109
+
110
+ fd,Dd,_,_,bd1,fdd,Ddd,_,_,bdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey)
111
+ fd,Dd,_,_,xbd1,fdd,Ddd,_,_,xbdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey1)
112
+
113
+ expr = -4*D1*(3*Pk + k1*(5*Pkd + Pkdd*k1))*(D1*(3*f*fd*(1 - 2*t)**2 + 7*f*t*(bd1 + xbd1)*(t - 1) + 7*fd*t**2*xb1) + Dd*f*(2*t - 1)*(f*(6*t - 3) + 7*t*xb1) + 7*b1*(t - 1)*(D1*fd*(t - 1) + Dd*f*(2*t - 1)))/(105*d**2*k1**2)
114
+
115
+ Erf = scipy.special.erf
116
+ if sigma != 0:
117
+ expr = -D1*(2*sigma*(D1*(f*(fd*(1 - 2*t)**2*(2*Pk*(sigma**4 + 18*sigma**2 + 180) + k1*(-Pkd*(2*sigma**4 + 15*sigma**2 + 135) + Pkdd*k1*(2*sigma**2 + 15))) + sigma**2*t*(bd1 + xbd1)*(t - 1)*(2*Pk*(sigma**2 + 12) + k1*(-Pkd*(sigma**2 + 15) + 3*Pkdd*k1))) + fd*sigma**2*(2*Pk*(sigma**2 + 12) + k1*(-Pkd*(sigma**2 + 15) + 3*Pkdd*k1))*(b1*(t - 1)**2 + t**2*xb1)) + Dd*f*(2*t - 1)*(f*(2*t - 1)*(2*Pk*(sigma**4 + 18*sigma**2 + 180) + k1*(-Pkd*(2*sigma**4 + 15*sigma**2 + 135) + Pkdd*k1*(2*sigma**2 + 15))) + sigma**2*(2*Pk*(sigma**2 + 12) + k1*(-Pkd*(sigma**2 + 15) + 3*Pkdd*k1))*(b1*(t - 1) + t*xb1))) + np.sqrt(2)*np.sqrt(np.pi)*(D1*(f*(-3*fd*(1 - 2*t)**2*(2*Pk*(sigma**4 - 14*sigma**2 + 60) - k1*(Pkd*(sigma**4 - 10*sigma**2 + 45) + Pkdd*k1*(sigma**2 - 5))) + sigma**2*t*(bd1 + xbd1)*(t - 1)*(6*Pk*(sigma**2 - 4) + k1*(Pkd*(sigma**4 - 4*sigma**2 + 15) + Pkdd*k1*(sigma**2 - 3)))) + fd*sigma**2*(6*Pk*(sigma**2 - 4) + k1*(Pkd*(sigma**4 - 4*sigma**2 + 15) + Pkdd*k1*(sigma**2 - 3)))*(b1*(t - 1)**2 + t**2*xb1)) - Dd*f*(2*t - 1)*(3*f*(2*t - 1)*(2*Pk*(sigma**4 - 14*sigma**2 + 60) - k1*(Pkd*(sigma**4 - 10*sigma**2 + 45) + Pkdd*k1*(sigma**2 - 5))) - sigma**2*(6*Pk*(sigma**2 - 4) + k1*(Pkd*(sigma**4 - 4*sigma**2 + 15) + Pkdd*k1*(sigma**2 - 3)))*(b1*(t - 1) + t*xb1)))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(d**2*k1**2*sigma**7)
118
+
119
+ return expr
120
+
121
+ def l2(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
122
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
123
+
124
+ b1 = cosmo_functions.survey.b_1(zz)
125
+ xb1 = cosmo_functions.survey1.b_1(zz)
126
+
127
+ fd,Dd,_,_,bd1,fdd,Ddd,_,_,bdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey)
128
+ fd,Dd,_,_,xbd1,fdd,Ddd,_,_,xbdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey1)
129
+
130
+ expr = -4*D1*(D1*(f*(fd*(1 - 2*t)**2*(6*Pk + k1*(6*Pkd + Pkdd*k1)) - t*(6*Pk - k1*(2*Pkd + Pkdd*k1))*(bd1 + xbd1)*(t - 1)) + fd*t**2*xb1*(-6*Pk + k1*(2*Pkd + Pkdd*k1))) + Dd*f*(2*t - 1)*(f*(6*Pk + k1*(6*Pkd + Pkdd*k1))*(2*t - 1) + t*xb1*(-6*Pk + k1*(2*Pkd + Pkdd*k1))) - b1*(6*Pk - k1*(2*Pkd + Pkdd*k1))*(t - 1)*(D1*fd*(t - 1) + Dd*f*(2*t - 1)))/(21*d**2*k1**2)
131
+
132
+ Erf = scipy.special.erf
133
+ if sigma != 0:
134
+ expr = 5*D1*(-2*sigma*(D1*(f*(fd*(1 - 2*t)**2*(2*Pk*(2*sigma**6 + 51*sigma**4 + 450*sigma**2 + 3780) + k1*(-Pkd*(4*sigma**6 + 51*sigma**4 + 360*sigma**2 + 2835) + Pkdd*k1*(4*sigma**4 + 45*sigma**2 + 315))) + sigma**2*t*(bd1 + xbd1)*(t - 1)*(Pk*(4*sigma**4 + 42*sigma**2 + 360) + k1*(-Pkd*(5*sigma**4 + 24*sigma**2 + 225) + 3*Pkdd*k1*(sigma**2 + 15)))) + fd*sigma**2*(Pk*(4*sigma**4 + 42*sigma**2 + 360) + k1*(-Pkd*(5*sigma**4 + 24*sigma**2 + 225) + 3*Pkdd*k1*(sigma**2 + 15)))*(b1*(t - 1)**2 + t**2*xb1)) + Dd*f*(2*t - 1)*(f*(2*t - 1)*(2*Pk*(2*sigma**6 + 51*sigma**4 + 450*sigma**2 + 3780) + k1*(-Pkd*(4*sigma**6 + 51*sigma**4 + 360*sigma**2 + 2835) + Pkdd*k1*(4*sigma**4 + 45*sigma**2 + 315))) + sigma**2*(Pk*(4*sigma**4 + 42*sigma**2 + 360) + k1*(-Pkd*(5*sigma**4 + 24*sigma**2 + 225) + 3*Pkdd*k1*(sigma**2 + 15)))*(b1*(t - 1) + t*xb1))) + np.sqrt(2)*np.sqrt(np.pi)*(D1*(f*(-3*fd*(1 - 2*t)**2*(2*Pk*(sigma**6 - 23*sigma**4 + 270*sigma**2 - 1260) - k1*(Pkd*(sigma**6 - 19*sigma**4 + 195*sigma**2 - 945) + Pkdd*k1*(sigma**4 - 20*sigma**2 + 105))) + sigma**2*t*(bd1 + xbd1)*(t - 1)*(6*Pk*(sigma**4 - 13*sigma**2 + 60) + k1*(Pkd*(sigma**6 - 7*sigma**4 + 51*sigma**2 - 225) + Pkdd*k1*(sigma**4 - 12*sigma**2 + 45)))) + fd*sigma**2*(6*Pk*(sigma**4 - 13*sigma**2 + 60) + k1*(Pkd*(sigma**6 - 7*sigma**4 + 51*sigma**2 - 225) + Pkdd*k1*(sigma**4 - 12*sigma**2 + 45)))*(b1*(t - 1)**2 + t**2*xb1)) - Dd*f*(2*t - 1)*(3*f*(2*t - 1)*(2*Pk*(sigma**6 - 23*sigma**4 + 270*sigma**2 - 1260) - k1*(Pkd*(sigma**6 - 19*sigma**4 + 195*sigma**2 - 945) + Pkdd*k1*(sigma**4 - 20*sigma**2 + 105))) - sigma**2*(6*Pk*(sigma**4 - 13*sigma**2 + 60) + k1*(Pkd*(sigma**6 - 7*sigma**4 + 51*sigma**2 - 225) + Pkdd*k1*(sigma**4 - 12*sigma**2 + 45)))*(b1*(t - 1) + t*xb1)))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(2*d**2*k1**2*sigma**9)
135
+
136
+ return expr
137
+
138
+ class RR2:
139
+ def l0(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
140
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
141
+
142
+ b1 = cosmo_functions.survey.b_1(zz)
143
+ xb1 = cosmo_functions.survey1.b_1(zz)
144
+
145
+ fd,Dd,_,_,bd1,fdd,Ddd,_,_,bdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey)
146
+ fd,Dd,_,_,xbd1,fdd,Ddd,_,_,xbdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey1)
147
+
148
+ expr = (D1**2*(f*(7*bd1*t**2*(8*Pk + k1*(10*Pkd + Pkdd*k1)) - 7*bdd1*t**2*(4*Pk + k1*(10*Pkd + 3*Pkdd*k1)) + 3*fd*(16*Pk + k1*(22*Pkd + 3*Pkdd*k1))*(2*t**2 - 2*t + 1) - 3*fdd*(8*Pk + k1*(18*Pkd + 5*Pkdd*k1))*(2*t**2 - 2*t + 1) + 7*(t - 1)**2*(Pk*(8*xbd1 - 4*xbdd1) + k1*(10*Pkd*(xbd1 - xbdd1) + Pkdd*k1*(xbd1 - 3*xbdd1)))) - t*(7*bd1*(2*fd*(4*Pk + k1*(10*Pkd + 3*Pkdd*k1))*(t - 1) + 5*k1*(2*Pkd + Pkdd*k1)*(t*(xb1 + 2*xbd1) - 2*xbd1)) + 6*fd**2*(8*Pk + k1*(18*Pkd + 5*Pkdd*k1))*(t - 1) - 7*fd*(8*Pk*(t*(xb1 - xbd1) + xbd1) + k1*(10*Pkd*(t*xb1 - 2*t*xbd1 + 2*xbd1) + Pkdd*k1*(t*xb1 - 6*t*xbd1 + 6*xbd1))) + 7*t*xb1*(4*Pk*fdd + 5*bdd1*k1*(2*Pkd + Pkdd*k1) + fdd*k1*(10*Pkd + 3*Pkdd*k1)))) + D1*(Dd*(3*f**2*(16*Pk + k1*(22*Pkd + 3*Pkdd*k1))*(2*t**2 - 2*t + 1) - f*(-56*Pk*(xb1*(2*t**2 - 2*t + 1) + xbd1*(-2*t**2 + 3*t - 1)) + 14*bd1*t*(4*Pk + k1*(10*Pkd + 3*Pkdd*k1))*(2*t - 1) + 6*fd*(1 - 2*t)**2*(8*Pk + k1*(18*Pkd + 5*Pkdd*k1)) + 7*k1*(-10*Pkd*(2*t**2*xb1 - 4*t**2*xbd1 - 2*t*xb1 + 6*t*xbd1 + xb1 - 2*xbd1) - Pkdd*k1*xb1*(2*t**2 - 2*t + 1) + 6*Pkdd*k1*xbd1*(2*t**2 - 3*t + 1))) - 14*t*xb1*(2*t - 1)*(4*Pk*fd + 5*bd1*k1*(2*Pkd + Pkdd*k1) + fd*k1*(10*Pkd + 3*Pkdd*k1))) - Ddd*f*(3*f*(8*Pk + k1*(18*Pkd + 5*Pkdd*k1)) + 7*xb1*(4*Pk + k1*(10*Pkd + 3*Pkdd*k1)))*(2*t**2 - 2*t + 1)) - 2*Dd**2*f*t*(t - 1)*(3*f*(8*Pk + k1*(18*Pkd + 5*Pkdd*k1)) + 7*xb1*(4*Pk + k1*(10*Pkd + 3*Pkdd*k1))) + 7*b1*(-D1**2*(t - 1)**2*(-fd*(8*Pk + k1*(10*Pkd + Pkdd*k1)) + fdd*(4*Pk + 10*Pkd*k1 + 3*Pkdd*k1**2) + 5*k1*(2*Pkd + Pkdd*k1)*(xbd1 + xbdd1)) + D1*(Dd*(f*(8*Pk + k1*(10*Pkd + Pkdd*k1))*(2*t**2 - 2*t + 1) - 2*fd*(4*Pk + k1*(10*Pkd + 3*Pkdd*k1))*(2*t**2 - 3*t + 1) - 5*k1*(2*Pkd + Pkdd*k1)*(2*t**2*xb1 + 4*t**2*xbd1 - 2*t*xb1 - 6*t*xbd1 + xb1 + 2*xbd1)) - Ddd*(2*t**2 - 2*t + 1)*(4*Pk*f + f*k1*(10*Pkd + 3*Pkdd*k1) + 5*k1*xb1*(2*Pkd + Pkdd*k1))) - 2*Dd**2*t*(t - 1)*(4*Pk*f + f*k1*(10*Pkd + 3*Pkdd*k1) + 5*k1*xb1*(2*Pkd + Pkdd*k1))))/(210*d**2*k1**2)
149
+
150
+ Erf = scipy.special.erf
151
+ if sigma != 0:
152
+ expr = (-2*sigma*(D1**2*(b1*sigma**2*(t - 1)**2*(2*Pk*fd*(sigma**2 + 24) + 2*Pk*fdd*(sigma**2 - 12) + 15*Pkd*fdd*k1 - Pkdd*fdd*k1**2*(sigma**2 + 3) + fd*k1*(-2*Pkd*(sigma**2 + 15) + Pkdd*k1*(sigma**2 + 6)) + k1*sigma**2*(-Pkd + Pkdd*k1)*(2*xbd1 - xbdd1)) + f*(fd*(Pk*(8*sigma**4 + 84*sigma**2 + 720) + k1*(-2*Pkd*(sigma**4 + 21*sigma**2 + 135) + Pkdd*k1*(sigma**4 + 7*sigma**2 + 30)))*(2*t**2 - 2*t + 1) - fdd*(12*Pk*(sigma**2 + 30) + k1*(-9*Pkd*(2*sigma**2 + 15) + Pkdd*k1*(sigma**4 + 5*sigma**2 + 15)))*(2*t**2 - 2*t + 1) + sigma**2*(bd1*t**2*(2*Pk*(sigma**2 + 24) + k1*(-2*Pkd*(sigma**2 + 15) + Pkdd*k1*(sigma**2 + 6))) + bdd1*t**2*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)) + (t - 1)**2*(2*Pk*(xbd1*(sigma**2 + 24) + xbdd1*(sigma**2 - 12)) + k1*(-2*Pkd*xbd1*(sigma**2 + 15) + 15*Pkd*xbdd1 + Pkdd*k1*xbd1*(sigma**2 + 6) - Pkdd*k1*xbdd1*(sigma**2 + 3))))) + t*(-2*fd**2*(t - 1)*(12*Pk*(sigma**2 + 30) + k1*(-9*Pkd*(2*sigma**2 + 15) + Pkdd*k1*(sigma**4 + 5*sigma**2 + 15))) + fd*sigma**2*(2*Pk*(t*xb1*(sigma**2 + 24) + 2*t*xbd1*(sigma**2 - 12) - 2*xbd1*(sigma**2 - 12)) + 2*bd1*(t - 1)*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)) + k1*(-2*Pkd*(t*xb1*(sigma**2 + 15) - 15*t*xbd1 + 15*xbd1) + Pkdd*k1*(t*xb1*(sigma**2 + 6) - 2*t*xbd1*(sigma**2 + 3) + 2*xbd1*(sigma**2 + 3)))) + fdd*sigma**2*t*xb1*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)) + k1*sigma**4*(-Pkd + Pkdd*k1)*(2*bd1*(t*(xb1 - xbd1) + xbd1) - bdd1*t*xb1))) + D1*(Dd*(f**2*(Pk*(8*sigma**4 + 84*sigma**2 + 720) + k1*(-2*Pkd*(sigma**4 + 21*sigma**2 + 135) + Pkdd*k1*(sigma**4 + 7*sigma**2 + 30)))*(2*t**2 - 2*t + 1) + f*(-2*fd*(1 - 2*t)**2*(12*Pk*(sigma**2 + 30) + k1*(-9*Pkd*(2*sigma**2 + 15) + Pkdd*k1*(sigma**4 + 5*sigma**2 + 15))) + sigma**2*(4*Pk*sigma**2*t**2*xb1 + 8*Pk*sigma**2*t**2*xbd1 - 4*Pk*sigma**2*t*xb1 - 12*Pk*sigma**2*t*xbd1 + 2*Pk*sigma**2*xb1 + 4*Pk*sigma**2*xbd1 + 96*Pk*t**2*xb1 - 96*Pk*t**2*xbd1 - 96*Pk*t*xb1 + 144*Pk*t*xbd1 + 48*Pk*xb1 - 48*Pk*xbd1 - 4*Pkd*k1*sigma**2*t**2*xb1 + 4*Pkd*k1*sigma**2*t*xb1 - 2*Pkd*k1*sigma**2*xb1 - 60*Pkd*k1*t**2*xb1 + 60*Pkd*k1*t**2*xbd1 + 60*Pkd*k1*t*xb1 - 90*Pkd*k1*t*xbd1 - 30*Pkd*k1*xb1 + 30*Pkd*k1*xbd1 + 2*Pkdd*k1**2*sigma**2*t**2*xb1 - 4*Pkdd*k1**2*sigma**2*t**2*xbd1 - 2*Pkdd*k1**2*sigma**2*t*xb1 + 6*Pkdd*k1**2*sigma**2*t*xbd1 + Pkdd*k1**2*sigma**2*xb1 - 2*Pkdd*k1**2*sigma**2*xbd1 + 12*Pkdd*k1**2*t**2*xb1 - 12*Pkdd*k1**2*t**2*xbd1 - 12*Pkdd*k1**2*t*xb1 + 18*Pkdd*k1**2*t*xbd1 + 6*Pkdd*k1**2*xb1 - 6*Pkdd*k1**2*xbd1 + b1*(2*Pk*(sigma**2 + 24) + k1*(-2*Pkd*(sigma**2 + 15) + Pkdd*k1*(sigma**2 + 6)))*(2*t**2 - 2*t + 1) + 2*bd1*t*(2*t - 1)*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)))) + 2*sigma**2*(b1*(fd*(2*t**2 - 3*t + 1)*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)) + k1*sigma**2*(-Pkd + Pkdd*k1)*(xb1*(2*t**2 - 2*t + 1) + xbd1*(-2*t**2 + 3*t - 1))) + t*xb1*(2*t - 1)*(bd1*k1*sigma**2*(Pkd - Pkdd*k1) + fd*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3))))) - Ddd*(2*t**2 - 2*t + 1)*(b1*k1*sigma**4*xb1*(-Pkd + Pkdd*k1) + f**2*(12*Pk*(sigma**2 + 30) + k1*(-9*Pkd*(2*sigma**2 + 15) + Pkdd*k1*(sigma**4 + 5*sigma**2 + 15))) - f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)))) - 2*Dd**2*t*(t - 1)*(b1*k1*sigma**4*xb1*(-Pkd + Pkdd*k1) + f**2*(12*Pk*(sigma**2 + 30) + k1*(-9*Pkd*(2*sigma**2 + 15) + Pkdd*k1*(sigma**4 + 5*sigma**2 + 15))) - f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**2 - 12) + 15*Pkd*k1 - Pkdd*k1**2*(sigma**2 + 3)))) + np.sqrt(2)*np.sqrt(np.pi)*(D1**2*(b1*sigma**2*(t - 1)**2*(fd*(2*Pk*(sigma**4 - 7*sigma**2 + 24) + k1*(Pkd*(8*sigma**2 - 30) - Pkdd*k1*(sigma**2 - 6))) - fdd*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1)) - k1*sigma**2*(Pkd*(2*xbd1 + xbdd1*(sigma**2 - 1)) + Pkdd*k1*(xbd1*(sigma**2 - 2) + xbdd1))) + f*(3*fd*(4*Pk*(sigma**4 - 13*sigma**2 + 60) + k1*(2*Pkd*(8*sigma**2 - 45) - Pkdd*k1*(sigma**2 - 10)))*(2*t**2 - 2*t + 1) - 3*fdd*(4*Pk*(sigma**4 - 9*sigma**2 + 30) + k1*(9*Pkd*(sigma**2 - 5) + 5*Pkdd*k1))*(2*t**2 - 2*t + 1) + sigma**2*(bd1*t**2*(2*Pk*(sigma**4 - 7*sigma**2 + 24) + k1*(Pkd*(8*sigma**2 - 30) - Pkdd*k1*(sigma**2 - 6))) - bdd1*t**2*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1)) + (t - 1)**2*(2*Pk*(xbd1*(sigma**4 - 7*sigma**2 + 24) - xbdd1*(sigma**4 - 5*sigma**2 + 12)) - k1*(Pkd*xbd1*(30 - 8*sigma**2) + 5*Pkd*xbdd1*(sigma**2 - 3) + Pkdd*k1*xbd1*(sigma**2 - 6) + 3*Pkdd*k1*xbdd1)))) - t*(6*fd**2*(t - 1)*(4*Pk*(sigma**4 - 9*sigma**2 + 30) + k1*(9*Pkd*(sigma**2 - 5) + 5*Pkdd*k1)) + fd*sigma**2*(-2*Pk*(t*xb1*(sigma**4 - 7*sigma**2 + 24) - 2*t*xbd1*(sigma**4 - 5*sigma**2 + 12) + 2*xbd1*(sigma**4 - 5*sigma**2 + 12)) + 2*bd1*(t - 1)*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1)) + k1*(-2*Pkd*(t*xb1*(4*sigma**2 - 15) - 5*t*xbd1*(sigma**2 - 3) + 5*xbd1*(sigma**2 - 3)) + Pkdd*k1*(t*xb1*(sigma**2 - 6) + 6*t*xbd1 - 6*xbd1))) + fdd*sigma**2*t*xb1*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1)) + k1*sigma**4*(bd1*(2*Pkd*(-sigma**2*xbd1 + t*(xb1 + xbd1*(sigma**2 - 1)) + xbd1) + Pkdd*k1*(t*xb1*(sigma**2 - 2) + 2*t*xbd1 - 2*xbd1)) + bdd1*t*xb1*(Pkd*(sigma**2 - 1) + Pkdd*k1)))) + D1*(Dd*(3*f**2*(4*Pk*(sigma**4 - 13*sigma**2 + 60) + k1*(2*Pkd*(8*sigma**2 - 45) - Pkdd*k1*(sigma**2 - 10)))*(2*t**2 - 2*t + 1) - f*(6*fd*(1 - 2*t)**2*(4*Pk*(sigma**4 - 9*sigma**2 + 30) + k1*(9*Pkd*(sigma**2 - 5) + 5*Pkdd*k1)) + sigma**2*(-4*Pk*sigma**4*t**2*xb1 + 8*Pk*sigma**4*t**2*xbd1 + 4*Pk*sigma**4*t*xb1 - 12*Pk*sigma**4*t*xbd1 - 2*Pk*sigma**4*xb1 + 4*Pk*sigma**4*xbd1 + 28*Pk*sigma**2*t**2*xb1 - 40*Pk*sigma**2*t**2*xbd1 - 28*Pk*sigma**2*t*xb1 + 60*Pk*sigma**2*t*xbd1 + 14*Pk*sigma**2*xb1 - 20*Pk*sigma**2*xbd1 - 96*Pk*t**2*xb1 + 96*Pk*t**2*xbd1 + 96*Pk*t*xb1 - 144*Pk*t*xbd1 - 48*Pk*xb1 + 48*Pk*xbd1 - 16*Pkd*k1*sigma**2*t**2*xb1 + 20*Pkd*k1*sigma**2*t**2*xbd1 + 16*Pkd*k1*sigma**2*t*xb1 - 30*Pkd*k1*sigma**2*t*xbd1 - 8*Pkd*k1*sigma**2*xb1 + 10*Pkd*k1*sigma**2*xbd1 + 60*Pkd*k1*t**2*xb1 - 60*Pkd*k1*t**2*xbd1 - 60*Pkd*k1*t*xb1 + 90*Pkd*k1*t*xbd1 + 30*Pkd*k1*xb1 - 30*Pkd*k1*xbd1 + 2*Pkdd*k1**2*sigma**2*t**2*xb1 - 2*Pkdd*k1**2*sigma**2*t*xb1 + Pkdd*k1**2*sigma**2*xb1 - 12*Pkdd*k1**2*t**2*xb1 + 12*Pkdd*k1**2*t**2*xbd1 + 12*Pkdd*k1**2*t*xb1 - 18*Pkdd*k1**2*t*xbd1 - 6*Pkdd*k1**2*xb1 + 6*Pkdd*k1**2*xbd1 - b1*(2*Pk*(sigma**4 - 7*sigma**2 + 24) + k1*(Pkd*(8*sigma**2 - 30) - Pkdd*k1*(sigma**2 - 6)))*(2*t**2 - 2*t + 1) + 2*bd1*t*(2*t - 1)*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1)))) - sigma**2*(b1*(2*fd*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1))*(2*t**2 - 3*t + 1) + k1*sigma**2*(2*Pkd*(xb1*(2*t**2 - 2*t + 1) + xbd1*(sigma**2 - 1)*(2*t**2 - 3*t + 1)) + Pkdd*k1*(xb1*(sigma**2 - 2)*(2*t**2 - 2*t + 1) + 2*xbd1*(2*t**2 - 3*t + 1)))) + 2*t*xb1*(2*t - 1)*(bd1*k1*sigma**2*(Pkd*(sigma**2 - 1) + Pkdd*k1) + fd*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1))))) - Ddd*(2*t**2 - 2*t + 1)*(b1*k1*sigma**4*xb1*(Pkd*(sigma**2 - 1) + Pkdd*k1) + 3*f**2*(4*Pk*(sigma**4 - 9*sigma**2 + 30) + k1*(9*Pkd*(sigma**2 - 5) + 5*Pkdd*k1)) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1)))) - 2*Dd**2*t*(t - 1)*(b1*k1*sigma**4*xb1*(Pkd*(sigma**2 - 1) + Pkdd*k1) + 3*f**2*(4*Pk*(sigma**4 - 9*sigma**2 + 30) + k1*(9*Pkd*(sigma**2 - 5) + 5*Pkdd*k1)) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**4 - 5*sigma**2 + 12) + k1*(5*Pkd*(sigma**2 - 3) + 3*Pkdd*k1))))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(4*d**2*k1**2*sigma**7)
153
+
154
+ return expr
155
+
156
+ def l2(cosmo_functions,k1,zz=0,t=0,sigma=0,nonlin=False):
157
+ k1,Pk,Pkd,Pkdd,d,f,D1 = cosmo_functions.get_params_pk(k1,zz,nonlinear=nonlin)
158
+
159
+ b1 = cosmo_functions.survey.b_1(zz)
160
+ xb1 = cosmo_functions.survey1.b_1(zz)
161
+
162
+ fd,Dd,_,_,bd1,fdd,Ddd,_,_,bdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey)
163
+ fd,Dd,_,_,xbd1,fdd,Ddd,_,_,xbdd1 = cosmo_functions.get_derivs(zz,tracer = cosmo_functions.survey1)
164
+
165
+ expr = (D1**2*(f*(-2*Pk*bd1*t**2 + 22*Pk*bdd1*t**2 - 2*Pk*t**2*xbd1 + 22*Pk*t**2*xbdd1 + 4*Pk*t*xbd1 - 44*Pk*t*xbdd1 - 2*Pk*xbd1 + 22*Pk*xbdd1 - 4*Pkd*bd1*k1*t**2 - 5*Pkd*bdd1*k1*t**2 - 4*Pkd*k1*t**2*xbd1 - 5*Pkd*k1*t**2*xbdd1 + 8*Pkd*k1*t*xbd1 + 10*Pkd*k1*t*xbdd1 - 4*Pkd*k1*xbd1 - 5*Pkd*k1*xbdd1 + 5*Pkdd*bd1*k1**2*t**2 - 6*Pkdd*bdd1*k1**2*t**2 + 5*Pkdd*k1**2*t**2*xbd1 - 6*Pkdd*k1**2*t**2*xbdd1 - 10*Pkdd*k1**2*t*xbd1 + 12*Pkdd*k1**2*t*xbdd1 + 5*Pkdd*k1**2*xbd1 - 6*Pkdd*k1**2*xbdd1 + 2*fd*(6*Pk + k1*(3*Pkd + 2*Pkdd*k1))*(2*t**2 - 2*t + 1) + fdd*(12*Pk - 9*Pkd*k1 - 5*Pkdd*k1**2)*(2*t**2 - 2*t + 1)) + t*(2*bd1*(fd*(22*Pk - k1*(5*Pkd + 6*Pkdd*k1))*(t - 1) + 7*k1*(-Pkd + Pkdd*k1)*(t*(xb1 - xbd1) + xbd1)) + 2*fd**2*(12*Pk - k1*(9*Pkd + 5*Pkdd*k1))*(t - 1) + fd*(-2*Pk*(t*(xb1 - 22*xbd1) + 22*xbd1) + k1*(-2*Pkd*(2*t*xb1 + 5*t*xbd1 - 5*xbd1) + Pkdd*k1*(5*t*xb1 - 12*t*xbd1 + 12*xbd1))) + t*xb1*(22*Pk*fdd + 7*bdd1*k1*(Pkd - Pkdd*k1) - fdd*k1*(5*Pkd + 6*Pkdd*k1)))) + D1*(Dd*(2*f**2*(6*Pk + k1*(3*Pkd + 2*Pkdd*k1))*(2*t**2 - 2*t + 1) + f*(-4*Pk*t**2*xb1 + 88*Pk*t**2*xbd1 + 4*Pk*t*xb1 - 132*Pk*t*xbd1 - 2*Pk*xb1 + 44*Pk*xbd1 - 8*Pkd*k1*t**2*xb1 - 20*Pkd*k1*t**2*xbd1 + 8*Pkd*k1*t*xb1 + 30*Pkd*k1*t*xbd1 - 4*Pkd*k1*xb1 - 10*Pkd*k1*xbd1 + 10*Pkdd*k1**2*t**2*xb1 - 24*Pkdd*k1**2*t**2*xbd1 - 10*Pkdd*k1**2*t*xb1 + 36*Pkdd*k1**2*t*xbd1 + 5*Pkdd*k1**2*xb1 - 12*Pkdd*k1**2*xbd1 + 2*bd1*t*(2*t - 1)*(22*Pk - 5*Pkd*k1 - 6*Pkdd*k1**2) + 2*fd*(1 - 2*t)**2*(12*Pk - k1*(9*Pkd + 5*Pkdd*k1))) + 2*t*xb1*(2*t - 1)*(22*Pk*fd + 7*bd1*k1*(Pkd - Pkdd*k1) - fd*k1*(5*Pkd + 6*Pkdd*k1))) + Ddd*f*(2*t**2 - 2*t + 1)*(12*Pk*f + 22*Pk*xb1 - f*k1*(9*Pkd + 5*Pkdd*k1) - k1*xb1*(5*Pkd + 6*Pkdd*k1))) + 2*Dd**2*f*t*(t - 1)*(12*Pk*f + 22*Pk*xb1 - f*k1*(9*Pkd + 5*Pkdd*k1) - k1*xb1*(5*Pkd + 6*Pkdd*k1)) - b1*(D1**2*(t - 1)**2*(2*Pk*fd - 22*Pk*fdd + fd*k1*(4*Pkd - 5*Pkdd*k1) + fdd*k1*(5*Pkd + 6*Pkdd*k1) + 7*k1*(Pkd - Pkdd*k1)*(2*xbd1 - xbdd1)) + D1*(Dd*(f*(2*Pk + k1*(4*Pkd - 5*Pkdd*k1))*(2*t**2 - 2*t + 1) - 2*fd*(22*Pk - k1*(5*Pkd + 6*Pkdd*k1))*(2*t**2 - 3*t + 1) - 14*k1*(-Pkd + Pkdd*k1)*(xb1*(2*t**2 - 2*t + 1) + xbd1*(-2*t**2 + 3*t - 1))) - Ddd*(2*t**2 - 2*t + 1)*(22*Pk*f - f*k1*(5*Pkd + 6*Pkdd*k1) + 7*k1*xb1*(Pkd - Pkdd*k1))) - 2*Dd**2*t*(t - 1)*(22*Pk*f - f*k1*(5*Pkd + 6*Pkdd*k1) + 7*k1*xb1*(Pkd - Pkdd*k1))))/(21*d**2*k1**2)
166
+
167
+ Erf = scipy.special.erf
168
+ if sigma != 0:
169
+ expr = (-10*sigma*(D1**2*(b1*sigma**2*(t - 1)**2*(fd*(2*Pk*(5*sigma**4 + 33*sigma**2 + 360) + k1*(-2*Pkd*(2*sigma**4 + 24*sigma**2 + 225) + Pkdd*k1*(2*sigma**4 + 15*sigma**2 + 90))) - fdd*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45))) + k1*sigma**2*(-Pkd*(2*xbd1*(2*sigma**2 + 9) + xbdd1*(sigma**2 - 9)) + Pkdd*k1*(xbd1*(sigma**2 + 18) - xbdd1*(2*sigma**2 + 9)))) + f*(fd*(4*Pk*(4*sigma**6 + 63*sigma**4 + 495*sigma**2 + 3780) + k1*(-2*Pkd*(2*sigma**6 + 48*sigma**4 + 450*sigma**2 + 2835) + Pkdd*k1*(2*sigma**6 + 20*sigma**4 + 135*sigma**2 + 630)))*(2*t**2 - 2*t + 1) - fdd*(60*Pk*(sigma**4 + 9*sigma**2 + 126) + k1*(-9*Pkd*(4*sigma**4 + 45*sigma**2 + 315) + Pkdd*k1*(2*sigma**6 + 16*sigma**4 + 90*sigma**2 + 315)))*(2*t**2 - 2*t + 1) + sigma**2*(bd1*t**2*(2*Pk*(5*sigma**4 + 33*sigma**2 + 360) + k1*(-2*Pkd*(2*sigma**4 + 24*sigma**2 + 225) + Pkdd*k1*(2*sigma**4 + 15*sigma**2 + 90))) - bdd1*t**2*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45))) + (t - 1)**2*(2*Pk*(xbd1*(5*sigma**4 + 33*sigma**2 + 360) - xbdd1*(sigma**4 + 3*sigma**2 + 180)) + k1*(-2*Pkd*xbd1*(2*sigma**4 + 24*sigma**2 + 225) + 15*Pkd*xbdd1*(sigma**2 + 15) + Pkdd*k1*xbd1*(2*sigma**4 + 15*sigma**2 + 90) - Pkdd*k1*xbdd1*(2*sigma**4 + 12*sigma**2 + 45))))) - t*(2*fd**2*(t - 1)*(60*Pk*(sigma**4 + 9*sigma**2 + 126) + k1*(-9*Pkd*(4*sigma**4 + 45*sigma**2 + 315) + Pkdd*k1*(2*sigma**6 + 16*sigma**4 + 90*sigma**2 + 315))) + fd*sigma**2*(-2*Pk*(t*xb1*(5*sigma**4 + 33*sigma**2 + 360) - 2*t*xbd1*(sigma**4 + 3*sigma**2 + 180) + 2*xbd1*(sigma**4 + 3*sigma**2 + 180)) + 2*bd1*(t - 1)*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45))) + k1*(Pkd*(t*xb1*(4*sigma**4 + 48*sigma**2 + 450) - 30*t*xbd1*(sigma**2 + 15) + 30*xbd1*(sigma**2 + 15)) - Pkdd*k1*(t*xb1*(2*sigma**4 + 15*sigma**2 + 90) - 2*t*xbd1*(2*sigma**4 + 12*sigma**2 + 45) + 2*xbd1*(2*sigma**4 + 12*sigma**2 + 45)))) + fdd*sigma**2*t*xb1*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45))) + k1*sigma**4*(bd1*(2*Pkd*(t*xb1*(2*sigma**2 + 9) + t*xbd1*(sigma**2 - 9) - xbd1*(sigma**2 - 9)) - Pkdd*k1*(t*xb1*(sigma**2 + 18) - 2*t*xbd1*(2*sigma**2 + 9) + 2*xbd1*(2*sigma**2 + 9))) + bdd1*t*xb1*(Pkd*(sigma**2 - 9) + Pkdd*k1*(2*sigma**2 + 9))))) + D1*(Dd*(f**2*(4*Pk*(4*sigma**6 + 63*sigma**4 + 495*sigma**2 + 3780) + k1*(-2*Pkd*(2*sigma**6 + 48*sigma**4 + 450*sigma**2 + 2835) + Pkdd*k1*(2*sigma**6 + 20*sigma**4 + 135*sigma**2 + 630)))*(2*t**2 - 2*t + 1) - 2*f*fd*(1 - 2*t)**2*(60*Pk*(sigma**4 + 9*sigma**2 + 126) + k1*(-9*Pkd*(4*sigma**4 + 45*sigma**2 + 315) + Pkdd*k1*(2*sigma**6 + 16*sigma**4 + 90*sigma**2 + 315))) + f*sigma**2*(20*Pk*sigma**4*t**2*xb1 - 8*Pk*sigma**4*t**2*xbd1 - 20*Pk*sigma**4*t*xb1 + 12*Pk*sigma**4*t*xbd1 + 10*Pk*sigma**4*xb1 - 4*Pk*sigma**4*xbd1 + 132*Pk*sigma**2*t**2*xb1 - 24*Pk*sigma**2*t**2*xbd1 - 132*Pk*sigma**2*t*xb1 + 36*Pk*sigma**2*t*xbd1 + 66*Pk*sigma**2*xb1 - 12*Pk*sigma**2*xbd1 + 1440*Pk*t**2*xb1 - 1440*Pk*t**2*xbd1 - 1440*Pk*t*xb1 + 2160*Pk*t*xbd1 + 720*Pk*xb1 - 720*Pk*xbd1 - 8*Pkd*k1*sigma**4*t**2*xb1 + 8*Pkd*k1*sigma**4*t*xb1 - 4*Pkd*k1*sigma**4*xb1 - 96*Pkd*k1*sigma**2*t**2*xb1 + 60*Pkd*k1*sigma**2*t**2*xbd1 + 96*Pkd*k1*sigma**2*t*xb1 - 90*Pkd*k1*sigma**2*t*xbd1 - 48*Pkd*k1*sigma**2*xb1 + 30*Pkd*k1*sigma**2*xbd1 - 900*Pkd*k1*t**2*xb1 + 900*Pkd*k1*t**2*xbd1 + 900*Pkd*k1*t*xb1 - 1350*Pkd*k1*t*xbd1 - 450*Pkd*k1*xb1 + 450*Pkd*k1*xbd1 + 4*Pkdd*k1**2*sigma**4*t**2*xb1 - 8*Pkdd*k1**2*sigma**4*t**2*xbd1 - 4*Pkdd*k1**2*sigma**4*t*xb1 + 12*Pkdd*k1**2*sigma**4*t*xbd1 + 2*Pkdd*k1**2*sigma**4*xb1 - 4*Pkdd*k1**2*sigma**4*xbd1 + 30*Pkdd*k1**2*sigma**2*t**2*xb1 - 48*Pkdd*k1**2*sigma**2*t**2*xbd1 - 30*Pkdd*k1**2*sigma**2*t*xb1 + 72*Pkdd*k1**2*sigma**2*t*xbd1 + 15*Pkdd*k1**2*sigma**2*xb1 - 24*Pkdd*k1**2*sigma**2*xbd1 + 180*Pkdd*k1**2*t**2*xb1 - 180*Pkdd*k1**2*t**2*xbd1 - 180*Pkdd*k1**2*t*xb1 + 270*Pkdd*k1**2*t*xbd1 + 90*Pkdd*k1**2*xb1 - 90*Pkdd*k1**2*xbd1 + b1*(2*Pk*(5*sigma**4 + 33*sigma**2 + 360) + k1*(-2*Pkd*(2*sigma**4 + 24*sigma**2 + 225) + Pkdd*k1*(2*sigma**4 + 15*sigma**2 + 90)))*(2*t**2 - 2*t + 1) - 2*bd1*t*(2*t - 1)*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45)))) - sigma**2*(b1*(2*fd*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45)))*(2*t**2 - 3*t + 1) + k1*sigma**2*(2*Pkd*(xb1*(2*sigma**2 + 9)*(2*t**2 - 2*t + 1) + xbd1*(sigma**2 - 9)*(2*t**2 - 3*t + 1)) + Pkdd*k1*(-xb1*(sigma**2 + 18)*(2*t**2 - 2*t + 1) + 2*xbd1*(2*sigma**2 + 9)*(2*t**2 - 3*t + 1)))) + 2*t*xb1*(2*t - 1)*(bd1*k1*sigma**2*(Pkd*(sigma**2 - 9) + Pkdd*k1*(2*sigma**2 + 9)) + fd*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45)))))) - Ddd*(2*t**2 - 2*t + 1)*(b1*k1*sigma**4*xb1*(Pkd*(sigma**2 - 9) + Pkdd*k1*(2*sigma**2 + 9)) + f**2*(60*Pk*(sigma**4 + 9*sigma**2 + 126) + k1*(-9*Pkd*(4*sigma**4 + 45*sigma**2 + 315) + Pkdd*k1*(2*sigma**6 + 16*sigma**4 + 90*sigma**2 + 315))) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45))))) - 2*Dd**2*t*(t - 1)*(b1*k1*sigma**4*xb1*(Pkd*(sigma**2 - 9) + Pkdd*k1*(2*sigma**2 + 9)) + f**2*(60*Pk*(sigma**4 + 9*sigma**2 + 126) + k1*(-9*Pkd*(4*sigma**4 + 45*sigma**2 + 315) + Pkdd*k1*(2*sigma**6 + 16*sigma**4 + 90*sigma**2 + 315))) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**4 + 3*sigma**2 + 180) + k1*(-15*Pkd*(sigma**2 + 15) + Pkdd*k1*(2*sigma**4 + 12*sigma**2 + 45))))) + 5*np.sqrt(2)*np.sqrt(np.pi)*(D1**2*(-b1*sigma**2*(t - 1)**2*(fd*(2*Pk*(sigma**6 - 10*sigma**4 + 87*sigma**2 - 360) + k1*(2*Pkd*(4*sigma**4 - 51*sigma**2 + 225) - Pkdd*k1*(sigma**4 - 15*sigma**2 + 90))) + fdd*(-2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(-5*Pkd*(sigma**4 - 12*sigma**2 + 45) - 3*Pkdd*k1*(sigma**2 - 15))) - k1*sigma**2*(2*Pkd*xbd1*(sigma**2 - 9) + Pkd*xbdd1*(sigma**4 - 4*sigma**2 + 9) + Pkdd*k1*xbd1*(sigma**4 - 5*sigma**2 + 18) + Pkdd*k1*xbdd1*(sigma**2 - 9))) + f*(-3*fd*(4*Pk*(sigma**6 - 22*sigma**4 + 255*sigma**2 - 1260) + k1*(2*Pkd*(8*sigma**4 - 165*sigma**2 + 945) - Pkdd*k1*(sigma**4 - 25*sigma**2 + 210)))*(2*t**2 - 2*t + 1) + 3*fdd*(4*Pk*(sigma**6 - 18*sigma**4 + 165*sigma**2 - 630) + k1*(9*Pkd*(sigma**4 - 20*sigma**2 + 105) + 5*Pkdd*k1*(sigma**2 - 21)))*(2*t**2 - 2*t + 1) + sigma**2*(bd1*t**2*(-2*Pk*(sigma**6 - 10*sigma**4 + 87*sigma**2 - 360) + k1*(-2*Pkd*(4*sigma**4 - 51*sigma**2 + 225) + Pkdd*k1*(sigma**4 - 15*sigma**2 + 90))) + bdd1*t**2*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15))) - (t - 1)**2*(2*Pk*(xbd1*(sigma**6 - 10*sigma**4 + 87*sigma**2 - 360) - xbdd1*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180)) - k1*(-2*Pkd*xbd1*(4*sigma**4 - 51*sigma**2 + 225) + 5*Pkd*xbdd1*(sigma**4 - 12*sigma**2 + 45) + Pkdd*k1*xbd1*(sigma**4 - 15*sigma**2 + 90) + 3*Pkdd*k1*xbdd1*(sigma**2 - 15))))) + t*(6*fd**2*(t - 1)*(4*Pk*(sigma**6 - 18*sigma**4 + 165*sigma**2 - 630) + k1*(9*Pkd*(sigma**4 - 20*sigma**2 + 105) + 5*Pkdd*k1*(sigma**2 - 21))) + fd*sigma**2*(-2*Pk*(t*xb1*(sigma**6 - 10*sigma**4 + 87*sigma**2 - 360) - 2*t*xbd1*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + 2*xbd1*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180)) + 2*bd1*(t - 1)*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15))) + k1*(-2*Pkd*(t*xb1*(4*sigma**4 - 51*sigma**2 + 225) - 5*t*xbd1*(sigma**4 - 12*sigma**2 + 45) + 5*xbd1*(sigma**4 - 12*sigma**2 + 45)) + Pkdd*k1*(t*xb1*(sigma**4 - 15*sigma**2 + 90) + 6*t*xbd1*(sigma**2 - 15) - 6*xbd1*(sigma**2 - 15)))) + fdd*sigma**2*t*xb1*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15))) + k1*sigma**4*(bd1*(2*Pkd*(t*xb1*(sigma**2 - 9) + t*xbd1*(sigma**4 - 4*sigma**2 + 9) - xbd1*(sigma**4 - 4*sigma**2 + 9)) + Pkdd*k1*(t*xb1*(sigma**4 - 5*sigma**2 + 18) + 2*t*xbd1*(sigma**2 - 9) - 2*xbd1*(sigma**2 - 9))) + bdd1*t*xb1*(Pkd*(sigma**4 - 4*sigma**2 + 9) + Pkdd*k1*(sigma**2 - 9))))) + D1*(Dd*(-3*f**2*(4*Pk*(sigma**6 - 22*sigma**4 + 255*sigma**2 - 1260) + k1*(2*Pkd*(8*sigma**4 - 165*sigma**2 + 945) - Pkdd*k1*(sigma**4 - 25*sigma**2 + 210)))*(2*t**2 - 2*t + 1) + f*(6*fd*(1 - 2*t)**2*(4*Pk*(sigma**6 - 18*sigma**4 + 165*sigma**2 - 630) + k1*(9*Pkd*(sigma**4 - 20*sigma**2 + 105) + 5*Pkdd*k1*(sigma**2 - 21))) + sigma**2*(-4*Pk*sigma**6*t**2*xb1 + 8*Pk*sigma**6*t**2*xbd1 + 4*Pk*sigma**6*t*xb1 - 12*Pk*sigma**6*t*xbd1 - 2*Pk*sigma**6*xb1 + 4*Pk*sigma**6*xbd1 + 40*Pk*sigma**4*t**2*xb1 - 64*Pk*sigma**4*t**2*xbd1 - 40*Pk*sigma**4*t*xb1 + 96*Pk*sigma**4*t*xbd1 + 20*Pk*sigma**4*xb1 - 32*Pk*sigma**4*xbd1 - 348*Pk*sigma**2*t**2*xb1 + 456*Pk*sigma**2*t**2*xbd1 + 348*Pk*sigma**2*t*xb1 - 684*Pk*sigma**2*t*xbd1 - 174*Pk*sigma**2*xb1 + 228*Pk*sigma**2*xbd1 + 1440*Pk*t**2*xb1 - 1440*Pk*t**2*xbd1 - 1440*Pk*t*xb1 + 2160*Pk*t*xbd1 + 720*Pk*xb1 - 720*Pk*xbd1 - 16*Pkd*k1*sigma**4*t**2*xb1 + 20*Pkd*k1*sigma**4*t**2*xbd1 + 16*Pkd*k1*sigma**4*t*xb1 - 30*Pkd*k1*sigma**4*t*xbd1 - 8*Pkd*k1*sigma**4*xb1 + 10*Pkd*k1*sigma**4*xbd1 + 204*Pkd*k1*sigma**2*t**2*xb1 - 240*Pkd*k1*sigma**2*t**2*xbd1 - 204*Pkd*k1*sigma**2*t*xb1 + 360*Pkd*k1*sigma**2*t*xbd1 + 102*Pkd*k1*sigma**2*xb1 - 120*Pkd*k1*sigma**2*xbd1 - 900*Pkd*k1*t**2*xb1 + 900*Pkd*k1*t**2*xbd1 + 900*Pkd*k1*t*xb1 - 1350*Pkd*k1*t*xbd1 - 450*Pkd*k1*xb1 + 450*Pkd*k1*xbd1 + 2*Pkdd*k1**2*sigma**4*t**2*xb1 - 2*Pkdd*k1**2*sigma**4*t*xb1 + Pkdd*k1**2*sigma**4*xb1 - 30*Pkdd*k1**2*sigma**2*t**2*xb1 + 12*Pkdd*k1**2*sigma**2*t**2*xbd1 + 30*Pkdd*k1**2*sigma**2*t*xb1 - 18*Pkdd*k1**2*sigma**2*t*xbd1 - 15*Pkdd*k1**2*sigma**2*xb1 + 6*Pkdd*k1**2*sigma**2*xbd1 + 180*Pkdd*k1**2*t**2*xb1 - 180*Pkdd*k1**2*t**2*xbd1 - 180*Pkdd*k1**2*t*xb1 + 270*Pkdd*k1**2*t*xbd1 + 90*Pkdd*k1**2*xb1 - 90*Pkdd*k1**2*xbd1 - b1*(2*Pk*(sigma**6 - 10*sigma**4 + 87*sigma**2 - 360) + k1*(2*Pkd*(4*sigma**4 - 51*sigma**2 + 225) - Pkdd*k1*(sigma**4 - 15*sigma**2 + 90)))*(2*t**2 - 2*t + 1) + 2*bd1*t*(2*t - 1)*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15))))) + sigma**2*(b1*(2*fd*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15)))*(2*t**2 - 3*t + 1) + k1*sigma**2*(2*Pkd*(xb1*(sigma**2 - 9)*(2*t**2 - 2*t + 1) + xbd1*(sigma**4 - 4*sigma**2 + 9)*(2*t**2 - 3*t + 1)) + Pkdd*k1*(xb1*(sigma**4 - 5*sigma**2 + 18)*(2*t**2 - 2*t + 1) + 2*xbd1*(sigma**2 - 9)*(2*t**2 - 3*t + 1)))) + 2*t*xb1*(2*t - 1)*(bd1*k1*sigma**2*(Pkd*(sigma**4 - 4*sigma**2 + 9) + Pkdd*k1*(sigma**2 - 9)) + fd*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15)))))) + Ddd*(2*t**2 - 2*t + 1)*(b1*k1*sigma**4*xb1*(Pkd*(sigma**4 - 4*sigma**2 + 9) + Pkdd*k1*(sigma**2 - 9)) + 3*f**2*(4*Pk*(sigma**6 - 18*sigma**4 + 165*sigma**2 - 630) + k1*(9*Pkd*(sigma**4 - 20*sigma**2 + 105) + 5*Pkdd*k1*(sigma**2 - 21))) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15))))) + 2*Dd**2*t*(t - 1)*(b1*k1*sigma**4*xb1*(Pkd*(sigma**4 - 4*sigma**2 + 9) + Pkdd*k1*(sigma**2 - 9)) + 3*f**2*(4*Pk*(sigma**6 - 18*sigma**4 + 165*sigma**2 - 630) + k1*(9*Pkd*(sigma**4 - 20*sigma**2 + 105) + 5*Pkdd*k1*(sigma**2 - 21))) + f*sigma**2*(b1 + xb1)*(2*Pk*(sigma**6 - 8*sigma**4 + 57*sigma**2 - 180) + k1*(5*Pkd*(sigma**4 - 12*sigma**2 + 45) + 3*Pkdd*k1*(sigma**2 - 15)))))*Erf(np.sqrt(2)*sigma/2)*np.exp(sigma**2/2))*np.exp(-sigma**2/2)/(8*d**2*k1**2*sigma**9)
170
+
171
+ return expr
172
+