def problem_3b(): import numpy as np from scipy.integrate import quad as integrate from sympy.solvers import solve def imf_N(mass=0, alpha=2.35): if mass <= 1: return (1/mass)*np.exp(-(np.log10(mass) - np.log10(0.22))**2 / (2*0.57**2)) elif mass > 1: return mass**-alpha alpha = 2.35 coeff_high = 25. / integrate(imf_N, 20, 100, args=(alpha))[0] mass = 1 coeff_low = coeff_high * mass**-alpha / \ ((1/mass)*np.exp(-(np.log10(mass) - np.log10(0.22))**2 / (2*0.57**2))) def imf_M(mass=0, alpha=-2.35): if mass <= 1: return coeff_low*(mass/mass)*np.exp(-(np.log10(mass) - np.log10(0.22))**2 / (2*0.57**2)) elif mass > 1: return coeff_high * mass**-alpha * mass mass = integrate(imf_M, 0.1, 100, args = (alpha))[0] print('Mass of cluster: %s' % mass)
def threshold_area(x, y, area_fraction=0.68): ''' Finds the limits of a 1D array which includes a given fraction of the integrated data. Parameters ---------- data : array-like 1D array. area_fraction : float Fraction of area. Returns ------- limits : tuple Lower and upper bound including fraction of area. ''' import numpy as np from scipy.integrate import simps as integrate # Step for lowering threshold step = (np.max(y) - np.median(y)) / 1000.0 # initial threshold threshold = np.max(y) - step threshold_area = 0.0 # area under whole function area = integrate(y, x) # Stop when the area below the threshold is greater than the max area while threshold_area < area * area_fraction: threshold_indices = np.where(y > threshold)[0] try: bounds_indices = (threshold_indices[0], threshold_indices[-1]) except IndexError: bounds_indices = () try: threshold_area = integrate(y[bounds_indices[0]:bounds_indices[1]], x[bounds_indices[0]:bounds_indices[1]]) threshold_area += threshold * (x[bounds_indices[1]] - \ x[bounds_indices[0]]) except IndexError: threshold_area = 0 threshold -= step x_peak = x[y == y.max()][0] low_error, up_error = x_peak - x[bounds_indices[0]], \ x[bounds_indices[1]] - x_peak return (x_peak, low_error, up_error)
def problem_3c(): import numpy as np from scipy.integrate import quad as integrate # Compute Salpeter mass def imf_N(mass=0, alpha=2.35): return mass**-alpha alpha = 2.35 coeff = 30. / integrate(imf_N, 20, 100, args=(alpha))[0] def imf_M(mass=0, alpha=-2.35): return mass**-alpha * mass mass_a = coeff*integrate(imf_M, 0.1, 100, args=(alpha))[0] # Compute Chabrier mass def imf_N(mass=0, alpha=2.35): if mass <= 1: return (1/mass)*np.exp(-(np.log10(mass) - np.log10(0.22))**2 / (2*0.57**2)) elif mass > 1: return mass**-alpha alpha = 2.35 coeff_high = 25. / integrate(imf_N, 20, 100, args=(alpha))[0] mass = 1 coeff_low = coeff_high * mass**-alpha / \ ((1/mass)*np.exp(-(np.log10(mass) - np.log10(0.22))**2 / (2*0.57**2))) def imf_M(mass=0, alpha=-2.35): if mass <= 1: return coeff_low*(mass/mass)*np.exp(-(np.log10(mass) - np.log10(0.22))**2 / (2*0.57**2)) elif mass > 1: return coeff_high * mass**-alpha * mass mass_b = integrate(imf_M, 0.1, 100, args = (alpha))[0] # now calculate velocity dipsersion min_vel_disp = mass_a - mass_b print('Min velocity resolution: %s' % min_vel_disp)
def w(z): s, phi = z h = lambda u: Vf(np.maximum(G(x, phi), u)) * F.pdf(u) integral, err = integrate(h, a, b) q = pi(s) * integral + (1.0 - pi(s)) * Vf(G(x, phi)) # == minus because we minimize == # return - x * (1.0 - phi - s) - beta * q
def gpc_make_prediction(self, tasks, x_star): task = tasks[0] y, f = self.Y[:,task], self.f num_tasks = len(tasks) # TODO: Revisar esta linea(puede fallar): I = np.matrix(np.eye(num_cols(self.X[task]))) W = -self.sigmoid.hessian_log_likelihood(y, f) # TODO: Revisar las dos siguientes lineas: # self.K = self.cov_function.cov_matrix(self.hyperparameters, self.X[task]) # K = self.K + eps*I K = self.cov_function.cov_matrix(self.hyperparameters, self.X[task]) K = K + eps*I sqrt_W = np.sqrt(W) self.L = cholesky(I + sqrt_W*K*sqrt_W) L = self.L k_star = compute_k_star(self.cov_function.cov_function, self.hyperparameters, self.X[task], x_star) # f_mean = dot(k_star.T, self.sigmoid.gradient_log_likelihood(y, f)) f_mean = (k_star.T)*(self.sigmoid.gradient_log_likelihood(y, f)) v = backslash(L, sqrt_W*k_star) k_star_star = compute_k_star(self.cov_function.cov_function, self.hyperparameters, x_star, x_star) f_var = k_star_star - np.dot(v.T, v) # TODO: # esto se puede hacer mejor def aux_fun(z, i): return self.sigmoid.evaluate(z)*scipy.stats.norm(f_mean[i,0], f_var[i,i]).pdf(z) # pi_star = integrate(aux_fun, -np.inf, np.inf) self.pi_star = [] for i in range(num_cols(x_star)): self.pi_star.append(integrate(aux_fun, -np.inf, np.inf, args=(i,))[0]) return self.pi_star """def aux_fun(f_i):
def problem_3a(): from scipy.integrate import quad as integrate def imf_N(mass=0, alpha=2.35): return mass**-alpha alpha = 2.35 coeff = 25. / integrate(imf_N, 20, 100, args=(alpha))[0] def imf_M(mass=0, alpha=-2.35): return mass**-alpha * mass mass = coeff*integrate(imf_M, 0.1, 100, args=(alpha))[0] print('Mass of cluster: %s' % mass)
def AverageFlux(d,**args): args['D']=d intFlux=lambda x:Flux(x,**args) #print args F=integrate(intFlux,0.0,2*PI)[0]/(2*PI) #print F #exit(0) return F
def ReadFiniteRadiusWaveform(n, filename, WaveformName, ChMass, InitialAdmEnergy, YLMRegex, LModes, DataType, Ws) : """ This is just a worker function defined for ReadFiniteRadiusData, below, reading a single waveform from an h5 file of many waveforms. You probably don't need to call this directly. """ from scipy.integrate import cumtrapz as integrate from numpy import setdiff1d, empty, delete, sqrt, log, array from h5py import File import GWFrames try : f = File(filename, 'r') except IOError : print("ReadFiniteRadiusWaveform could not open the file '{0}'".format(filename)) raise try : W = f[WaveformName] NTimes_Input = W['AverageLapse.dat'].shape[0] T = W['AverageLapse.dat'][:,0] Indices = MonotonicIndices(T) T = T[Indices] Radii = array(W['ArealRadius.dat'])[Indices,1] AverageLapse = array(W['AverageLapse.dat'])[Indices,1] CoordRadius = W['CoordRadius.dat'][0,1] YLMdata = [DataSet for DataSet in list(W) for m in [YLMRegex.search(DataSet)] if (m and int(m.group('L')) in LModes)] YLMdata = sorted(YLMdata, key=lambda DataSet : [int(YLMRegex.search(DataSet).group('L')), int(YLMRegex.search(DataSet).group('M'))]) LM = sorted([[int(m.group('L')), int(m.group('M'))] for DataSet in YLMdata for m in [YLMRegex.search(DataSet)] if m]) NModes = len(LM) # Lapse is given by 1/sqrt(-g^{00}), where g is the full 4-metric T[1:] = integrate(AverageLapse/sqrt(((-2.0*InitialAdmEnergy)/Radii) + 1.0), T) + T[0] T -= (Radii + (2.0*InitialAdmEnergy)*log((Radii/(2.0*InitialAdmEnergy))-1.0)) Ws[n].SetTime(T/ChMass) # WRONG!!!: # Radii /= ChMass NTimes = Ws[n].NTimes() # Ws[n].SetFrame is not done, because we assume the inertial frame Ws[n].SetFrameType(GWFrames.Inertial) # Assumption! (but this should be safe) Ws[n].SetDataType(DataType) Ws[n].SetRIsScaledOut(True) # Assumption! (but it should be safe) Ws[n].SetMIsScaledOut(True) # We have made this true Ws[n].SetLM(LM) Data = empty((NModes, NTimes), dtype='complex') if(DataType == GWFrames.h) : UnitScaleFactor = 1.0 / ChMass elif(DataType == GWFrames.hdot) : UnitScaleFactor = 1.0 elif(DataType == GWFrames.Psi4) : UnitScaleFactor = ChMass else : raise ValueError('DataType "{0}" is unknown.'.format(DataType)) RadiusRatio = Radii / CoordRadius for m,DataSet in enumerate(YLMdata) : modedata = array(W[DataSet]) Data[m,:] = (modedata[Indices,1] + 1j*modedata[Indices,2]) * RadiusRatio * UnitScaleFactor Ws[n].SetData(Data) finally : f.close() return Radii/ChMass
def GL_coupling_coefficient(r, w_0, a, p): #Assumes a corrugated horn waveguide, where the E-field at the horn aperture is known analytically (HE_11 mode). #With that, used Goldsmith equation 7.34 to calculate coefficients. x = 2.*r**2./w_0**2. s = w_0/a t = 1.7005 integral = integrate(integrand,0.,2./s**2., args=(s,t,p))[0] c_p = 1.362*s*integral return c_p
def w(z): # z = (s, phi) """ Objective function, corresponding to the right-hand side of the Bellman equation. Negated because we will minimize. """ s, phi = z integrand = lambda u: Vf(np.maximum(G(x, phi), u)) * F.pdf(u) integral, err = integrate(integrand, a, b) q = pi(s) * integral + (1 - pi(s)) * Vf(G(x, phi)) return - x * (1 - phi - s) - beta * q
def calc_avg_N_photons(mass_limits=(18,100), Gamma=-1.35): ''' Calculates number of photons produced in a stars lifetime in a given mass range of the IMF. Parameters ---------- mass_limits : tuple (lower limit, upper limit) in M_sun. Gamma : float Gamma in IMF Returns ------- N_photons_avg : float Number of photons produced in a stars lifetime in a given mass range of the IMF. ''' # import external modules import numpy as np from scipy.integrate import quad as integrate def integrand(mass=0, Gamma=Gamma): return calc_N_photons(mass) * calc_star_lifetime(mass)\ * calc_N_stars(mass=mass, Gamma=Gamma) N_photons_total = integrate(integrand, mass_limits[0], mass_limits[1], args=(Gamma))[0] N_stars = integrate(calc_N_stars, mass_limits[0], mass_limits[1], args=(Gamma))[0] N_photons_avg = N_photons_total / N_stars * 365 * 24 * 3600 return N_photons_avg
def findArcLength(fromPoint,toPoint,definePt): # Rename the parameters given for brevity p0,p1,p2 = fromPoint, toPoint, definePt # Get the parameters that describe the parabola (ax^2+bx+c) (a,b,c) = findParabola(p0,p1,p2) # Import basic integrating tool from scipy.integrate import quad as integrate # Function for the arc length integrand: Sqrt(1+[y']^2) from numpy import sqrt func = lambda x : sqrt( 1 + (2*a*x + b) * (2*a*x + b) ) # Integrate to find arc length arcLength = integrate(func,p0.x,p1.x)[0] return arcLength
def CalcXk(self, v_r_spline, r_cut, k, r_max): # Tolerances abs_tol = 1.e-11 rel_tol = 1.e-11 # Integrand v_integrand = lambda r: r*sin(k*r)*v_r_spline(r) # Calculate x_k r_first = r_cut + ((pi/k)-(r_cut % (pi/k))) if (self.n_d == 2): # FIXME: This probably isn't right prefactor = -2.*pi elif (self.n_d == 3): prefactor = -4.*pi/k x_k = 0. if (r_max >= r_first): # First segment x_k += prefactor * integrate(v_integrand, r_cut, r_first, divmax=20) # Other segments if (int(k) != 0): n_pi_k = int(k)*pi/k # TODO: Manually fixed number currently else: n_pi_k = pi/k n_seg = max(int(floor((r_max-r_first)/n_pi_k)),1) for i in range(n_seg): x_k += prefactor * integrate(v_integrand, r_first+i*n_pi_k, r_first+(i+1)*n_pi_k, divmax=20) r_end = r_first + n_seg*n_pi_k elif (r_max >= r_cut): x_k += prefactor * integrate(v_integrand, r_cut, r_max, divmax=20) r_end = r_max else: r_end = r_cut # Add in analytic part after r_end x_k += self.CalcXkCoul(k,r_end) return x_k
def calc_sfr_coeff(mass_limits_ionizing=(18,100), mass_limits_total=(0.1,100), Gamma=-1.35, N_photons_avg=2.52e63): ''' Calculates coefficient to convert Halpha luminosity into a SFR. Parameters ---------- mass_limits_ionizing : tuple (lower limit, upper limit) in M_sun of stars creating Halpha. mass_limits_total : tuple (lower limit, upper limit) in M_sun of all stars. Gamma : float Gamma in IMF. N_photons_avg : float Average number of photons per star emitted in one year. Returns ------- sfr_coeff : float SFR (M_sun) = sfr_coeff * Halpha luminosity ''' # import external modules import numpy as np from scipy.integrate import quad as integrate N_stars_ionizing = integrate(calc_N_stars, mass_limits_ionizing[0], mass_limits_ionizing[1], args=(Gamma))[0] print('N %s' % N_stars_ionizing) # Number of ionizing photons per second by massive stars efficiency = 2/3. sec2yr = 365 * 24 * 3600. n = 7.37e11 * efficiency / N_photons_avg * sec2yr sfr_coeff = n \ / (mass_limits_ionizing[1]**Gamma - \ mass_limits_ionizing[0]**Gamma) \ * (Gamma / (Gamma + 1)) \ * (mass_limits_total[1]**(Gamma+1) - \ mass_limits_total[0]**(Gamma+1)) return sfr_coeff
def probdensity(func, x, x0=0, scale=True): """ Probability Density Function. This function uses an integral to compute the probability density of a given function. Parameters ---------- func: function The function for which to calculate the PDF x: numpy.ndarray The (array of) value(s) at which to calculate the PDF x0: float, optional The lower-bound of the integral, starting point for the PDF to be calculated over, default=0 scale: bool, optional The scaling to be applied to the output, default=True Returns ------- sumx: numpy.ndarray The (array of) value(s) computed as the PDF at point(s) x """ sumx = _np.array([]) try: lx = len(x) # Find length of Input except: lx = 1 # Length 1 x = [x] # Pack into list # Recursively Find Probability Density for i in range(lx): sumx = _np.append(sumx, integrate(func, x0, x[i])[0]) # Return only the 0-th value if there's only 1 value available if (len(sumx) == 1): sumx = sumx[0] else: if (scale == True): mx = sumx.max() sumx /= mx elif (scale != False): sumx /= scale return (sumx)
def main(argv): """ Generates random data using specified parameters, integrates and saves plots as PDFs """ ### Integration t = sc.linspace(0, 50, 1000) R0 = 10 C0 = 5 RC0 = sc.array([R0, C0]) #pops input pops, infodict = integrate(dCR_dt, RC0, t, full_output=True) ### Plotting pop density over time f1 = p.figure() p.plot(t, pops[:, 0], 'g-', label='Resource density') p.plot(t, pops[:, 1], 'b-', label='Consumer density') p.grid() p.legend(loc='best') p.xlabel('Time') p.ylabel('Population density') p.title('Consumer-Resource population dynamics') if len(sys.argv) == 5: p.text( 5 / 9 * max(t), 6 / 7 * max(pops[:, 0:1]), "r=" + sys.argv[1] + ", a=" + sys.argv[2] + ", z=" + sys.argv[3] + ", e=" + sys.argv[4]) else: p.text(5 / 9 * max(t), 6 / 7 * max(pops[:, 0:1]), "r=1.0, a=0.1, z=1.5, e=0.75") f1.savefig('../results/LV_model2.pdf') print("Final predator and prey populations are", round(pops[len(t) - 1, 1], 2), "and", round(pops[len(t) - 1, 0], 2), "respectively.") ### plotting Comsumer density by resource density f2 = p.figure() p.plot(pops[:, 0], pops[:, 1], 'r-', label='Resource density') # Plot p.grid() p.xlabel('Resource density') p.ylabel('Consumer density') p.title('Consumer-Resource population dynamics') #p.show()# To display the figure f2.savefig('../results/LV_model2-1.pdf') p.close('all') return None
def gausdist(x, mu=0, sigma=1): """ Gaussian Distribution Function. This function is designed to calculate the generic distribution of a gaussian function with controls for mu and sigma. Parameters ---------- x: numpy.ndarray The input (array) x mu: float, optional Optional control argument, default=0 sigma: float, optional Optional control argument, default=1 Returns ------- F: numpy.ndarray Computed distribution of the gausian function at the points specified by (array) x """ # Define Integrand def integrand(sq): return (_np.exp(-sq**2 / 2)) try: lx = len(x) # Find length of Input except: lx = 1 # Length 1 x = [x] # Pack into list F = _np.zeros(lx, dtype=_np.float64) for i in range(lx): x_tmp = x[i] # Evaluate X (altered by mu and sigma) X = (x_tmp - mu) / sigma integral = integrate(integrand, _np.NINF, X) # Integrate result = 1 / _np.sqrt(2 * _np.pi) * integral[0] # Evaluate Result F[i] = result # Return only the 0-th value if there's only 1 value available if (len(F) == 1): F = F[0] return (F)
def _rho_s_eqn(self, rho_s): """ Returns the value of the rho_s equation (25) with all terms on the LHS, used to find rho_s via root-finding. Args: rho_s : float The resource utilization level such that phi_ivp = pbar; parameter we search for via root-finding """ lb = self.s ub = self.alpha_min * rho_s int_val = integrate(lambda nu: (nu**(self.s - 1)) * np.exp(-nu), lb, ub) rat1 = (self.s**self.s) / np.exp(self.s) rat2 = self.pbar * (self.s**self.s) / (self.c_ub * np.exp(self.alpha_min * rho_s)) val = int_val - (rat1 - rat2) return val
def _u_cdt_huc1_eqn(self, u_cdt): """ Returns the value of the HUC1 equation with all terms on the LHS, used to find u_cdt via root-finding. Args: u_cdt : float The critical dividing threshold; parameter we search for via root-finding """ lb = u_cdt * self.alpha_min ub = self.alpha_min int_val = integrate(lambda nu: (nu**(self.s - 1)) * np.exp(-nu), lb, ub) rat1 = (self.s**self.s) / np.exp(u_cdt * self.alpha_min) rat2 = self.pbar * (self.s** self.s) / (self.c_ub * np.exp(self.alpha_min)) val = int_val - (rat1 - rat2) return val
def rmse_of_non_central_chi_squared_polynomial_approximations(): lambdas = [1, 5, 10, 50, 100, 200] nus = [1, 5, 10, 50, 100] poly_orders = [1, 3, 5] n_intervals = 16 results = { poly_order: {nu: {} for nu in nus} for poly_order in poly_orders } for poly_order in poly_orders: for nu in nus: ncx2_approx = construct_inverse_non_central_chi_squared_interpolated_polynomial_approximation( dof=nu, n_intervals=n_intervals + 1, polynomial_order=poly_order) discontinuities = sorted( [0.5**(i + 2) for i in range(n_intervals)] + [0.5] + [1.0 - 0.5**(i + 2) for i in range(n_intervals)]) for l in lambdas: rmse = integrate(lambda u: (ncx2.ppf( u, df=nu, nc=l) - ncx2_approx(u, non_centrality=l))**2, 0, 1, points=discontinuities, limit=50 + 10 * len(discontinuities))[0]**0.5 results[poly_order][nu][l] = rmse for poly_order, result in results.items(): df = pd.DataFrame(result) df.index = df.index.rename('lambda') df.columns = df.columns.rename('nu') print(poly_order, df.min().min(), df.max().max()) print(round(df, 3)) print('\n') print( round(df, 3).apply(lambda x: ' & '.join([str(i) for i in list(x)]) + r' \\', axis=1)) print('\n' * 3)
def funcrms(func, T): """ Root-Mean-Square (RMS) Evaluator for Callable Functions. Integral-based RMS calculator, evaluates the RMS value of a repetative signal (f) given the signal's specific period (T) Parameters ---------- func: float The periodic function, a callable like f(t) T: float The period of the function f, so that f(0)==f(T) Returns ------- RMS: The RMS value of the function (f) over the interval ( 0, T ) """ fn = lambda x: func(x)**2 integral, _ = integrate(fn, 0, T) return _np.sqrt(1 / T * integral)
def prob1b(): import numpy as np import pandas as pd from scipy.integrate import simps as integrate from scipy.integrate import cumtrapz print('\n---------------') print('1b') print('---------------\n') df = pd.DataFrame.from_csv('cluster_data.csv', index_col=None) Ms = df['Mass [Msun]'] Ls = df['Luminosity [Lsun]'] Ts = df['Teff [K]'] A = 5.297e3 Gamma = 1.3 phi = lambda m: A * m**-(Gamma + 1.0) N_m = phi(Ms) #* tau_ms(masses) L_bol = integrate(N_m * Ls, Ms) print('\nBolometric luminosity = {0:e} Lsun'.format(L_bol)) L_cdf = cumtrapz(N_m * Ls, Ms) M_half = np.interp(0.5 * L_bol, L_cdf, Ms[1:]) if 0: import matplotlib.pyplot as plt plt.close() plt.clf() plt.plot(Ms[1:], L_cdf / L_cdf.max()) plt.show() print('\nHalf light mass = {0:.2f} Msun'.format(M_half))
def plotError(f, bounds, n): # calculate the exact definite integral exact = integrate(f, min(bounds), max(bounds))[0] # create an array of the exact value to plot exact = [exact for i in range(1, n)] # generate an array of approximate integrals with increasing sample size approx = [integrate_mc(f, bounds, i) for i in range(1, n)] # plot the approximate and exact results plt.plot([i for i in range(1, n)], approx) plt.plot([i for i in range(1, n)], exact) # plot details plt.legend(['Monte Carlo', 'Exact Solution']) plt.title('Integral Approximation of 2*x^2 + 3*x + 1 from 0 to 10') plt.xlabel('Number of estimations') plt.ylabel('Area Under the Curve') # show the plot plt.show()
def main(argv): """ Generates random data using specified parameters, integrates and saves plots as PDFs """ ### Integration t = sc.linspace(0, 15, 1000) #from 0 to 15 (units not relevent in this eg), 1000 subdivisions R0 = 10 C0 = 5 RC0 = sc.array([R0, C0]) #pops input pops, infodict = integrate(dCR_dt, RC0, t, full_output=True) ### Plotting pop density over time f1 = p.figure() #open empty fihure object p.plot(t, pops[:,0], 'g-', label='Resource density') # Plot p.plot(t, pops[:,1] , 'b-', label='Consumer density') p.grid() p.legend(loc='best') p.xlabel('Time') p.ylabel('Population density') p.title('Consumer-Resource population dynamics') f1.savefig('../results/LV_model1.pdf') ### Plotting Comsumer density by resource density f2 = p.figure() # open empty fihure object p.plot(pops[:, 0], pops[:, 1], 'r-', label='Resource density') # Plot p.grid() p.xlabel('Resource density') p.ylabel('Consumer density') p.title('Consumer-Resource population dynamics') #p.show()# To display the figures f2.savefig('../results/LV_model1-1.pdf') p.close('all') # Save and clear figure - prevents accumalation return None
def gpc_make_prediction(self, tasks, x_star): task = tasks[0] y, f = self.Y[:, task], self.f num_tasks = len(tasks) # TODO: Revisar esta linea(puede fallar): I = np.matrix(np.eye(num_cols(self.X[task]))) W = -self.sigmoid.hessian_log_likelihood(y, f) # TODO: Revisar las dos siguientes lineas: # self.K = self.cov_function.cov_matrix(self.hyperparameters, self.X[task]) # K = self.K + eps*I K = self.cov_function.cov_matrix(self.hyperparameters, self.X[task]) K = K + eps * I sqrt_W = np.sqrt(W) self.L = cholesky(I + sqrt_W * K * sqrt_W) L = self.L k_star = compute_k_star(self.cov_function.cov_function, self.hyperparameters, self.X[task], x_star) # f_mean = dot(k_star.T, self.sigmoid.gradient_log_likelihood(y, f)) f_mean = (k_star.T) * (self.sigmoid.gradient_log_likelihood(y, f)) v = backslash(L, sqrt_W * k_star) k_star_star = compute_k_star(self.cov_function.cov_function, self.hyperparameters, x_star, x_star) f_var = k_star_star - np.dot(v.T, v) # TODO: # esto se puede hacer mejor def aux_fun(z, i): return self.sigmoid.evaluate(z) * scipy.stats.norm( f_mean[i, 0], f_var[i, i]).pdf(z) # pi_star = integrate(aux_fun, -np.inf, np.inf) self.pi_star = [] for i in range(num_cols(x_star)): self.pi_star.append( integrate(aux_fun, -np.inf, np.inf, args=(i, ))[0]) return self.pi_star """def aux_fun(f_i):
def rms(f, T): """ rms Function Integral-based RMS calculator, evaluates the RMS value of a repetative signal (f) given the signal's specific period (T) Parameters ---------- f: float The periodic function, a callable like f(t) T: float The period of the function f, so that f(0)==f(T) Returns ------- RMS: The RMS value of the function (f) over the interval ( 0, T ) """ fn = lambda x: f(x)**2 integral = integrate(fn,0,T) RMS = np.sqrt(1/T*integral) return(RMS)
def planckPower(lamb1,lamb2,T): R,dR=integrate(planckDistrib,lamb1,lamb2,args=(T,)) return R
from scipy.integrate import quadrature as integrate def phi_l(xl, xr): return lambda x: (xr - x) / (xr - xl) def phi_r(xl, xr): return lambda x: (x - xl) / (xr - xl) def dphi_l(xl, xr): return lambda x: -1 / (xr - xl) def dphi_r(xl, xr): return lambda x: 1 / (xr - xl) l = phi_l(0, 1) r = phi_r(0, 1) dl = dphi_l(0, 1) dr = dphi_r(0, 1) print(integrate(lambda x: dr(x) * dl(x), 0, 1))
def _false_negative_probability(threshold, b, r): _probability = lambda s : 1 - (1 - (1 - s**float(r))**float(b)) a, err = integrate(_probability, threshold, 1.0) return a
def main(): import numpy as np import numpy from scipy.integrate import quad as integrate # Parameters in script # -------------------------------------------------------------------------- clouds = ('taurus', 'perseus',)# 'california') dec_ranges = ((35, 20), (35, 24), (44, 35)) ra_ranges = ((5.5, 3.9), (4, 3), (70, 40)) tspin_threshold = 200.0 # Data locations in script # -------------------------------------------------------------------------- filedir = '/home/ezbc/research/data/taurus/python_output/' # Read the data source_table = read_data(filedir + 'taurus_stanimirovic14_sources.txt') param_table = read_data(filedir + 'taurus_stanimirovic14_temps.txt') # Extract headers and data source_cols = source_table.colnames source_data = np.asarray(source_table._data) param_cols = param_table.colnames param_data = np.asarray(param_table._data) # Extract source names and RA / Dec source_decs = np.empty(source_data.shape) source_ras = np.empty(source_data.shape) source_names = ['' for x in range(source_data.shape[0])] source_names = np.empty(source_data.shape, dtype=object) for i, source in enumerate(source_data): source_dec = source[source_cols.index('Decl. (J2000)')] source_decs[i] = float(source_dec.split(':')[0]) source_ra = source[source_cols.index('R.A. (J2000)')] source_ras[i] = float(source_ra.split(':')[0]) source_names[i] = source[source_cols.index('Source')] # Find T_cnm temperatures for each cloud cloud_counts_list = [] cloud_bins_list = [] cloud_t_cnm_lists = [] weights_list = [] for i, cloud in enumerate(clouds): dec_range = dec_ranges[i] ra_range = ra_ranges[i] # Choose only sources within RA and Dec range indices = np.where((source_decs >= dec_range[1]) &\ (source_decs <= dec_range[0]) &\ (source_ras >= ra_range[1]) &\ (source_ras <= ra_range[0]) ) cloud_decs = source_decs[indices] cloud_ras = source_ras[indices] cloud_sources = source_names[indices] # Get the spin temperatures of chosen sources t_cnm_list = [] cloud_t_cnm_list = [] source_list = [] weights = [] for j in xrange(len(param_data)): tspin = param_data[j][param_cols.index('Ts')] tau_error = param_data[j][param_cols.index('e_Ts')] if param_data[j][param_cols.index('Source')] in cloud_sources: if tspin < tspin_threshold and tau_error != 0.0: cloud_t_cnm_list.append(tspin) Tpeak = param_data[j][param_cols.index('TB')] DelV = param_data[j][param_cols.index('DelV')] VLSR = param_data[j][param_cols.index('VLSR')] T_integ = integrate(gaussian, -1000, 1000, args=(Tpeak, DelV/2.0, VLSR)) weights.append(T_integ[0]) if tspin < tspin_threshold: t_cnm_list.append(tspin) if cloud=='perseus': bins=3 else: bins=8 cloud_counts, cloud_bins = np.histogram(cloud_t_cnm_list, bins=bins) cloud_counts = cloud_counts / np.sum(cloud_counts, dtype=numpy.float) cloud_counts = np.append(cloud_counts, 0) cloud_counts_list.append(cloud_counts) cloud_bins_list.append(cloud_bins) cloud_t_cnm_lists.append(cloud_t_cnm_list) weights_list.append(weights) print cloud, np.median(cloud_t_cnm_list), 'Median CNM temp [K]' print cloud, np.average(cloud_t_cnm_list, weights=weights), 'Intensity-weighted mean CNM temp [K]'
def _false_positive_probability(threshold, b, r): def _probability(s): return 1 - (1 - s**float(r))**float(b) a, err = integrate(_probability, 0.0, threshold) return a
def f(s,t): x,y,z = s[:N] r = np.sqrt(x*x+y*y+z*z) v = s[N:] V = np.sqrt(np.sum(v*v)) b = V/(np.sqrt(2.0)*sigma) fx,fy,fz = -K*rho(r)*v*(erf(b)-2.0*b*np.exp(-0.5*b)/np.sqrt(np.pi))/(V*V*V) return np.array([v[0],v[1],v[2],(M(r)*Fx(x,y,z)+fx),(M(r)*Fy(x,y,z)+fy),(M(r)*Fz(x,y,z)+fz)]) # Initial conditions vlct = np.array([200,300,400])*1.022 t = np.linspace(0,1000.0,n_iter) for vel in vlct: print vel s_0 = np.array([1,0,0,0,0,vel]) #[x,y,z,v_x,v_y,v_z] s = integrate(f,s_0,t) #E = 0.5*m*np.sum(v*v,axis=1)+2.0*np.pi*G*rho_0*np.log(x[:,0]*x[:,0]+x[:,1]*x[:,1]+x[:,2]*x[:,2]) x,v = s[:,:N],s[:,N:] pylab.plot(t*1E6,np.sqrt(x[:,0]*x[:,0]+x[:,1]*x[:,1]+x[:,2]*x[:,2]),label='$\mathrm{'+str(vel)+'\ Pc/Myr}$') pylab.legend(loc=2) pylab.xlabel('$\mathrm{Time\ (Years)}$',fontsize=16) pylab.ylabel('$\mathrm{Radial\ Distance\ (Pc)}$',fontsize=16) pylab.xscale('log') pylab.yscale('log') pylab.ylim(ymin=3) pylab.xlim(xmin=2E4) pylab.savefig('r.png',dpi=200) pylab.close()
return 4*np.pi*(m_tot-m)*rho(x,y,z)*G*G*m*m*(v_s*v_s+u*u+v*v+w*w)**-1.5 return 0 def D(s,t): x,y,z = s[:3] u,v,w = s[3:-1] m = s[-1] dm = mdot(x,y,z,u,v,w,m) a_x = (Hx(x,y,z)+(m_tot-m)*Gx(x,y,z)-dm*u)/m a_y = (Hy(x,y,z)+(m_tot-m)*Gy(x,y,z)-dm*v)/m a_z = (Hz(x,y,z)+(m_tot-m)*Gz(x,y,z)-dm*w)/m return np.array([u,v,w,a_x,a_y,a_z,dm]) t = np.linspace(0,10000,n_iter) s_0 = np.array([1,0,0,200/np.sqrt(3),200/np.sqrt(3),200/np.sqrt(3),m_0]) #[x,y,z,u,v,w,m] s = integrate(D,s_0,t) x,y,z = np.transpose(s[:,:3]) u,v,w = np.transpose(s[:,3:-1]) m = np.transpose(s[:,-1]) r = (x*x+y*y+z*z)**0.5 pylab.plot(t,r) pylab.xlabel('$t$') pylab.ylabel('$r(t)$') pylab.savefig('r.png',dpi=200) pylab.show() r = 1.5e4 theta = np.linspace(0,2*np.pi,100) pylab.plot(x,z)
def g(self, v): integrand = lambda vPrime: self.B(vPrime) / self.integralRadical( v, vPrime) return integrate(integrand, -0.5, v - self.delta)[0] + ( self.B(v) * self.correctionFactor(v))
def main(): import numpy as np import numpy from scipy.integrate import quad as integrate # Parameters in script # -------------------------------------------------------------------------- clouds = ( 'taurus', 'perseus', ) # 'california') dec_ranges = ((35, 20), (35, 24), (44, 35)) ra_ranges = ((80, 60), (60, 40), (70, 40)) tspin_threshold = 200.0 # Data locations in script # -------------------------------------------------------------------------- filedir = '/d/bip3/ezbc/multicloud/data/cnm_data/heiles03/' # Read the data source_table = read_data(filedir + 'heiles03_sources.tsv') param_table = read_data(filedir + 'heiles03_fit_params.tsv') # Extract headers and data source_cols = source_table.colnames source_data = np.asarray(source_table._data) param_cols = param_table.colnames param_data = np.asarray(param_table._data) # Extract source names and RA / Dec source_decs = np.empty(source_data.shape) source_ras = np.empty(source_data.shape) source_names = ['' for x in range(source_data.shape[0])] source_names = np.empty(source_data.shape, dtype=object) for i, source in enumerate(source_data): source_decs[i] = source[source_cols.index('_DE.icrs')] source_ras[i] = source[source_cols.index('_RA.icrs')] source_names[i] = source[source_cols.index('Name')] # Find T_cnm temperatures for each cloud cloud_counts_list = [] cloud_bins_list = [] cloud_t_cnm_lists = [] weights_list = [] for i, cloud in enumerate(clouds): dec_range = dec_ranges[i] ra_range = ra_ranges[i] # Choose only sources within RA and Dec range indices = np.where((source_decs > dec_range[1]) &\ (source_decs < dec_range[0]) &\ (source_ras > ra_range[1]) &\ (source_ras < ra_range[0]) )[0] cloud_decs = source_decs[indices] cloud_ras = source_ras[indices] cloud_sources = source_names[indices] # Get the spin temperatures of chosen sources t_cnm_list = [] cloud_t_cnm_list = [] source_list = [] weights = [] for j in xrange(len(param_data)): tspin = param_data[j][param_cols.index('Tspin')] tau_error = param_data[j][param_cols.index('e_tau')] if param_data[j][param_cols.index('Name')] in cloud_sources: if tspin < tspin_threshold and tau_error != 0.0: cloud_t_cnm_list.append(tspin) Tpeak = param_data[j][param_cols.index('Tpeak')] DelV = param_data[j][param_cols.index('DelV')] VLSR = param_data[j][param_cols.index('VLSR')] T_integ = integrate(gaussian, -1000, 1000, args=(Tpeak, DelV / 2.0, VLSR)) weights.append(T_integ[0]) if tspin < tspin_threshold: t_cnm_list.append(tspin) if cloud == 'perseus': bins = 3 else: bins = 8 cloud_counts, cloud_bins = np.histogram(cloud_t_cnm_list, bins=bins) cloud_counts = cloud_counts / np.sum(cloud_counts, dtype=numpy.float) cloud_counts = np.append(cloud_counts, 0) cloud_counts_list.append(cloud_counts) cloud_bins_list.append(cloud_bins) cloud_t_cnm_lists.append(cloud_t_cnm_list) weights_list.append(weights) print cloud, np.median(cloud_t_cnm_list), 'Median CNM temp [K]' print cloud, np.average( cloud_t_cnm_list, weights=weights), 'Intensity-weighted mean CNM temp [K]' print weights, cloud_t_cnm_list global_counts, global_bins = np.histogram(t_cnm_list, bins=20) global_counts = global_counts / np.sum(global_counts, dtype=numpy.float) global_counts = np.append(global_counts, 0) # Plot the spin temperatures plot_spin_temps(cloud_counts_list, cloud_bins_list=cloud_bins_list, global_spin_temps=global_counts, global_bins=global_bins, clouds=clouds, filename=\ '/d/bip3/ezbc/multicloud/figures/heiles03_spin_temp_hist.png')
import matplotlib.pyplot as plt from math import e from numpy import array,sin,cos,exp from numpy import arange from sympy import * from scipy.integrate import quad import scipy.integrate.odeint as integrate x = Symbol('x') y1 = cos(x) y2 = sin(x) gx = 1 + tan(x) dy1 = y1.diff(x) dy2 = y2.diff(x) W = y1*dy2 - y2*dy1 W = simplify(W) du1 = (y2*gx)/W print du1 u1 = integrate(du1) ##func = lambda du1 : du1 ##u1 = quad(func) print u1
def w(z): s, phi = z integrand = lambda u: Vf(np.maximum(G(x, phi), u)) * F.pdf(u) integral, err = integrate(integrand, a, b) q = pi(s) * integral + (1 - pi(s)) * Vf(G(x, phi)) return - x * (1 - phi - s) - beta * q # minus because we minimize
def OptimizedBreakup(self): print 'Performing optimized Ewald breakup...' # Read potential and spline it print '...reading potential...' data = np.loadtxt(self.prefix+'_sq_'+self.object_string+'_diag.dat') rs,r_min,r_max = data[:,0],data[0,0],data[-1,0] vs = data[:,1] v_r_spline = spline(rs, vs) # Set up basis print '...forming LPQHI basis...' basis = LPQHIBasis(self.L,self.r_cut,self.n_d,self.n_knots) # Extend k space to continuum print '...extending k space...' k_cont = 50.*self.k_avg k_max = 50.*pi/basis.delta self.ExtendKs(k_cont,k_max) n_k = len(self.opt_mag_ks) n_r = basis.GetNElements() # Determine r max from tolerances v_tol = 1.e-4 # TODO: This is fixed v_c = self.cofactor*self.z_1_z_2/r_max if (abs(v_r_spline(r_max) - v_c) > v_tol): print 'WARNING: |v(r_max) - v_{c}(r_max)| = ',abs(v_r_spline(r_max) - v_c),'>',v_tol,'with r_max =',r_max,' v(r_max) = ',v_r_spline(r_max),' v_{c}(r_max) = ',v_c else: i = 1 r_max = rs[i] while (abs(v_r_spline(r_max) - self.cofactor*self.z_1_z_2/r_max) > v_tol) and (i+1 < len(rs)-1): i += 1 r_max = rs[i] if (r_max < self.r_cut): r_max = self.r_cut v_c = self.cofactor*self.z_1_z_2/r_max print '...setting r_max = ',r_max,'with |v(r_max) - v_{c}(r_max)| <',v_tol,'...' # Calculate x_k print '...calculating Xk...' x_k = [] tot_x_k = 0. percent_i = 1 for k_i in range(n_k): k = self.opt_mag_ks[k_i][0] x_k.append(self.CalcXk(v_r_spline, self.r_cut, k, r_max)/self.vol) if (float(k_i)/float(n_k)) > percent_i*0.1: print '......', percent_i*10, '% complete...' percent_i += 1 tot_x_k += x_k[k_i] # Fill in c_n_k print '...filling in c_n_k...' c_n_k = np.zeros((n_r,n_k)) for n in range(n_r): for k_i in range(n_k): c_n_k[n,k_i] = basis.c(n,self.opt_mag_ks[k_i][0]) # Fill in A and b print '...filling in A and b...' A = np.zeros((n_r,n_r)) b = np.zeros((n_r)) for l in range(n_r): for k_i in range(n_k): b[l] += self.opt_mag_ks[k_i][1] * x_k[k_i] * c_n_k[l,k_i] for n in range(n_r): A[l,n] += self.opt_mag_ks[k_i][1] * c_n_k[l,k_i] * c_n_k[n,k_i] # Add constraints t = np.zeros((n_r)) adjust = np.ones((n_r)) # TODO: Currently no constraints # Reduce for constraints n_r_c = n_r for i in range(n_r): if not adjust[i]: n_r_c -= 1 # Build constrained A_c and b_c A_c = np.zeros((n_r_c,n_r_c)) b_c = np.zeros((n_r_c)) j = 0 for col in range(n_r): if adjust[col]: i = 0 for row in range(n_r): if adjust[row]: A_c[i,j] = A[row,col] i += 1 j += 1 else: for row in range(n_r): b[row] -= A[row,col]*t[col] j = 0 for row in range(n_r): if adjust[row]: b_c[j] = b[row] j += 1 # Do SVD print '...performing SVD...' U, S, V = np.linalg.svd(A_c, full_matrices=True) # Get maximum value in S s_max = S[0] for i in range(1,n_r_c): s_max = max(S[i],s_max) # Check for negative singular values for i in range(n_r_c): if S[i] < 0.: print 'WARNING: Negative singular value.' # Assign inverse S breakup_tol = 1.e-16 i_S = np.zeros((n_r_c)) n_singular = 0 for i in range(n_r_c): if (S[i] < breakup_tol*s_max): i_S[i] = 0. else: i_S[i] = 1./S[i] if (i_S[i] == 0.): n_singular += 1 if (n_singular > 0): print 'WARNING: There were',n_singular,'singular values.' # Compute t_n, removing singular values t_c = np.zeros((n_r_c)) for i in range(n_r_c): coef = 0. for j in range(n_r_c): coef += U[j,i]*b_c[j] coef *= i_S[i] for k in range(n_r_c): t_c[k] += coef*V[i,k] # Copy t_c values into t j = 0 for i in range(n_r): if adjust[i]: t[i] = t_c[j] j += 1 # Calculate chi-squared chi_2 = 0. for k_i in range(n_k): y_k = x_k[k_i] for n in range(n_r): y_k -= c_n_k[n,k_i]*t[n] chi_2 += self.opt_mag_ks[k_i][1]*y_k*y_k print '...chi^2 = ', chi_2,'...' # Compose real space part print '...composing real space part...' v_l_0 = 0. for n in range(n_r): v_l_0 += t[n]*basis.h(n,0.) v_l = np.zeros((self.n_points)) for i in range(self.n_points): r = self.rs[i] if (r <= self.r_cut): for n in range(n_r): v_l[i] += t[n]*basis.h(n,r) else: v_l[i] = v_r_spline(r) v_l_spline = spline(self.rs, v_l) # Get k=0 components (short) print '...computing k=0 components...' def v_short_integrand(r): if r < self.r_min: r = self.r_min return r*r*(v_r_spline(r) - v_l_spline(r)) f_v_s_0 = -integrate(v_short_integrand, 1.e-100, self.r_cut, divmax=100) if (self.n_d == 2): f_v_s_0 *= 2.*pi/self.vol # FIXME: Probably wrong for 2D elif (self.n_d == 3): f_v_s_0 *= 4.*pi/self.vol # Get k=0 components (long) def v_long_integrand(r): if r < self.r_min: r = self.r_min return r*r*v_l_spline(r) f_v_l_0 = -integrate(v_long_integrand, 1.e-100, self.r_cut, divmax=100) if (self.n_d == 2): f_v_s_0 *= 2.*pi/self.vol # FIXME: Probably wrong for 2D elif (self.n_d == 3): f_v_l_0 *= 4.*pi/self.vol # Write r space part to file f = open(self.prefix+'_sq_'+self.object_string+'_diag_r.dat','w') f.write('%.10E %.10E\n'%(0.,v_l_0)) for i in range(self.n_points): r = self.rs[i] f.write('%.10E %.10E\n'%(r,v_l[i])) f.close() # Compose k space part f = open(self.prefix+'_sq_'+self.object_string+'_diag_k.dat','w') f.write('%.10E %.10E\n'%(0.,f_v_s_0)) f_v_ls = [] for k in self.ks: k_2 = np.dot(k,k) mag_k = np.sqrt(k_2) f_v_l = 0. for n in range(n_r): f_v_l += t[n]*basis.c(n,mag_k) f_v_l -= self.CalcXk(v_r_spline, self.r_cut, mag_k, self.r_max)/self.vol f_v_ls.append([mag_k, f_v_l]) mag_k_prev = -1 for [mag_k,f_v_l] in sorted(f_v_ls): if abs(mag_k-mag_k_prev) > 1.e-8: f.write('%.10E %.10E\n'%(mag_k,f_v_l)) mag_k_prev = mag_k f.close()
def continuous_entropy(p, start, end): answer, err = integrate(lambda x: p(x) * np.log(p(x)), start, end) return -answer
if disttype != 3: #comoving distance out to scale factor a0: integral(da'/(a'^2 H(a')),a0,1) #H^2 a^4=omegaR +omegaM a^1 + omegaE a^4 + omegaK a^2 def integrand(a, H0, R, M, L, K): #1/(a^2 H) return (R + M * a + L * a**4 + K * a**2)**-0.5 / H0 else: #lookback time def integrand(a, H0, R, M, L, K): #1/(a^2 H) return a * (R + M * a + L * a**4 + K * a**2)**-0.5 / H0 if isSequenceType(a0): integratevec = vectorize( lambda x: integrate(integrand, x, 1, args=(H0, omegaR, omegaM, omegaL, omegaK), **intkwargs)) res = integratevec(a0) intres, interr = res[0], res[1] try: if np.any(interr / intres > inttol): raise Exception( 'Integral fractional error for one of the integrals is beyond tolerance' ) except ZeroDivisionError: pass else: res = integrate(integrand, a0,
def main(): import numpy as np import numpy from scipy.integrate import quad as integrate import pickle # Parameters in script # -------------------------------------------------------------------------- clouds = ('taurus', 'perseus', 'california') dec_ranges = ((37, 19), (37, 19), (37, 35)) ra_ranges = ((5.5, 3.8), (3.8, 2.9), (5.5, 3.5)) tspin_threshold = 500.0 # Data locations in script # -------------------------------------------------------------------------- filedir = '/d/bip3/ezbc/multicloud/data/cnm_data/stanimirovic14/' # Read the data source_table = read_data(filedir + 'stanimirovic14_sources.txt') param_table = read_data(filedir + 'stanimirovic14_temps.txt') avg_temp_table = read_data(filedir + 'stanimirovic14_avg_temps.txt', data_start=0, delimiter=' ') # Extract headers and data source_cols = source_table.colnames source_data = np.asarray(source_table._data) param_cols = param_table.colnames param_data = np.asarray(param_table._data) print('cnm temp columns', param_cols) print('avg temp columns', avg_temp_table.colnames) #avg_temp_cols = np.asarray(avg_temp_table.colnames) #avg_temp_data = np.asarray(avg_temp_table._data) avg_temp_sources = [] avg_temp_data = [] for row in avg_temp_table._data: avg_temp_sources.append(row[0]) avg_temp_data.append(row[1]) avg_temp_data = np.asarray(avg_temp_data) avg_temp_sources = np.asarray(avg_temp_sources) # Extract source names and RA / Dec source_decs = np.empty(source_data.shape) source_ras = np.empty(source_data.shape) source_names = ['' for x in range(source_data.shape[0])] source_names = np.empty(source_data.shape, dtype=object) for i, source in enumerate(source_data): source_dec = source[source_cols.index('Decl. (J2000)')] source_decs[i] = float(source_dec.split(':')[0]) source_ra = source[source_cols.index('R.A. (J2000)')] source_ras[i] = float(source_ra.split(':')[0]) source_names[i] = source[source_cols.index('Source')] # Find T_cnm temperatures for each cloud cloud_counts_list = [] cloud_bins_list = [] cloud_t_cnm_lists = [] weights_list = [] temp_dict = {} sources_taurus = [ '4C+27.14', '3C133', '3C132', '4C+25.14', '3C108', 'B20400+25', ] for i, cloud in enumerate(clouds): temp_dict[cloud] = {} dec_range = dec_ranges[i] ra_range = ra_ranges[i] # Choose only sources within RA and Dec range indices = np.where((source_decs >= dec_range[1]) &\ (source_decs <= dec_range[0]) &\ (source_ras >= ra_range[1]) &\ (source_ras <= ra_range[0]) ) cloud_decs = source_decs[indices] cloud_ras = source_ras[indices] cloud_sources = source_names[indices] # Get the spin temperatures of chosen sources t_cnm_list = [] t_int_list = [] tk_list = [] tk_error_list = [] t_cnm_error_list = [] avg_tspin_list = [] avg_tspin_error_list = [] cloud_t_cnm_list = [] source_list = [] weights = [] TB_dict = {} tau_dict = {} velocities = np.linspace(-1000, 1000, 1000) for j in xrange(len(param_data)): tspin = param_data[j][param_cols.index('Ts')] TB = param_data[j][param_cols.index('TB')] tau = param_data[j][param_cols.index('tau')] tspin_error = param_data[j][param_cols.index('e_Ts')] source = param_data[j][param_cols.index('Source')] Tpeak = param_data[j][param_cols.index('TB')] Tk = param_data[j][param_cols.index('Tkmax')] Tk_error = Tk * 0.1 DelV = param_data[j][param_cols.index('DelV')] VLSR = param_data[j][param_cols.index('VLSR')] if source in cloud_sources: if source not in source_list: avg_temp_added = False else: avg_temp_added = True source_list.append(source) #print source # add the source avg Tspin if 1: #if not avg_temp_added: print '' print source print 'TB:', TB print 'tau:', tau print 'T_kinetic:', Tk print 'sigma:', DelV / 2.0 print 'vlsr:', VLSR avg_temp = \ avg_temp_data[avg_temp_sources == source][0] # for error see section 3.1 of Kim et al. (2014) who # describe the harmonic mean temperature is within 10% of # the observed optical depth weighted spin temperature. This # may be due to multiple clouds with varying optical depths # along the LOS. avg_temp_error = 0.1 * avg_temp avg_tspin_list.append(avg_temp) avg_tspin_error_list.append(avg_temp_error) #avg_temp = np.mean(TB) / np.mean(tau) else: # Calculate brightness temp and tau spectra TB_spectrum = gaussian(velocities, TB, DelV / 2.0, VLSR) tau_spectrum = gaussian(velocities, tau, DelV / 2.0, VLSR) # add them to the source list if source not in TB_dict: TB_dict[source] = TB_spectrum tau_dict[source] = tau_spectrum else: TB_dict[source] = \ TB_dict[source] + TB_spectrum tau_dict[source] = \ tau_dict[source] + tau_spectrum #avg_tspin_list.append(avg_temp) if tspin < tspin_threshold and tspin_error != 0.0: cloud_t_cnm_list.append(tspin) T_integ = integrate(gaussian, -1000, 1000, args=(Tpeak, DelV / 2.0, VLSR)) #weights.append(T_integ[0]) if tspin < tspin_threshold and VLSR < 15 and VLSR > -5: t_cnm_list.append(tspin) t_cnm_error_list.append(tspin_error) t_int_list.append(Tk) if source in sources_taurus: print source, tspin if VLSR < 15 and VLSR > -5: tk_list.append(Tk) tk_error_list.append(Tk_error) # convert TB and tau to average spin temperatue #avg_tspin_list = calc_avg_Ts(TB_dict, tau_dict, velocities) #print 'avg t spins:', avg_tspin_list temp_dict[cloud]['Ts_list'] = t_cnm_list temp_dict[cloud]['Ts_error_list'] = t_cnm_error_list #avg_tspin_list = [] #for source in TB_dict: # avg_tspin_list.append(TB_dict[source]) temp_dict[cloud]['Ts_avg_list'] = avg_tspin_list temp_dict[cloud]['Ts_avg_error_list'] = avg_tspin_error_list temp_dict[cloud]['Tk_list'] = tk_list temp_dict[cloud]['Tk_error_list'] = tk_error_list if 0: if cloud == 'perseus': bins = 3 else: bins = 8 cloud_counts, cloud_bins = np.histogram(cloud_t_cnm_list, bins=bins) cloud_counts = cloud_counts / np.sum(cloud_counts, dtype=numpy.float) cloud_counts = np.append(cloud_counts, 0) cloud_counts_list.append(cloud_counts) cloud_bins_list.append(cloud_bins) cloud_t_cnm_lists.append(cloud_t_cnm_list) weights_list.append(weights) avg = np.average(cloud_t_cnm_list, weights=weights) med = np.median(cloud_t_cnm_list) print(cloud.capitalize()) print('\tMedian CNM temp = ' + \ '{0:.2f} [K]'.format(med)) print('\tIntensity-weighted mean CNM temp = ' + \ '{0:.2f} [K]\n'.format(avg)) # Save data with open('/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_temps.pickle', 'wb') as f: pickle.dump(temp_dict, f) filename = \ '/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_temps.npy' np.savetxt(filename, np.array(t_cnm_list)) filename = \ '/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_int_temps.npy' np.savetxt(filename, np.array(t_int_list)) filename = \ '/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_temp_errors.npy' np.savetxt(filename, np.array(t_cnm_error_list))
def test_gauss_pdf_integral(self): ''' Check that Gauss pdf integral is 1 ''' result, _ = integrate(pylandau.get_gauss_pdf, 0, 10000, args=(10, 3)) self.assertAlmostEqual(result, 1, delta=1e-3)
import scipy as sp from scipy.integrate import quad as integrate import numpy as np import matplotlib.pyplot as plt a, b = 1, 2 p = lambda x: 1 f = lambda x: 0.8 * sp.log(x) + 0.6 * sp.cos(x) basis = [(lambda power: lambda x: x**power)(power) for power in range(6)] A = np.array([[ integrate(lambda value: p(value) * x(value) * y(value), a, b)[0] for x in basis ] for y in basis]) B = np.array([ integrate(lambda value: p(value) * x(value) * f(value), a, b)[0] for x in basis ]) coefs = np.linalg.solve(A, B) def g(x): sum = 0 for i in range(len(coefs)): sum += coefs[i] * basis[i](x) return sum xRange = np.linspace(a, b, (b - a) * 100) print("Accuracy: %e" % np.max(np.abs(f(xRange) - g(xRange))))
#!/usr/bin/env python2.7 import math from scipy.integrate import quad as integrate if __name__ == '__main__': print integrate(lambda x: math.exp(-x)*(2.99792458e18/(x*x)), 1.0, 2.0) print integrate(lambda x: 2.0*(math.sin(10.0*x) + 1.0), 1.0, 2.0)
def other(ks, n1, n2=float('inf')): # The probability of the two distributions taking on necessary values prob_val = lambda val,truth: (normal_pdf(val,truth,truth*(1-truth)) * normal_pdf(val+ks,truth,truth*(1-truth))) prob_truth = lambda truth: integrate(lambda v: prob_val(v,truth), 0, 1-ks)[0] return 2 * prob_val(.5-(ks/2),.5) / np.sqrt(n1*n2)
def main(): import numpy as np import numpy from scipy.integrate import quad as integrate import pickle # Parameters in script # -------------------------------------------------------------------------- clouds = ('taurus', 'perseus', 'california') dec_ranges = ((37, 19), (37, 19), (37, 35)) ra_ranges = ((5.5, 3.8), (3.8, 2.9), (5.5, 3.5)) tspin_threshold = 500.0 # Data locations in script # -------------------------------------------------------------------------- filedir = '/d/bip3/ezbc/multicloud/data/cnm_data/stanimirovic14/' # Read the data source_table = read_data(filedir + 'stanimirovic14_sources.txt') param_table = read_data(filedir + 'stanimirovic14_temps.txt') avg_temp_table = read_data(filedir + 'stanimirovic14_avg_temps.txt', data_start=0, delimiter=' ') # Extract headers and data source_cols = source_table.colnames source_data = np.asarray(source_table._data) param_cols = param_table.colnames param_data = np.asarray(param_table._data) print('cnm temp columns', param_cols) print('avg temp columns', avg_temp_table.colnames) #avg_temp_cols = np.asarray(avg_temp_table.colnames) #avg_temp_data = np.asarray(avg_temp_table._data) avg_temp_sources = [] avg_temp_data = [] for row in avg_temp_table._data: avg_temp_sources.append(row[0]) avg_temp_data.append(row[1]) avg_temp_data = np.asarray(avg_temp_data) avg_temp_sources = np.asarray(avg_temp_sources) # Extract source names and RA / Dec source_decs = np.empty(source_data.shape) source_ras = np.empty(source_data.shape) source_names = ['' for x in range(source_data.shape[0])] source_names = np.empty(source_data.shape, dtype=object) for i, source in enumerate(source_data): source_dec = source[source_cols.index('Decl. (J2000)')] source_decs[i] = float(source_dec.split(':')[0]) source_ra = source[source_cols.index('R.A. (J2000)')] source_ras[i] = float(source_ra.split(':')[0]) source_names[i] = source[source_cols.index('Source')] # Find T_cnm temperatures for each cloud cloud_counts_list = [] cloud_bins_list = [] cloud_t_cnm_lists = [] weights_list = [] temp_dict = {} sources_taurus = ['4C+27.14', '3C133', '3C132', '4C+25.14', '3C108', 'B20400+25',] for i, cloud in enumerate(clouds): temp_dict[cloud] = {} dec_range = dec_ranges[i] ra_range = ra_ranges[i] # Choose only sources within RA and Dec range indices = np.where((source_decs >= dec_range[1]) &\ (source_decs <= dec_range[0]) &\ (source_ras >= ra_range[1]) &\ (source_ras <= ra_range[0]) ) cloud_decs = source_decs[indices] cloud_ras = source_ras[indices] cloud_sources = source_names[indices] # Get the spin temperatures of chosen sources t_cnm_list = [] t_int_list = [] tk_list = [] tk_error_list = [] t_cnm_error_list = [] avg_tspin_list = [] avg_tspin_error_list = [] cloud_t_cnm_list = [] source_list = [] weights = [] TB_dict = {} tau_dict = {} velocities = np.linspace(-1000, 1000, 1000) for j in xrange(len(param_data)): tspin = param_data[j][param_cols.index('Ts')] TB = param_data[j][param_cols.index('TB')] tau = param_data[j][param_cols.index('tau')] tspin_error = param_data[j][param_cols.index('e_Ts')] source = param_data[j][param_cols.index('Source')] Tpeak = param_data[j][param_cols.index('TB')] Tk = param_data[j][param_cols.index('Tkmax')] Tk_error = Tk * 0.1 DelV = param_data[j][param_cols.index('DelV')] VLSR = param_data[j][param_cols.index('VLSR')] if source in cloud_sources: if source not in source_list: avg_temp_added = False else: avg_temp_added = True source_list.append(source) #print source # add the source avg Tspin if 1: #if not avg_temp_added: print '' print source print 'TB:', TB print 'tau:', tau print 'T_kinetic:', Tk print 'sigma:', DelV/2.0 print 'vlsr:', VLSR avg_temp = \ avg_temp_data[avg_temp_sources == source][0] # for error see section 3.1 of Kim et al. (2014) who # describe the harmonic mean temperature is within 10% of # the observed optical depth weighted spin temperature. This # may be due to multiple clouds with varying optical depths # along the LOS. avg_temp_error = 0.1 * avg_temp avg_tspin_list.append(avg_temp) avg_tspin_error_list.append(avg_temp_error) #avg_temp = np.mean(TB) / np.mean(tau) else: # Calculate brightness temp and tau spectra TB_spectrum = gaussian(velocities, TB, DelV/2.0, VLSR) tau_spectrum = gaussian(velocities, tau, DelV/2.0, VLSR) # add them to the source list if source not in TB_dict: TB_dict[source] = TB_spectrum tau_dict[source] = tau_spectrum else: TB_dict[source] = \ TB_dict[source] + TB_spectrum tau_dict[source] = \ tau_dict[source] + tau_spectrum #avg_tspin_list.append(avg_temp) if tspin < tspin_threshold and tspin_error != 0.0: cloud_t_cnm_list.append(tspin) T_integ = integrate(gaussian, -1000, 1000, args=(Tpeak, DelV/2.0, VLSR)) #weights.append(T_integ[0]) if tspin < tspin_threshold and VLSR < 15 and VLSR > -5: t_cnm_list.append(tspin) t_cnm_error_list.append(tspin_error) t_int_list.append(Tk) if source in sources_taurus: print source, tspin if VLSR < 15 and VLSR > -5: tk_list.append(Tk) tk_error_list.append(Tk_error) # convert TB and tau to average spin temperatue #avg_tspin_list = calc_avg_Ts(TB_dict, tau_dict, velocities) #print 'avg t spins:', avg_tspin_list temp_dict[cloud]['Ts_list'] = t_cnm_list temp_dict[cloud]['Ts_error_list'] = t_cnm_error_list #avg_tspin_list = [] #for source in TB_dict: # avg_tspin_list.append(TB_dict[source]) temp_dict[cloud]['Ts_avg_list'] = avg_tspin_list temp_dict[cloud]['Ts_avg_error_list'] = avg_tspin_error_list temp_dict[cloud]['Tk_list'] = tk_list temp_dict[cloud]['Tk_error_list'] = tk_error_list if 0: if cloud=='perseus': bins=3 else: bins=8 cloud_counts, cloud_bins = np.histogram(cloud_t_cnm_list, bins=bins) cloud_counts = cloud_counts / np.sum(cloud_counts, dtype=numpy.float) cloud_counts = np.append(cloud_counts, 0) cloud_counts_list.append(cloud_counts) cloud_bins_list.append(cloud_bins) cloud_t_cnm_lists.append(cloud_t_cnm_list) weights_list.append(weights) avg = np.average(cloud_t_cnm_list, weights=weights) med = np.median(cloud_t_cnm_list) print(cloud.capitalize()) print('\tMedian CNM temp = ' + \ '{0:.2f} [K]'.format(med)) print('\tIntensity-weighted mean CNM temp = ' + \ '{0:.2f} [K]\n'.format(avg)) # Save data with open('/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_temps.pickle', 'wb') as f: pickle.dump(temp_dict, f) filename = \ '/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_temps.npy' np.savetxt(filename, np.array(t_cnm_list)) filename = \ '/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_int_temps.npy' np.savetxt(filename, np.array(t_int_list)) filename = \ '/d/bip3/ezbc/multicloud/data/python_output/tables/' + \ 'stanimirovic14_temp_errors.npy' np.savetxt(filename, np.array(t_cnm_error_list))
def w(z): s, phi = z integrand = lambda u: Vf(np.maximum(G(x, phi), u)) * F.pdf(u) integral, err = integrate(integrand, a, b) q = pi(s) * integral + (1 - pi(s)) * Vf(G(x, phi)) return -x * (1 - phi - s) - beta * q # minus because we minimize
def _false_negative_probability(threshold, b, r): def _probability(s): return 1 - (1 - (1 - s**float(r))**float(b)) a, err = integrate(_probability, threshold, 1.0) return a
#!/usr/bin/python # 2c import numpy as np from math import pi,exp from scipy.integrate import quad as integrate # SI units e = 1.602e-19 me = 9.31e-31 c = 2.98e8 h = 6.652e-34 k = 1.38e-23 T = 5e3 * e / k energy_low = 0.5e3 * e energy_high = 3e3 * e nu_low = energy_low / h nu_high = energy_high / h r = 1.52e22 constant = 4*pi*r**2 * 4*pi*8*e**6/(h*3*me*c**3) * (2/(pi*k*me))**0.5 * T**-0.5 def integrand(nu,T): return exp(-h*nu/(k*T)/nu) result = integrate(integrand, nu_low, nu_high, args=(T))[0]
def _false_positive_probability(threshold, b, r): _probability = lambda s : 1 - (1 - s**float(r))**float(b) a, err = integrate(_probability, 0.0, threshold) return a
def calc_symmetric_error(x, y=None, alpha=0.05): ''' Parameters ---------- x : array-like y : array-like, optional If provided, treated as the PDF of x ''' import numpy as np from scipy.integrate import simps as integrate if len(x) < 4: #raise ValueError('x and y must have lengths > 3') return x[0], 0, 0 # Create histogram with bin widths normalized by the density of values if y is None: x = np.sort(x) y = np.ones(x.shape) if np.any(y < 0): raise ValueError('y values mush be greater than 0') confidence = (1.0 - alpha) # area under whole function with warnings.catch_warnings(): warnings.filterwarnings("ignore",category=DeprecationWarning) area = integrate(y, x) # Get weighted average of PDF mid_pos = np.argmin(np.abs(x - np.average(x, weights=y))) #mid_pos = np.argmin(np.abs(x - np.median(x, weights=y))) #mid_pos = np.interp # If the cum sum had duplicates, then multiple median pos will be derived, # take the one in the middle. try: if len(mid_pos) > 1: mid_pos = mid_pos[len(mid_pos) / 2] except TypeError: pass # Lower error pos = mid_pos - 1 low_area = -np.Inf #area = integrate(y[0:mid_pos], x[0:mid_pos]) while low_area <= area * confidence / 2.0 and pos > 0: y_clip = y[pos:mid_pos]# + 1] x_clip = x[pos:mid_pos]# + 1] low_area = integrate(y_clip, x_clip) # Catch the error if going to far if pos < 0: pos = 0 break pos -= 1 # set result to lower position low_pos = pos if pos == 0: low_pos = np.min(np.where(y != 0)) # higher error pos = mid_pos + 1 max_pos = len(x) high_area = -np.Inf #area = integrate(y[mid_pos:-1], x[mid_pos:-1]) while high_area <= area * confidence / 2.0 and pos < max_pos: y_clip = y[mid_pos:pos] x_clip = x[mid_pos:pos] high_area = integrate(y_clip, x_clip) if pos > max_pos: pos = max_pos break pos += 1 high_pos = pos if pos >= max_pos: high_pos = np.max(np.where(y != 0)) median = x[mid_pos] low_error = x[mid_pos] - x[low_pos] high_error = x[high_pos] - x[mid_pos] return median, high_error, low_error
def threshold_area(x, y, area_fraction=0.68): ''' Finds the limits of a 1D array which includes a given fraction of the integrated data. Parameters ---------- data : array-like 1D array. area_fraction : float Fraction of area. Returns ------- limits : tuple Lower and upper bound including fraction of area. ''' import numpy as np from scipy.integrate import simps as integrate # Check if size of data if x.size == 1: return x[0], 0, 0 # Step for lowering threshold step = (np.max(y) - np.median(y)) / 10000.0 # initial threshold threshold = np.max(y) - step threshold_area = 0.0 # area under whole function area = integrate(y, x) # Stop when the area below the threshold is greater than the max area while threshold_area < area * area_fraction and threshold > 0: threshold_indices = np.where(y > threshold)[0] try: bounds_indices = (threshold_indices[0], threshold_indices[-1]) except IndexError: bounds_indices = () try: threshold_area = integrate(y[bounds_indices[0]:bounds_indices[1]], x[bounds_indices[0]:bounds_indices[1]]) threshold_area += threshold * (x[bounds_indices[1]] - \ x[bounds_indices[0]]) except IndexError: threshold_area = 0 threshold -= step if threshold < 0: bounds_indices = (0, len(x) - 1) x_peak = x[y == y.max()][0] low_error, up_error = x_peak - x[bounds_indices[0]], \ x[bounds_indices[1]] - x_peak return (x_peak, low_error, up_error)
def __init__(self, val_func, pbar): """ Args: val_func : ValuationFunc Valuation function instance we want optimal pricing for pbar : float The maximum possible bidder valuation """ self.pbar = pbar # Copy params from cost function self.s = val_func.s self.a = val_func.a logger.debug(f'Creating optimal power pricing func ' f'(a = {self.a}, s = {self.s}, pbar = {pbar})') # Initialize params we'll need later self.c_lb = val_func.get_min_marginal_cost() self.c_ub = val_func.get_max_marginal_cost() assert self.pbar > self.c_lb, f'Need pbar={self.pbar} > {self.c_lb}' self._is_luc = (pbar > self.c_lb) and (pbar <= self.c_ub) self.alpha_min = self.s**(self.s / (self.s - 1)) logger.debug(f'\tLUC = {self._is_luc}, alpha_min = {self.alpha_min}') logger.debug(f'\tc_lb = {self.c_lb}, c_ub = {self.c_ub}') # Compute Cs int_val = integrate(lambda nu: (nu**(self.s - 1)) * np.exp(-nu), self.s, self.alpha_min) self.Cs = self.c_ub self.Cs *= (1 / np.exp(self.s)) - (int_val / (self.s**self.s)) self.Cs *= np.exp(self.alpha_min) logger.debug(f'\tCs = {self.Cs}') # Detect operating regime (LUC or HUC) + one-time setup actions if self._is_luc: self.w = val_func.inverse(pbar / val_func.s) self.v = val_func.inverse(pbar) assert self.w > 0, 'Error: w > 0 must hold' assert self.w < self.v, 'Error: w < v must hold' assert self.v <= 1, 'Error: v <= 1 must hold' # TODO: what's a good init for m? self.set_m((self.v + self.w) / 2) logger.debug('\tDone LUC init. (w, v) = ({self.w}, {self.v})') else: # Determine whether HUC1 or HUC2 if self.pbar > self.Cs: self._huc_mode = 2 else: self._huc_mode = 1 logger.debug(f'\tHUC mode {self._huc_mode}') # Compute CDT. # The following computations are prone to numerical instabilities # near the open end points...so try to avoid them for now and # assume it won't be a problem... # # WARNING: if brentq is complaining about the lb and ub not having # different signs, it is likely that the root we are searching for # is very close to the open end point (and not within the selected # epsilon tolerance). To compensate for this, you could do two # things: # 1. Decrease epsilon (not recommended, for numerical reasons) # 2. Perturb pbar. Likely, pbar is too close to Cs if you are # experiencing this self.u_s = (1 / self.s)**(1 / (self.s - 1)) EPS = 5e-3 if abs(self.Cs - self.pbar) < self.Cs / 10: # If we detect that Cs and pbar are "very close", try # decreasing EPS to avoid the breqnt complained explained # above. This will NOT work flawlessly for all cases; ideally # we need to set EPS adaptively; this is, however, beyond the # current scope EPS /= 10 logger.debug(f'\tStarting u_cdt search. u_s = {self.u_s}') if self._huc_mode == 1: lb = self.u_s ub = 1 - EPS logger.debug(f'\t\tlb = {lb}, ub = {ub}') self.u_cdt, r = brentq(self._u_cdt_huc1_eqn, lb, ub, full_output=True) assert r.converged, 'Root finder failed to converge' logger.debug(f'\t\tu_cdt = {self.u_cdt}') else: lb = EPS ub = self.u_s - EPS logger.debug(f'\t\tlb = {lb}, ub = {ub}') self.u_cdt, r = brentq(self._u_cdt_huc2_eqn, lb, ub, full_output=True) assert r.converged, 'Root finder failed to converge' logger.debug(f'\t\tu_cdt = {self.u_cdt}') # Find rho_s if HUC1. rho_s is a resource utilization level, so it # lies in [0, 1] (or maybe the open interval?) if self._huc_mode == 1: lb = 0 ub = 1 logger.debug(f'\tStarting rho_s search. lb = {lb}, ub = {ub}') self.rho_s, r = brentq(self._rho_s_eqn, lb, ub, full_output=True) assert r.converged, 'Root finder failed to converge' logger.debug(f'\t\trho_s = {self.rho_s}') # Set u parameter if HUC1 if self._huc_mode == 1: # TODO: what's a good init for u? self.set_u((self.u_s + self.u_cdt) / 2)
def planckPhotons(lamb1,lamb2,T): N,dN=integrate(planckPhotonDistrib,lamb1,lamb2,args=(T,)) return N
def find_coefficient_b(k): return 4 / period * integrate( lambda t, k: input_signal_function(t, t_i, amplitude, period) * sin(omega * k * t), 0, period / 2, args=(k,))[0]
def main(): import numpy as np import numpy from scipy.integrate import quad as integrate # Parameters in script # -------------------------------------------------------------------------- clouds = ('taurus', 'perseus',)# 'california') dec_ranges = ((35, 20), (35, 24), (44, 35)) ra_ranges = ((80, 60), (60, 40), (70, 40)) tspin_threshold = 200.0 # Data locations in script # -------------------------------------------------------------------------- filedir = '/d/bip3/ezbc/multicloud/data/cnm_data/heiles03/' # Read the data source_table = read_data(filedir + 'heiles03_sources.tsv') param_table = read_data(filedir + 'heiles03_fit_params.tsv') # Extract headers and data source_cols = source_table.colnames source_data = np.asarray(source_table._data) param_cols = param_table.colnames param_data = np.asarray(param_table._data) # Extract source names and RA / Dec source_decs = np.empty(source_data.shape) source_ras = np.empty(source_data.shape) source_names = ['' for x in range(source_data.shape[0])] source_names = np.empty(source_data.shape, dtype=object) for i, source in enumerate(source_data): source_decs[i] = source[source_cols.index('_DE.icrs')] source_ras[i] = source[source_cols.index('_RA.icrs')] source_names[i] = source[source_cols.index('Name')] # Find T_cnm temperatures for each cloud cloud_counts_list = [] cloud_bins_list = [] cloud_t_cnm_lists = [] weights_list = [] for i, cloud in enumerate(clouds): dec_range = dec_ranges[i] ra_range = ra_ranges[i] # Choose only sources within RA and Dec range indices = np.where((source_decs > dec_range[1]) &\ (source_decs < dec_range[0]) &\ (source_ras > ra_range[1]) &\ (source_ras < ra_range[0]) )[0] cloud_decs = source_decs[indices] cloud_ras = source_ras[indices] cloud_sources = source_names[indices] # Get the spin temperatures of chosen sources t_cnm_list = [] cloud_t_cnm_list = [] source_list = [] weights = [] for j in xrange(len(param_data)): tspin = param_data[j][param_cols.index('Tspin')] tau_error = param_data[j][param_cols.index('e_tau')] if param_data[j][param_cols.index('Name')] in cloud_sources: if tspin < tspin_threshold and tau_error != 0.0: cloud_t_cnm_list.append(tspin) Tpeak = param_data[j][param_cols.index('Tpeak')] DelV = param_data[j][param_cols.index('DelV')] VLSR = param_data[j][param_cols.index('VLSR')] T_integ = integrate(gaussian, -1000, 1000, args=(Tpeak, DelV/2.0, VLSR)) weights.append(T_integ[0]) if tspin < tspin_threshold: t_cnm_list.append(tspin) if cloud=='perseus': bins=3 else: bins=8 cloud_counts, cloud_bins = np.histogram(cloud_t_cnm_list, bins=bins) cloud_counts = cloud_counts / np.sum(cloud_counts, dtype=numpy.float) cloud_counts = np.append(cloud_counts, 0) cloud_counts_list.append(cloud_counts) cloud_bins_list.append(cloud_bins) cloud_t_cnm_lists.append(cloud_t_cnm_list) weights_list.append(weights) print cloud, np.median(cloud_t_cnm_list), 'Median CNM temp [K]' print cloud, np.average(cloud_t_cnm_list, weights=weights), 'Intensity-weighted mean CNM temp [K]' print weights, cloud_t_cnm_list global_counts, global_bins = np.histogram(t_cnm_list, bins=20) global_counts = global_counts / np.sum(global_counts, dtype=numpy.float) global_counts = np.append(global_counts, 0) # Plot the spin temperatures plot_spin_temps(cloud_counts_list, cloud_bins_list=cloud_bins_list, global_spin_temps=global_counts, global_bins=global_bins, clouds=clouds, filename=\ '/d/bip3/ezbc/multicloud/figures/heiles03_spin_temp_hist.png')
def get_integrated_conductivity(material, T1, T2): model, Tlow, Thigh = conductivity_model(material) if type(T1) in [list, np.ndarray]: T1 = np.array(T1) if (T1 < Tlow).sum() or (T1 > Thigh).sum(): pass #print 'WARNING: Low temperatures are outside model\'s range of ' \ # + 'validity: %.3f - %.3f K' %(Tlow,Thigh) if type(T2) in [list, np.ndarray]: T2 = np.array(T2) if (T2 < Tlow).sum() or (T2 > Thigh).sum(): pass #print 'WARNING: High temperatures are outside model\'s range of ' \ # + 'validity: %.3f - %.3f K' %(Tlow,Thigh) K = np.zeros_like(T1) for i in range(len(T1)): K[i] = integrate(model, T1[i], T2[i], epsabs = 0.0, epsrel = 1E-7)[0] return K else: K = np.zeros_like(T1) for i in range(len(T1)): K[i] = integrate(model, T1[i], T2, epsabs = 0.0, epsrel = 1E-7)[0] return K elif type(T2) in [list, np.ndarray]: T2 = np.array(T2) if (T2 < Tlow).sum() or (T2 > Thigh).sum(): pass #print 'WARNING: High temperatures are outside model\'s range of ' \ # + 'validity: %.3f - %.3f K' %(Tlow,Thigh) K = np.zeros_like(T2) for i in range(len(T2)): K[i] = integrate(model, T1, T2[i], epsabs = 0.0, epsrel = 1E-7)[0] return K else: if T1 < Tlow or T1 > Thigh: pass #print 'WARNING: Low Temperature is outside model\'s range of validity: ' \ # + '%.3f - %.3f K' %(Tlow,Thigh) if T2 < Tlow or T2 > Thigh: pass #print 'WARNING: High Temperature is outside model\'s range of ' \ # + 'validity: %.3f - %.3f K' %(Tlow,Thigh) return integrate(model, T1, T2, epsabs = 0.0, epsrel = 1E-7)[0]
def __get_sr_t_no_o4(self): new_matrix = self.__matrix[:self.m+1, :self.m+1] ftu = sum([sum([self.__matrix[i, j] for j in range(self.m+1, self.m+self.n+1)]) for i in range(self.m+1)]) tu = integrate(lambda x: x * ftu, 0, np.inf) return tu[0]