def _lorentzian_pink_beam(alpha, beta, fwhm_l, tth, tth_list): """ @author Saransh Singh, Lawrence Livermore National Lab @date 03/22/2021 SS 1.0 original @details the lorentzian component of the pink beam peak profile obtained by convolution of gaussian with normalized back to back exponentials. more details can be found in Von Dreele et. al., J. Appl. Cryst. (2021). 54, 3–6 """ del_tth = tth_list - tth p = -alpha * del_tth + 1j * 0.5 * alpha * fwhm_l q = -beta * del_tth + 1j * 0.5 * beta * fwhm_l y = np.zeros(tth_list.shape) mask = np.logical_or(np.abs(np.real(p)) > 1e2, np.abs(np.imag(p)) > 1e2) f1 = np.zeros(tth_list.shape) f1[mask] = np.imag(np.exp(p[mask]) * exp1(p[mask])) mask = np.logical_or(np.abs(np.real(q)) > 1e2, np.abs(np.imag(q)) > 1e2) f2 = np.zeros(tth_list.shape) f2[mask] = np.imag(np.exp(q[mask]) * exp1(q[mask])) y = -(alpha*beta)/(np.pi*(alpha + beta)) *\ (f1 + f2) y = np.nan_to_num(y) return y
def ILS_solver_global_coeff(): coeff_all = np.zeros([BHE_wall_points_num_all, BHE_num, timestep_tot]) for currstep in range(0, timestep_tot): #data container dist_bhe_to_ref_po = np.zeros([BHE_wall_points_num_all, BHE_num]) localcoeff = np.zeros([BHE_wall_points_num_all, BHE_num]) for i in range(0, BHE_num): #coefficient of current timestep for j in range(0, BHE_wall_points_num_all): dist_bhe_to_ref_po[j,i] = (bhe_pos_x[i] - bhe_wall_pos_x[j] )**2 \ + (bhe_pos_y[i] - bhe_wall_pos_y[j] )**2 exp1 = dist_bhe_to_ref_po[j, i] / (4 * alpha * delta_t * (currstep + 1)) n1 = sp.exp1(exp1) localcoeff[j, i] = 1 / (4 * math.pi * k_s) * n1 #coefficient of current timestep after if currstep > 0: for j in range(0, BHE_wall_points_num_all): dist_bhe_to_ref_po[j,i] = (bhe_pos_x[i] - bhe_wall_pos_x[j] )**2 \ + (bhe_pos_y[i] - bhe_wall_pos_y[j] )**2 exp1 = dist_bhe_to_ref_po[j, i] / (4 * alpha * delta_t * currstep) n1 = sp.exp1(exp1) localcoeff[ j, i] = localcoeff[j, i] - 1 / (4 * math.pi * k_s) * n1 #reverse the coefficient order coeff_all[:, :, 1:] = coeff_all[:, :, :timestep_tot - 1] #store each timestep's localcoefficient into global time coefficient dataframe coeff_all[:, :, 0] = localcoeff return coeff_all
def _screening(e, ma): if ma == 0: return 0 r0 = 1 / 0.001973 # 0.001973 MeV A -> 1 A (Ge) = 1/0.001973 x = (r0 * ma**2 / (4 * e))**2 numerator = 2 * log(2 * e / ma) - 1 - exp(-x) * (1 - exp(-x) / 2) + ( x + 0.5) * exp1(2 * x) - (1 + x) * exp1(x) denomenator = 2 * log(2 * e / ma) - 1 return numerator / denomenator
def func(t, T, S): ftheis = Q / 4 / np.pi / T * exp1( R**2 * S / 4 / T / (t + 1e-9)) - Q / 4 / np.pi / T * exp1(R**2 * S / 4 / T / (trecov + 1e-9)) if include_image_well: ftheis += Q / 4 / np.pi / T * exp1( Rimage**2 * S / 4 / T / (t + 1e-9)) - Q / 4 / np.pi / T * exp1( Rimage**2 * S / 4 / T / (trecov + 1e-9)) return ftheis
def analytic_soln(z): EPS = 1e-9 src_mag = 8 sigma_t = 8 zstop = 1 if src_mag != sigma_t: print('Bad src_mag != sigma_t') sys.exit(-1) return 1 - 0.5 * (np.exp(-z * sigma_t) + np.exp(sigma_t * (z - zstop)) - src_mag * z * sp.exp1(sigma_t * z + EPS) - src_mag * (zstop - z) * sp.exp1(sigma_t * (zstop - z) + EPS))
def imp_lsc(self, gamma, sigma, w, dz): """ gamma - energy sigma - transverse RMS size of the beam w - omega = 2*pi*f """ eps = 1e-16 ass = 40.0 alpha = w * sigma / (gamma * speed_of_light) alpha2 = alpha * alpha inda = np.where(alpha2 > ass)[0] ind = np.where((alpha2 <= ass) & (alpha2 >= eps))[0] T = np.zeros(w.shape) T[ind] = np.exp(alpha2[ind]) *exp1(alpha2[ind]) x= alpha2[inda] k = 0 for i in range(10): k += (-1) ** i * factorial(i) / (x ** (i + 1)) T[inda] = k Z = 1j * Z0 / (4 * pi * speed_of_light*gamma**2) * w * T * dz return Z # --> Omm/m
def exp_int(s, x): r"""Calculate the exponential integral :math:`E_s(x)`. Given by: :math:`E_s(x) = \int_1^\infty \frac{e^{-xt}}{t^s}\,\mathrm dt` Parameters ---------- s : :class:`float` exponent in the integral (should be > -100) x : :class:`numpy.ndarray` input values """ if np.isclose(s, 1): return sps.exp1(x) if np.isclose(s, np.around(s)) and s > -0.5: return sps.expn(int(np.around(s)), x) x = np.array(x, dtype=np.double) x_neg = x < 0 x = np.abs(x) x_compare = x**min((10, max(((1 - s), 1)))) res = np.empty_like(x) # use asymptotic behavior for zeros x_zero = np.isclose(x_compare, 0, atol=1e-20) x_inf = x > max(30, -s / 2) # function is like exp(-x)*(1/x + s/x^2) x_fin = np.logical_not(np.logical_or(x_zero, x_inf)) x_fin_pos = np.logical_and(x_fin, np.logical_not(x_neg)) if s > 1.0: # limit at x=+0 res[x_zero] = 1.0 / (s - 1.0) else: res[x_zero] = np.inf res[x_inf] = np.exp(-x[x_inf]) * (x[x_inf]**-1 - s * x[x_inf]**-2) res[x_fin_pos] = inc_gamma(1 - s, x[x_fin_pos]) * x[x_fin_pos]**(s - 1) res[x_neg] = np.nan # nan for x < 0 return res
def upper_gamma_ext(a, x): if a > 0: return gammaincc(a, x) * gamma_func(a) elif a == 0: return exp1(x) else: return (upper_gamma_ext(a + 1, x) - np.power(x, a) * np.exp(-x)) / a
def trans_rate(k, h, phi, mu, ct, B, rw, pwf, pi, t): """trans_rate(k, h, phi, mu, ct, B, rw, pwf, pi, t) Calculates the transient flow rate""" td = (2.637 * 10**(-4)) * k * (t * 24) / (phi * mu * ct * (rw**2)) return (7.08 * 10**(-3)) * (k * h / (mu * B)) * ((pi - pwf) / (0.5 * sp.exp1(1 / (4 * td))))
def test_GG(x, y): # Test some properties of the function according to [Del, p.367]. z = x + 1j*y assert np.isclose(E1(z), exp1(z), rtol=1e-3) # (A3.5) assert np.isclose(E1(x - 1j*y), np.conjugate(E1(x + 1j*y)), rtol=1e-3)
def forward(ctx, input): ctx.save_for_backward(input) dev = input.device with torch.no_grad(): x = special.exp1(input.detach().cpu()).to(dev) input.to(dev) return x
def gfunc(xi, gamma=None): """ MMSE-LSA Gain function """ nu = np.multiply(np.divide(xi, np.add(1, xi)), gamma) G = np.multiply(np.divide(xi, np.add(1, xi)), np.exp(np.multiply(0.5, exp1(nu)))) return G
def distFunc(r_i): """ Eq (20) of Bailer-Jones (2015) with everything that can be calculated outside, moved outside. """ sc_int = .5 * exp1(.5 * ((r_i - mu) / lim_u)**2) sc_int.T[np.isinf(sc_int.T)] = 0. return B2 * sc_int
def test_exponential_integral(x, y): z = x + 1j*y # Compare with Scipy implementation assert np.isclose(E1(z), exp1(z), rtol=1e-3) # Test property (A3.5) of the function according to [Del, p.367]. if y != 0.0: assert np.isclose(E1(np.conjugate(z)), np.conjugate(E1(z)), rtol=1e-3)
def CSTR_2_macro (x, p, grad=False): R = p * x[0] * x[1] if R < 1.5e-3: # Risk of overflow C = np.array([1.]) dC = np.array([0.]) else: C = (1. / R) * np.exp(1. / R) * exp1(1. / R) dC = (1. - C*R - C)/(R*p) return C if not grad else [C, dC[None,:]]
def _compute_van_regemorter(self, T, f_lu, nu_lu): g = 0.2 # This value is set to 2. We should select the value based on the main quantum number u = constants.h.cgs.value * nu_lu / constants.k_B.cgs.value / T I = 13.6 # eV c0 = 5.46510e-11 gamma = lambda a,u: max(a,(0.276 * np.exp(u) * scisp.exp1(u))) #c = c0 * T ** (0.5) * 14.5 * (I / constants.h.cgs.value / nu_lu ) * f_lu * constants.h.cgs.value * nu_lu \ # / constants.k_B.cgs.value / T * np.exp(- u) * gamma c = c0 * T ** (0.5) * 14.5 * (I / constants.h.cgs.value / nu_lu ) * f_lu * u * np.exp(- u) * gamma(g, u) return c
def step(self, p, dt=1, cutoff=0.99): if isinstance(dt, np.ndarray): t = dt else: self.tmax = max(self.get_tmax(p, cutoff), 3 * dt) t = np.arange(dt, self.tmax, dt) r = p[2] u = r**2.0 * p[0] / (4.0 * p[1] * t) s = self.up * exp1(u) return s
def chi(z): """Hyperbolic cosine integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = -(exp1(-zc) + exp1(zc) + log(-zc) - log(zc)) / 2.0 if not iscomplexobj(z): res = real(res) # Return -inf for 0, +inf for +inf, +inf for -inf: res[where(zc == -inf)[0]] = inf res[where(zc == inf)[0]] = inf res[where(zc == 0)[0]] = -inf if iterable(z): return res else: return asscalar(res)
def _compute_mean(C, g, ctx): """ Compute mean according to equation 8a, page 773. """ mag = ctx.mag dis = ctx.rrup # computing r02 parameter and the average distance to the fault surface ro2 = 1.4447e-5 * np.exp(2.3026 * mag) avg = np.sqrt(dis**2 + ro2) # computing fourth term of Eq. 8a, page 773. trm4 = (exp1(C['c4'] * dis) - exp1(C['c4'] * avg)) / ro2 # computing the mean mean = C['c1'] + C['c2'] * mag + C['c3'] * np.log(trm4) # convert from cm/s**2 to 'g' mean = np.log(np.exp(mean) * 1e-2 / g) return mean
def chi(z): """Hyperbolic cosine integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = -(exp1(-zc)+exp1(zc)+log(-zc)-log(zc))/2.0 if not iscomplexobj(z): res = real(res) # Return -inf for 0, +inf for +inf, +inf for -inf: res[where(zc==-inf)[0]] = inf res[where(zc==inf)[0]] = inf res[where(zc==0)[0]] = -inf if iterable(z): return res else: return asscalar(res)
def si(z): """Sine integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = (1j/2)*(exp1(-1j*zc)-exp1(1j*zc)+log(-1j*zc)-log(1j*zc)) if not iscomplexobj(z): res = real(res) # Return 0 for 0, pi/2 for +inf, -pi/2 for -inf: res[where(zc==-inf)[0]] = -pi/2 res[where(zc==inf)[0]] = pi/2 res[where(zc==0)[0]] = 0 if iterable(z): return res else: return asscalar(res)
def si(z): """Sine integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = (1j / 2) * (exp1(-1j * zc) - exp1(1j * zc) + log(-1j * zc) - log(1j * zc)) if not iscomplexobj(z): res = real(res) # Return 0 for 0, pi/2 for +inf, -pi/2 for -inf: res[where(zc == -inf)[0]] = -pi / 2 res[where(zc == inf)[0]] = pi / 2 res[where(zc == 0)[0]] = 0 if iterable(z): return res else: return asscalar(res)
def ci(z): """Cosine integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = log(zc)-(exp1(-1j*zc)+exp1(1j*zc)+log(-1j*zc)+log(1j*zc))/2.0 if not iscomplexobj(z): res = real(res) # Return -inf for 0, 0 for +inf, and pi*1j for -inf: res[where(zc==-inf)[0]] = pi*1j res[where(zc==inf)[0]] = 0 res[where(zc==0)[0]] = -inf if iterable(z): return res else: return asscalar(res)
def i_tir_integrand(lamb, z_s, bc03): prefactor = 1 / (8 * np.pi) / np.sin(np.abs(b)) term1 = 1 - dust_albedo_f(lamb) term2 = surface_power_deriv(bc03, z_s, lamb) tau_zs = tau_f(lamb, z_s) tau_0 = tau_f(lamb, 0) term3 = 2 + tau_zs * special.exp1(tau_zs) - np.exp(-tau_zs) \ + (tau_0 - tau_zs) * special.exp1(tau_0 - tau_zs) - np.exp(tau_zs - tau_0) term3_2 = (tau_0 - tau_zs)*special.exp1(tau_zs - tau_0) + np.exp(tau_0 - tau_zs) \ + tau_zs * special.exp1(tau_zs) - np.exp(-tau_zs) if type(z_s) == np.ndarray or type(lamb) == np.ndarray: np.putmask(term3, tau_zs > tau_0, term3_2) elif tau_zs > tau_0: term3 = term3_2 # apply neg. sign: term3 = -term3 result = prefactor * term1 * term2 * term3 return result
def gompertz_lifeyears(par, minage, maxage): a = par[0] b = par[1] if -0.00001 < b < 0.00001: # b is approximately 0 return exp(-a) - exp(-a - exp(a) * (maxage - minage)) else: f_min = 1 / b * exp(a + b * minage) f_max = 1 / b * exp(a + b * maxage) cons_of_integ = exp(f_min) if b > 0: LY = -1 * cons_of_integ / b * (exp1(f_max) - exp1(f_min)) else: LY = -1 * cons_of_integ / b * (exp1(complex(f_max)) - exp1(complex(f_min))).real if isnan(LY) and gompertz_survival( a, b, minage, minage + 0.01) < 0.00001: # everyone dies instantly return 0.0 else: return LY
def ci(z): """Cosine integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = log(zc) - (exp1(-1j * zc) + exp1(1j * zc) + log(-1j * zc) + log(1j * zc)) / 2.0 if not iscomplexobj(z): res = real(res) # Return -inf for 0, 0 for +inf, and pi*1j for -inf: res[where(zc == -inf)[0]] = pi * 1j res[where(zc == inf)[0]] = 0 res[where(zc == 0)[0]] = -inf if iterable(z): return res else: return asscalar(res)
def f_dust(tau): '''(ndarray) -> ndarray Dust extinction functin''' out = nu.zeros_like(tau) if nu.all(out == tau): #if all zeros return nu.ones_like(tau) if nu.any(tau < 0): #if has negitive tau out.fill(nu.inf) return out temp = tau[tau <= 1] out[tau <= 1] = (1 / (2. * temp) * (1 + (temp - 1) * nu.exp(-temp) - temp ** 2 * exp1(temp))) out[tau > 1] = nu.exp(-tau[tau > 1]) return out
def f_dust(tau): '''(ndarray) -> ndarray Dust extinction functin''' out = nu.zeros_like(tau) if nu.all(out == tau): #if all zeros return nu.ones_like(tau) if nu.any(tau < 0): #if has negitive tau out.fill(nu.inf) return out temp = tau[tau <= 1] out[tau <= 1] = (1 / (2. * temp) * (1 + (temp - 1) * nu.exp(-temp) - temp**2 * exp1(temp))) out[tau > 1] = nu.exp(-tau[tau > 1]) return out
def rate_function_Dere2007(Te, arr): """ temperature is in eV """ tck = interpolate.splrep(arr[2], arr[3], s=1) # spline representation of ionisation rate # arr[2] is x values, arr[3] is scaled rates redt = Te / arr[0] # ratio of temperature in eV to IP xval = 1.0 - np.log(2.0) / np.log(2.0 + redt) # Eq. (4) of Dere+ 2007 #print(xval) rho = interpolate.splev(xval, tck, der=0, ext=0) rateval = (redt**-0.5) * (arr[0]**-1.5) * ( 1.0E-6 * rho) * specialfunc.exp1(1.0 / redt) return rateval
def test_branch_cut(self): assert np.isnan(sc.exp1(-1)) assert sc.exp1(complex(-1, 0)).imag == (-sc.exp1(complex(-1, -0.0)).imag) assert_allclose(sc.exp1(complex(-1, 0)), sc.exp1(-1 + 1e-20j), atol=0, rtol=1e-15) assert_allclose(sc.exp1(complex(-1, -0.0)), sc.exp1(-1 - 1e-20j), atol=0, rtol=1e-15)
def imp_lsc(self, gamma, sigma, w, dz): """ gamma - energy sigma - transverse RMS size of the beam w - omega = 2*pi*f """ indx = np.where(w < 1e-7)[0] w[indx] = 1e-7 alpha = w * sigma / (gamma * speed_of_light) alpha2 = alpha * alpha ksi = np.exp(alpha2 + np.log(exp1(alpha2)) - 2 * np.log(gamma)) Z = 1j * Z0 / (4 * pi * speed_of_light) * w * ksi * dz Z[indx] = 0 return Z * 1e-12 # --> V/pC
def mmse_lsa(xi, gamma): ''' Computes the MMSE-LSA gain function. Input/s: xi - a priori SNR. gamma - a posteriori SNR. Output/s: MMSE-LSA gain function. ''' nu = np.multiply(np.divide(xi, np.add(1, xi)), gamma) return np.multiply(np.divide(xi, np.add(1, xi)), np.exp(np.multiply( 0.5, exp1(nu)))) # MMSE-LSA gain function.
def function(self, x, y, kappa_0, theta_c, center_x=0, center_y=0): """ :param x: angular position (normally in units of arc seconds) :param y: angular position (normally in units of arc seconds) :param kappa_0: central convergence of profile :param theta_c: core radius (in arcsec) :param center_x: center of halo (in angular units) :param center_y: center of halo (in angular units) :return: lensing potential (in arcsec^2) """ x_ = x - center_x y_ = y - center_y r = np.sqrt(x_**2 + y_**2) r = np.maximum(r, self._s) Integral_factor = 0.5 * exp1((r / theta_c)**2) + np.log((r / theta_c)) function = kappa_0 * theta_c**2 * Integral_factor return function
def exp_int(s, x): r"""The exponential integral :math:`E_s(x)` Given by: :math:`E_s(x) = \int_1^\infty \frac{e^{-xt}}{t^s}\,\mathrm dt` Parameters ---------- s : :class:`float` exponent in the integral x : :class:`numpy.ndarray` input values """ if np.isclose(s, 1): return sps.exp1(x) if np.isclose(s, np.around(s)) and s > -1: return sps.expn(int(np.around(s)), x) return inc_gamma(1 - s, x) * x**(s - 1)
def ei(z): """Exponential integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = -exp1(-zc)+(log(zc)-log(1.0/zc))/2.0-log(-zc) if not iscomplexobj(z): res = real(res) # Return 0 for -inf, inf for +inf, and -inf for 0: res[where(zc==-inf)[0]] = 0 res[where(zc==inf)[0]] = inf res[where(zc==0)[0]] = -inf if iterable(z): return res else: return asscalar(res)
def li(z): """Logarithmic integral of a complex value.""" if iterable(z): zc = asarray(z, complex) else: zc = array(z, complex, ndmin=1) res = -exp1(-log(zc))+(log(log(zc))-log(1/log(zc)))/2.0-log(-log(zc)) if not iscomplexobj(z) and not any(z < 0): res = real(res) # Return 0 for 0, -inf for 1, and +inf for +inf: res[where(zc==inf)[0]] = inf res[where(zc==0)[0]] = 0 res[where(zc==1)[0]] = -inf if iterable(z): return res else: return asscalar(res)
def step(self, p, dt=1, cutoff=None): rho = p[1] cS = p[2] k0rho = k0(rho) if isinstance(dt, np.ndarray): t = dt else: self.tmax = max(self.get_tmax(p, cutoff), 10 * dt) t = np.arange(dt, self.tmax, dt) tau = t / cS tau1 = tau[tau < rho / 2] tau2 = tau[tau >= rho / 2] w = (exp1(rho) - k0rho) / (exp1(rho) - exp1(rho / 2)) F = np.zeros_like(tau) F[tau < rho / 2] = w * exp1(rho ** 2 / (4 * tau1)) - (w - 1) * exp1( tau1 + rho ** 2 / (4 * tau1)) F[tau >= rho / 2] = 2 * k0rho - w * exp1(tau2) + (w - 1) * exp1( tau2 + rho ** 2 / (4 * tau2)) return p[0] * F / (2 * k0rho)
def compute_by_noise_pow(self,signal,n_pow): s_spec = sp.fft(signal*self._window) s_amp = sp.absolute(s_spec) s_phase = sp.angle(s_spec) gamma = self._calc_aposteriori_snr(s_amp,n_pow) xi = self._calc_apriori_snr(gamma) #xi = self._calc_apriori_snr2(gamma,n_pow) self._prevGamma = gamma nu = gamma * xi / (1.0+xi) self._G = xi/(1.0+xi)*sp.exp(0.5*spc.exp1(nu)) idx = sp.less(s_amp**2.0,n_pow) self._G[idx] = self._constant idx = sp.isnan(self._G) + sp.isinf(self._G) self._G[idx] = xi[idx] / ( xi[idx] + 1.0) idx = sp.isnan(self._G) + sp.isinf(self._G) self._G[idx] = self._constant self._G = sp.maximum(self._G,0.0) amp = self._G * s_amp amp = sp.maximum(amp,0.0) amp2 = self._ratio*amp + (1.0-self._ratio)*s_amp self._prevAmp = amp spec = amp2 * sp.exp(s_phase*1j) return sp.real(sp.ifft(spec))
def test_exp1_complex128(self): z = np.asarray(np.random.rand(4, 4) + 1j*np.random.rand(4, 4), np.complex128) z_gpu = gpuarray.to_gpu(z) e_gpu = special.exp1(z_gpu) assert np.allclose(sp.special.exp1(z), e_gpu.get())
def W0(t): '''compute the dimensionless pressure increase in the bottom aquifer created by the injection, at the distance d''' return exp1(d**2/(4*t*GetTSratio(w_b, k_b, Cr_b, mu_b, Cb_b)))
def W_lb(t): '''compute the dimensionless well pressure decrease in the bottom aquifer created by the leakage, at the leak location''' return exp1(r_l**2/(4*t*GetTSratio(w_b, k_b, Cr_b, mu_b, Cb_b)))
def W_lt(t): '''compute the dimensionless well pressure increase in the top aquifer created by the leakage, at the leak location''' return rho_t*mu_t*h_b*k_b/(rho_b*mu_b*h_t*k_t) * exp1(r_l**2/(4*t*GetTSratio(w_t, k_t, Cr_t, mu_t, Cb_t)))
Deff=k/(theta*beta*mu) Tunit=k*b Sunit=b*theta*beta Kg=k*rho*g/mu vinj=Qv/(2*np.pi*rwell*b) Re=2*rwell*rho*vinj/mu Trans = Tunit*rho*g/mu Stor = Sunit*rho*g r=np.linspace(rwell, rout, 1000) rMat=np.tile(r,(len(t), 1)) tMat=np.tile(t,(1,len(r))) u=np.power(rMat,2.)*Stor/(4*Trans*tMat) W=sp.exp1(u) s=Qv/(4*np.pi*Trans)*W pres=P-s*rho*g falc=np.loadtxt('../Theis problem BM/theis_falcon.csv',delimiter=',',skiprows=1) p1 = plt.plot(r,pres[0,:],'b-',r,pres[1,:],'g-',r,pres[2,:],'r-') p2 = plt.plot(falc[:,0],falc[:,1],'bs',falc[:,0],falc[:,2],'gs',falc[:,0],falc[:,3],'rs') plt.setp(p2, alpha=0.25) plt.xlabel('Radius [m]') plt.ylabel('Pressure [Pa]') p1.extend(p2) plt.legend(p1,['Ana. $t=2.00$ s','Ana. $t=20.0$ s','Ana. $t=200$ s','FALCON $t=2.00$ s','FALCON $t=20.0$ s','FALCON $t=200$ s'],loc=4) plt.ylim([9.2e4, 1e5]) #tikz_save('Theis.tikz',figureheight=r'\figureheight', figurewidth=r'\figurewidth',show_info=False) plt.show()
def function(x): return 1 / x * exp(-x / average) - exp1(x / average) / average
def theor_prod_uni_norm(a, sigma, x): return 0.5/sqrt(2*numpy.pi) * exp1(0.5 * (x/(a*sigma))**2)